pub struct ServiceChainFactory<Sf, St, Req> { /* private fields */ }Expand description
A builder for composing service factories and combinators.
Created by factory() and factory combinators. Builder methods consume
the chain and configure how future services are constructed; they do not
create services immediately.
The chain implements ServiceFactory by forwarding creation to its
enclosed factory. Self::pipeline additionally stores the supplied state
with the created service and binds it for readiness notifications.
Self::map_err transforms call and readiness errors from created
services, while Self::map_init_err transforms construction errors.
Self::apply installs a Middleware wrapper on each created service.
Cloning clones the enclosed factory without creating a service. Whether the clones share factory state depends on the enclosed implementation.
Implementations§
Source§impl<Sf, St, Req> ServiceChainFactory<Sf, St, Req>where
Sf: ServiceFactory<St, Req>,
impl<Sf, St, Req> ServiceChainFactory<Sf, St, Req>where
Sf: ServiceFactory<St, Req>,
Sourcepub fn and_then<U>(
self,
factory: impl IntoServiceFactory<U, St, <Sf as ServiceFactory<St, Req>>::Res>,
) -> ServiceChainFactory<AndThenFactory<Sf, U>, St, Req>where
ServiceChainFactory<Sf, St, Req>: Sized,
U: ServiceFactory<St, <Sf as ServiceFactory<St, Req>>::Res, Error = <Sf as ServiceFactory<St, Req>>::Error, InitError = <Sf as ServiceFactory<St, Req>>::InitError>,
pub fn and_then<U>(
self,
factory: impl IntoServiceFactory<U, St, <Sf as ServiceFactory<St, Req>>::Res>,
) -> ServiceChainFactory<AndThenFactory<Sf, U>, St, Req>where
ServiceChainFactory<Sf, St, Req>: Sized,
U: ServiceFactory<St, <Sf as ServiceFactory<St, Req>>::Res, Error = <Sf as ServiceFactory<St, Req>>::Error, InitError = <Sf as ServiceFactory<St, Req>>::InitError>,
Chains another factory after this factory’s services.
Each created service passes its response to the next service as its request. If the first service returns an error, the next service is not called.
Factories use the same state, service-error, and initialization-error
types. They are created sequentially with the same state reference; a
first-factory error prevents creation of the second service.
Initialization errors are returned unchanged. See AndThenFactory.
Sourcepub fn apply<U>(
self,
tr: U,
) -> ServiceChainFactory<ApplyMiddleware<U, Sf>, St, Req>
pub fn apply<U>( self, tr: U, ) -> ServiceChainFactory<ApplyMiddleware<U, Sf>, St, Req>
Applies middleware to this service factory.
This is shorthand for calling crate::apply on the chained factory.
The inner factory creates a service first, then the middleware wraps it
synchronously with the same state reference. Initialization errors
bypass the middleware.
For the result to implement ServiceFactory, the middleware’s service
must accept the same state and request types. It may change response and
service-error types.
Sourcepub fn apply_fn<F, In, Out, Err>(
self,
f: F,
) -> ServiceChainFactory<ApplyFactory<F, Sf, St, Req, In, Out, Err>, St, In>where
F: AsyncFn(In, &ApplyCtx<'_, <Sf as ServiceFactory<St, Req>>::Service, St, Req>) -> Result<Out, Err> + Clone,
Err: From<<Sf as ServiceFactory<St, Req>>::Error>,
pub fn apply_fn<F, In, Out, Err>(
self,
f: F,
) -> ServiceChainFactory<ApplyFactory<F, Sf, St, Req, In, Out, Err>, St, In>where
F: AsyncFn(In, &ApplyCtx<'_, <Sf as ServiceFactory<St, Req>>::Service, St, Req>) -> Result<Out, Err> + Clone,
Err: From<<Sf as ServiceFactory<St, Req>>::Error>,
Applies an asynchronous function as middleware to this service factory.
This is shorthand for calling crate::apply_fn_factory on the chained
factory. Each successful creation wraps the service with a clone of the
function, which receives an input request and an ApplyCtx.
Request, response, and service-error types may change; state and
initialization errors remain unchanged. See crate::apply_fn for
lifecycle forwarding and readiness semantics.
Sourcepub fn then<F, U>(
self,
factory: F,
) -> ServiceChainFactory<ThenFactory<Sf, U>, St, Req>where
ServiceChainFactory<Sf, St, Req>: Sized,
F: IntoServiceFactory<U, St, Result<<Sf as ServiceFactory<St, Req>>::Res, <Sf as ServiceFactory<St, Req>>::Error>>,
U: ServiceFactory<St, Result<<Sf as ServiceFactory<St, Req>>::Res, <Sf as ServiceFactory<St, Req>>::Error>, Error = <Sf as ServiceFactory<St, Req>>::Error, InitError = <Sf as ServiceFactory<St, Req>>::InitError>,
pub fn then<F, U>(
self,
factory: F,
) -> ServiceChainFactory<ThenFactory<Sf, U>, St, Req>where
ServiceChainFactory<Sf, St, Req>: Sized,
F: IntoServiceFactory<U, St, Result<<Sf as ServiceFactory<St, Req>>::Res, <Sf as ServiceFactory<St, Req>>::Error>>,
U: ServiceFactory<St, Result<<Sf as ServiceFactory<St, Req>>::Res, <Sf as ServiceFactory<St, Req>>::Error>, Error = <Sf as ServiceFactory<St, Req>>::Error, InitError = <Sf as ServiceFactory<St, Req>>::InitError>,
Chains a factory whose services receive the preceding service’s complete
Result.
The second service can recover from a failed first call or transform a successful response. Both services use the same state and error types. Errors from the chain’s readiness check are returned directly, rather than passed to the second service.
Factories must also share their initialization-error type. Creation is
sequential with the same state reference, and an initialization error
stops construction rather than being passed to the next factory.
See ThenFactory for an example.
Sourcepub fn map<F, Res>(
self,
f: F,
) -> ServiceChainFactory<MapFactory<F, Sf, Res>, St, Req>where
ServiceChainFactory<Sf, St, Req>: Sized,
F: Fn(<Sf as ServiceFactory<St, Req>>::Res) -> Res + Clone,
pub fn map<F, Res>(
self,
f: F,
) -> ServiceChainFactory<MapFactory<F, Sf, Res>, St, Req>where
ServiceChainFactory<Sf, St, Req>: Sized,
F: Fn(<Sf as ServiceFactory<St, Req>>::Res) -> Res + Clone,
Maps responses produced by this factory’s services.
Each successful creation clones the synchronous mapping function into
the new service. The function runs only on successful responses, not
during initialization. Request, state, service-error, and
initialization-error types are unchanged. See MapFactory.
Sourcepub fn map_err<F, E>(
self,
f: F,
) -> ServiceChainFactory<MapErrFactory<F, Sf, E>, St, Req>where
ServiceChainFactory<Sf, St, Req>: Sized,
F: Fn(<Sf as ServiceFactory<St, Req>>::Error) -> E + Clone,
pub fn map_err<F, E>(
self,
f: F,
) -> ServiceChainFactory<MapErrFactory<F, Sf, E>, St, Req>where
ServiceChainFactory<Sf, St, Req>: Sized,
F: Fn(<Sf as ServiceFactory<St, Req>>::Error) -> E + Clone,
Maps errors produced by this factory’s services.
Each successful creation clones the synchronous mapping function into
the new service. It transforms call and readiness errors, leaving
successful responses unchanged. Initialization errors are not mapped;
use Self::map_init_err for those. See MapErrFactory.
Sourcepub fn map_init_err<F, E>(
self,
f: F,
) -> ServiceChainFactory<MapInitErr<F, Sf, E>, St, Req>where
ServiceChainFactory<Sf, St, Req>: Sized,
F: Fn(<Sf as ServiceFactory<St, Req>>::InitError) -> E + Clone,
pub fn map_init_err<F, E>(
self,
f: F,
) -> ServiceChainFactory<MapInitErr<F, Sf, E>, St, Req>where
ServiceChainFactory<Sf, St, Req>: Sized,
F: Fn(<Sf as ServiceFactory<St, Req>>::InitError) -> E + Clone,
Maps this factory’s initialization error.
The synchronous function runs only when creating the inner service
fails. Successful services are returned unchanged, including their
call and readiness error types. Use Self::map_err to map those.
Sourcepub fn readiness<F>(
self,
ready: F,
) -> ServiceChainFactory<AndThenFactory<Sf, FnReadiness<F, <Sf as ServiceFactory<St, Req>>::Error>>, St, Req>where
ServiceChainFactory<Sf, St, Req>: Sized,
F: AsyncFn(&St) -> Result<(), <Sf as ServiceFactory<St, Req>>::Error> + Clone,
pub fn readiness<F>(
self,
ready: F,
) -> ServiceChainFactory<AndThenFactory<Sf, FnReadiness<F, <Sf as ServiceFactory<St, Req>>::Error>>, St, Req>where
ServiceChainFactory<Sf, St, Req>: Sized,
F: AsyncFn(&St) -> Result<(), <Sf as ServiceFactory<St, Req>>::Error> + Clone,
Adds a custom readiness check to each created service.
Each created service gets a clone of the callback. Its readiness future is polled alongside the wrapped service’s readiness future; the service is ready only when both succeed. Requests and responses are unchanged.
The inner factory must have std::convert::Infallible initialization
errors for this composition to implement ServiceFactory.
Successful readiness can be cached, so the callback need not run for
every request.
The callback receives only pipeline state. For scoped readiness and
change notifications, implement Service directly.
Sourcepub fn shutdown<F>(
self,
sh: F,
) -> ServiceChainFactory<AndThenFactory<Sf, FnShutdown<F, <Sf as ServiceFactory<St, Req>>::Error>>, St, Req>
pub fn shutdown<F>( self, sh: F, ) -> ServiceChainFactory<AndThenFactory<Sf, FnShutdown<F, <Sf as ServiceFactory<St, Req>>::Error>>, St, Req>
Adds a shutdown callback to each created service.
Each service gets its own callback, invoked at most once with pipeline state. It is polled alongside the inner service’s shutdown, and shutdown waits for both. Cancellation does not restore a consumed callback; dropping a service alone does not invoke it.
The inner factory must have std::convert::Infallible initialization
errors for this composition to implement ServiceFactory.
Sourcepub async fn pipeline(
&self,
st: St,
) -> Result<Pipeline<Req, <Sf as ServiceFactory<St, Req>>::Res, <Sf as ServiceFactory<St, Req>>::Error>, <Sf as ServiceFactory<St, Req>>::InitError>where
Sf: 'static,
St: 'static,
Req: 'static,
pub async fn pipeline(
&self,
st: St,
) -> Result<Pipeline<Req, <Sf as ServiceFactory<St, Req>>::Res, <Sf as ServiceFactory<St, Req>>::Error>, <Sf as ServiceFactory<St, Req>>::InitError>where
Sf: 'static,
St: 'static,
Req: 'static,
Creates a service and wraps it with its state in a Pipeline.
The factory first borrows st for creation, then the pipeline takes
ownership of both state and service and binds readiness notifications.
Creation errors are returned unchanged.
This does not wait for service readiness. Use Pipeline::ready to
check it explicitly; Pipeline::call checks it before dispatch.
Each invocation creates a new service and enclosing pipeline readiness
scope, subject to any sharing introduced by the inner factory.
Trait Implementations§
Source§impl<Sf, St, Req> Clone for ServiceChainFactory<Sf, St, Req>where
Sf: Clone,
impl<Sf, St, Req> Clone for ServiceChainFactory<Sf, St, Req>where
Sf: Clone,
Source§fn clone(&self) -> ServiceChainFactory<Sf, St, Req>
fn clone(&self) -> ServiceChainFactory<Sf, St, Req>
1.0.0 (const: unstable) · Source§fn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
source. Read moreSource§impl<Sf, St, Req> Debug for ServiceChainFactory<Sf, St, Req>where
Sf: Debug,
impl<Sf, St, Req> Debug for ServiceChainFactory<Sf, St, Req>where
Sf: Debug,
Source§impl<Sf, St, Req> ServiceFactory<St, Req> for ServiceChainFactory<Sf, St, Req>where
Sf: ServiceFactory<St, Req>,
impl<Sf, St, Req> ServiceFactory<St, Req> for ServiceChainFactory<Sf, St, Req>where
Sf: ServiceFactory<St, Req>,
Source§type Res = <Sf as ServiceFactory<St, Req>>::Res
type Res = <Sf as ServiceFactory<St, Req>>::Res
Source§type Error = <Sf as ServiceFactory<St, Req>>::Error
type Error = <Sf as ServiceFactory<St, Req>>::Error
Source§type Service = <Sf as ServiceFactory<St, Req>>::Service
type Service = <Sf as ServiceFactory<St, Req>>::Service
Service produced by this factory.Source§type InitError = <Sf as ServiceFactory<St, Req>>::InitError
type InitError = <Sf as ServiceFactory<St, Req>>::InitError
Source§async fn create(
&self,
st: &St,
) -> Result<<Sf as ServiceFactory<St, Req>>::Service, <Sf as ServiceFactory<St, Req>>::InitError>
async fn create( &self, st: &St, ) -> Result<<Sf as ServiceFactory<St, Req>>::Service, <Sf as ServiceFactory<St, Req>>::InitError>
Source§async fn pipeline(
&self,
st: St,
) -> Result<Pipeline<Req, Self::Res, Self::Error>, Self::InitError>where
Self: 'static,
St: 'static,
Req: 'static,
async fn pipeline(
&self,
st: St,
) -> Result<Pipeline<Req, Self::Res, Self::Error>, Self::InitError>where
Self: 'static,
St: 'static,
Req: 'static,
Pipeline.