Refine search
/** * <pre> * Alarm activates, deactivates, and queries alarms regarding cluster health. * </pre> */ public void alarm(etcdserverpb.Rpc.AlarmRequest request, io.grpc.stub.StreamObserver<etcdserverpb.Rpc.AlarmResponse> responseObserver) { asyncUnaryCall( getChannel().newCall(METHOD_ALARM, getCallOptions()), request, responseObserver); }
/** * <pre> * LeaseGrant creates a lease which expires if the server does not receive a keepAlive * within a given time to live period. All keys attached to the lease will be expired and * deleted if the lease expires. Each expired key generates a delete event in the event history. * </pre> */ public etcdserverpb.Rpc.LeaseGrantResponse leaseGrant(etcdserverpb.Rpc.LeaseGrantRequest request) { return blockingUnaryCall( getChannel(), METHOD_LEASE_GRANT, getCallOptions(), request); }
/** * <pre> * Status gets the status of the member. * </pre> */ public com.google.common.util.concurrent.ListenableFuture<etcdserverpb.Rpc.StatusResponse> status( etcdserverpb.Rpc.StatusRequest request) { return futureUnaryCall( getChannel().newCall(METHOD_STATUS, getCallOptions()), request); }
/** * <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 asyncBidiStreamingCall( getChannel().newCall(METHOD_LEASE_KEEP_ALIVE, getCallOptions()), responseObserver); }
/** * <pre> * Snapshot sends a snapshot of the entire backend from a member over a stream to a client. * </pre> */ public void snapshot(etcdserverpb.Rpc.SnapshotRequest request, io.grpc.stub.StreamObserver<etcdserverpb.Rpc.SnapshotResponse> responseObserver) { asyncServerStreamingCall( getChannel().newCall(METHOD_SNAPSHOT, getCallOptions()), request, responseObserver); } }
/** * <pre> * Snapshot sends a snapshot of the entire backend from a member over a stream to a client. * </pre> */ public java.util.Iterator<etcdserverpb.Rpc.SnapshotResponse> snapshot( etcdserverpb.Rpc.SnapshotRequest request) { return blockingServerStreamingCall( getChannel(), METHOD_SNAPSHOT, getCallOptions(), request); } }
/** * <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 asyncBidiStreamingCall( getChannel().newCall(METHOD_ROUTE_CHAT, getCallOptions()), responseObserver); } }
/** * <pre> * A server-to-client streaming RPC. * Obtains the Features available within the given Rectangle. Results are * streamed rather than returned at once (e.g. in a response message with a * repeated field), as the rectangle may cover a large area and contain a * huge number of features. * </pre> */ public void listFeatures(io.grpc.examples.routeguide.Rectangle request, io.grpc.stub.StreamObserver<io.grpc.examples.routeguide.Feature> responseObserver) { asyncServerStreamingCall( getChannel().newCall(METHOD_LIST_FEATURES, getCallOptions()), request, responseObserver); }
/** * <pre> * A server-to-client streaming RPC. * Obtains the Features available within the given Rectangle. Results are * streamed rather than returned at once (e.g. in a response message with a * repeated field), as the rectangle may cover a large area and contain a * huge number of features. * </pre> */ public java.util.Iterator<io.grpc.examples.routeguide.Feature> listFeatures( io.grpc.examples.routeguide.Rectangle request) { return blockingServerStreamingCall( getChannel(), METHOD_LIST_FEATURES, getCallOptions(), request); } }
/** * <pre> * Status gets the status of the member. * </pre> */ public void status(etcdserverpb.Rpc.StatusRequest request, io.grpc.stub.StreamObserver<etcdserverpb.Rpc.StatusResponse> responseObserver) { asyncUnaryCall( getChannel().newCall(METHOD_STATUS, getCallOptions()), request, responseObserver); }
/** * <pre> * Authenticate processes an authenticate request. * </pre> */ public com.google.common.util.concurrent.ListenableFuture<etcdserverpb.Rpc.AuthenticateResponse> authenticate( etcdserverpb.Rpc.AuthenticateRequest request) { return futureUnaryCall( getChannel().newCall(METHOD_AUTHENTICATE, getCallOptions()), request); }
/** * <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 asyncBidiStreamingCall( getChannel().newCall(METHOD_WATCH, getCallOptions()), responseObserver); } }
/** * * * <pre> * Runs a query. * </pre> */ public void runQuery( com.google.firestore.v1.RunQueryRequest request, io.grpc.stub.StreamObserver<com.google.firestore.v1.RunQueryResponse> responseObserver) { asyncServerStreamingCall( getChannel().newCall(getRunQueryMethodHelper(), getCallOptions()), request, responseObserver); }
/** * <pre> * Txn processes multiple requests in a single transaction. * A txn request increments the revision of the key-value store * and generates events with the same revision for every completed request. * It is not allowed to modify the same key several times within one txn. * </pre> */ public etcdserverpb.Rpc.TxnResponse txn(etcdserverpb.Rpc.TxnRequest request) { return blockingUnaryCall( getChannel(), METHOD_TXN, getCallOptions(), request); }
/** * * * <pre> * Runs a query. * </pre> */ public java.util.Iterator<com.google.firestore.v1.RunQueryResponse> runQuery( com.google.firestore.v1.RunQueryRequest request) { return blockingServerStreamingCall( getChannel(), getRunQueryMethodHelper(), getCallOptions(), request); }
/** * <pre> * Put puts the given key into the key-value store. * A put request increments the revision of the key-value store * and generates one event in the event history. * </pre> */ public void put(etcdserverpb.Rpc.PutRequest request, io.grpc.stub.StreamObserver<etcdserverpb.Rpc.PutResponse> responseObserver) { asyncUnaryCall( getChannel().newCall(METHOD_PUT, getCallOptions()), request, responseObserver); }
/** * <pre> * UserAdd adds a new user. * </pre> */ public com.google.common.util.concurrent.ListenableFuture<etcdserverpb.Rpc.AuthUserAddResponse> userAdd( etcdserverpb.Rpc.AuthUserAddRequest request) { return futureUnaryCall( getChannel().newCall(METHOD_USER_ADD, getCallOptions()), request); }
/** */ public io.grpc.stub.StreamObserver<alluxio.grpc.WriteRequest> writeBlock( io.grpc.stub.StreamObserver<alluxio.grpc.WriteResponse> responseObserver) { return asyncBidiStreamingCall( getChannel().newCall(getWriteBlockMethod(), getCallOptions()), responseObserver); }
/** * * * <pre> * Runs a query. * </pre> */ public void runQuery( com.google.firestore.v1beta1.RunQueryRequest request, io.grpc.stub.StreamObserver<com.google.firestore.v1beta1.RunQueryResponse> responseObserver) { asyncServerStreamingCall( getChannel().newCall(getRunQueryMethodHelper(), getCallOptions()), request, responseObserver); }
/** * <pre> * AuthDisable disables authentication. * </pre> */ public etcdserverpb.Rpc.AuthDisableResponse authDisable(etcdserverpb.Rpc.AuthDisableRequest request) { return blockingUnaryCall( getChannel(), METHOD_AUTH_DISABLE, getCallOptions(), request); }