Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
* #### Introduction
* The Log Stream API manages LogStream resources which are used to stream
* writes and reads of an ordered sequence of bytes of unknown eventual length.
* Note that this is an API Interface and not an API Service, per the definitons
* at: https://cloud.google.com/apis/design/glossary
* Log Stream API supports the reading of unfinalized LogStreams either by
* seeking or in "tail" mode, for example by end-users browsing to a build
* result UI interested in seeing logs from a build action as soon as they are
* (or as they become) available.
* Reads and Writes of LogStreams are done via the Byte Stream API:
* https://cloud.google.com/dataproc/docs/reference/rpc/google.bytestream
* https://github.com/googleapis/googleapis/blob/master/google/bytestream/bytestream.proto
* #### Writing LogStreams
* LogStreams are written to via the Byte Stream API's `Write` RPC. Bytes
* written to LogStreams are expected to be committed and available for reading
* within a reasonable period of time (implementation-defined). Committed bytes
* to a LogStream cannot be overwritten, and finalized LogStreams - indicated by
* setting `finish_write` field in the final WriteRequest - also cannot be
* appended to.
* When calling the Byte Stream API's `Write` RPC to write LogStreams, writers
* must pass the `write_resource_name` of a LogStream as
* `ByteStream.WriteRequest.resource_name` rather than the LogStream's `name`.
* Separate resource names for reading and writing allows for broadcasting the
* read resource name widely while simultaneously ensuring that only writer(s)
* with knowledge of the write resource name may have written bytes to the
* LogStream.
* #### Reading LogStreams
* Use the Byte Stream API's `Read` RPC to read LogStreams. When reading
* finalized LogStreams the server will stream all contents of the LogStream
* starting at `ByteStream.ReadRequest.read_offset`.
* When reading unfinalized LogStreams the server must keep the streaming
* `ByteStream.Read` RPC open and send `ByteStream.ReadResponse` messages as
* more bytes become available or the LogStream is finalized.
* #### Example Multi-Party Read/Write Flow
* 1. LogStream Writer calls `CreateLogStream`
* 2. LogStream Writer publishes `LogStream.name`
* 3. LogStream Writer calls `ByteStream.Write` with
* `LogStream.write_resource_name` as
* `ByteStream.WriteRequest.resource_name`,
* `ByteStream.WriteRequest.finish_write`=false.
* 4. LogStream Reader(s) call `ByteStream.Read` with the published
* `LogStream.name` as `ByteStream.ReadRequest.resource_name`.
* 5. LogStream Service streams all committed bytes to LogStream Reader(s),
* leave the stream open.
* 6. LogStream Writer calls `ByteStream.Write` with
* `LogStream.write_resource_name` as
* `ByteStream.WriteRequest.resource_name`,
* `ByteStream.WriteRequest.finish_write`=true.
* 7. LogStream Service streams all remaining bytes to LogStream Reader(s),
* terminates the stream.
*
*/
@javax.annotation.Generated(
value = "by gRPC proto compiler (version 1.65.0)",
comments = "Source: build/bazel/remote/logstream/v1/remote_logstream.proto")
@io.grpc.stub.annotations.GrpcGenerated
public final class LogStreamServiceGrpc {
private LogStreamServiceGrpc() {}
public static final java.lang.String SERVICE_NAME = "build.bazel.remote.logstream.v1.LogStreamService";
// Static method descriptors that strictly reflect the proto.
private static volatile io.grpc.MethodDescriptor getCreateLogStreamMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "CreateLogStream",
requestType = build.bazel.remote.logstream.v1.CreateLogStreamRequest.class,
responseType = build.bazel.remote.logstream.v1.LogStream.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getCreateLogStreamMethod() {
io.grpc.MethodDescriptor getCreateLogStreamMethod;
if ((getCreateLogStreamMethod = LogStreamServiceGrpc.getCreateLogStreamMethod) == null) {
synchronized (LogStreamServiceGrpc.class) {
if ((getCreateLogStreamMethod = LogStreamServiceGrpc.getCreateLogStreamMethod) == null) {
LogStreamServiceGrpc.getCreateLogStreamMethod = getCreateLogStreamMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "CreateLogStream"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
build.bazel.remote.logstream.v1.CreateLogStreamRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
build.bazel.remote.logstream.v1.LogStream.getDefaultInstance()))
.setSchemaDescriptor(new LogStreamServiceMethodDescriptorSupplier("CreateLogStream"))
.build();
}
}
}
return getCreateLogStreamMethod;
}
/**
* Creates a new async stub that supports all call types for the service
*/
public static LogStreamServiceStub newStub(io.grpc.Channel channel) {
io.grpc.stub.AbstractStub.StubFactory factory =
new io.grpc.stub.AbstractStub.StubFactory() {
@java.lang.Override
public LogStreamServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
return new LogStreamServiceStub(channel, callOptions);
}
};
return LogStreamServiceStub.newStub(factory, channel);
}
/**
* Creates a new blocking-style stub that supports unary and streaming output calls on the service
*/
public static LogStreamServiceBlockingStub newBlockingStub(
io.grpc.Channel channel) {
io.grpc.stub.AbstractStub.StubFactory factory =
new io.grpc.stub.AbstractStub.StubFactory() {
@java.lang.Override
public LogStreamServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
return new LogStreamServiceBlockingStub(channel, callOptions);
}
};
return LogStreamServiceBlockingStub.newStub(factory, channel);
}
/**
* Creates a new ListenableFuture-style stub that supports unary calls on the service
*/
public static LogStreamServiceFutureStub newFutureStub(
io.grpc.Channel channel) {
io.grpc.stub.AbstractStub.StubFactory factory =
new io.grpc.stub.AbstractStub.StubFactory() {
@java.lang.Override
public LogStreamServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
return new LogStreamServiceFutureStub(channel, callOptions);
}
};
return LogStreamServiceFutureStub.newStub(factory, channel);
}
/**
*
* #### Introduction
* The Log Stream API manages LogStream resources which are used to stream
* writes and reads of an ordered sequence of bytes of unknown eventual length.
* Note that this is an API Interface and not an API Service, per the definitons
* at: https://cloud.google.com/apis/design/glossary
* Log Stream API supports the reading of unfinalized LogStreams either by
* seeking or in "tail" mode, for example by end-users browsing to a build
* result UI interested in seeing logs from a build action as soon as they are
* (or as they become) available.
* Reads and Writes of LogStreams are done via the Byte Stream API:
* https://cloud.google.com/dataproc/docs/reference/rpc/google.bytestream
* https://github.com/googleapis/googleapis/blob/master/google/bytestream/bytestream.proto
* #### Writing LogStreams
* LogStreams are written to via the Byte Stream API's `Write` RPC. Bytes
* written to LogStreams are expected to be committed and available for reading
* within a reasonable period of time (implementation-defined). Committed bytes
* to a LogStream cannot be overwritten, and finalized LogStreams - indicated by
* setting `finish_write` field in the final WriteRequest - also cannot be
* appended to.
* When calling the Byte Stream API's `Write` RPC to write LogStreams, writers
* must pass the `write_resource_name` of a LogStream as
* `ByteStream.WriteRequest.resource_name` rather than the LogStream's `name`.
* Separate resource names for reading and writing allows for broadcasting the
* read resource name widely while simultaneously ensuring that only writer(s)
* with knowledge of the write resource name may have written bytes to the
* LogStream.
* #### Reading LogStreams
* Use the Byte Stream API's `Read` RPC to read LogStreams. When reading
* finalized LogStreams the server will stream all contents of the LogStream
* starting at `ByteStream.ReadRequest.read_offset`.
* When reading unfinalized LogStreams the server must keep the streaming
* `ByteStream.Read` RPC open and send `ByteStream.ReadResponse` messages as
* more bytes become available or the LogStream is finalized.
* #### Example Multi-Party Read/Write Flow
* 1. LogStream Writer calls `CreateLogStream`
* 2. LogStream Writer publishes `LogStream.name`
* 3. LogStream Writer calls `ByteStream.Write` with
* `LogStream.write_resource_name` as
* `ByteStream.WriteRequest.resource_name`,
* `ByteStream.WriteRequest.finish_write`=false.
* 4. LogStream Reader(s) call `ByteStream.Read` with the published
* `LogStream.name` as `ByteStream.ReadRequest.resource_name`.
* 5. LogStream Service streams all committed bytes to LogStream Reader(s),
* leave the stream open.
* 6. LogStream Writer calls `ByteStream.Write` with
* `LogStream.write_resource_name` as
* `ByteStream.WriteRequest.resource_name`,
* `ByteStream.WriteRequest.finish_write`=true.
* 7. LogStream Service streams all remaining bytes to LogStream Reader(s),
* terminates the stream.
*
*/
public interface AsyncService {
/**
*
* Create a LogStream which may be written to.
* The returned LogStream resource name will include a `write_resource_name`
* which is the resource to use when writing to the LogStream.
* Callers of CreateLogStream are expected to NOT publish the
* `write_resource_name`.
*
*/
default void createLogStream(build.bazel.remote.logstream.v1.CreateLogStreamRequest request,
io.grpc.stub.StreamObserver responseObserver) {
io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getCreateLogStreamMethod(), responseObserver);
}
}
/**
* Base class for the server implementation of the service LogStreamService.
*
* #### Introduction
* The Log Stream API manages LogStream resources which are used to stream
* writes and reads of an ordered sequence of bytes of unknown eventual length.
* Note that this is an API Interface and not an API Service, per the definitons
* at: https://cloud.google.com/apis/design/glossary
* Log Stream API supports the reading of unfinalized LogStreams either by
* seeking or in "tail" mode, for example by end-users browsing to a build
* result UI interested in seeing logs from a build action as soon as they are
* (or as they become) available.
* Reads and Writes of LogStreams are done via the Byte Stream API:
* https://cloud.google.com/dataproc/docs/reference/rpc/google.bytestream
* https://github.com/googleapis/googleapis/blob/master/google/bytestream/bytestream.proto
* #### Writing LogStreams
* LogStreams are written to via the Byte Stream API's `Write` RPC. Bytes
* written to LogStreams are expected to be committed and available for reading
* within a reasonable period of time (implementation-defined). Committed bytes
* to a LogStream cannot be overwritten, and finalized LogStreams - indicated by
* setting `finish_write` field in the final WriteRequest - also cannot be
* appended to.
* When calling the Byte Stream API's `Write` RPC to write LogStreams, writers
* must pass the `write_resource_name` of a LogStream as
* `ByteStream.WriteRequest.resource_name` rather than the LogStream's `name`.
* Separate resource names for reading and writing allows for broadcasting the
* read resource name widely while simultaneously ensuring that only writer(s)
* with knowledge of the write resource name may have written bytes to the
* LogStream.
* #### Reading LogStreams
* Use the Byte Stream API's `Read` RPC to read LogStreams. When reading
* finalized LogStreams the server will stream all contents of the LogStream
* starting at `ByteStream.ReadRequest.read_offset`.
* When reading unfinalized LogStreams the server must keep the streaming
* `ByteStream.Read` RPC open and send `ByteStream.ReadResponse` messages as
* more bytes become available or the LogStream is finalized.
* #### Example Multi-Party Read/Write Flow
* 1. LogStream Writer calls `CreateLogStream`
* 2. LogStream Writer publishes `LogStream.name`
* 3. LogStream Writer calls `ByteStream.Write` with
* `LogStream.write_resource_name` as
* `ByteStream.WriteRequest.resource_name`,
* `ByteStream.WriteRequest.finish_write`=false.
* 4. LogStream Reader(s) call `ByteStream.Read` with the published
* `LogStream.name` as `ByteStream.ReadRequest.resource_name`.
* 5. LogStream Service streams all committed bytes to LogStream Reader(s),
* leave the stream open.
* 6. LogStream Writer calls `ByteStream.Write` with
* `LogStream.write_resource_name` as
* `ByteStream.WriteRequest.resource_name`,
* `ByteStream.WriteRequest.finish_write`=true.
* 7. LogStream Service streams all remaining bytes to LogStream Reader(s),
* terminates the stream.
*
*/
public static abstract class LogStreamServiceImplBase
implements io.grpc.BindableService, AsyncService {
@java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
return LogStreamServiceGrpc.bindService(this);
}
}
/**
* A stub to allow clients to do asynchronous rpc calls to service LogStreamService.
*
* #### Introduction
* The Log Stream API manages LogStream resources which are used to stream
* writes and reads of an ordered sequence of bytes of unknown eventual length.
* Note that this is an API Interface and not an API Service, per the definitons
* at: https://cloud.google.com/apis/design/glossary
* Log Stream API supports the reading of unfinalized LogStreams either by
* seeking or in "tail" mode, for example by end-users browsing to a build
* result UI interested in seeing logs from a build action as soon as they are
* (or as they become) available.
* Reads and Writes of LogStreams are done via the Byte Stream API:
* https://cloud.google.com/dataproc/docs/reference/rpc/google.bytestream
* https://github.com/googleapis/googleapis/blob/master/google/bytestream/bytestream.proto
* #### Writing LogStreams
* LogStreams are written to via the Byte Stream API's `Write` RPC. Bytes
* written to LogStreams are expected to be committed and available for reading
* within a reasonable period of time (implementation-defined). Committed bytes
* to a LogStream cannot be overwritten, and finalized LogStreams - indicated by
* setting `finish_write` field in the final WriteRequest - also cannot be
* appended to.
* When calling the Byte Stream API's `Write` RPC to write LogStreams, writers
* must pass the `write_resource_name` of a LogStream as
* `ByteStream.WriteRequest.resource_name` rather than the LogStream's `name`.
* Separate resource names for reading and writing allows for broadcasting the
* read resource name widely while simultaneously ensuring that only writer(s)
* with knowledge of the write resource name may have written bytes to the
* LogStream.
* #### Reading LogStreams
* Use the Byte Stream API's `Read` RPC to read LogStreams. When reading
* finalized LogStreams the server will stream all contents of the LogStream
* starting at `ByteStream.ReadRequest.read_offset`.
* When reading unfinalized LogStreams the server must keep the streaming
* `ByteStream.Read` RPC open and send `ByteStream.ReadResponse` messages as
* more bytes become available or the LogStream is finalized.
* #### Example Multi-Party Read/Write Flow
* 1. LogStream Writer calls `CreateLogStream`
* 2. LogStream Writer publishes `LogStream.name`
* 3. LogStream Writer calls `ByteStream.Write` with
* `LogStream.write_resource_name` as
* `ByteStream.WriteRequest.resource_name`,
* `ByteStream.WriteRequest.finish_write`=false.
* 4. LogStream Reader(s) call `ByteStream.Read` with the published
* `LogStream.name` as `ByteStream.ReadRequest.resource_name`.
* 5. LogStream Service streams all committed bytes to LogStream Reader(s),
* leave the stream open.
* 6. LogStream Writer calls `ByteStream.Write` with
* `LogStream.write_resource_name` as
* `ByteStream.WriteRequest.resource_name`,
* `ByteStream.WriteRequest.finish_write`=true.
* 7. LogStream Service streams all remaining bytes to LogStream Reader(s),
* terminates the stream.
*
*/
public static final class LogStreamServiceStub
extends io.grpc.stub.AbstractAsyncStub {
private LogStreamServiceStub(
io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
super(channel, callOptions);
}
@java.lang.Override
protected LogStreamServiceStub build(
io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
return new LogStreamServiceStub(channel, callOptions);
}
/**
*
* Create a LogStream which may be written to.
* The returned LogStream resource name will include a `write_resource_name`
* which is the resource to use when writing to the LogStream.
* Callers of CreateLogStream are expected to NOT publish the
* `write_resource_name`.
*
*/
public void createLogStream(build.bazel.remote.logstream.v1.CreateLogStreamRequest request,
io.grpc.stub.StreamObserver responseObserver) {
io.grpc.stub.ClientCalls.asyncUnaryCall(
getChannel().newCall(getCreateLogStreamMethod(), getCallOptions()), request, responseObserver);
}
}
/**
* A stub to allow clients to do synchronous rpc calls to service LogStreamService.
*
* #### Introduction
* The Log Stream API manages LogStream resources which are used to stream
* writes and reads of an ordered sequence of bytes of unknown eventual length.
* Note that this is an API Interface and not an API Service, per the definitons
* at: https://cloud.google.com/apis/design/glossary
* Log Stream API supports the reading of unfinalized LogStreams either by
* seeking or in "tail" mode, for example by end-users browsing to a build
* result UI interested in seeing logs from a build action as soon as they are
* (or as they become) available.
* Reads and Writes of LogStreams are done via the Byte Stream API:
* https://cloud.google.com/dataproc/docs/reference/rpc/google.bytestream
* https://github.com/googleapis/googleapis/blob/master/google/bytestream/bytestream.proto
* #### Writing LogStreams
* LogStreams are written to via the Byte Stream API's `Write` RPC. Bytes
* written to LogStreams are expected to be committed and available for reading
* within a reasonable period of time (implementation-defined). Committed bytes
* to a LogStream cannot be overwritten, and finalized LogStreams - indicated by
* setting `finish_write` field in the final WriteRequest - also cannot be
* appended to.
* When calling the Byte Stream API's `Write` RPC to write LogStreams, writers
* must pass the `write_resource_name` of a LogStream as
* `ByteStream.WriteRequest.resource_name` rather than the LogStream's `name`.
* Separate resource names for reading and writing allows for broadcasting the
* read resource name widely while simultaneously ensuring that only writer(s)
* with knowledge of the write resource name may have written bytes to the
* LogStream.
* #### Reading LogStreams
* Use the Byte Stream API's `Read` RPC to read LogStreams. When reading
* finalized LogStreams the server will stream all contents of the LogStream
* starting at `ByteStream.ReadRequest.read_offset`.
* When reading unfinalized LogStreams the server must keep the streaming
* `ByteStream.Read` RPC open and send `ByteStream.ReadResponse` messages as
* more bytes become available or the LogStream is finalized.
* #### Example Multi-Party Read/Write Flow
* 1. LogStream Writer calls `CreateLogStream`
* 2. LogStream Writer publishes `LogStream.name`
* 3. LogStream Writer calls `ByteStream.Write` with
* `LogStream.write_resource_name` as
* `ByteStream.WriteRequest.resource_name`,
* `ByteStream.WriteRequest.finish_write`=false.
* 4. LogStream Reader(s) call `ByteStream.Read` with the published
* `LogStream.name` as `ByteStream.ReadRequest.resource_name`.
* 5. LogStream Service streams all committed bytes to LogStream Reader(s),
* leave the stream open.
* 6. LogStream Writer calls `ByteStream.Write` with
* `LogStream.write_resource_name` as
* `ByteStream.WriteRequest.resource_name`,
* `ByteStream.WriteRequest.finish_write`=true.
* 7. LogStream Service streams all remaining bytes to LogStream Reader(s),
* terminates the stream.
*
*/
public static final class LogStreamServiceBlockingStub
extends io.grpc.stub.AbstractBlockingStub {
private LogStreamServiceBlockingStub(
io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
super(channel, callOptions);
}
@java.lang.Override
protected LogStreamServiceBlockingStub build(
io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
return new LogStreamServiceBlockingStub(channel, callOptions);
}
/**
*
* Create a LogStream which may be written to.
* The returned LogStream resource name will include a `write_resource_name`
* which is the resource to use when writing to the LogStream.
* Callers of CreateLogStream are expected to NOT publish the
* `write_resource_name`.
*
*/
public build.bazel.remote.logstream.v1.LogStream createLogStream(build.bazel.remote.logstream.v1.CreateLogStreamRequest request) {
return io.grpc.stub.ClientCalls.blockingUnaryCall(
getChannel(), getCreateLogStreamMethod(), getCallOptions(), request);
}
}
/**
* A stub to allow clients to do ListenableFuture-style rpc calls to service LogStreamService.
*
* #### Introduction
* The Log Stream API manages LogStream resources which are used to stream
* writes and reads of an ordered sequence of bytes of unknown eventual length.
* Note that this is an API Interface and not an API Service, per the definitons
* at: https://cloud.google.com/apis/design/glossary
* Log Stream API supports the reading of unfinalized LogStreams either by
* seeking or in "tail" mode, for example by end-users browsing to a build
* result UI interested in seeing logs from a build action as soon as they are
* (or as they become) available.
* Reads and Writes of LogStreams are done via the Byte Stream API:
* https://cloud.google.com/dataproc/docs/reference/rpc/google.bytestream
* https://github.com/googleapis/googleapis/blob/master/google/bytestream/bytestream.proto
* #### Writing LogStreams
* LogStreams are written to via the Byte Stream API's `Write` RPC. Bytes
* written to LogStreams are expected to be committed and available for reading
* within a reasonable period of time (implementation-defined). Committed bytes
* to a LogStream cannot be overwritten, and finalized LogStreams - indicated by
* setting `finish_write` field in the final WriteRequest - also cannot be
* appended to.
* When calling the Byte Stream API's `Write` RPC to write LogStreams, writers
* must pass the `write_resource_name` of a LogStream as
* `ByteStream.WriteRequest.resource_name` rather than the LogStream's `name`.
* Separate resource names for reading and writing allows for broadcasting the
* read resource name widely while simultaneously ensuring that only writer(s)
* with knowledge of the write resource name may have written bytes to the
* LogStream.
* #### Reading LogStreams
* Use the Byte Stream API's `Read` RPC to read LogStreams. When reading
* finalized LogStreams the server will stream all contents of the LogStream
* starting at `ByteStream.ReadRequest.read_offset`.
* When reading unfinalized LogStreams the server must keep the streaming
* `ByteStream.Read` RPC open and send `ByteStream.ReadResponse` messages as
* more bytes become available or the LogStream is finalized.
* #### Example Multi-Party Read/Write Flow
* 1. LogStream Writer calls `CreateLogStream`
* 2. LogStream Writer publishes `LogStream.name`
* 3. LogStream Writer calls `ByteStream.Write` with
* `LogStream.write_resource_name` as
* `ByteStream.WriteRequest.resource_name`,
* `ByteStream.WriteRequest.finish_write`=false.
* 4. LogStream Reader(s) call `ByteStream.Read` with the published
* `LogStream.name` as `ByteStream.ReadRequest.resource_name`.
* 5. LogStream Service streams all committed bytes to LogStream Reader(s),
* leave the stream open.
* 6. LogStream Writer calls `ByteStream.Write` with
* `LogStream.write_resource_name` as
* `ByteStream.WriteRequest.resource_name`,
* `ByteStream.WriteRequest.finish_write`=true.
* 7. LogStream Service streams all remaining bytes to LogStream Reader(s),
* terminates the stream.
*
*/
public static final class LogStreamServiceFutureStub
extends io.grpc.stub.AbstractFutureStub {
private LogStreamServiceFutureStub(
io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
super(channel, callOptions);
}
@java.lang.Override
protected LogStreamServiceFutureStub build(
io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
return new LogStreamServiceFutureStub(channel, callOptions);
}
/**
*
* Create a LogStream which may be written to.
* The returned LogStream resource name will include a `write_resource_name`
* which is the resource to use when writing to the LogStream.
* Callers of CreateLogStream are expected to NOT publish the
* `write_resource_name`.
*
*/
public com.google.common.util.concurrent.ListenableFuture createLogStream(
build.bazel.remote.logstream.v1.CreateLogStreamRequest request) {
return io.grpc.stub.ClientCalls.futureUnaryCall(
getChannel().newCall(getCreateLogStreamMethod(), getCallOptions()), request);
}
}
private static final int METHODID_CREATE_LOG_STREAM = 0;
private static final class MethodHandlers implements
io.grpc.stub.ServerCalls.UnaryMethod,
io.grpc.stub.ServerCalls.ServerStreamingMethod,
io.grpc.stub.ServerCalls.ClientStreamingMethod,
io.grpc.stub.ServerCalls.BidiStreamingMethod {
private final AsyncService serviceImpl;
private final int methodId;
MethodHandlers(AsyncService serviceImpl, int methodId) {
this.serviceImpl = serviceImpl;
this.methodId = methodId;
}
@java.lang.Override
@java.lang.SuppressWarnings("unchecked")
public void invoke(Req request, io.grpc.stub.StreamObserver responseObserver) {
switch (methodId) {
case METHODID_CREATE_LOG_STREAM:
serviceImpl.createLogStream((build.bazel.remote.logstream.v1.CreateLogStreamRequest) request,
(io.grpc.stub.StreamObserver) responseObserver);
break;
default:
throw new AssertionError();
}
}
@java.lang.Override
@java.lang.SuppressWarnings("unchecked")
public io.grpc.stub.StreamObserver invoke(
io.grpc.stub.StreamObserver responseObserver) {
switch (methodId) {
default:
throw new AssertionError();
}
}
}
public static final io.grpc.ServerServiceDefinition bindService(AsyncService service) {
return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
.addMethod(
getCreateLogStreamMethod(),
io.grpc.stub.ServerCalls.asyncUnaryCall(
new MethodHandlers<
build.bazel.remote.logstream.v1.CreateLogStreamRequest,
build.bazel.remote.logstream.v1.LogStream>(
service, METHODID_CREATE_LOG_STREAM)))
.build();
}
private static abstract class LogStreamServiceBaseDescriptorSupplier
implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier {
LogStreamServiceBaseDescriptorSupplier() {}
@java.lang.Override
public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
return build.bazel.remote.logstream.v1.RemoteLogStreamProto.getDescriptor();
}
@java.lang.Override
public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() {
return getFileDescriptor().findServiceByName("LogStreamService");
}
}
private static final class LogStreamServiceFileDescriptorSupplier
extends LogStreamServiceBaseDescriptorSupplier {
LogStreamServiceFileDescriptorSupplier() {}
}
private static final class LogStreamServiceMethodDescriptorSupplier
extends LogStreamServiceBaseDescriptorSupplier
implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
private final java.lang.String methodName;
LogStreamServiceMethodDescriptorSupplier(java.lang.String methodName) {
this.methodName = methodName;
}
@java.lang.Override
public com.google.protobuf.Descriptors.MethodDescriptor getMethodDescriptor() {
return getServiceDescriptor().findMethodByName(methodName);
}
}
private static volatile io.grpc.ServiceDescriptor serviceDescriptor;
public static io.grpc.ServiceDescriptor getServiceDescriptor() {
io.grpc.ServiceDescriptor result = serviceDescriptor;
if (result == null) {
synchronized (LogStreamServiceGrpc.class) {
result = serviceDescriptor;
if (result == null) {
serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
.setSchemaDescriptor(new LogStreamServiceFileDescriptorSupplier())
.addMethod(getCreateLogStreamMethod())
.build();
}
}
}
return result;
}
}
