[−][src]Trait tower_grpc::codegen::server::tower::MakeService

pub trait MakeService<Target, Request>: Sealed<(Target, Request)> where
    <Self::Service as Service<Request>>::Response == Self::Response,
    <Self::Service as Service<Request>>::Error == Self::Error,
    <Self::Future as Future>::Item == Self::Service,
    <Self::Future as Future>::Error == Self::MakeError, {
    type Response;
    type Error;
    type Service: Service<Request>;
    type MakeError;
    type Future: Future;
    fn poll_ready(&mut self) -> Result<Async<()>, Self::MakeError>;

    fn make_service(&mut self, target: Target) -> Self::Future;
}

Creates new Service values.

Acts as a service factory. This is useful for cases where new Service values must be produced. One case is a TCP servier listener. The listner accepts new TCP streams, obtains a new Service value using the MakeService trait, and uses that new Service value to process inbound requests on that new TCP stream.

This is essentially a trait alias for a Service of Services.

Associated Types

type Response

Responses given by the service

type Error

Errors produced by the service

type Service: Service<Request>

The Service value created by this factory

type MakeError

Errors produced while building a service.

type Future: Future

The future of the Service instance.

Loading content...

Required methods

fn poll_ready(&mut self) -> Result<Async<()>, Self::MakeError>

Returns Ready when the factory is able to process create more services.

If the service is at capacity, then NotReady is returned and the task is notified when the service becomes ready again. This function is expected to be called while on a task.

This is a best effort implementation. False positives are permitted. It is permitted for the service to return Ready from a poll_ready call and the next invocation of call results in an error.

fn make_service(&mut self, target: Target) -> Self::Future

Create and return a new service value asynchronously.

Loading content...

Implementors

impl<M, S, Target, Request> MakeService<Target, Request> for M where
    M: Service<Target, Response = S>,
    S: Service<Request>, [src]

type Response = <S as Service<Request>>::Response

type Error = <S as Service<Request>>::Error

type Service = S

type MakeError = <M as Service<Target>>::Error

type Future = <M as Service<Target>>::Future

Loading content...