Struct _chidori::execution_runtime_client::ExecutionRuntimeClient

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

API:

Implementations

impl ExecutionRuntimeClient<Channel>

pub async fn connect<D>( dst: D ) -> impl Future<Output = Result<ExecutionRuntimeClient<Channel>, Error>>where D: TryInto<Endpoint>, <D as TryInto<Endpoint>>::Error: Into<Box<dyn Error + Send + Sync, Global>>,

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

impl<T> ExecutionRuntimeClient<T>where T: GrpcService<UnsyncBoxBody<Bytes, Status>>, <T as GrpcService<UnsyncBoxBody<Bytes, Status>>>::Error: Into<Box<dyn Error + Send + Sync, Global>>, <T as GrpcService<UnsyncBoxBody<Bytes, Status>>>::ResponseBody: Body<Data = Bytes> + Send + 'static, <<T as GrpcService<UnsyncBoxBody<Bytes, Status>>>::ResponseBody as Body>::Error: Into<Box<dyn Error + Send + Sync, Global>> + Send,

pub fn new(inner: T) -> ExecutionRuntimeClient<T>

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

pub fn with_interceptor<F>( inner: T, interceptor: F ) -> ExecutionRuntimeClient<InterceptedService<T, F>>where F: Interceptor, <T as GrpcService<UnsyncBoxBody<Bytes, Status>>>::ResponseBody: Default, T: Service<Request<UnsyncBoxBody<Bytes, Status>>, Response = Response<<T as GrpcService<UnsyncBoxBody<Bytes, Status>>>::ResponseBody>>, <T as Service<Request<UnsyncBoxBody<Bytes, Status>>>>::Error: Into<Box<dyn Error + Send + Sync, Global>> + Send + Sync,

pub fn send_compressed( self, encoding: CompressionEncoding ) -> ExecutionRuntimeClient<T>

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 ) -> ExecutionRuntimeClient<T>

Enable decompressing responses.

pub fn max_decoding_message_size( self, limit: usize ) -> ExecutionRuntimeClient<T>

Limits the maximum size of a decoded message.

Default: 4MB

pub fn max_encoding_message_size( self, limit: usize ) -> ExecutionRuntimeClient<T>

Limits the maximum size of an encoded message.

Default: usize::MAX

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

pub async fn merge( &mut self, request: impl IntoRequest<RequestFileMerge> ) -> impl Future<Output = 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> ) -> impl Future<Output = 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> ) -> impl Future<Output = 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> ) -> impl Future<Output = Result<Response<ExecutionStatus>, Status>>

• Resume execution

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

• Pause execution

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

• Split history into a separate branch

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

• Get all branches

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

• List all registered files

pub async fn list_input_proposals( &mut self, request: impl IntoRequest<RequestOnlyId> ) -> impl Future<Output = 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> ) -> impl Future<Output = 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> ) -> impl Future<Output = 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> ) -> impl Future<Output = Result<Response<Streaming<NodeWillExecuteOnBranch>>, Status>>

pub async fn poll_custom_node_will_execute_events( &mut self, request: impl IntoRequest<FilteredPollNodeWillExecuteEventsRequest> ) -> impl Future<Output = 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> ) -> impl Future<Output = Result<Response<ExecutionStatus>, Status>>

pub async fn push_worker_event( &mut self, request: impl IntoRequest<FileAddressedChangeValueWithCounter> ) -> impl Future<Output = 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> ) -> impl Future<Output = Result<Response<ExecutionStatus>, Status>>

Trait Implementations

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

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

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.