Struct FlowServiceClient 

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

Hosted by Dex server; SDKs call these RPCs.

Implementations

impl FlowServiceClient<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> FlowServiceClient<T>

where T: GrpcService<Body>, 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, ) -> FlowServiceClient<InterceptedService<T, F>>

where F: Interceptor, T::ResponseBody: Default, T: Service<Request<Body>, Response = Response<<T as GrpcService<Body>>::ResponseBody>>, <T as Service<Request<Body>>>::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 get_server_info( &mut self, request: impl IntoRequest<()>, ) -> Result<Response<ServerInfo>, Status>

Returns diagnostic release metadata and the Server’s inclusive protocol interval.

pub async fn start_flow( &mut self, request: impl IntoRequest<StartFlowRequest>, ) -> Result<Response<StartFlowResponse>, Status>

pub async fn publish_to_channel( &mut self, request: impl IntoRequest<PublishToChannelRequest>, ) -> Result<Response<()>, Status>

pub async fn get_channel_messages( &mut self, request: impl IntoRequest<GetChannelMessagesRequest>, ) -> Result<Response<GetChannelMessagesResponse>, Status>

pub async fn delete_channel_message( &mut self, request: impl IntoRequest<DeleteChannelMessageRequest>, ) -> Result<Response<()>, Status>

pub async fn write_stream( &mut self, request: impl IntoRequest<WriteStreamRequest>, ) -> Result<Response<()>, Status>

pub async fn read_stream( &mut self, request: impl IntoRequest<ReadStreamRequest>, ) -> Result<Response<ReadStreamResponse>, Status>

pub async fn list_stream_messages( &mut self, request: impl IntoRequest<ListStreamMessagesRequest>, ) -> Result<Response<ListStreamMessagesResponse>, Status>

pub async fn stop_flow( &mut self, request: impl IntoRequest<StopFlowRequest>, ) -> Result<Response<()>, Status>

pub async fn get_attributes( &mut self, request: impl IntoRequest<GetAttributesRequest>, ) -> Result<Response<GetAttributesResponse>, Status>

pub async fn set_attributes( &mut self, request: impl IntoRequest<SetAttributesRequest>, ) -> Result<Response<()>, Status>

pub async fn load_blobs( &mut self, request: impl IntoRequest<LoadBlobsRequest>, ) -> Result<Response<LoadBlobsResponse>, Status>

pub async fn wait_for_flow( &mut self, request: impl IntoRequest<WaitForFlowRequest>, ) -> Result<Response<FlowResult>, Status>

pub async fn search_flows( &mut self, request: impl IntoRequest<SearchFlowsRequest>, ) -> Result<Response<SearchFlowsResponse>, Status>

pub async fn sync_attribute_indexes( &mut self, request: impl IntoRequest<SyncAttributeIndexRequest>, ) -> Result<Response<SyncAttributeIndexResponse>, Status>

pub async fn get_flow_summary( &mut self, request: impl IntoRequest<GetFlowSummaryRequest>, ) -> Result<Response<GetFlowSummaryResponse>, Status>

pub async fn get_history_events( &mut self, request: impl IntoRequest<GetHistoryEventsRequest>, ) -> Result<Response<GetHistoryEventsResponse>, Status>

pub async fn wait_for_history_event( &mut self, request: impl IntoRequest<WaitForHistoryEventRequest>, ) -> Result<Response<WaitForHistoryEventResponse>, Status>

pub async fn get_flow_state( &mut self, request: impl IntoRequest<GetFlowStateRequest>, ) -> Result<Response<GetFlowStateResponse>, Status>

pub async fn reset_flow( &mut self, request: impl IntoRequest<ResetFlowRequest>, ) -> Result<Response<ResetFlowResponse>, Status>

pub async fn invoke_rpc( &mut self, request: impl IntoRequest<InvokeRpcRequest>, ) -> Result<Response<InvokeRpcResponse>, Status>

pub async fn skip_timer( &mut self, request: impl IntoRequest<SkipTimerRequest>, ) -> Result<Response<()>, Status>

pub async fn update_flow_config( &mut self, request: impl IntoRequest<UpdateFlowConfigRequest>, ) -> Result<Response<()>, Status>

pub async fn wait_for_step_completion( &mut self, request: impl IntoRequest<WaitForStepCompletionRequest>, ) -> Result<Response<WaitForStepCompletionResponse>, Status>

pub async fn wait_for_attribute( &mut self, request: impl IntoRequest<WaitForAttributeRequest>, ) -> Result<Response<WaitForAttributeResponse>, Status>

pub async fn health_check( &mut self, request: impl IntoRequest<()>, ) -> Result<Response<HealthInfo>, Status>

pub async fn upload_flow_definitions( &mut self, request: impl IntoRequest<UploadFlowDefinitionsRequest>, ) -> Result<Response<UploadFlowDefinitionsResponse>, Status>

Stores Flow Definition Graph (FDG 2.0) JSON documents, one for each Flow type.

Workers call it at startup so that Dex Web can render their Flows without a definition directory. The server keeps one document for each Flow type and decides each item separately. The outcome is CREATED when no document was stored for the Flow type. It is UNCHANGED when the stored document has the same SHA-256 digest; nothing is written then. It is REPLACED when the digest differs and generated_at is strictly later than the stored generated_at, compared at microsecond precision, or when force is set. Otherwise it is KEPT_EXISTING: the stored document stays, and the result reports its digest and generation time.

Items are independent. Concurrent uploads of one Flow type are safe: each item’s outcome is decided against the document stored when its write commits. If the call fails partway, earlier items may already be stored; repeating the call is safe and reports them as UNCHANGED.

The server checks only that each document is a JSON object of at most flowDefinitions.maxDefinitionBytes, that its schemaVersion starts with “2.”, and that its flow.name equals flow_type. Dex Web validates the full graph when it reads it.

Fails with InvalidArgument and FLOW_DEFINITION_INVALID, before storing anything, for an invalid item, more than 256 items, a repeated flow_type, a missing generated_at, or a generated_at more than 24 hours after the server’s clock. Fails with Unavailable when object storage fails; the call is then safe to retry.

pub async fn list_flow_definitions( &mut self, request: impl IntoRequest<ListFlowDefinitionsRequest>, ) -> Result<Response<ListFlowDefinitionsResponse>, Status>

Lists the Flow types that have a stored definition, one page at a time.

It returns names only; call GetFlowDefinitions for content and metadata. Pages follow the order of the stored object keys, which is stable but is not exactly the order of Flow types. A Flow type first stored during a listing may or may not appear. Fails with InvalidArgument for a negative page_size or an invalid page token, and with Unavailable when object storage fails.

pub async fn get_flow_definitions( &mut self, request: impl IntoRequest<GetFlowDefinitionsRequest>, ) -> Result<Response<GetFlowDefinitionsResponse>, Status>

Returns the stored Flow definitions of the requested Flow types, with content.

A requested Flow type that has no stored definition is left out of the response. Fails with InvalidArgument and FLOW_DEFINITION_INVALID for no Flow types, more than 256, or an invalid Flow type. Fails with ResourceExhausted and FLOW_DEFINITION_RESPONSE_TOO_LARGE when the content would not fit in one response message; request fewer Flow types.

Trait Implementations

impl<T: Clone> Clone for FlowServiceClient<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for FlowServiceClient<T>

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

Formats the value using the given formatter.