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>
  • 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
    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.