Struct WorkflowService 

pub struct WorkflowService<B, Input, Output>
where
    B: Backend + WireFormatBackend,
{ /* private fields */ }

The main workflow service that orchestrates the execution of workflow steps.

Implementations

impl<B, Input, Output> WorkflowService<B, Input, Output>

where B: Backend + WireFormatBackend,

pub fn new( services: HashMap<usize, BoxCloneSyncService<Task<B::Compact>, GoTo<StepResponse>, BoxDynError>>, backend: B, ) -> Self

Creates a new WorkflowService with the given services and backend.

Trait Implementations

impl<B, Input: Clone, Output: Clone> Clone for WorkflowService<B, Input, Output>

where B: Backend + WireFormatBackend + Clone, B::Compact: Clone,

fn clone(&self) -> WorkflowService<B, Input, Output>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<B, Input: Debug, Output: Debug> Debug for WorkflowService<B, Input, Output>

where B: Backend + WireFormatBackend + Debug, B::Compact: Debug,

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

Formats the value using the given formatter.

impl<Input, Output, Current, B, Compact, L, Err> IntoWorkerService<B, WorkflowService<B, Input, Output>> for SteppedFlow<Input, Current, B, L>

where B: Backend<Task = Task<Compact>, Error = Err> + WireFormatBackend<Compact = Compact> + BackendConfig<Args = Input> + Send + Sync + 'static + Sink<Task<Compact>, Error = Err> + Clone + Unpin, B::Id: Send + 'static + Default + GenerateId, L: Layer<RootStep<Current>>, L::Step: Step<Output, B>, B::Codec: Clone, Err: Error + Send + Sync + 'static, Compact: Send + 'static,

type Task = Task<Compact>

The task type processed by the worker.

type Backend = WorkflowBackend<B>

The backend type used by the worker service.

fn into_service( self, backend: B, ) -> WorkerService<Self::Backend, WorkflowService<B, Input, Output>>

Builds a worker service from the provided backend.

impl<B, Err, Input, Output> Service<Task<<B as WireFormatBackend>::Compact>> for WorkflowService<B, Input, Output>

where B: Sink<Task<B::Compact>, Error = Err> + Unpin + WireFormatBackend + BackendConfig<Args = Input> + Clone + Send + Sync + 'static + Backend<Error = Err>, B::Compact: Send + 'static, Err: Error + Send + Sync + 'static, B::Id: GenerateId + Send + 'static,

type Response = GoTo<StepResponse>

Responses given by the service.

type Error = Box<dyn Error + Sync + Send>

Errors produced by the service.

type Future = Pin<Box<dyn Future<Output = Result<<WorkflowService<B, Input, Output> as Service<Task<<B as WireFormatBackend>::Compact>>>::Response, <WorkflowService<B, Input, Output> as Service<Task<<B as WireFormatBackend>::Compact>>>::Error>> + Send>>

The future response value.

fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call(&mut self, req: Task<B::Compact>) -> Self::Future

Process the request and return the response asynchronously.