Package io.deephaven.proto.backplane.grpc

Class ObjectServiceGrpc.ObjectServiceStub

java.lang.Object
io.grpc.stub.AbstractStub<S>
io.grpc.stub.AbstractAsyncStub<ObjectServiceGrpc.ObjectServiceStub>
io.deephaven.proto.backplane.grpc.ObjectServiceGrpc.ObjectServiceStub
Enclosing class:
ObjectServiceGrpc
public static final class ObjectServiceGrpc.ObjectServiceStub extends io.grpc.stub.AbstractAsyncStub<ObjectServiceGrpc.ObjectServiceStub>
A stub to allow clients to do asynchronous rpc calls to service ObjectService.

  • Nested Class Summary

    Nested classes/interfaces inherited from class io.grpc.stub.AbstractStub

    io.grpc.stub.AbstractStub.StubFactory<T extends io.grpc.stub.AbstractStub<T>>

  • Method Summary

    Modifier and Type
    Method
    Description
    protected ObjectServiceGrpc.ObjectServiceStub
    build(io.grpc.Channel channel, io.grpc.CallOptions callOptions)
     
    void
    fetchObject(FetchObjectRequest request, io.grpc.stub.StreamObserver<FetchObjectResponse> responseObserver)
    Deprecated.
    io.grpc.stub.StreamObserver<StreamRequest>
    messageStream(io.grpc.stub.StreamObserver<StreamResponse> responseObserver)
    Provides a generic stream feature for Deephaven instances to use to add arbitrary functionality.
    void
    nextMessageStream(StreamRequest request, io.grpc.stub.StreamObserver<BrowserNextResponse> responseObserver)
    Other half of the browser-based implementation for MessageStream.
    void
    openMessageStream(StreamRequest request, io.grpc.stub.StreamObserver<StreamResponse> responseObserver)
    Half of the browser-based (browser's can't do bidirectional streams without websockets) implementation for MessageStream.

    Methods inherited from class io.grpc.stub.AbstractAsyncStub

    newStub, newStub

    Methods inherited from class io.grpc.stub.AbstractStub

    getCallOptions, getChannel, withCallCredentials, withChannel, withCompression, withDeadline, withDeadlineAfter, withExecutor, withInterceptors, withMaxInboundMessageSize, withMaxOutboundMessageSize, withOption, withWaitForReady

    Methods inherited from class java.lang.Object

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

  • Method Details

    • build

      protected ObjectServiceGrpc.ObjectServiceStub build(io.grpc.Channel channel, io.grpc.CallOptions callOptions)
      Specified by:
      build in class io.grpc.stub.AbstractStub<ObjectServiceGrpc.ObjectServiceStub>

    • fetchObject

      @Deprecated public void fetchObject(FetchObjectRequest request, io.grpc.stub.StreamObserver<FetchObjectResponse> responseObserver)
      Deprecated.
       Fetches a server-side object as a binary payload and assorted other tickets pointing at
 other server-side objects that may need to be read to properly use this payload. The binary
 format is implementation specific, but the implementation should be specified by the "type"
 identifier in the typed ticket.
 Deprecated in favor of MessageStream, which is able to handle the same content.

    • messageStream

      public io.grpc.stub.StreamObserver<StreamRequest> messageStream(io.grpc.stub.StreamObserver<StreamResponse> responseObserver)
       Provides a generic stream feature for Deephaven instances to use to add arbitrary functionality.
 Presently these take the form of "object type plugins", where server-side code can specify how
 an object could be serialized and/or communicate with a client. This gRPC stream is somewhat lower level
 than the plugin API, giving the server and client APIs features to correctly establish and
 control the stream. At this time, this is limited to a "ConnectRequest" to start the call.
 The first message sent to the server is expected to have a ConnectRequest, indicating which
 export ticket to connect to. It is an error for the client to attempt to connect to an object
 that has no plugin for its object type installed.
 The first request sent by the client should be a ConnectRequest. No other client message should
 be sent until the server responds. The server will respond with Data as soon as it is able (i.e.
 once the object in question has been resolved and the plugin has responded), indicating that the
 request was successful. After that point, the client may send Data requests.
 All replies from the server to the client contain Data instances. When sent from the server to
 the client, Data contains a bytes payload created by the server implementation of the plugin,
 and server-created export tickets containing any object references specified to be sent by the
 server-side plugin. As server-created exports, they are already resolved, and can be fetched or
 otherwise referenced right away. The client API is expected to wrap those tickets in appropriate
 objects, and the client is expected to release those tickets as appropriate, according to the
 plugin's use case. Note that it is possible for the "type" field to be null, indicating that
 there is no corresponding ObjectType plugin for these exported objects. This limits the client
 to specifying those tickets in a subsequent request, or releasing the ticket to let the object
 be garbage collected on the server.
 All Data instances sent from the client likewise contain a bytes payload, and may contain
 references to objects that already exist or may soon exist on the server, not just tickets sent
 by this same plugin. Note however that if those tickets are not yet resolved, neither the current
 Data nor subsequent requests can be processed by the plugin, as the required references can't be
 resolved.
 Presently there is no explicit "close" message to send, but plugin implementations can devise
 their own "half-close" protocol if they so choose. For now, if one end closes the connection,
 the other is expected to follow suit by closing their end too. At present, if there is an error
 with the stream, it is conveyed to the client in the usual gRPC fashion, but the server plugin
 will only be informed that the stream closed.

    • openMessageStream

      public void openMessageStream(StreamRequest request, io.grpc.stub.StreamObserver<StreamResponse> responseObserver)
       Half of the browser-based (browser's can't do bidirectional streams without websockets)
 implementation for MessageStream.

    • nextMessageStream

      public void nextMessageStream(StreamRequest request, io.grpc.stub.StreamObserver<BrowserNextResponse> responseObserver)
       Other half of the browser-based implementation for MessageStream.