הגדרת זמן קצוב לתפוגה של עסקה

בדף הזה מוסבר איך להגדיר זמן קצוב לתפוגה של עסקאות באמצעות ספריות הלקוח של Spanner. העסקה נכשלת עם השגיאה DEADLINE_EXCEEDED אם היא לא מסתיימת בתוך ערך הזמן הקצוב שניתן.

אם שגיאת הזמן הקצוב לתפוגה מתרחשת במהלך הביצוע של הבקשה Commit, עדיין יכול להיות שהטרנזקציה בוצעה.

זמנים קצובים לתפוגת RPC ולולאות של ניסיונות חוזרים לביצוע טרנזקציות

זמני קצובים לתפוגה של RPC וזמנים קצובים לתפוגה של טרנזקציות מגבילים היקפי עבודה שונים:

  • זמן קצוב לתפוגה של RPC מגביל את משך הזמן שבו בקשה אחת, כמו שאילתה, קריאה או בקשת Commit, יכולה לפעול. אם הזמן הקצוב לתפוגה של עסקה ארוך יותר מהזמן הקצוב לתפוגה של RPC, הזמן הקצוב לתפוגה של RPC לא יוארך. מידע נוסף מופיע במאמר הגדרת זמן קצוב לתפוגה וניסיונות חוזרים בהתאמה אישית.
  • זמן קצוב לתפוגה של עסקה מגביל את משך הזמן הכולל שספריית הלקוח מקדישה להרצת עסקה של קריאה וכתיבה, כולל כל ניסיון שספריית הלקוח מבצעת אחרי ש-Spanner מבטל את העסקה.

כש-Spanner מבטל עסקה של קריאה וכתיבה, ספריית הלקוח מריצה מחדש את פונקציית העסקה. זמני קצובים קצרים של RPC לא מגבילים את משך הזמן שבו ספריית הלקוח ממשיכה לנסות מחדש עסקה שבוטלה. אם לא מגדירים זמן קצוב לתפוגה של טרנזקציה, התנהגות ברירת המחדל של הניסיונות החוזרים תלויה בספריית הלקוח:

  • ‫Java: מריץ הטרנזקציות מנסה שוב לבצע טרנזקציות שבוטלו במשך עד 24 שעות, ללא הגבלה על מספר הניסיונות.
  • ‫Go: ספריית הלקוח מנסה שוב לבצע עסקאות שבוטלו עד שהעסקה מתבצעת, או עד שהאובייקט context.Context שאתם מעבירים לעסקה מגיע למועד האחרון או מבוטל.
  • ‫Node.js: ספריית הלקוח מפסיקה לנסות שוב עסקאות שבוטלו אחרי שעה אחת (3600000 אלפיות השנייה). כדי לשנות את המגבלה הזו, מגדירים את השדה timeout באובייקט RunTransactionOptions שמעבירים ל-method‏ runTransaction או runTransactionAsync.
  • ‫Python: ספריית הלקוח מפסיקה לנסות מחדש טרנזקציות שבוטלו אחרי 30 שניות. כדי לשנות את המגבלה הזו, מעבירים את הארגומנט timeout_secs ל-method‏ run_in_transaction.

בעומסי עבודה עם תחרות גבוהה על נעילות, כל ניסיון חוזר מתחרה על אותן נעילות, כך שלולאת ניסיונות חוזרים ארוכה יכולה להאריך את זמני ההמתנה לנעילה של טרנזקציות אחרות. כדי להגביל את משך הזמן הכולל שבו טרנזקציה יכולה לפעול, מגדירים זמן קצוב לתפוגה של טרנזקציה, כמו שמוצג בדוגמאות שבדף הזה.

הגדרת זמן קצוב לתפוגה של עסקה

אפשר להגדיר זמן קצוב לתפוגה של עסקה באמצעות ספריות הלקוח של Go, ‏ Java, ‏ Python ו-Node.js.

המשך


import (
	"context"
	"errors"
	"fmt"
	"io"
	"time"

	"cloud.google.com/go/spanner"
	"google.golang.org/api/iterator"
	"google.golang.org/grpc/codes"
)

