Package io.deephaven.server.object

Class ObjectServiceGrpcImpl

java.lang.Object
io.deephaven.proto.backplane.grpc.ObjectServiceGrpc.ObjectServiceImplBase
io.deephaven.server.object.ObjectServiceGrpcImpl
All Implemented Interfaces:
ObjectServiceGrpc.AsyncService, io.grpc.BindableService
public class ObjectServiceGrpcImpl extends ObjectServiceGrpc.ObjectServiceImplBase

  • Constructor Details

  • Method Details

    • fetchObject

      public void fetchObject(@NotNull @NotNull FetchObjectRequest request, @NotNull @NotNull io.grpc.stub.StreamObserver<FetchObjectResponse> responseObserver)
      Description copied from interface: ObjectServiceGrpc.AsyncService
       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)
      Description copied from interface: ObjectServiceGrpc.AsyncService
       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.