googleapis · ldetmer · Feb 25, 2025 · Feb 25, 2025 · Feb 25, 2025 · Feb 25, 2025
diff --git a/.cloudbuild/library_generation/library_generation.Dockerfile b/.cloudbuild/library_generation/library_generation.Dockerfile
@@ -51,7 +51,7 @@ FROM docker.io/library/python:3.13.2-alpine3.20@sha256:816feb29731cdee64b15b0ae9
 
 ARG OWLBOT_CLI_COMMITTISH=3a68a9c0de318784b3aefadcc502a6521b3f1bc5
 ARG PROTOC_VERSION=25.5
-ARG GRPC_VERSION=1.69.1
+ARG GRPC_VERSION=1.70.0
 ARG JAVA_FORMAT_VERSION=1.7
 ENV HOME=/home
 ENV OS_ARCHITECTURE="linux-x86_64"

diff --git a/gapic-generator-java-pom-parent/pom.xml b/gapic-generator-java-pom-parent/pom.xml
@@ -26,7 +26,7 @@
     <!-- External dependencies, especially gRPC and Protobuf version, should be
         consistent across modules in this repository -->
     <javax.annotation-api.version>1.3.2</javax.annotation-api.version>
-    <grpc.version>1.69.1</grpc.version>
+    <grpc.version>1.70.0</grpc.version>
     <google.auth.version>1.32.1</google.auth.version>
     <google.http-client.version>1.46.1</google.http-client.version>
     <gson.version>2.12.1</gson.version>

diff --git a/...otos/grpc-google-common-protos/src/main/java/com/google/cloud/location/LocationsGrpc.java b/...otos/grpc-google-common-protos/src/main/java/com/google/cloud/location/LocationsGrpc.java
@@ -134,6 +134,19 @@ public LocationsStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOp
     return LocationsStub.newStub(factory, channel);
   }
 
+  /** Creates a new blocking-style stub that supports all types of calls on the service */
+  public static LocationsBlockingV2Stub newBlockingV2Stub(io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<LocationsBlockingV2Stub> factory =
+        new io.grpc.stub.AbstractStub.StubFactory<LocationsBlockingV2Stub>() {
+          @java.lang.Override
+          public LocationsBlockingV2Stub newStub(
+              io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+            return new LocationsBlockingV2Stub(channel, callOptions);
+          }
+        };
+    return LocationsBlockingV2Stub.newStub(factory, channel);
+  }
+
   /**
    * Creates a new blocking-style stub that supports unary and streaming output calls on the service
    */
