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> * 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> * 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 asyncClientStreamingCall( getChannel().newCall(METHOD_RECORD_ROUTE, getCallOptions()), 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); }
/** */ 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> * 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> * 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); }
/** * <pre> * Replaces ShortCircuitBlockReadHandler. * </pre> */ public io.grpc.stub.StreamObserver<alluxio.grpc.OpenLocalBlockRequest> openLocalBlock( io.grpc.stub.StreamObserver<alluxio.grpc.OpenLocalBlockResponse> responseObserver) { return asyncBidiStreamingCall( getChannel().newCall(getOpenLocalBlockMethod(), getCallOptions()), responseObserver); }
/** * <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> * RoleDelete deletes a specified role. * </pre> */ public com.google.common.util.concurrent.ListenableFuture<etcdserverpb.Rpc.AuthRoleDeleteResponse> roleDelete( etcdserverpb.Rpc.AuthRoleDeleteRequest request) { return futureUnaryCall( getChannel().newCall(METHOD_ROLE_DELETE, getCallOptions()), request); }
/** * <pre> * AuthDisable disables authentication. * </pre> */ public void authDisable(etcdserverpb.Rpc.AuthDisableRequest request, io.grpc.stub.StreamObserver<etcdserverpb.Rpc.AuthDisableResponse> responseObserver) { asyncUnaryCall( getChannel().newCall(METHOD_AUTH_DISABLE, getCallOptions()), request, responseObserver); }
/** * <pre> * MemberUpdate updates the member configuration. * </pre> */ public com.google.common.util.concurrent.ListenableFuture<etcdserverpb.Rpc.MemberUpdateResponse> memberUpdate( etcdserverpb.Rpc.MemberUpdateRequest request) { return futureUnaryCall( getChannel().newCall(METHOD_MEMBER_UPDATE, getCallOptions()), request); }
/** * <pre> * Hash returns the hash of the local KV state for consistency checking purpose. * This is designed for testing; do not use this in production when there * are ongoing transactions. * </pre> */ public void hash(etcdserverpb.Rpc.HashRequest request, io.grpc.stub.StreamObserver<etcdserverpb.Rpc.HashResponse> responseObserver) { asyncUnaryCall( getChannel().newCall(METHOD_HASH, getCallOptions()), request, responseObserver); }
/** * <pre> * Defragment defragments a member's backend database to recover storage space. * </pre> */ public com.google.common.util.concurrent.ListenableFuture<etcdserverpb.Rpc.DefragmentResponse> defragment( etcdserverpb.Rpc.DefragmentRequest request) { return futureUnaryCall( getChannel().newCall(METHOD_DEFRAGMENT, getCallOptions()), request); }
/** * <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 void leaseGrant(etcdserverpb.Rpc.LeaseGrantRequest request, io.grpc.stub.StreamObserver<etcdserverpb.Rpc.LeaseGrantResponse> responseObserver) { asyncUnaryCall( getChannel().newCall(METHOD_LEASE_GRANT, 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 com.google.common.util.concurrent.ListenableFuture<etcdserverpb.Rpc.LeaseGrantResponse> leaseGrant( etcdserverpb.Rpc.LeaseGrantRequest request) { return futureUnaryCall( getChannel().newCall(METHOD_LEASE_GRANT, getCallOptions()), request); }
/** * <pre> * LeaseRevoke revokes a lease. All keys attached to the lease will expire and be deleted. * </pre> */ public void leaseRevoke(etcdserverpb.Rpc.LeaseRevokeRequest request, io.grpc.stub.StreamObserver<etcdserverpb.Rpc.LeaseRevokeResponse> responseObserver) { asyncUnaryCall( getChannel().newCall(METHOD_LEASE_REVOKE, getCallOptions()), request, responseObserver); }
/** * <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 com.google.common.util.concurrent.ListenableFuture<etcdserverpb.Rpc.PutResponse> put( etcdserverpb.Rpc.PutRequest request) { return futureUnaryCall( getChannel().newCall(METHOD_PUT, getCallOptions()), request); }