Struct ExecutionRuntimeClient

pub struct ExecutionRuntimeClient<T> { /* private fields */ }

API:

Implementations

impl ExecutionRuntimeClient<Channel>

pub async fn connect<D>(dst: D) -> Result<Self, Error>

where D: TryInto<Endpoint>, D::Error: Into<StdError>,

Attempt to create a new client by connecting to a given endpoint.

impl<T> ExecutionRuntimeClient<T>

where T: GrpcService<BoxBody>, T::Error: Into<StdError>, T::ResponseBody: Body<Data = Bytes> + Send + 'static, <T::ResponseBody as Body>::Error: Into<StdError> + Send,

pub fn new(inner: T) -> Self

pub fn with_origin(inner: T, origin: Uri) -> Self

pub fn with_interceptor<F>( inner: T, interceptor: F, ) -> ExecutionRuntimeClient<InterceptedService<T, F>>

where F: Interceptor, T::ResponseBody: Default, T: Service<Request<BoxBody>, Response = Response<<T as GrpcService<BoxBody>>::ResponseBody>>, <T as Service<Request<BoxBody>>>::Error: Into<StdError> + Send + Sync,

pub fn send_compressed(self, encoding: CompressionEncoding) -> Self

Compress requests with the given encoding.

This requires the server to support it otherwise it might respond with an error.

pub fn accept_compressed(self, encoding: CompressionEncoding) -> Self

Enable decompressing responses.

pub fn max_decoding_message_size(self, limit: usize) -> Self

Limits the maximum size of a decoded message.

Default: 4MB

pub fn max_encoding_message_size(self, limit: usize) -> Self

Limits the maximum size of an encoded message.

Default: usize::MAX

pub async fn run_query( &mut self, request: impl IntoRequest<QueryAtFrame>, ) -> Result<Response<QueryAtFrameResponse>, Status>

pub async fn merge( &mut self, request: impl IntoRequest<RequestFileMerge>, ) -> Result<Response<ExecutionStatus>, Status>

• Merge a new file - if an existing file is available at the id, will merge the new file into the existing one

pub async fn current_file_state( &mut self, request: impl IntoRequest<RequestOnlyId>, ) -> Result<Response<File>, Status>

• Get the current graph state of a file at a branch and counter position

pub async fn get_parquet_history( &mut self, request: impl IntoRequest<RequestOnlyId>, ) -> Result<Response<ParquetFile>, Status>

• Get the parquet history for a specific branch and Id - returns bytes

pub async fn play( &mut self, request: impl IntoRequest<RequestAtFrame>, ) -> Result<Response<ExecutionStatus>, Status>

• Resume execution

pub async fn pause( &mut self, request: impl IntoRequest<RequestAtFrame>, ) -> Result<Response<ExecutionStatus>, Status>

• Pause execution

pub async fn branch( &mut self, request: impl IntoRequest<RequestNewBranch>, ) -> Result<Response<ExecutionStatus>, Status>

• Split history into a separate branch

pub async fn list_branches( &mut self, request: impl IntoRequest<RequestListBranches>, ) -> Result<Response<ListBranchesRes>, Status>

• Get all branches

pub async fn list_registered_graphs( &mut self, request: impl IntoRequest<Empty>, ) -> Result<Response<ListRegisteredGraphsResponse>, Status>

• List all registered files

pub async fn list_input_proposals( &mut self, request: impl IntoRequest<RequestOnlyId>, ) -> Result<Response<Streaming<InputProposal>>, Status>

• Receive a stream of input proposals <- this is a server-side stream

pub async fn respond_to_input_proposal( &mut self, request: impl IntoRequest<RequestInputProposalResponse>, ) -> Result<Response<Empty>, Status>

• Push responses to input proposals (these wait for some input from a host until they’re resolved) <- RPC client to server

pub async fn list_change_events( &mut self, request: impl IntoRequest<RequestOnlyId>, ) -> Result<Response<Streaming<ChangeValueWithCounter>>, Status>

• Observe the stream of execution events <- this is a server-side stream

pub async fn list_node_will_execute_events( &mut self, request: impl IntoRequest<RequestOnlyId>, ) -> Result<Response<Streaming<NodeWillExecuteOnBranch>>, Status>

pub async fn poll_custom_node_will_execute_events( &mut self, request: impl IntoRequest<FilteredPollNodeWillExecuteEventsRequest>, ) -> Result<Response<RespondPollNodeWillExecuteEvents>, Status>

• Observe when the server thinks our local node implementation should execute and with what changes

pub async fn ack_node_will_execute_event( &mut self, request: impl IntoRequest<RequestAckNodeWillExecuteEvent>, ) -> Result<Response<ExecutionStatus>, Status>

pub async fn push_worker_event( &mut self, request: impl IntoRequest<FileAddressedChangeValueWithCounter>, ) -> Result<Response<ExecutionStatus>, Status>

• Receive events from workers <- this is an RPC client to server, we don’t need to wait for a response from the server

pub async fn push_template_partial( &mut self, request: impl IntoRequest<UpsertPromptLibraryRecord>, ) -> Result<Response<ExecutionStatus>, Status>

Trait Implementations

impl<T: Clone> Clone for ExecutionRuntimeClient<T>

fn clone(&self) -> ExecutionRuntimeClient<T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for ExecutionRuntimeClient<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.