Integrate App Engine Task Queue API with Google Cloud Tasks v2 for GA.

Routes App Engine push queue operations to Google Cloud Tasks v2 when the APPENGINE_USE_CLOUDTASK_PUSH_QUEUE environment variable is enabled, while retaining v2beta3 for QueueStatistics.
Key changes include:
- Adding CloudTasksClientWrapper to handle task creation, batch creation, deletion, batch deletion, and queue purging using the Cloud Tasks v2 gRPC client SDK (with v2beta3 retained for QueueStatistics).
- Implementing transactional task queuing via a Datastore-backed buffer (_AE_PendingCloudTask) and a background sweeper (SweeperServlet and TaskProcessor) using the Cloud Tasks v2 gRPC client SDK.
- Updating QueueImpl and TaskHandle to delegate push queue operations to the Cloud Tasks integration.
- Updating Maven and Bazel build files to include the required Google Cloud Tasks, GAX, and proto dependencies.

PiperOrigin-RevId: 999953510
Change-Id: I17726a56170136cb7fcdc11949c8555ac62f9ca1

Author: gae-java-bot

api/pom.xml

@@ -122,6 +122,10 @@
       <groupId>javax.servlet</groupId>
       <artifactId>javax.servlet-api</artifactId>
     </dependency>
+    <dependency>
+      <groupId>com.google.cloud</groupId>
+      <artifactId>google-cloud-tasks</artifactId>
+    </dependency>
     <dependency>
       <groupId>org.antlr</groupId>
       <artifactId>antlr-runtime</artifactId>

api/src/main/java/com/google/appengine/api/datastore/DatastoreApiHelper.java

@@ -31,7 +31,9 @@
 import com.google.rpc.Code;
 import java.util.ConcurrentModificationException;
 import java.util.List;
+import java.util.Objects;
 import java.util.concurrent.Future;
+import org.jspecify.annotations.Nullable;
 
 /**
  * Helper methods and constants shared by classes that implement the Java api on top of the
@@ -56,6 +58,64 @@ public final class DatastoreApiHelper {
 
   private DatastoreApiHelper() {}
 
+  /**
+   * Registers a callback to be executed immediately after the specified transaction commits. If the
+   * transaction is rolled back or fails to commit, the callback will not be invoked.
+   *
+   * <p>Transactions wrapped by frameworks (for example Objectify) are resolved to the native
+   * transaction active on the current thread with the same app and transaction ID.
+   *
+   * @return {@code true} if the callback was registered, {@code false} if the native transaction
+   *     could not be resolved
+   */
+  public static boolean addPostCommitCallback(Transaction txn, Runnable callback) {
+    if (callback == null) {
+      return false;
+    }
+    TransactionImpl txnImpl = resolveTransactionImpl(txn);
+    if (txnImpl == null) {
+      return false;
+    }
+    txnImpl.addPostCommitCallback(callback);
+    return true;
+  }
+
+  /**
+   * Returns the native transaction backing {@code txn}, or {@code txn} itself if it cannot be
+   * resolved.
+   */
+  public static Transaction unwrapTransaction(Transaction txn) {
+    TransactionImpl txnImpl = resolveTransactionImpl(txn);
+    return txnImpl != null ? txnImpl : txn;
+  }
+
+  private static @Nullable TransactionImpl resolveTransactionImpl(@Nullable Transaction txn) {
+    if (txn == null) {
+      return null;
+    }
+    if (txn instanceof TransactionImpl txnImpl) {
+      return txnImpl;
+    }
+    try {
+      String id = txn.getId();
+      String app = txn.getApp();
+      if (id == null) {
+        return null;
+      }
+      for (Transaction active :
+          DatastoreServiceFactory.getDatastoreService().getActiveTransactions()) {
+        if (active instanceof TransactionImpl activeImpl
+            && id.equals(activeImpl.getId())
+            && Objects.equals(app, activeImpl.getApp())) {
+          return activeImpl;
+        }
+      }
+    } catch (RuntimeException e) {
+      // Wrapped transaction could not be resolved; fall through.
+    }
+    return null;
+  }
+
   // Corresponds to _ToDatastoreError in datastore.py.
   // Keep in sync!
   public static RuntimeException translateError(ApiProxy.ApplicationException exception) {

api/src/main/java/com/google/appengine/api/datastore/TransactionImpl.java

@@ -81,6 +81,13 @@ enum TransactionState {
 
   TransactionState state = TransactionState.BEGUN;
 
+  private final List<Runnable> postCommitCallbacks =
+      new java.util.concurrent.CopyOnWriteArrayList<>();
+
+  void addPostCommitCallback(Runnable callback) {
+    postCommitCallbacks.add(callback);
+  }
+
   /** A {@link PostOpFuture} implementation that runs both post put and post delete callbacks. */
   private class PostCommitFuture extends PostOpFuture<Void> {
     private final List<Entity> putEntities;
@@ -100,6 +107,13 @@ void executeCallbacks(Void ignoreMe) {
       DeleteContext deleteContext =
           new DeleteContext(TransactionImpl.this, TransactionImpl.this, deletedKeys);
       callbacks.executePostDeleteCallbacks(deleteContext);
+      for (Runnable callback : postCommitCallbacks) {
+        try {
+          callback.run();
+        } catch (Throwable t) {
+          logger.log(Level.SEVERE, "Exception in post-commit callback: " + t.getMessage(), t);
+        }
+      }
     }
   }