Package com.google.storage.v2

Class StorageGrpc.StorageStub

java.lang.Object
io.grpc.stub.AbstractStub<S>
io.grpc.stub.AbstractAsyncStub<StorageGrpc.StorageStub>
com.google.storage.v2.StorageGrpc.StorageStub
Enclosing class:
StorageGrpc
public static final class StorageGrpc.StorageStub extends io.grpc.stub.AbstractAsyncStub<StorageGrpc.StorageStub>
A stub to allow clients to do asynchronous rpc calls to service Storage. 
 ## API Overview and Naming Syntax
 The Cloud Storage gRPC API allows applications to read and write data through
 the abstractions of buckets and objects. For a description of these
 abstractions please see [Cloud Storage
 documentation](https://cloud.google.com/storage/docs).
 Resources are named as follows:
   - Projects are referred to as they are defined by the Resource Manager API,
     using strings like `projects/123456` or `projects/my-string-id`.
   - Buckets are named using string names of the form:
     `projects/{project}/buckets/{bucket}`.
     For globally unique buckets, `_` might be substituted for the project.
   - Objects are uniquely identified by their name along with the name of the
     bucket they belong to, as separate strings in this API. For example:
         ```
         ReadObjectRequest {
         bucket: 'projects/_/buckets/my-bucket'
         object: 'my-object'
         }
         ```
 Note that object names can contain `/` characters, which are treated as
 any other character (no special directory semantics).

  • Method Details

    • build

      protected StorageGrpc.StorageStub build(io.grpc.Channel channel, io.grpc.CallOptions callOptions)
      Specified by:
      build in class io.grpc.stub.AbstractStub<StorageGrpc.StorageStub>

    • deleteBucket

      public void deleteBucket(DeleteBucketRequest request, io.grpc.stub.StreamObserver<com.google.protobuf.Empty> responseObserver)
       Permanently deletes an empty bucket.
 The request fails if there are any live or
 noncurrent objects in the bucket, but the request succeeds if the
 bucket only contains soft-deleted objects or incomplete uploads, such
 as ongoing XML API multipart uploads. Does not permanently delete
 soft-deleted objects.
 When this API is used to delete a bucket containing an object that has a
 soft delete policy
 enabled, the object becomes soft deleted, and the
 `softDeleteTime` and `hardDeleteTime` properties are set on the
 object.
 Objects and multipart uploads that were in the bucket at the time of
 deletion are also retained for the specified retention duration. When
 a soft-deleted bucket reaches the end of its retention duration, it
 is permanently deleted. The `hardDeleteTime` of the bucket always
 equals
 or exceeds the expiration time of the last soft-deleted object in the
 bucket.
 **IAM Permissions**:
 Requires `storage.buckets.delete` IAM permission on the bucket.

    • getBucket

      public void getBucket(GetBucketRequest request, io.grpc.stub.StreamObserver<Bucket> responseObserver)
       Returns metadata for the specified bucket.
 **IAM Permissions**:
 Requires `storage.buckets.get`
 IAM permission on
 the bucket. Additionally, to return specific bucket metadata, the
 authenticated user must have the following permissions:
 - To return the IAM policies: `storage.buckets.getIamPolicy`
 - To return the bucket IP filtering rules: `storage.buckets.getIpFilter`

    • createBucket

      public void createBucket(CreateBucketRequest request, io.grpc.stub.StreamObserver<Bucket> responseObserver)
       Creates a new bucket.
 **IAM Permissions**:
 Requires `storage.buckets.create` IAM permission on the bucket.
 Additionally, to enable specific bucket features, the authenticated user
 must have the following permissions:
 - To enable object retention using the `enableObjectRetention` query
 parameter: `storage.buckets.enableObjectRetention`
 - To set the bucket IP filtering rules: `storage.buckets.setIpFilter`

    • listBuckets

      public void listBuckets(ListBucketsRequest request, io.grpc.stub.StreamObserver<ListBucketsResponse> responseObserver)
       Retrieves a list of buckets for a given project, ordered
 lexicographically by name.
 **IAM Permissions**:
 Requires `storage.buckets.list` IAM permission on the bucket.
 Additionally, to enable specific bucket features, the authenticated
 user must have the following permissions:
 - To list the IAM policies: `storage.buckets.getIamPolicy`
 - To list the bucket IP filtering rules: `storage.buckets.getIpFilter`

    • lockBucketRetentionPolicy

      public void lockBucketRetentionPolicy(LockBucketRetentionPolicyRequest request, io.grpc.stub.StreamObserver<Bucket> responseObserver)
       Permanently locks the retention
 policy that is
 currently applied to the specified bucket.
 Caution: Locking a bucket is an
 irreversible action. Once you lock a bucket:
 - You cannot remove the retention policy from the bucket.
 - You cannot decrease the retention period for the policy.
 Once locked, you must delete the entire bucket in order to remove the
 bucket's retention policy. However, before you can delete the bucket, you
 must delete all the objects in the bucket, which is only
 possible if all the objects have reached the retention period set by the
 retention policy.
 **IAM Permissions**:
 Requires `storage.buckets.update` IAM permission on the bucket.

    • getIamPolicy

      public void getIamPolicy(com.google.iam.v1.GetIamPolicyRequest request, io.grpc.stub.StreamObserver<com.google.iam.v1.Policy> responseObserver)
       Gets the IAM policy for a specified bucket or managed folder.
 The `resource` field in the request should be
 `projects/_/buckets/{bucket}` for a bucket, or
 `projects/_/buckets/{bucket}/managedFolders/{managedFolder}`
 for a managed folder.
 **IAM Permissions**:
 Requires `storage.buckets.getIamPolicy` on the bucket or
 `storage.managedFolders.getIamPolicy` IAM permission on the
 managed folder.

    • setIamPolicy

      public void setIamPolicy(com.google.iam.v1.SetIamPolicyRequest request, io.grpc.stub.StreamObserver<com.google.iam.v1.Policy> responseObserver)
       Updates an IAM policy for the specified bucket or managed folder.
 The `resource` field in the request should be
 `projects/_/buckets/{bucket}` for a bucket, or
 `projects/_/buckets/{bucket}/managedFolders/{managedFolder}`
 for a managed folder.

    • testIamPermissions

      public void testIamPermissions(com.google.iam.v1.TestIamPermissionsRequest request, io.grpc.stub.StreamObserver<com.google.iam.v1.TestIamPermissionsResponse> responseObserver)
       Tests a set of permissions on the given bucket, object, or managed folder
 to see which, if any, are held by the caller. The `resource` field in the
 request should be `projects/_/buckets/{bucket}` for a bucket,
 `projects/_/buckets/{bucket}/objects/{object}` for an object, or
 `projects/_/buckets/{bucket}/managedFolders/{managedFolder}`
 for a managed folder.

    • updateBucket

      public void updateBucket(UpdateBucketRequest request, io.grpc.stub.StreamObserver<Bucket> responseObserver)
       Updates a bucket. Changes to the bucket are readable immediately after
 writing, but configuration changes might take time to propagate. This
 method supports `patch` semantics.
 **IAM Permissions**:
 Requires `storage.buckets.update` IAM permission on the bucket.
 Additionally, to enable specific bucket features, the authenticated user
 must have the following permissions:
 - To set bucket IP filtering rules: `storage.buckets.setIpFilter`
 - To update public access prevention policies or access control lists
 (ACLs): `storage.buckets.setIamPolicy`

    • composeObject

      public void composeObject(ComposeObjectRequest request, io.grpc.stub.StreamObserver<Object> responseObserver)
       Concatenates a list of existing objects into a new object in the same
 bucket. The existing source objects are unaffected by this operation.
 **IAM Permissions**:
 Requires the `storage.objects.create` and `storage.objects.get` IAM
 permissions to use this method. If the new composite object
 overwrites an existing object, the authenticated user must also have
 the `storage.objects.delete` permission. If the request body includes
 the retention property, the authenticated user must also have the
 `storage.objects.setRetention` IAM permission.

    • deleteObject

      public void deleteObject(DeleteObjectRequest request, io.grpc.stub.StreamObserver<com.google.protobuf.Empty> responseObserver)
       Deletes an object and its metadata. Deletions are permanent if versioning
 is not enabled for the bucket, or if the generation parameter is used, or
 if soft delete is not
 enabled for the bucket.
 When this API is used to delete an object from a bucket that has soft
 delete policy enabled, the object becomes soft deleted, and the
 `softDeleteTime` and `hardDeleteTime` properties are set on the object.
 This API cannot be used to permanently delete soft-deleted objects.
 Soft-deleted objects are permanently deleted according to their
 `hardDeleteTime`.
 You can use the [`RestoreObject`][google.storage.v2.Storage.RestoreObject]
 API to restore soft-deleted objects until the soft delete retention period
 has passed.
 **IAM Permissions**:
 Requires `storage.objects.delete` IAM permission on the bucket.

    • restoreObject

      public void restoreObject(RestoreObjectRequest request, io.grpc.stub.StreamObserver<Object> responseObserver)
       Restores a
 soft-deleted object.
 When a soft-deleted object is restored, a new copy of that object is
 created in the same bucket and inherits the same metadata as the
 soft-deleted object. The inherited metadata is the metadata that existed
 when the original object became soft deleted, with the following
 exceptions:
   - The `createTime` of the new object is set to the time at which the
   soft-deleted object was restored.
   - The `softDeleteTime` and `hardDeleteTime` values are cleared.
   - A new generation is assigned and the metageneration is reset to 1.
   - If the soft-deleted object was in a bucket that had Autoclass enabled,
   the new object is
     restored to Standard storage.
   - The restored object inherits the bucket's default object ACL, unless
   `copySourceAcl` is `true`.
 If a live object using the same name already exists in the bucket and
 becomes overwritten, the live object becomes a noncurrent object if Object
 Versioning is enabled on the bucket. If Object Versioning is not enabled,
 the live object becomes soft deleted.
 **IAM Permissions**:
 Requires the following IAM permissions to use this method:
   - `storage.objects.restore`
   - `storage.objects.create`
   - `storage.objects.delete` (only required if overwriting an existing
   object)
   - `storage.objects.getIamPolicy` (only required if `projection` is `full`
   and the relevant bucket
     has uniform bucket-level access disabled)
   - `storage.objects.setIamPolicy` (only required if `copySourceAcl` is
   `true` and the relevant
     bucket has uniform bucket-level access disabled)

    • cancelResumableWrite

      public void cancelResumableWrite(CancelResumableWriteRequest request, io.grpc.stub.StreamObserver<CancelResumableWriteResponse> responseObserver)
       Cancels an in-progress resumable upload.
 Any attempts to write to the resumable upload after cancelling the upload
 fail.
 The behavior for any in-progress write operations is not guaranteed;
 they could either complete before the cancellation or fail if the
 cancellation completes first.

    • getObject

      public void getObject(GetObjectRequest request, io.grpc.stub.StreamObserver<Object> responseObserver)
       Retrieves object metadata.
 **IAM Permissions**:
 Requires `storage.objects.get` IAM permission on the bucket.
 To return object ACLs, the authenticated user must also have
 the `storage.objects.getIamPolicy` permission.

    • readObject

      public void readObject(ReadObjectRequest request, io.grpc.stub.StreamObserver<ReadObjectResponse> responseObserver)
       Retrieves object data.
 **IAM Permissions**:
 Requires `storage.objects.get` IAM permission on the bucket.

    • bidiReadObject

      public io.grpc.stub.StreamObserver<BidiReadObjectRequest> bidiReadObject(io.grpc.stub.StreamObserver<BidiReadObjectResponse> responseObserver)
       Reads an object's data.
 This bi-directional API reads data from an object, allowing you to request
 multiple data ranges within a single stream, even across several messages.
 If an error occurs with any request, the stream closes with a relevant
 error code. Since you can have multiple outstanding requests, the error
 response includes a `BidiReadObjectError` proto in its `details` field,
 reporting the specific error, if any, for each pending `read_id`.
 **IAM Permissions**:
 Requires `storage.objects.get` IAM permission on the bucket.

    • updateObject

      public void updateObject(UpdateObjectRequest request, io.grpc.stub.StreamObserver<Object> responseObserver)
       Updates an object's metadata.
 Equivalent to JSON API's `storage.objects.patch` method.
 **IAM Permissions**:
 Requires `storage.objects.update` IAM permission on the bucket.

    • writeObject

      public io.grpc.stub.StreamObserver<WriteObjectRequest> writeObject(io.grpc.stub.StreamObserver<WriteObjectResponse> responseObserver)
       Stores a new object and metadata.
 An object can be written either in a single message stream or in a
 resumable sequence of message streams. To write using a single stream,
 the client should include in the first message of the stream an
 `WriteObjectSpec` describing the destination bucket, object, and any
 preconditions. Additionally, the final message must set 'finish_write' to
 true, or else it is an error.
 For a resumable write, the client should instead call
 `StartResumableWrite()`, populating a `WriteObjectSpec` into that request.
 They should then attach the returned `upload_id` to the first message of
 each following call to `WriteObject`. If the stream is closed before
 finishing the upload (either explicitly by the client or due to a network
 error or an error response from the server), the client should do as
 follows:
   - Check the result Status of the stream, to determine if writing can be
     resumed on this stream or must be restarted from scratch (by calling
     `StartResumableWrite()`). The resumable errors are `DEADLINE_EXCEEDED`,
     `INTERNAL`, and `UNAVAILABLE`. For each case, the client should use
     binary exponential backoff before retrying.  Additionally, writes can
     be resumed after `RESOURCE_EXHAUSTED` errors, but only after taking
     appropriate measures, which might include reducing aggregate send rate
     across clients and/or requesting a quota increase for your project.
   - If the call to `WriteObject` returns `ABORTED`, that indicates
     concurrent attempts to update the resumable write, caused either by
     multiple racing clients or by a single client where the previous
     request was timed out on the client side but nonetheless reached the
     server. In this case the client should take steps to prevent further
     concurrent writes. For example, increase the timeouts and stop using
     more than one process to perform the upload. Follow the steps below for
     resuming the upload.
   - For resumable errors, the client should call `QueryWriteStatus()` and
     then continue writing from the returned `persisted_size`. This might be
     less than the amount of data the client previously sent. Note also that
     it is acceptable to send data starting at an offset earlier than the
     returned `persisted_size`; in this case, the service skips data at
     offsets that were already persisted (without checking that it matches
     the previously written data), and write only the data starting from the
     persisted offset. Even though the data isn't written, it might still
     incur a performance cost over resuming at the correct write offset.
     This behavior can make client-side handling simpler in some cases.
   - Clients must only send data that is a multiple of 256 KiB per message,
     unless the object is being finished with `finish_write` set to `true`.
 The service does not view the object as complete until the client has
 sent a `WriteObjectRequest` with `finish_write` set to `true`. Sending any
 requests on a stream after sending a request with `finish_write` set to
 `true` causes an error. The client must check the response it
 receives to determine how much data the service is able to commit and
 whether the service views the object as complete.
 Attempting to resume an already finalized object results in an `OK`
 status, with a `WriteObjectResponse` containing the finalized object's
 metadata.
 Alternatively, you can use the `BidiWriteObject` operation to write an
 object with controls over flushing and the ability to fetch the ability to
 determine the current persisted size.
 **IAM Permissions**:
 Requires `storage.objects.create`
 IAM permission on
 the bucket.

    • bidiWriteObject

      public io.grpc.stub.StreamObserver<BidiWriteObjectRequest> bidiWriteObject(io.grpc.stub.StreamObserver<BidiWriteObjectResponse> responseObserver)
       Stores a new object and metadata.
 This is similar to the `WriteObject` call with the added support for
 manual flushing of persisted state, and the ability to determine current
 persisted size without closing the stream.
 The client might specify one or both of the `state_lookup` and `flush`
 fields in each `BidiWriteObjectRequest`. If `flush` is specified, the data
 written so far is persisted to storage. If `state_lookup` is specified, the
 service responds with a `BidiWriteObjectResponse` that contains the
 persisted size. If both `flush` and `state_lookup` are specified, the flush
 always occurs before a `state_lookup`, so that both might be set in the
 same request and the returned state is the state of the object
 post-flush. When the stream is closed, a `BidiWriteObjectResponse`
 is always sent to the client, regardless of the value of `state_lookup`.

    • listObjects

      public void listObjects(ListObjectsRequest request, io.grpc.stub.StreamObserver<ListObjectsResponse> responseObserver)
       Retrieves a list of objects matching the criteria.
 **IAM Permissions**:
 The authenticated user requires `storage.objects.list`
 IAM permission to use this method. To return object ACLs, the
 authenticated user must also
 have the `storage.objects.getIamPolicy` permission.

    • rewriteObject

      public void rewriteObject(RewriteObjectRequest request, io.grpc.stub.StreamObserver<RewriteResponse> responseObserver)
       Rewrites a source object to a destination object. Optionally overrides
 metadata.

    • startResumableWrite

      public void startResumableWrite(StartResumableWriteRequest request, io.grpc.stub.StreamObserver<StartResumableWriteResponse> responseObserver)
       Starts a resumable write operation. This
 method is part of the Resumable
 upload feature.
 This allows you to upload large objects in multiple chunks, which is more
 resilient to network interruptions than a single upload. The validity
 duration of the write operation, and the consequences of it becoming
 invalid, are service-dependent.
 **IAM Permissions**:
 Requires `storage.objects.create` IAM permission on the bucket.

    • queryWriteStatus

      public void queryWriteStatus(QueryWriteStatusRequest request, io.grpc.stub.StreamObserver<QueryWriteStatusResponse> responseObserver)
       Determines the `persisted_size` of an object that is being written. This
 method is part of the resumable
 upload feature.
 The returned value is the size of the object that has been persisted so
 far. The value can be used as the `write_offset` for the next `Write()`
 call.
 If the object does not exist, meaning if it was deleted, or the
 first `Write()` has not yet reached the service, this method returns the
 error `NOT_FOUND`.
 This method is useful for clients that buffer data and need to know which
 data can be safely evicted. The client can call `QueryWriteStatus()` at any
 time to determine how much data has been logged for this object.
 For any sequence of `QueryWriteStatus()` calls for a given
 object name, the sequence of returned `persisted_size` values are
 non-decreasing.

    • moveObject

      public void moveObject(MoveObjectRequest request, io.grpc.stub.StreamObserver<Object> responseObserver)
       Moves the source object to the destination object in the same bucket.
 This operation moves a source object to a destination object in the
 same bucket by renaming the object. The move itself is an atomic
 transaction, ensuring all steps either complete successfully or no
 changes are made.
 **IAM Permissions**:
 Requires the following IAM permissions to use this method:
   - `storage.objects.move`
   - `storage.objects.create`
   - `storage.objects.delete` (only required if overwriting an existing
   object)