func transactionTimeout(w io.Writer, db string) error {
	ctx := context.Background()
	client, err := spanner.NewClient(ctx, db)
	if err != nil {
		return err
	}
	defer client.Close()

	// Create a context with a 60-second timeout and use this context to run a read/write transaction.
	// This context timeout will be applied to the entire transaction, and the transaction will fail
	// if it cannot finish within the specified timeout value. The Spanner client library applies the
	// (remainder of the) timeout to each statement that is executed in the transaction.
	ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
	defer cancel()

	_, err = client.ReadWriteTransaction(ctx, func(ctx context.Context, txn *spanner.ReadWriteTransaction) error {
		selectStmt := spanner.Statement{
			SQL: `SELECT SingerId, FirstName, LastName FROM Singers ORDER BY LastName, FirstName`,
		}
		// The context that is passed in to the transaction function should be used for each statement
		// is executed.
		iter := txn.Query(ctx, selectStmt)
		defer iter.Stop()
		for {
			row, err := iter.Next()
			if errors.Is(err, iterator.Done) {
				break
			}
			if err != nil {
				return err
			}
			var singerID int64
			var firstName, lastName string
			if err := row.Columns(&singerID, &firstName, &lastName); err != nil {
				return err
			}
			fmt.Fprintf(w, "%d %s %s\n", singerID, firstName, lastName)
		}
		stmt := spanner.Statement{
			SQL: `INSERT INTO Singers (SingerId, FirstName, LastName)
					VALUES (38, 'George', 'Washington')`,
		}
		rowCount, err := txn.Update(ctx, stmt)
		if err != nil {
			return err
		}
		fmt.Fprintf(w, "%d record(s) inserted.\n", rowCount)
		return nil
	})
	// Check if an error was returned by the transaction.
	// The spanner.ErrCode(err) function will return codes.OK if err == nil.
	code := spanner.ErrCode(err)
	if code == codes.OK {
		fmt.Fprintf(w, "Transaction with timeout was executed successfully\n")
	} else if code == codes.DeadlineExceeded {
		fmt.Fprintf(w, "Transaction timed out\n")
	} else {
		fmt.Fprintf(w, "Transaction failed with error code %v\n", code)
	}
	return err
}

Java


import com.google.cloud.spanner.DatabaseClient;
import com.google.cloud.spanner.DatabaseId;
import com.google.cloud.spanner.ResultSet;
import com.google.cloud.spanner.Spanner;
import com.google.cloud.spanner.SpannerOptions;
import com.google.cloud.spanner.Statement;
import io.grpc.Context;
import io.grpc.Context.CancellableContext;
import io.grpc.Deadline;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

/**
 * Sample showing how to set a timeout for an entire transaction for the Cloud Spanner Java client.
 */
class TransactionTimeoutExample {

  static void executeTransactionWithTimeout() {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "my-project";
    String instanceId = "my-instance";
    String databaseId = "my-database";

    executeTransactionWithTimeout(projectId, instanceId, databaseId, 60L, TimeUnit.SECONDS);
  }

  // Execute a read/write transaction with a timeout for the entire transaction.
  static void executeTransactionWithTimeout(
      String projectId,
      String instanceId,
      String databaseId,
      long timeoutValue,
      TimeUnit timeoutUnit) {
    try (Spanner spanner = SpannerOptions.newBuilder().setProjectId(projectId).build()
        .getService()) {
      DatabaseClient client =
          spanner.getDatabaseClient(DatabaseId.of(projectId, instanceId, databaseId));
      // Create a gRPC context with a deadline and with cancellation.
      // gRPC context deadlines require the use of a scheduled executor.
      ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor();
      try (CancellableContext context =
          Context.current()
              .withDeadline(Deadline.after(timeoutValue, timeoutUnit), executor)
              .withCancellation()) {
        context.run(
            () -> {
              client
                  .readWriteTransaction()
                  .run(
                      transaction -> {
                        try (ResultSet resultSet =
                            transaction.executeQuery(
                                Statement.of(
                                    "SELECT SingerId, FirstName, LastName\n"
                                        + "FROM Singers\n"
                                        + "ORDER BY LastName, FirstName"))) {
                          while (resultSet.next()) {
                            System.out.printf(
                                "%d %s %s\n",
                                resultSet.getLong("SingerId"),
                                resultSet.getString("FirstName"),
                                resultSet.getString("LastName"));
                          }
                        }
                        String sql =
                            "INSERT INTO Singers (SingerId, FirstName, LastName)\n"
                                + "VALUES (20, 'George', 'Washington')";
                        long rowCount = transaction.executeUpdate(Statement.of(sql));
                        System.out.printf("%d record inserted.%n", rowCount);
                        return null;
                      });
            });
      }
    }
  }
}