@@ -282,6 +295,54 @@ public void getLocation(
    * [Location.metadata][google.cloud.location.Location.metadata] field.
    * </pre>
    */
+  public static final class LocationsBlockingV2Stub
+      extends io.grpc.stub.AbstractBlockingStub<LocationsBlockingV2Stub> {
+    private LocationsBlockingV2Stub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected LocationsBlockingV2Stub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new LocationsBlockingV2Stub(channel, callOptions);
+    }
+
+    /**
+     *
+     *
+     * <pre>
+     * Lists information about the supported locations for this service.
+     * </pre>
+     */
+    public com.google.cloud.location.ListLocationsResponse listLocations(
+        com.google.cloud.location.ListLocationsRequest request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getListLocationsMethod(), getCallOptions(), request);
+    }
+
+    /**
+     *
+     *
+     * <pre>
+     * Gets information about a location.
+     * </pre>
+     */
+    public com.google.cloud.location.Location getLocation(
+        com.google.cloud.location.GetLocationRequest request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getGetLocationMethod(), getCallOptions(), request);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do limited synchronous rpc calls to service Locations.
+   *
+   * <pre>
+   * An abstract interface that provides location-related information for
+   * a service. Service-specific metadata is provided through the
+   * [Location.metadata][google.cloud.location.Location.metadata] field.
+   * </pre>
+   */
   public static final class LocationsBlockingStub
       extends io.grpc.stub.AbstractBlockingStub<LocationsBlockingStub> {
     private LocationsBlockingStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {

diff --git a/...protos/grpc-google-common-protos/src/main/java/com/google/longrunning/OperationsGrpc.java b/...protos/grpc-google-common-protos/src/main/java/com/google/longrunning/OperationsGrpc.java
@@ -262,6 +262,19 @@ public OperationsStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callO
     return OperationsStub.newStub(factory, channel);
   }
 
+  /** Creates a new blocking-style stub that supports all types of calls on the service */
+  public static OperationsBlockingV2Stub newBlockingV2Stub(io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<OperationsBlockingV2Stub> factory =
+        new io.grpc.stub.AbstractStub.StubFactory<OperationsBlockingV2Stub>() {
+          @java.lang.Override
+          public OperationsBlockingV2Stub newStub(
+              io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+            return new OperationsBlockingV2Stub(channel, callOptions);
+          }
+        };
+    return OperationsBlockingV2Stub.newStub(factory, channel);
+  }
+
   /**
    * Creates a new blocking-style stub that supports unary and streaming output calls on the service
    */
@@ -568,6 +581,122 @@ public void waitOperation(
    * developers can have a consistent client experience.
    * </pre>
    */
+  public static final class OperationsBlockingV2Stub
+      extends io.grpc.stub.AbstractBlockingStub<OperationsBlockingV2Stub> {
+    private OperationsBlockingV2Stub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected OperationsBlockingV2Stub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new OperationsBlockingV2Stub(channel, callOptions);
+    }
+
+    /**
+     *
+     *
+     * <pre>
+     * Lists operations that match the specified filter in the request. If the
+     * server doesn't support this method, it returns `UNIMPLEMENTED`.
+     * </pre>
+     */
+    public com.google.longrunning.ListOperationsResponse listOperations(
+        com.google.longrunning.ListOperationsRequest request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getListOperationsMethod(), getCallOptions(), request);
+    }
+
+    /**
+     *
+     *
+     * <pre>
+     * Gets the latest state of a long-running operation.  Clients can use this
+     * method to poll the operation result at intervals as recommended by the API
+     * service.
+     * </pre>
+     */
+    public com.google.longrunning.Operation getOperation(
+        com.google.longrunning.GetOperationRequest request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getGetOperationMethod(), getCallOptions(), request);
+    }
+
+    /**
+     *
+     *
+     * <pre>
+     * Deletes a long-running operation. This method indicates that the client is
+     * no longer interested in the operation result. It does not cancel the
+     * operation. If the server doesn't support this method, it returns
+     * `google.rpc.Code.UNIMPLEMENTED`.
+     * </pre>
+     */
+    public com.google.protobuf.Empty deleteOperation(
+        com.google.longrunning.DeleteOperationRequest request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getDeleteOperationMethod(), getCallOptions(), request);
+    }
+
+    /**
+     *
+     *
+     * <pre>
+     * Starts asynchronous cancellation on a long-running operation.  The server
+     * makes a best effort to cancel the operation, but success is not
+     * guaranteed.  If the server doesn't support this method, it returns
+     * `google.rpc.Code.UNIMPLEMENTED`.  Clients can use
+     * [Operations.GetOperation][google.longrunning.Operations.GetOperation] or
+     * other methods to check whether the cancellation succeeded or whether the
+     * operation completed despite cancellation. On successful cancellation,
+     * the operation is not deleted; instead, it becomes an operation with
+     * an [Operation.error][google.longrunning.Operation.error] value with a
+     * [google.rpc.Status.code][google.rpc.Status.code] of `1`, corresponding to
+     * `Code.CANCELLED`.
+     * </pre>
+     */
+    public com.google.protobuf.Empty cancelOperation(
+        com.google.longrunning.CancelOperationRequest request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getCancelOperationMethod(), getCallOptions(), request);
+    }
+
+    /**
+     *
+     *
+     * <pre>
+     * Waits until the specified long-running operation is done or reaches at most
+     * a specified timeout, returning the latest state.  If the operation is
+     * already done, the latest state is immediately returned.  If the timeout
+     * specified is greater than the default HTTP/RPC timeout, the HTTP/RPC
+     * timeout is used.  If the server does not support this method, it returns
+     * `google.rpc.Code.UNIMPLEMENTED`.
+     * Note that this method is on a best-effort basis.  It may return the latest
+     * state before the specified timeout (including immediately), meaning even an
+     * immediate response is no guarantee that the operation is done.
+     * </pre>
+     */
+    public com.google.longrunning.Operation waitOperation(
+        com.google.longrunning.WaitOperationRequest request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getWaitOperationMethod(), getCallOptions(), request);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do limited synchronous rpc calls to service Operations.
+   *
+   * <pre>
+   * Manages long-running operations with an API service.
+   * When an API method normally takes long time to complete, it can be designed
+   * to return [Operation][google.longrunning.Operation] to the client, and the
+   * client can use this interface to receive the real response asynchronously by
+   * polling the operation resource, or pass the operation resource to another API
+   * (such as Pub/Sub API) to receive the response.  Any API service that returns
+   * long-running operations should implement the `Operations` interface so
+   * developers can have a consistent client experience.
+   * </pre>
+   */
   public static final class OperationsBlockingStub
       extends io.grpc.stub.AbstractBlockingStub<OperationsBlockingStub> {
     private OperationsBlockingStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {

diff --git a/java-iam/grpc-google-iam-v1/src/main/java/com/google/iam/v1/IAMPolicyGrpc.java b/java-iam/grpc-google-iam-v1/src/main/java/com/google/iam/v1/IAMPolicyGrpc.java
@@ -183,6 +183,19 @@ public IAMPolicyStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOp
     return IAMPolicyStub.newStub(factory, channel);
   }
 
+  /** Creates a new blocking-style stub that supports all types of calls on the service */
+  public static IAMPolicyBlockingV2Stub newBlockingV2Stub(io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<IAMPolicyBlockingV2Stub> factory =
+        new io.grpc.stub.AbstractStub.StubFactory<IAMPolicyBlockingV2Stub>() {
+          @java.lang.Override
+          public IAMPolicyBlockingV2Stub newStub(
+              io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+            return new IAMPolicyBlockingV2Stub(channel, callOptions);
+          }
+        };
+    return IAMPolicyBlockingV2Stub.newStub(factory, channel);
+  }
+
   /**
    * Creates a new blocking-style stub that supports unary and streaming output calls on the service
    */
@@ -439,6 +452,89 @@ public void testIamPermissions(
    * attached.
    * </pre>
    */
+  public static final class IAMPolicyBlockingV2Stub
+      extends io.grpc.stub.AbstractBlockingStub<IAMPolicyBlockingV2Stub> {
+    private IAMPolicyBlockingV2Stub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected IAMPolicyBlockingV2Stub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new IAMPolicyBlockingV2Stub(channel, callOptions);
+    }
+
+    /**
+     *
+     *
+     * <pre>
+     * Sets the access control policy on the specified resource. Replaces any
+     * existing policy.
+     * Can return `NOT_FOUND`, `INVALID_ARGUMENT`, and `PERMISSION_DENIED` errors.
+     * </pre>
+     */
+    public com.google.iam.v1.Policy setIamPolicy(com.google.iam.v1.SetIamPolicyRequest request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getSetIamPolicyMethod(), getCallOptions(), request);
+    }
+
+    /**
+     *
+     *
+     * <pre>
+     * Gets the access control policy for a resource.
+     * Returns an empty policy if the resource exists and does not have a policy
+     * set.
+     * </pre>
+     */
+    public com.google.iam.v1.Policy getIamPolicy(com.google.iam.v1.GetIamPolicyRequest request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getGetIamPolicyMethod(), getCallOptions(), request);
+    }
+
+    /**
+     *
+     *
+     * <pre>
+     * Returns permissions that a caller has on the specified resource.
+     * If the resource does not exist, this will return an empty set of
+     * permissions, not a `NOT_FOUND` error.
+     * Note: This operation is designed to be used for building permission-aware
+     * UIs and command-line tools, not for authorization checking. This operation
+     * may "fail open" without warning.
+     * </pre>
+     */
+    public com.google.iam.v1.TestIamPermissionsResponse testIamPermissions(
+        com.google.iam.v1.TestIamPermissionsRequest request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getTestIamPermissionsMethod(), getCallOptions(), request);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do limited synchronous rpc calls to service IAMPolicy.
+   *
+   * <pre>
+   * API Overview
+   * Manages Identity and Access Management (IAM) policies.
+   * Any implementation of an API that offers access control features
+   * implements the google.iam.v1.IAMPolicy interface.
+   * ## Data model
+   * Access control is applied when a principal (user or service account), takes
+   * some action on a resource exposed by a service. Resources, identified by
+   * URI-like names, are the unit of access control specification. Service
+   * implementations can choose the granularity of access control and the
+   * supported permissions for their resources.
+   * For example one database service may allow access control to be
+   * specified only at the Table level, whereas another might allow access control
+   * to also be specified at the Column level.
+   * ## Policy Structure
+   * See google.iam.v1.Policy
+   * This is intentionally not a CRUD style API because access control policies
+   * are created and deleted implicitly with the resources to which they are
+   * attached.
+   * </pre>
+   */
   public static final class IAMPolicyBlockingStub
       extends io.grpc.stub.AbstractBlockingStub<IAMPolicyBlockingStub> {
     private IAMPolicyBlockingStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {