com.google.storage.v2

Class StorageGrpc.StorageImplBase

java.lang.Object

com.google.storage.v2.StorageGrpc.StorageImplBase

All Implemented Interfaces:

io.grpc.BindableService

Enclosing class:

StorageGrpc

public abstract static class StorageGrpc.StorageImplBase
extends Object
implements io.grpc.BindableService

 ## API Overview and Naming Syntax
 The GCS gRPC API allows applications to read and write data through the
 abstractions of buckets and objects. For a description of these abstractions
 please see 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, `_` may 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).
 

Constructor Summary

Constructors

Constructor and Description
StorageImplBase()

Method Summary

Modifier and Type	Method and Description
io.grpc.ServerServiceDefinition	bindService()
void	queryWriteStatus(QueryWriteStatusRequest request, io.grpc.stub.StreamObserver<QueryWriteStatusResponse> responseObserver) Determines the `persisted_size` for an object that is being written, which can then be used as the `write_offset` for the next `Write()` call.
void	readObject(ReadObjectRequest request, io.grpc.stub.StreamObserver<ReadObjectResponse> responseObserver) Reads an object's data.
void	startResumableWrite(StartResumableWriteRequest request, io.grpc.stub.StreamObserver<StartResumableWriteResponse> responseObserver) Starts a resumable write.
io.grpc.stub.StreamObserver<WriteObjectRequest>	writeObject(io.grpc.stub.StreamObserver<WriteObjectResponse> responseObserver) Stores a new object and metadata.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

StorageImplBase

public StorageImplBase()

Method Detail

readObject

public void readObject(ReadObjectRequest request,
                       io.grpc.stub.StreamObserver<ReadObjectResponse> responseObserver)

 Reads an object's data.
 

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()` and provide that method an `WriteObjectSpec.`
 They should then attach the returned `upload_id` to the first message of
 each following call to `Create`. If there is an error or the connection is
 broken during the resumable `Create()`, the client should check the status
 of the `Create()` by calling `QueryWriteStatus()` and continue writing from
 the returned `persisted_size`. This may be less than the amount of data the
 client previously sent.
 The service will 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` will cause an error. The client **should** check the response it
 receives to determine how much data the service was able to commit and
 whether the service views the object as complete.
 

startResumableWrite

public void startResumableWrite(StartResumableWriteRequest request,
                                io.grpc.stub.StreamObserver<StartResumableWriteResponse> responseObserver)

 Starts a resumable write. How long the write operation remains valid, and
 what happens when the write operation becomes invalid, are
 service-dependent.
 

queryWriteStatus

public void queryWriteStatus(QueryWriteStatusRequest request,
                             io.grpc.stub.StreamObserver<QueryWriteStatusResponse> responseObserver)

 Determines the `persisted_size` for an object that is being written, which
 can then be used as the `write_offset` for the next `Write()` call.
 If the object does not exist (i.e., the object has been deleted, or the
 first `Write()` has not yet reached the service), this method returns the
 error `NOT_FOUND`.
 The client **may** call `QueryWriteStatus()` at any time to determine how
 much data has been processed for this object. This is useful if the
 client is buffering data and needs to know which data can be safely
 evicted. For any sequence of `QueryWriteStatus()` calls for a given
 object name, the sequence of returned `persisted_size` values will be
 non-decreasing.
 

bindService

public final io.grpc.ServerServiceDefinition bindService()

Specified by:

bindService in interface io.grpc.BindableService