/** * <pre> * LeaseKeepAlive keeps the lease alive by streaming keep alive requests from the client * to the server and streaming keep alive responses from the server to the client. * </pre> */ public io.grpc.stub.StreamObserver<etcdserverpb.Rpc.LeaseKeepAliveRequest> leaseKeepAlive( io.grpc.stub.StreamObserver<etcdserverpb.Rpc.LeaseKeepAliveResponse> responseObserver) { return asyncUnimplementedStreamingCall(METHOD_LEASE_KEEP_ALIVE, responseObserver); }
/** * <pre> * A client-to-server streaming RPC. * Accepts a stream of Points on a route being traversed, returning a * RouteSummary when traversal is completed. * </pre> */ public io.grpc.stub.StreamObserver<io.grpc.examples.routeguide.Point> recordRoute( io.grpc.stub.StreamObserver<io.grpc.examples.routeguide.RouteSummary> responseObserver) { return asyncUnimplementedStreamingCall(METHOD_RECORD_ROUTE, responseObserver); }
/** * <pre> * Watch watches for events happening or that have happened. Both input and output * are streams; the input stream is for creating and canceling watchers and the output * stream sends events. One watch RPC can watch on multiple key ranges, streaming events * for several watches at once. The entire event history can be watched starting from the * last compaction revision. * </pre> */ public io.grpc.stub.StreamObserver<etcdserverpb.Rpc.WatchRequest> watch( io.grpc.stub.StreamObserver<etcdserverpb.Rpc.WatchResponse> responseObserver) { return asyncUnimplementedStreamingCall(METHOD_WATCH, responseObserver); }
/** * <pre> * A Bidirectional streaming RPC. * Accepts a stream of RouteNotes sent while a route is being traversed, * while receiving other RouteNotes (e.g. from other users). * </pre> */ public io.grpc.stub.StreamObserver<io.grpc.examples.routeguide.RouteNote> routeChat( io.grpc.stub.StreamObserver<io.grpc.examples.routeguide.RouteNote> responseObserver) { return asyncUnimplementedStreamingCall(METHOD_ROUTE_CHAT, responseObserver); }
/** */ public io.grpc.stub.StreamObserver<alluxio.grpc.WriteRequest> writeBlock( io.grpc.stub.StreamObserver<alluxio.grpc.WriteResponse> responseObserver) { return asyncUnimplementedStreamingCall(getWriteBlockMethod(), responseObserver); }
/** * <pre> ** * Used to drive Sasl negotiation with clients. * </pre> */ public io.grpc.stub.StreamObserver<alluxio.grpc.SaslMessage> authenticate( io.grpc.stub.StreamObserver<alluxio.grpc.SaslMessage> responseObserver) { return asyncUnimplementedStreamingCall(getAuthenticateMethod(), responseObserver); }
/** * <pre> * Replaces ShortCircuitBlockReadHandler. * </pre> */ public io.grpc.stub.StreamObserver<alluxio.grpc.OpenLocalBlockRequest> openLocalBlock( io.grpc.stub.StreamObserver<alluxio.grpc.OpenLocalBlockResponse> responseObserver) { return asyncUnimplementedStreamingCall(getOpenLocalBlockMethod(), responseObserver); }
/** */ public io.grpc.stub.StreamObserver<alluxio.grpc.ReadRequest> readBlock( io.grpc.stub.StreamObserver<alluxio.grpc.ReadResponse> responseObserver) { return asyncUnimplementedStreamingCall(getReadBlockMethod(), responseObserver); }
/** * <pre> * Replaces ShortCircuitBlockWriteHandler. * </pre> */ public io.grpc.stub.StreamObserver<alluxio.grpc.CreateLocalBlockRequest> createLocalBlock( io.grpc.stub.StreamObserver<alluxio.grpc.CreateLocalBlockResponse> responseObserver) { return asyncUnimplementedStreamingCall(getCreateLocalBlockMethod(), responseObserver); }
/** * <pre> * A sequence of requests with each request served by the server immediately. * As one request could lead to multiple responses, this interface * demonstrates the idea of full duplexing. * </pre> */ public io.grpc.stub.StreamObserver<io.vertx.example.grpc.Messages.StreamingOutputCallRequest> fullDuplexCall( io.grpc.stub.StreamObserver<io.vertx.example.grpc.Messages.StreamingOutputCallResponse> responseObserver) { return asyncUnimplementedStreamingCall(getFullDuplexCallMethod(), responseObserver); }
/** * <pre> * A sequence of requests followed by one response (streamed upload). * The server returns the aggregated size of client payload as the result. * </pre> */ public io.grpc.stub.StreamObserver<io.vertx.example.grpc.Messages.StreamingInputCallRequest> streamingInputCall( io.grpc.stub.StreamObserver<io.vertx.example.grpc.Messages.StreamingInputCallResponse> responseObserver) { return asyncUnimplementedStreamingCall(getStreamingInputCallMethod(), responseObserver); }
/** * <pre> * A sequence of requests followed by one response (streamed upload). * The server returns the aggregated size of client payload as the result. * </pre> */ public void streamingInputCall(io.vertx.grpc.GrpcReadStream<io.vertx.example.grpc.Messages.StreamingInputCallRequest> request, io.vertx.core.Future<io.vertx.example.grpc.Messages.StreamingInputCallResponse> response) { request.setReadObserver(asyncUnimplementedStreamingCall(getStreamingInputCallMethod(), ProducerServiceGrpc.toObserver(response.completer()))); }
/** * <pre> * A sequence of requests with each request served by the server immediately. * As one request could lead to multiple responses, this interface * demonstrates the idea of full duplexing. * </pre> */ public void fullDuplexCall( io.vertx.grpc.GrpcBidiExchange<io.vertx.example.grpc.Messages.StreamingOutputCallRequest, io.vertx.example.grpc.Messages.StreamingOutputCallResponse> exchange) { exchange.setReadObserver(asyncUnimplementedStreamingCall(getFullDuplexCallMethod(), exchange.writeObserver())); }
/** * <pre> * A client-to-server streaming RPC. * Accepts a stream of Points on a route being traversed, returning a * RouteSummary when traversal is completed. * </pre> */ public void recordRoute(io.vertx.grpc.GrpcReadStream<io.grpc.examples.routeguide.Point> request, io.vertx.core.Future<io.grpc.examples.routeguide.RouteSummary> response) { request.setReadObserver(asyncUnimplementedStreamingCall(getRecordRouteMethod(), RouteGuideGrpc.toObserver(response.completer()))); }
/** * <pre> * A Bidirectional streaming RPC. * Accepts a stream of RouteNotes sent while a route is being traversed, * while receiving other RouteNotes (e.g. from other users). * </pre> */ public void routeChat( io.vertx.grpc.GrpcBidiExchange<io.grpc.examples.routeguide.RouteNote, io.grpc.examples.routeguide.RouteNote> exchange) { exchange.setReadObserver(asyncUnimplementedStreamingCall(getRouteChatMethod(), exchange.writeObserver())); }
/** * <pre> * A streaming call that always throws an error in the stub implementation, not message handler. The error * is thrown in startCall. * </pre> */ public io.grpc.stub.StreamObserver<com.linecorp.armeria.grpc.testing.Messages.SimpleRequest> streamThrowsErrorInStub( io.grpc.stub.StreamObserver<com.linecorp.armeria.grpc.testing.Messages.SimpleResponse> responseObserver) { return asyncUnimplementedStreamingCall(getStreamThrowsErrorInStubMethod(), responseObserver); }
/** * <pre> * A sequence of requests followed by one response (streamed upload). * The server returns the aggregated size of client payload as the result. * </pre> */ public io.grpc.stub.StreamObserver<com.linecorp.armeria.grpc.testing.Messages.StreamingInputCallRequest> streamingInputCall( io.grpc.stub.StreamObserver<com.linecorp.armeria.grpc.testing.Messages.StreamingInputCallResponse> responseObserver) { return asyncUnimplementedStreamingCall(getStreamingInputCallMethod(), responseObserver); }
/** * <pre> * Neither server nor control exert backpressure. * </pre> */ public io.grpc.stub.StreamObserver<com.linecorp.armeria.grpc.testing.Messages.SimpleRequest> noBackPressure( io.grpc.stub.StreamObserver<com.linecorp.armeria.grpc.testing.Messages.SimpleResponse> responseObserver) { return asyncUnimplementedStreamingCall(getNoBackPressureMethod(), responseObserver); }
/** * <pre> * A streaming RPC where the client cancels without explicitly closing the stream (e.g. socket disconnect). * </pre> */ public io.grpc.stub.StreamObserver<com.linecorp.armeria.grpc.testing.Messages.SimpleRequest> streamClientCancels( io.grpc.stub.StreamObserver<com.linecorp.armeria.grpc.testing.Messages.SimpleResponse> responseObserver) { return asyncUnimplementedStreamingCall(getStreamClientCancelsMethod(), responseObserver); }
/** * <pre> * A sequence of requests followed by a sequence of responses. * The server buffers all the client requests and then serves them in order. A * stream of responses are returned to the client when the server starts with * first request. * </pre> */ public io.grpc.stub.StreamObserver<com.linecorp.armeria.grpc.testing.Messages.StreamingOutputCallRequest> halfDuplexCall( io.grpc.stub.StreamObserver<com.linecorp.armeria.grpc.testing.Messages.StreamingOutputCallResponse> responseObserver) { return asyncUnimplementedStreamingCall(getHalfDuplexCallMethod(), responseObserver); }