Node.js

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const projectId = 'my-project-id';
// const instanceId = 'my-instance';
// const databaseId = 'my-database';

// Imports the Google Cloud client library
const {Spanner} = require('@google-cloud/spanner');

// Creates a client
const spanner = new Spanner({
  projectId: projectId,
});

async function executeTransactionWithTimeout() {
  // Gets a reference to a Cloud Spanner instance and database.
  const instance = spanner.instance(instanceId);
  const database = instance.database(databaseId);

  const options = {
    timeout: 60000, // 60 seconds timeout
  };

  try {
    await database.runTransactionAsync(options, async tx => {
      const [results] = await tx.run(
        'SELECT SingerId, FirstName, LastName FROM Singers ORDER BY LastName, FirstName',
      );
      results.forEach(result => {
        console.log(
          `${result[0].name}: ${result[0].value.value}, ${result[1].name}: ${result[1].value}, ${result[2].name}: ${result[2].value}`,
        );
      });
      const sql =
        "INSERT INTO Singers (SingerId, FirstName, LastName) VALUES (100, 'George', 'Washington')";
      const [rowCount] = await tx.runUpdate(sql);
      console.log(`${rowCount} record inserted.`);
      await tx.commit();
    });
  } catch (err) {
    console.error('ERROR:', err);
  } finally {
    await database.close();
  }
}
executeTransactionWithTimeout();

Python

# instance_id = "your-spanner-instance"
# database_id = "your-spanner-db-id"
spanner_client = spanner.Client()
instance = spanner_client.instance(instance_id)
database = instance.database(database_id)

def read_then_write(transaction):
    # Read records.
    results = transaction.execute_sql(
        "SELECT SingerId, FirstName, LastName FROM Singers ORDER BY LastName, FirstName"
    )
    for result in results:
        print("SingerId: {}, FirstName: {}, LastName: {}".format(*result))

    # Insert a record.
    row_ct = transaction.execute_update(
        "INSERT INTO Singers (SingerId, FirstName, LastName) "
        " VALUES (100, 'George', 'Washington')"
    )
    print("{} record(s) inserted.".format(row_ct))

# configure transaction timeout to 60 seconds
database.run_in_transaction(read_then_write, timeout_secs=60)

הגדרת זמן קצוב לתפוגה של טרנזקציות Java אסינכרוניות

בדוגמה של Java בדף הזה, נעשה שימוש באובייקט Context של gRPC עם מועד אחרון להגדרת הזמן הקצוב לתפוגה של העסקה. האובייקט Context של gRPC מצורף ל-thread הנוכחי.

כשמריצים טרנזקציה באופן אסינכרוני באמצעות השיטה AsyncRunner.runAsync(), ספריית הלקוח מריצה את הטרנזקציה באובייקט Executor שאתם מספקים. ספריית הלקוח לא מעבירה לאותו executor את האובייקט Context של ה-thread שקורא, כולל המועד האחרון שלו. כתוצאה מכך, הטרנזקציה פועלת ללא זמן קצוב לתפוגה ויכולה להמשיך לנסות שוב ניסיונות שבוטלו במשך עד 24 שעות.

כדי להחיל את הזמן הקצוב לתפוגה על טרנזקציה אסינכרונית, מבצעים אחת מהפעולות הבאות:

  • עוטפים את ה-executor באמצעות קריאה ל-method‏ Context.currentContextExecutor(executor) בזמן שהאובייקט Context עם המועד האחרון הוא הנוכחי, ומעבירים את ה-executor העטוף ל-method‏ runAsync().
  • משתמשים בממשק AsyncTransactionManager או TransactionManager במקום בממשק AsyncRunner. כשמשתמשים במנהל טרנזקציות, כותבים את לולאת הניסיון החוזר בעצמכם ואפשר להפסיק את הניסיונות החוזרים כשתוקף הזמן הקצוב לתפוגה פג.