Trait Service 

pub trait Service<Input>:
    Sized
    + Send
    + Sync
    + 'static {
    type Output: Send + 'static;
    type Error: Send + 'static;

    // Required method
    fn serve(
        &self,
        input: Input,
    ) -> impl Future<Output = Result<Self::Output, Self::Error>> + Send;

    // Provided method
    fn boxed(self) -> BoxService<Input, Self::Output, Self::Error> { ... }
}

A Service that produces rama services, to serve given an input, be it transport layer Inputs or application layer http requests, or something else entirely.

Required Associated Types

type Output: Send + 'static

The type of the output returned by the service.

type Error: Send + 'static

The type of error returned by the service.

Required Methods

fn serve( &self, input: Input, ) -> impl Future<Output = Result<Self::Output, Self::Error>> + Send

Serve an output or an error for the given input

Provided Methods

fn boxed(self) -> BoxService<Input, Self::Output, Self::Error>

Box this service to allow for dynamic dispatch.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl<Input> Service<Input> for ()

where Input: Send + 'static,

type Output = Input

type Error = !

async fn serve( &self, input: Input, ) -> Result<<() as Service<Input>>::Output, <() as Service<Input>>::Error>

impl<S, Input> Service<Input> for &'static S

where S: Service<Input>,

type Output = <S as Service<Input>>::Output

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

fn serve( &self, input: Input, ) -> impl Future<Output = Result<<&'static S as Service<Input>>::Output, <&'static S as Service<Input>>::Error>> + Send

Implementors

impl Service<AppendRecord> for Collection

type Output = RecordId

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

impl Service<AppendRecord> for CollectionWriter

type Output = RecordId

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

impl Service<AsyncWebSocket> for WebSocketEchoService

type Output = ()

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

impl Service<BridgeIo<Connection, Connection>> for QuicRelay

type Output = ()

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

impl Service<CaptureQuery> for CaptureStore

type Output = CaptureSnapshot

type Error = !

impl Service<ConnectRequest> for SharedQuicEndpoint

type Output = EstablishedClientConnection<ClientEndpoint, ConnectRequest>

type Error = ConnectionError

impl Service<ConnectRequest> for UdpConnector

type Output = EstablishedClientConnection<UdpPacketSocket, ConnectRequest>

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

impl Service<CreateCollection> for FileStore

type Output = Collection

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

impl Service<CreateCollection> for MemoryStore

type Output = Collection

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

impl Service<FastCgiClientRequest> for FastCgiTcpConnector

type Output = EstablishedClientConnection<TcpStream, FastCgiClientRequest>

type Error = ConnectionError

impl Service<FastCgiClientRequest> for FastCgiUnixConnector

type Output = EstablishedClientConnection<UnixStream, FastCgiClientRequest>

type Error = ConnectionError

impl Service<ListRecords> for Collection

type Output = Vec<RecordId>

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

impl Service<ListRecords> for CollectionReader

type Output = Vec<RecordId>

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

impl Service<OptionsRequest> for NoOptionsDiscovery

type Output = Arc<ServiceCapabilities>

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

impl Service<ReadRecord> for Collection

type Output = Pin<Box<dyn AsyncRead + Send>>

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

impl Service<ReadRecord> for CollectionReader

type Output = Pin<Box<dyn AsyncRead + Send>>

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

impl Service<Request> for rama::cli::service::echo::EchoService

Available on crate features cli and haproxy and http and net and std only.

type Output = Response

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

impl Service<Request> for GrpcRouter

type Output = Response

type Error = !

impl Service<SocketAddress> for DefaultAcceptorFactory

type Output = TcpListener

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

impl Service<SocketAddress> for DefaultUdpBinder

type Output = UdpSocket

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

impl Service<SocketAddress> for UdpSocketFactory

type Output = UdpPacketSocket

type Error = DatagramError

impl Service<SystemProxyPacRequest> for SystemPacResolver

type Output = Option<ProxyRoutes>

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

impl Service<TlsMitmClientAuthInput> for TlsMitmClientAuthPolicy

type Output = TlsMitmClientAuthPlan

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

impl Service<Upgraded> for WebSocketEchoService

type Output = ()

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

impl Service<Uri> for FetchPacScript

type Output = PacScript

type Error = OpaqueError

impl Service<Uri> for StaticPacScript

type Output = PacScript

type Error = OpaqueError

impl Service<Uri> for SystemPacProxy

type Output = SystemPacResolver

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

impl<A, B, C, D, E, F, G, H, I, Input, Output> Service<Input> for Either9<A, B, C, D, E, F, G, H, I>

where A: Service<Input, Output = Output>, B: Service<Input, Output = Output>, <B as Service<Input>>::Error: Into<<A as Service<Input>>::Error>, C: Service<Input, Output = Output>, <C as Service<Input>>::Error: Into<<A as Service<Input>>::Error>, D: Service<Input, Output = Output>, <D as Service<Input>>::Error: Into<<A as Service<Input>>::Error>, E: Service<Input, Output = Output>, <E as Service<Input>>::Error: Into<<A as Service<Input>>::Error>, F: Service<Input, Output = Output>, <F as Service<Input>>::Error: Into<<A as Service<Input>>::Error>, G: Service<Input, Output = Output>, <G as Service<Input>>::Error: Into<<A as Service<Input>>::Error>, H: Service<Input, Output = Output>, <H as Service<Input>>::Error: Into<<A as Service<Input>>::Error>, I: Service<Input, Output = Output>, <I as Service<Input>>::Error: Into<<A as Service<Input>>::Error>, Input: Send + 'static, Output: Send + 'static,

type Output = Output

type Error = <A as Service<Input>>::Error

impl<A, B, C, D, E, F, G, H, I, Input, Output> Service<Input> for EitherConn9Connected<A, B, C, D, E, F, G, H, I>

where A: Service<Input, Output = Output>, <A as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, B: Service<Input, Output = Output>, <B as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, C: Service<Input, Output = Output>, <C as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, D: Service<Input, Output = Output>, <D as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, E: Service<Input, Output = Output>, <E as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, F: Service<Input, Output = Output>, <F as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, G: Service<Input, Output = Output>, <G as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, H: Service<Input, Output = Output>, <H as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, I: Service<Input, Output = Output>, <I as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, Input: Send + 'static, Output: Send + 'static,

type Output = Output

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

impl<A, B, C, D, E, F, G, H, Input, Output> Service<Input> for Either8<A, B, C, D, E, F, G, H>

where A: Service<Input, Output = Output>, B: Service<Input, Output = Output>, <B as Service<Input>>::Error: Into<<A as Service<Input>>::Error>, C: Service<Input, Output = Output>, <C as Service<Input>>::Error: Into<<A as Service<Input>>::Error>, D: Service<Input, Output = Output>, <D as Service<Input>>::Error: Into<<A as Service<Input>>::Error>, E: Service<Input, Output = Output>, <E as Service<Input>>::Error: Into<<A as Service<Input>>::Error>, F: Service<Input, Output = Output>, <F as Service<Input>>::Error: Into<<A as Service<Input>>::Error>, G: Service<Input, Output = Output>, <G as Service<Input>>::Error: Into<<A as Service<Input>>::Error>, H: Service<Input, Output = Output>, <H as Service<Input>>::Error: Into<<A as Service<Input>>::Error>, Input: Send + 'static, Output: Send + 'static,

type Output = Output

type Error = <A as Service<Input>>::Error

impl<A, B, C, D, E, F, G, H, Input, Output> Service<Input> for EitherConn8Connected<A, B, C, D, E, F, G, H>

where A: Service<Input, Output = Output>, <A as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, B: Service<Input, Output = Output>, <B as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, C: Service<Input, Output = Output>, <C as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, D: Service<Input, Output = Output>, <D as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, E: Service<Input, Output = Output>, <E as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, F: Service<Input, Output = Output>, <F as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, G: Service<Input, Output = Output>, <G as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, H: Service<Input, Output = Output>, <H as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, Input: Send + 'static, Output: Send + 'static,

type Output = Output

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

impl<A, B, C, D, E, F, G, Input, Output> Service<Input> for Either7<A, B, C, D, E, F, G>

where A: Service<Input, Output = Output>, B: Service<Input, Output = Output>, <B as Service<Input>>::Error: Into<<A as Service<Input>>::Error>, C: Service<Input, Output = Output>, <C as Service<Input>>::Error: Into<<A as Service<Input>>::Error>, D: Service<Input, Output = Output>, <D as Service<Input>>::Error: Into<<A as Service<Input>>::Error>, E: Service<Input, Output = Output>, <E as Service<Input>>::Error: Into<<A as Service<Input>>::Error>, F: Service<Input, Output = Output>, <F as Service<Input>>::Error: Into<<A as Service<Input>>::Error>, G: Service<Input, Output = Output>, <G as Service<Input>>::Error: Into<<A as Service<Input>>::Error>, Input: Send + 'static, Output: Send + 'static,

type Output = Output

type Error = <A as Service<Input>>::Error

impl<A, B, C, D, E, F, G, Input, Output> Service<Input> for EitherConn7Connected<A, B, C, D, E, F, G>

where A: Service<Input, Output = Output>, <A as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, B: Service<Input, Output = Output>, <B as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, C: Service<Input, Output = Output>, <C as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, D: Service<Input, Output = Output>, <D as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, E: Service<Input, Output = Output>, <E as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, F: Service<Input, Output = Output>, <F as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, G: Service<Input, Output = Output>, <G as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, Input: Send + 'static, Output: Send + 'static,

type Output = Output

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

impl<A, B, C, D, E, F, Input, Output> Service<Input> for Either6<A, B, C, D, E, F>

where A: Service<Input, Output = Output>, B: Service<Input, Output = Output>, <B as Service<Input>>::Error: Into<<A as Service<Input>>::Error>, C: Service<Input, Output = Output>, <C as Service<Input>>::Error: Into<<A as Service<Input>>::Error>, D: Service<Input, Output = Output>, <D as Service<Input>>::Error: Into<<A as Service<Input>>::Error>, E: Service<Input, Output = Output>, <E as Service<Input>>::Error: Into<<A as Service<Input>>::Error>, F: Service<Input, Output = Output>, <F as Service<Input>>::Error: Into<<A as Service<Input>>::Error>, Input: Send + 'static, Output: Send + 'static,

type Output = Output

type Error = <A as Service<Input>>::Error

impl<A, B, C, D, E, F, Input, Output> Service<Input> for EitherConn6Connected<A, B, C, D, E, F>

where A: Service<Input, Output = Output>, <A as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, B: Service<Input, Output = Output>, <B as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, C: Service<Input, Output = Output>, <C as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, D: Service<Input, Output = Output>, <D as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, E: Service<Input, Output = Output>, <E as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, F: Service<Input, Output = Output>, <F as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, Input: Send + 'static, Output: Send + 'static,

type Output = Output

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

impl<A, B, C, D, E, Input, Output> Service<Input> for Either5<A, B, C, D, E>

where A: Service<Input, Output = Output>, B: Service<Input, Output = Output>, <B as Service<Input>>::Error: Into<<A as Service<Input>>::Error>, C: Service<Input, Output = Output>, <C as Service<Input>>::Error: Into<<A as Service<Input>>::Error>, D: Service<Input, Output = Output>, <D as Service<Input>>::Error: Into<<A as Service<Input>>::Error>, E: Service<Input, Output = Output>, <E as Service<Input>>::Error: Into<<A as Service<Input>>::Error>, Input: Send + 'static, Output: Send + 'static,

type Output = Output

type Error = <A as Service<Input>>::Error

impl<A, B, C, D, E, Input, Output> Service<Input> for EitherConn5Connected<A, B, C, D, E>

where A: Service<Input, Output = Output>, <A as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, B: Service<Input, Output = Output>, <B as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, C: Service<Input, Output = Output>, <C as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, D: Service<Input, Output = Output>, <D as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, E: Service<Input, Output = Output>, <E as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, Input: Send + 'static, Output: Send + 'static,

type Output = Output

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

impl<A, B, C, D, Input, Output> Service<Input> for Either4<A, B, C, D>

where A: Service<Input, Output = Output>, B: Service<Input, Output = Output>, <B as Service<Input>>::Error: Into<<A as Service<Input>>::Error>, C: Service<Input, Output = Output>, <C as Service<Input>>::Error: Into<<A as Service<Input>>::Error>, D: Service<Input, Output = Output>, <D as Service<Input>>::Error: Into<<A as Service<Input>>::Error>, Input: Send + 'static, Output: Send + 'static,

type Output = Output

type Error = <A as Service<Input>>::Error

impl<A, B, C, D, Input, Output> Service<Input> for EitherConn4Connected<A, B, C, D>

where A: Service<Input, Output = Output>, <A as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, B: Service<Input, Output = Output>, <B as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, C: Service<Input, Output = Output>, <C as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, D: Service<Input, Output = Output>, <D as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, Input: Send + 'static, Output: Send + 'static,

type Output = Output

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

impl<A, B, C, Input, Output> Service<Input> for Either3<A, B, C>

where A: Service<Input, Output = Output>, B: Service<Input, Output = Output>, <B as Service<Input>>::Error: Into<<A as Service<Input>>::Error>, C: Service<Input, Output = Output>, <C as Service<Input>>::Error: Into<<A as Service<Input>>::Error>, Input: Send + 'static, Output: Send + 'static,

type Output = Output

type Error = <A as Service<Input>>::Error

impl<A, B, C, Input, Output> Service<Input> for EitherConn3Connected<A, B, C>

where A: Service<Input, Output = Output>, <A as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, B: Service<Input, Output = Output>, <B as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, C: Service<Input, Output = Output>, <C as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, Input: Send + 'static, Output: Send + 'static,

type Output = Output

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

impl<A, B, Input, Output> Service<Input> for Either<A, B>

where A: Service<Input, Output = Output>, B: Service<Input, Output = Output>, <B as Service<Input>>::Error: Into<<A as Service<Input>>::Error>, Input: Send + 'static, Output: Send + 'static,

type Output = Output

type Error = <A as Service<Input>>::Error

impl<A, B, Input, Output> Service<Input> for EitherConnConnected<A, B>

where A: Service<Input, Output = Output>, <A as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, B: Service<Input, Output = Output>, <B as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, Input: Send + 'static, Output: Send + 'static,

type Output = Output

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

impl<A, B, T, EA, EB> Service<StreamBridge<A, B>> for StreamForwardService

where A: Stream<Item = Result<T, EA>> + Sink<T, Error = EA> + Send + Unpin + 'static, B: Stream<Item = Result<T, EB>> + Sink<T, Error = EB> + Send + Unpin + 'static, T: Send + 'static, EA: Into<Box<dyn Error + Send + Sync>> + Send + 'static, EB: Into<Box<dyn Error + Send + Sync>> + Send + 'static,

type Output = BridgeCloseReason

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

impl<A, B> Service<BridgeIo<A, B>> for ConnectUdpRelay

where A: DatagramSocket, B: DatagramSocket,

type Output = ()

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

impl<A, B> Service<BridgeIo<A, B>> for DatagramForwardService

where A: DatagramSocket, B: DatagramSocket,

Forward between two connected sockets, as Peer::connected makes them: a DatagramToProxyBridge association, for example.

type Output = ()

type Error = DatagramForwardError

impl<A, B> Service<BridgeIo<Peer<A>, Peer<B>>> for DatagramForwardService

where A: DatagramSocket, B: DatagramSocket,

type Output = ()

type Error = DatagramForwardError

impl<A, C, L, S, ReqBody, ResBody> Service<Request<ReqBody>> for ProxyAuthService<A, C, S, L>

where A: Authority<C, L>, C: Credentials + Extension + Clone, S: Service<Request<ReqBody>, Output = Response<ResBody>>, <S as Service<Request<ReqBody>>>::Error: Into<Box<dyn Error + Send + Sync>>, L: 'static, ReqBody: Send + 'static, ResBody: Send + 'static,

type Output = Response<OptionalBody<ResBody>>

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

impl<A, ConnA, B, ConnB, C, ConnC, D, ConnD, E, ConnE, F, ConnF, G, ConnG, H, ConnH, I, ConnI, Input> Service<Input> for EitherConn9<A, B, C, D, E, F, G, H, I>

where A: ConnectorService<Input, Connection = ConnA>, ConnA: Send + 'static, B: ConnectorService<Input, Connection = ConnB>, ConnB: Send + 'static, C: ConnectorService<Input, Connection = ConnC>, ConnC: Send + 'static, D: ConnectorService<Input, Connection = ConnD>, ConnD: Send + 'static, E: ConnectorService<Input, Connection = ConnE>, ConnE: Send + 'static, F: ConnectorService<Input, Connection = ConnF>, ConnF: Send + 'static, G: ConnectorService<Input, Connection = ConnG>, ConnG: Send + 'static, H: ConnectorService<Input, Connection = ConnH>, ConnH: Send + 'static, I: ConnectorService<Input, Connection = ConnI>, ConnI: Send + 'static, Input: Send + 'static,

type Output = EstablishedClientConnection<EitherConn9Connected<ConnA, ConnB, ConnC, ConnD, ConnE, ConnF, ConnG, ConnH, ConnI>, Input>

type Error = ConnectionError

impl<A, ConnA, B, ConnB, C, ConnC, D, ConnD, E, ConnE, F, ConnF, G, ConnG, H, ConnH, Input> Service<Input> for EitherConn8<A, B, C, D, E, F, G, H>

where A: ConnectorService<Input, Connection = ConnA>, ConnA: Send + 'static, B: ConnectorService<Input, Connection = ConnB>, ConnB: Send + 'static, C: ConnectorService<Input, Connection = ConnC>, ConnC: Send + 'static, D: ConnectorService<Input, Connection = ConnD>, ConnD: Send + 'static, E: ConnectorService<Input, Connection = ConnE>, ConnE: Send + 'static, F: ConnectorService<Input, Connection = ConnF>, ConnF: Send + 'static, G: ConnectorService<Input, Connection = ConnG>, ConnG: Send + 'static, H: ConnectorService<Input, Connection = ConnH>, ConnH: Send + 'static, Input: Send + 'static,

type Output = EstablishedClientConnection<EitherConn8Connected<ConnA, ConnB, ConnC, ConnD, ConnE, ConnF, ConnG, ConnH>, Input>

type Error = ConnectionError

impl<A, ConnA, B, ConnB, C, ConnC, D, ConnD, E, ConnE, F, ConnF, G, ConnG, Input> Service<Input> for EitherConn7<A, B, C, D, E, F, G>

where A: ConnectorService<Input, Connection = ConnA>, ConnA: Send + 'static, B: ConnectorService<Input, Connection = ConnB>, ConnB: Send + 'static, C: ConnectorService<Input, Connection = ConnC>, ConnC: Send + 'static, D: ConnectorService<Input, Connection = ConnD>, ConnD: Send + 'static, E: ConnectorService<Input, Connection = ConnE>, ConnE: Send + 'static, F: ConnectorService<Input, Connection = ConnF>, ConnF: Send + 'static, G: ConnectorService<Input, Connection = ConnG>, ConnG: Send + 'static, Input: Send + 'static,

type Output = EstablishedClientConnection<EitherConn7Connected<ConnA, ConnB, ConnC, ConnD, ConnE, ConnF, ConnG>, Input>

type Error = ConnectionError

impl<A, ConnA, B, ConnB, C, ConnC, D, ConnD, E, ConnE, F, ConnF, Input> Service<Input> for EitherConn6<A, B, C, D, E, F>

where A: ConnectorService<Input, Connection = ConnA>, ConnA: Send + 'static, B: ConnectorService<Input, Connection = ConnB>, ConnB: Send + 'static, C: ConnectorService<Input, Connection = ConnC>, ConnC: Send + 'static, D: ConnectorService<Input, Connection = ConnD>, ConnD: Send + 'static, E: ConnectorService<Input, Connection = ConnE>, ConnE: Send + 'static, F: ConnectorService<Input, Connection = ConnF>, ConnF: Send + 'static, Input: Send + 'static,

type Output = EstablishedClientConnection<EitherConn6Connected<ConnA, ConnB, ConnC, ConnD, ConnE, ConnF>, Input>

type Error = ConnectionError

impl<A, ConnA, B, ConnB, C, ConnC, D, ConnD, E, ConnE, Input> Service<Input> for EitherConn5<A, B, C, D, E>

where A: ConnectorService<Input, Connection = ConnA>, ConnA: Send + 'static, B: ConnectorService<Input, Connection = ConnB>, ConnB: Send + 'static, C: ConnectorService<Input, Connection = ConnC>, ConnC: Send + 'static, D: ConnectorService<Input, Connection = ConnD>, ConnD: Send + 'static, E: ConnectorService<Input, Connection = ConnE>, ConnE: Send + 'static, Input: Send + 'static,

type Output = EstablishedClientConnection<EitherConn5Connected<ConnA, ConnB, ConnC, ConnD, ConnE>, Input>

type Error = ConnectionError

impl<A, ConnA, B, ConnB, C, ConnC, D, ConnD, Input> Service<Input> for EitherConn4<A, B, C, D>

where A: ConnectorService<Input, Connection = ConnA>, ConnA: Send + 'static, B: ConnectorService<Input, Connection = ConnB>, ConnB: Send + 'static, C: ConnectorService<Input, Connection = ConnC>, ConnC: Send + 'static, D: ConnectorService<Input, Connection = ConnD>, ConnD: Send + 'static, Input: Send + 'static,

type Output = EstablishedClientConnection<EitherConn4Connected<ConnA, ConnB, ConnC, ConnD>, Input>

type Error = ConnectionError

impl<A, ConnA, B, ConnB, C, ConnC, Input> Service<Input> for EitherConn3<A, B, C>

where A: ConnectorService<Input, Connection = ConnA>, ConnA: Send + 'static, B: ConnectorService<Input, Connection = ConnB>, ConnB: Send + 'static, C: ConnectorService<Input, Connection = ConnC>, ConnC: Send + 'static, Input: Send + 'static,

type Output = EstablishedClientConnection<EitherConn3Connected<ConnA, ConnB, ConnC>, Input>

type Error = ConnectionError

impl<A, ConnA, B, ConnB, Input> Service<Input> for EitherConn<A, B>

where A: ConnectorService<Input, Connection = ConnA>, ConnA: Send + 'static, B: ConnectorService<Input, Connection = ConnB>, ConnB: Send + 'static, Input: Send + 'static,

type Output = EstablishedClientConnection<EitherConnConnected<ConnA, ConnB>, Input>

type Error = ConnectionError

impl<A, H, R, L, B> Service<Request<B>> for ConnectIpService<A, H, R, L>

where A: Service<ConnectIpRequest<B>, Output = ConnectIpSessionConfig>, <A as Service<ConnectIpRequest<B>>>::Error: Into<Box<dyn Error + Send + Sync>>, H: Service<ConnectIpSession, Output = ()>, <H as Service<ConnectIpSession>>::Error: Into<Box<dyn Error + Send + Sync>>, R: DnsAddressResolver, L: AdmitTunnel<Request<B>>, B: Send + 'static,

type Output = Response

type Error = !

impl<B, S, Response, IO> Service<IO> for rama::http::server::service::HttpService<B, S>

where B: HttpCoreConnServer, S: Service<Request, Output = Response, Error = !> + Clone, Response: IntoResponse + Send + 'static, IO: Io + ExtensionsRef,

type Output = ()

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

impl<Body, ConnectionBody, Connection, IncomingBody, L> Service<Request<Body>> for EasyHttpWebClient<Body, EstablishedClientConnection<Connection, Request<ConnectionBody>>, L>

where Body: StreamingBody<Data: Send + 'static, Error: Into<BoxError>> + Unpin + Send + 'static, Connection: Service<Request<ConnectionBody>, Output = Response<IncomingBody>, Error = BoxError> + ExtensionsRef, IncomingBody: Send + Sync + 'static, Body: From<IncomingBody>, ConnectionBody: StreamingBody<Data: Send + 'static, Error: Into<BoxError>> + Unpin + Send + 'static, L: Layer<HttpForwardProxyService<MapResponseBody<Connection, fn(IncomingBody) -> Body>>, Service: Service<Request<ConnectionBody>, Output = Response, Error = BoxError>> + Send + Sync + 'static,

Available on crate features dns and http-backend and http and std and tcp only.

type Output = Response

type Error = OpaqueError

impl<Body, ResBody> Service<Request<Body>> for RedirectStatic<ResBody>

where Body: Send + 'static, ResBody: Send + 'static,

type Output = Response<OptionalBody<ResBody>>

type Error = !

impl<Body, S> Service<Request<Body>> for DnsResolveModeService<S>

where Body: Send + Sync + 'static, S: Service<Request<Body>>, <S as Service<Request<Body>>>::Error: Into<Box<dyn Error + Send + Sync>> + Send + Sync + 'static,

type Output = <S as Service<Request<Body>>>::Output

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

impl<Body> Service<Request<Body>> for HttpClientService<Body>

where Body: Body + Unpin + Send + 'static, <Body as Body>::Data: Send + 'static, <Body as Body>::Error: Into<Box<dyn Error + Send + Sync>>,

type Output = Response

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

impl<Body> Service<Request<Body>> for LazyHttpProxyConnectReplyService

where Body: Send + 'static,

type Output = UpgradeResponse<Request<Body>, Response>

type Error = Response

impl<Body> Service<Request<Body>> for WebSocketAcceptor

where Body: Send + 'static,

type Output = UpgradeResponse<Request<Body>, Response>

type Error = Response

impl<C, B, U, A, S> Service<S> for Socks5Acceptor<C, B, U, A>

where C: Socks5Connector<S>, U: Socks5UdpAssociator<S>, A: Authorizer<Basic>, <A as Authorizer<Basic>>::Error: Debug, B: Socks5Binder<S>, S: Io + Unpin + ExtensionsRef,

type Output = ()

type Error = Error

impl<C, IO> Service<OptionsRequest> for OptionsService<C>

where C: ConnectorService<ConnectRequest, Connection = ClientConnection<IO>>, IO: Io + Unpin + ExtensionsRef,

type Output = ServiceCapabilities

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

impl<C, Input> Service<Input> for TtrpcConnector<C>

where C: ConnectorService<Input>, <C as ConnectorService<Input>>::Connection: Io, Input: Send + 'static,

type Output = EstablishedClientConnection<Client, Input>

type Error = ConnectionError

impl<C, ReqBody, RespBody> Service<Request<ReqBody>> for BindBodyToConn<C>

where C: Service<Request<ReqBody>, Output = Response<RespBody>, Error = Box<dyn Error + Send + Sync>>, ReqBody: Send + 'static, RespBody: Body<Data = Bytes> + Send + Sync + 'static, <RespBody as Body>::Error: Into<Box<dyn Error + Send + Sync>>,

type Output = Response

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

impl<C, S, Body> Service<Request<Body>> for EagerHttpProxyConnector<C, S>

where C: ConnectorService<ConnectRequest>, <C as ConnectorService<ConnectRequest>>::Connection: Io + Unpin, S: Service<BridgeIo<Upgraded, <C as ConnectorService<ConnectRequest>>::Connection>> + Clone, <S as Service<BridgeIo<Upgraded, <C as ConnectorService<ConnectRequest>>::Connection>>>::Error: Into<Box<dyn Error + Send + Sync>>, Body: Send + 'static,

type Output = UpgradeOutput<Request<Body>, Response>

type Error = Response

impl<C, S, Response> Service<C> for rama::http::server::service::HttpService<Config, S>

where C: Connection, S: Service<Request, Output = Response, Error = !> + Clone, Response: IntoResponse + Send + 'static,

Available on crate feature quic only.

type Output = ()

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

impl<C> Service<ConnectRequest> for QuicEndpointConnector<C>

where C: ConnectorService<ConnectRequest>, <C as ConnectorService<ConnectRequest>>::Connection: DatagramSocket,

type Output = EstablishedClientConnection<ClientEndpoint, ConnectRequest>

type Error = ConnectionError

impl<C> Service<Request> for Http3EgressService<C>

where C: ReserveBiStreams,

type Output = Response

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

impl<E> Service<ConnectRequest> for Http3Connector<E>

where E: ConnectorService<ConnectRequest, Connection = ClientEndpoint>,

type Output = EstablishedClientConnection<Http3Transport, ConnectRequest>

type Error = ConnectionError

impl<E> Service<ConnectRequest> for QuicConnector<E>

where E: ConnectorService<ConnectRequest, Connection = ClientEndpoint>,

type Output = EstablishedClientConnection<Connection, ConnectRequest>

type Error = ConnectionError

impl<F, S, ReqBody, ResBody, NewReqBody> Service<Request<ReqBody>> for MapRequestBody<S, F>

where S: Service<Request<NewReqBody>, Output = Response<ResBody>>, ReqBody: Send + 'static, NewReqBody: Send + 'static, ResBody: Send + Sync + 'static, F: Fn(ReqBody) -> NewReqBody + Send + Sync + 'static,

type Output = <S as Service<Request<NewReqBody>>>::Output

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

impl<F, S, ReqBody, ResBody, NewResBody> Service<Request<ReqBody>> for MapResponseBody<S, F>

where S: Service<Request<ReqBody>, Output = Response<ResBody>>, ReqBody: Send + 'static, ResBody: Send + Sync + 'static, NewResBody: Send + Sync + 'static, F: Fn(ResBody) -> NewResBody + Clone + Send + Sync + 'static,

type Output = Response<NewResBody>

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

impl<F, T, State> Service<Request> for EndpointServiceFnWrapper<F, T, State>

where F: EndpointServiceFn<T, State>, T: Send + 'static, State: Send + Sync + Clone + 'static,

type Output = <F as Sealed<T, State>>::Output

type Error = <F as Sealed<T, State>>::Error

impl<H, S, Body> Service<Request<Body>> for GetForwardedHeaderService<S, H>

where H: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

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

impl<I, E, M, P, D> Service<BridgeIo<I, E>> for Http3MitmRelay<M, P, D>

where I: Connection, E: ReserveBiStreams, (RemoveRequestHeaderLayer, M, RemoveResponseHeaderLayer, ValidateRequestHeaderLayer<Option<BoundAuthority<P>>>): Layer<Http3EgressService<E>> + Clone, <(RemoveRequestHeaderLayer, M, RemoveResponseHeaderLayer, ValidateRequestHeaderLayer<Option<BoundAuthority<P>>>) as Layer<Http3EgressService<E>>>::Service: Service<Request, Output = Response> + Clone, <<(RemoveRequestHeaderLayer, M, RemoveResponseHeaderLayer, ValidateRequestHeaderLayer<Option<BoundAuthority<P>>>) as Layer<Http3EgressService<E>>>::Service as Service<Request>>::Error: Into<Box<dyn Error + Send + Sync>>, M: Send + Sync + 'static + Clone, P: Matcher<Request> + Clone, D: Service<BridgeIo<Upgraded, Upgraded>> + Clone, <D as Service<BridgeIo<Upgraded, Upgraded>>>::Error: Into<Box<dyn Error + Send + Sync>>,

type Output = ()

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

impl<I, F, Ingress, Egress> Service<BridgeIo<Ingress, Egress>> for Socks5MitmRelayService<I, F>

where I: Service<BridgeIo<Ingress, Egress>>, <I as Service<BridgeIo<Ingress, Egress>>>::Error: Into<Box<dyn Error + Send + Sync>>, F: Service<BridgeIo<Ingress, Egress>>, <F as Service<BridgeIo<Ingress, Egress>>>::Error: Into<Box<dyn Error + Send + Sync>>, Ingress: Io + Unpin + ExtensionsRef, Egress: Io + Unpin + ExtensionsRef,

type Output = ()

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

impl<I, K, S, F, O> Service<I> for PeekQuicClientHelloService<K, S, F>

where I: DatagramPeekInput, <I as DatagramPeekInput>::Mapped<PrefixedDatagramSocket<<I as DatagramPeekInput>::Socket>>: ExtensionsRef, K: KeyProvider + Send + Sync + 'static, S: Service<InputWithQuicClientHello<<I as DatagramPeekInput>::Mapped<PrefixedDatagramSocket<<I as DatagramPeekInput>::Socket>>>, Output = O>, <S as Service<InputWithQuicClientHello<<I as DatagramPeekInput>::Mapped<PrefixedDatagramSocket<<I as DatagramPeekInput>::Socket>>>>>::Error: Into<Box<dyn Error + Send + Sync>>, F: Service<<I as DatagramPeekInput>::Mapped<PrefixedDatagramSocket<<I as DatagramPeekInput>::Socket>>, Output = O>, <F as Service<<I as DatagramPeekInput>::Mapped<PrefixedDatagramSocket<<I as DatagramPeekInput>::Socket>>>>::Error: Into<Box<dyn Error + Send + Sync>>, O: Send + 'static,

type Output = O

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

impl<I, O> Service<I> for StaticOutput<O>

where I: Send + 'static, O: Clone + Send + Sync + 'static,

type Output = O

type Error = !

impl<I, P, Input> Service<Input> for InspectionGate<I, P>

where Input: Send + 'static, I: Service<Input, Output = ()>, <I as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, P: Service<Input, Output = ()>, <P as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>,

type Output = ()

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

impl<I, S> Service<I> for QuicAdmissionService<S>

where I: DatagramPeekInput, <I as DatagramPeekInput>::Socket: Socket, S: Service<I>, <S as Service<I>>::Error: Into<Box<dyn Error + Send + Sync>>,

type Output = <S as Service<I>>::Output

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

impl<IO> Service<IO> for TtrpcServer

where IO: Io,

type Output = ()

type Error = Error

impl<Ingress, Egress, M, P> Service<BridgeIo<Ingress, Egress>> for HttpMitmRelay<M, P>

where Ingress: Io + Unpin + ExtensionsRef, Egress: Io + Unpin + ExtensionsRef, (RemoveRequestHeaderLayer, M, RemoveResponseHeaderLayer, ValidateRequestHeaderLayer<Option<BoundAuthority<P>>>): Layer<HttpClientService<Body>> + Clone, <(RemoveRequestHeaderLayer, M, RemoveResponseHeaderLayer, ValidateRequestHeaderLayer<Option<BoundAuthority<P>>>) as Layer<HttpClientService<Body>>>::Service: Service<Request, Output = Response> + Clone, <<(RemoveRequestHeaderLayer, M, RemoveResponseHeaderLayer, ValidateRequestHeaderLayer<Option<BoundAuthority<P>>>) as Layer<HttpClientService<Body>>>::Service as Service<Request>>::Error: Into<Box<dyn Error + Send + Sync>>, M: Send + Sync + 'static + Clone, P: Matcher<Request> + Clone,

type Output = ()

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

impl<Inner, Ingress, Egress> Service<WebSocketBridge<Ingress, Egress>> for HARWebSocketService<Inner>

where Inner: Service<WebSocketBridge<HARWebSocket<Ingress>, HARWebSocket<Egress>>>, Ingress: WebSocketIo, Egress: WebSocketIo,

type Output = <Inner as Service<WebSocketBridge<HARWebSocket<Ingress>, HARWebSocket<Egress>>>>::Output

type Error = <Inner as Service<WebSocketBridge<HARWebSocket<Ingress>, HARWebSocket<Egress>>>>::Error

impl<Inner, Socket> Service<ClientWebSocket<Socket>> for HARWebSocketService<Inner>

where Inner: Service<ClientWebSocket<HARWebSocket<Socket>>>, Socket: WebSocketIo,

type Output = <Inner as Service<ClientWebSocket<HARWebSocket<Socket>>>>::Output

type Error = <Inner as Service<ClientWebSocket<HARWebSocket<Socket>>>>::Error

impl<Inner, Socket> Service<ServerWebSocket<Socket>> for HARWebSocketService<Inner>

where Inner: Service<ServerWebSocket<HARWebSocket<Socket>>>, Socket: WebSocketIo,

type Output = <Inner as Service<ServerWebSocket<HARWebSocket<Socket>>>>::Output

type Error = <Inner as Service<ServerWebSocket<HARWebSocket<Socket>>>>::Error

impl<Input, C, ID> Service<Input> for LeasedConnection<C, ID>

where ID: Send + Sync + Debug + 'static, C: Service<Input> + ExtensionsRef, Input: ExtensionsMut + Send + 'static,

type Output = <C as Service<Input>>::Output

type Error = <C as Service<Input>>::Error

impl<Input, C, ID> Service<Input> for MultiplexedConnection<C, ID>

where C: Service<Input> + ExtensionsRef, ID: Send + Sync + 'static, Input: ExtensionsMut + Send + 'static,

type Output = <C as Service<Input>>::Output

type Error = <C as Service<Input>>::Error

impl<Input, ConnectorFactory> Service<Input> for UnixConnector<ConnectorFactory>

where Input: Send + 'static, ConnectorFactory: UnixStreamConnectorFactory + Clone, <ConnectorFactory as UnixStreamConnectorFactory>::Connector: UnixStreamConnector, <<ConnectorFactory as UnixStreamConnectorFactory>::Connector as UnixStreamConnector>::Error: Into<Box<dyn Error + Send + Sync>> + Send + 'static, <ConnectorFactory as UnixStreamConnectorFactory>::Error: Into<Box<dyn Error + Send + Sync>> + Send + 'static,

type Output = EstablishedClientConnection<UnixStream, Input>

type Error = ConnectionError

impl<Input, F, T, R, O, E> Service<Input> for ServiceFn<F, T, R, O, E>

where F: Factory<T, R, O, E>, R: Future<Output = Result<O, E>> + Send + 'static, T: FromInput<Input>, O: Send + 'static, E: Send + Sync + 'static,

type Output = O

type Error = E

impl<Input, Output, Error> Service<Input> for BoxService<Input, Output, Error>

where Input: 'static, Output: Send + 'static, Error: Send + 'static,

type Output = Output

type Error = Error

impl<Input, Output, Error> Service<Input> for RejectService<Output, Error>

where Input: 'static, Output: Send + 'static, Error: Clone + Send + Sync + 'static,

type Output = Output

type Error = Error

impl<Input, S, F, O> Service<Input> for AlpnRouter<S, F>

where Input: ExtensionsRef + Send + 'static, S: Service<Input, Output = O>, <S as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, F: Service<Input, Output = O>, <F as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, O: Send + 'static,

type Output = O

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

impl<Input, S, P, R> Service<Input> for PooledConnector<S, P, R>

where S: ConnectorService<Input>, Input: Send + ExtensionsRef + 'static, P: Pool<<S as ConnectorService<Input>>::Connection, <R as ReqToConnID<Input>>::ID> + Extension, R: ReqToConnID<Input>,

type Output = EstablishedClientConnection<<P as Pool<<S as ConnectorService<Input>>::Connection, <R as ReqToConnID<Input>>::ID>>::Connection, Input>

type Error = ConnectionError

impl<Input, S, T, F> Service<Input> for GetInputExtensionRef<S, T, F>

where Input: Send + ExtensionsRef + 'static, S: Service<Input>, T: Extension, F: Fn(&T) + Send + Sync + 'static,

type Output = <S as Service<Input>>::Output

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

impl<Input, S, T, F> Service<Input> for GetOutputExtensionRef<S, T, F>

where Input: Send + 'static, S: Service<Input>, <S as Service<Input>>::Output: Send + ExtensionsRef + 'static, T: Extension, F: Fn(&T) + Send + Sync + 'static,

type Output = <S as Service<Input>>::Output

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

impl<Input, S, T, Fut, F> Service<Input> for GetInputExtensionOwned<S, T, Fut, F>

where Input: Send + ExtensionsRef + 'static, S: Service<Input>, T: Extension, F: Fn(Arc<T>) -> Fut + Send + Sync + 'static, Fut: Future<Output = ()> + Send + 'static,

type Output = <S as Service<Input>>::Output

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

impl<Input, S, T, Fut, F> Service<Input> for GetOutputExtensionOwned<S, T, Fut, F>

where Input: Send + 'static, S: Service<Input>, <S as Service<Input>>::Output: Send + ExtensionsRef + 'static, T: Extension, F: Fn(Arc<T>) -> Fut + Send + Sync + 'static, Fut: Future<Output = ()> + Send + 'static,

type Output = <S as Service<Input>>::Output

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

impl<Input, S, T> Service<Input> for AddInputExtension<S, T>

where Input: Send + ExtensionsRef + 'static, S: Service<Input>, T: Extension,

type Output = <S as Service<Input>>::Output

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

impl<Input, S, T> Service<Input> for AddOutputExtension<S, T>

where Input: Send + 'static, S: Service<Input>, <S as Service<Input>>::Output: Send + ExtensionsRef + 'static, T: Extension,

type Output = <S as Service<Input>>::Output

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

impl<Input, S> Service<Input> for ProxyConnector<S>

where S: ConnectorService<Input, Connection: Io + Unpin>, Input: AuthorityInputExt + ProtocolInputExt + HttpVersionInputExt + TargetHttpVersionInputExt + Send + ExtensionsRef + 'static,

Available on crate features dns and http-backend and http and std and tcp only.

type Output = EstablishedClientConnection<MaybeProxiedConnection<<S as ConnectorService<Input>>::Connection>, Input>

type Error = ConnectionError

impl<Input, StreamConnector> Service<Input> for TcpConnector<StreamConnector>

where Input: ConnectorTargetInputExt + ConnectorTransportProtocolInputExt + Send + 'static, StreamConnector: TcpStreamConnector + Send + 'static, <StreamConnector as TcpStreamConnector>::Error: Into<Box<dyn Error + Send + Sync>>,

type Output = EstablishedClientConnection<TcpStream, Input>

type Error = ConnectionError

impl<Input, T> Service<Input> for PathRouter<T>

where Input: ExtensionsRef + PathInputExt + Send + 'static, T: Service<Input>,

type Output = <T as Service<Input>>::Output

type Error = PathRouterError<<T as Service<Input>>::Error>

impl<Input> Service<Input> for MirrorService

where Input: Send + 'static,

type Output = Input

type Error = !

impl<Issuer, Inner, Ingress, Egress> Service<BridgeIo<Ingress, Egress>> for TlsMitmRelayService<Issuer, Inner>

where Issuer: BoringMitmCertIssuer, <Issuer as BoringMitmCertIssuer>::Error: Into<Box<dyn Error + Send + Sync>>, Inner: Service<BridgeIo<TlsStream<Ingress>, TlsStream<Egress>>>, <Inner as Service<BridgeIo<TlsStream<Ingress>, TlsStream<Egress>>>>::Error: Into<Box<dyn Error + Send + Sync>>, Ingress: Io + Unpin + ExtensionsRef, Egress: Io + Unpin + ExtensionsRef,

type Output = ()

type Error = TlsMitmRelayError

impl<Issuer, Inner, Ingress, Egress> Service<InputWithClientHello<BridgeIo<Ingress, Egress>>> for TlsMitmRelayService<Issuer, Inner>

where Issuer: BoringMitmCertIssuer, <Issuer as BoringMitmCertIssuer>::Error: Into<Box<dyn Error + Send + Sync>>, Inner: Service<BridgeIo<TlsStream<Ingress>, TlsStream<Egress>>>, <Inner as Service<BridgeIo<TlsStream<Ingress>, TlsStream<Egress>>>>::Error: Into<Box<dyn Error + Send + Sync>>, Ingress: Io + Unpin + ExtensionsRef, Egress: Io + Unpin + ExtensionsRef,

type Output = ()

type Error = TlsMitmRelayError

impl<Issuer, S, Ingress, Egress> Service<InputWithQuicClientHello<BridgeIo<Ingress, Egress>>> for QuicMitmRelayService<Issuer, S>

where Issuer: BoringMitmCertIssuer + Clone, <Issuer as BoringMitmCertIssuer>::Error: Into<Box<dyn Error + Send + Sync>>, S: Service<BridgeIo<Connection, Connection>>, <S as Service<BridgeIo<Connection, Connection>>>::Error: Into<Box<dyn Error + Send + Sync>>, Ingress: DatagramSocket + ExtensionsRef, Egress: DatagramSocket,

type Output = <S as Service<BridgeIo<Connection, Connection>>>::Output

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

impl<L, R> Service<BridgeIo<L, R>> for HttpDatagramRelay

where L: Io + Unpin + ExtensionsRef, R: Io + Unpin + ExtensionsRef,

type Output = DatagramRelayOutcome

type Error = SessionError

impl<M, S, ReqBody, ModReqBody, ResBody, ModResBody> Service<Request<ReqBody>> for HttpUpgradeMitmRelay<M, S>

where <M as ServiceMatcher<Request<ReqBody>>>::Error: IntoResponse, <M as ServiceMatcher<Request<ReqBody>>>::Service: ServiceMatcher<Response<ResBody>, ModifiedInput = Response<ModResBody>>, <<M as ServiceMatcher<Request<ReqBody>>>::Service as ServiceMatcher<Response<ResBody>>>::Error: Into<<S as Service<Request>>::Error>, <<M as ServiceMatcher<Request<ReqBody>>>::Service as ServiceMatcher<Response<ResBody>>>::Service: Service<BridgeIo<Upgraded, Upgraded>>, <<<M as ServiceMatcher<Request<ReqBody>>>::Service as ServiceMatcher<Response<ResBody>>>::Service as Service<BridgeIo<Upgraded, Upgraded>>>::Error: Into<Box<dyn Error + Send + Sync>>, S: Service<Request, Output = Response<ResBody>>, ReqBody: Body<Data = Bytes> + Send + Sync + 'static, <ReqBody as Body>::Error: Into<Box<dyn Error + Send + Sync>>, ModReqBody: Body<Data = Bytes> + Send + Sync + 'static, <ModReqBody as Body>::Error: Into<Box<dyn Error + Send + Sync>>, ResBody: Body<Data = Bytes> + Send + Sync + 'static, <ResBody as Body>::Error: Into<Box<dyn Error + Send + Sync>>, ModResBody: Body<Data = Bytes> + Send + Sync + 'static, M: ServiceMatcher<Request<ReqBody>, ModifiedInput = Request<ModReqBody>>, <ModResBody as Body>::Error: Into<Box<dyn Error + Send + Sync>>,

type Output = Response

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

impl<M, S, ReqBody, ResBody> Service<Request<ReqBody>> for BodyCaptureService<M, S>

where M: MakeBodyCaptureSink, S: Service<Request, Output = Response<ResBody>>, ReqBody: Body<Data = Bytes> + Send + Sync + 'static, <ReqBody as Body>::Error: Into<Box<dyn Error + Send + Sync>>, ResBody: Body<Data = Bytes> + Send + Sync + 'static, <ResBody as Body>::Error: Into<Box<dyn Error + Send + Sync>>,

type Output = Response

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

impl<M_T1, T1, M_T2, T2, M_T3, T3, M_T4, T4, M_T5, T5, M_T6, T6, M_T7, T7, M_T8, T8, M_T9, T9, M_T10, T10, M_T11, T11, M_T12, T12, S, Input, Output, Error> Service<Input> for MatcherRouter<((M_T1, T1), (M_T2, T2), (M_T3, T3), (M_T4, T4), (M_T5, T5), (M_T6, T6), (M_T7, T7), (M_T8, T8), (M_T9, T9), (M_T10, T10), (M_T11, T11), (M_T12, T12), S)>

where Input: Send + ExtensionsRef + 'static, Output: Send + 'static, M_T1: Matcher<Input>, T1: Service<Input, Output = Output, Error = Error>, M_T2: Matcher<Input>, T2: Service<Input, Output = Output, Error = Error>, M_T3: Matcher<Input>, T3: Service<Input, Output = Output, Error = Error>, M_T4: Matcher<Input>, T4: Service<Input, Output = Output, Error = Error>, M_T5: Matcher<Input>, T5: Service<Input, Output = Output, Error = Error>, M_T6: Matcher<Input>, T6: Service<Input, Output = Output, Error = Error>, M_T7: Matcher<Input>, T7: Service<Input, Output = Output, Error = Error>, M_T8: Matcher<Input>, T8: Service<Input, Output = Output, Error = Error>, M_T9: Matcher<Input>, T9: Service<Input, Output = Output, Error = Error>, M_T10: Matcher<Input>, T10: Service<Input, Output = Output, Error = Error>, M_T11: Matcher<Input>, T11: Service<Input, Output = Output, Error = Error>, M_T12: Matcher<Input>, T12: Service<Input, Output = Output, Error = Error>, S: Service<Input, Output = Output, Error = Error>, Error: Send + 'static,

type Output = Output

type Error = Error

impl<M_T1, T1, M_T2, T2, M_T3, T3, M_T4, T4, M_T5, T5, M_T6, T6, M_T7, T7, M_T8, T8, M_T9, T9, M_T10, T10, M_T11, T11, S, Input, Output, Error> Service<Input> for MatcherRouter<((M_T1, T1), (M_T2, T2), (M_T3, T3), (M_T4, T4), (M_T5, T5), (M_T6, T6), (M_T7, T7), (M_T8, T8), (M_T9, T9), (M_T10, T10), (M_T11, T11), S)>

where Input: Send + ExtensionsRef + 'static, Output: Send + 'static, M_T1: Matcher<Input>, T1: Service<Input, Output = Output, Error = Error>, M_T2: Matcher<Input>, T2: Service<Input, Output = Output, Error = Error>, M_T3: Matcher<Input>, T3: Service<Input, Output = Output, Error = Error>, M_T4: Matcher<Input>, T4: Service<Input, Output = Output, Error = Error>, M_T5: Matcher<Input>, T5: Service<Input, Output = Output, Error = Error>, M_T6: Matcher<Input>, T6: Service<Input, Output = Output, Error = Error>, M_T7: Matcher<Input>, T7: Service<Input, Output = Output, Error = Error>, M_T8: Matcher<Input>, T8: Service<Input, Output = Output, Error = Error>, M_T9: Matcher<Input>, T9: Service<Input, Output = Output, Error = Error>, M_T10: Matcher<Input>, T10: Service<Input, Output = Output, Error = Error>, M_T11: Matcher<Input>, T11: Service<Input, Output = Output, Error = Error>, S: Service<Input, Output = Output, Error = Error>, Error: Send + 'static,

type Output = Output

type Error = Error

impl<M_T1, T1, M_T2, T2, M_T3, T3, M_T4, T4, M_T5, T5, M_T6, T6, M_T7, T7, M_T8, T8, M_T9, T9, M_T10, T10, S, Input, Output, Error> Service<Input> for MatcherRouter<((M_T1, T1), (M_T2, T2), (M_T3, T3), (M_T4, T4), (M_T5, T5), (M_T6, T6), (M_T7, T7), (M_T8, T8), (M_T9, T9), (M_T10, T10), S)>

where Input: Send + ExtensionsRef + 'static, Output: Send + 'static, M_T1: Matcher<Input>, T1: Service<Input, Output = Output, Error = Error>, M_T2: Matcher<Input>, T2: Service<Input, Output = Output, Error = Error>, M_T3: Matcher<Input>, T3: Service<Input, Output = Output, Error = Error>, M_T4: Matcher<Input>, T4: Service<Input, Output = Output, Error = Error>, M_T5: Matcher<Input>, T5: Service<Input, Output = Output, Error = Error>, M_T6: Matcher<Input>, T6: Service<Input, Output = Output, Error = Error>, M_T7: Matcher<Input>, T7: Service<Input, Output = Output, Error = Error>, M_T8: Matcher<Input>, T8: Service<Input, Output = Output, Error = Error>, M_T9: Matcher<Input>, T9: Service<Input, Output = Output, Error = Error>, M_T10: Matcher<Input>, T10: Service<Input, Output = Output, Error = Error>, S: Service<Input, Output = Output, Error = Error>, Error: Send + 'static,

type Output = Output

type Error = Error

impl<M_T1, T1, M_T2, T2, M_T3, T3, M_T4, T4, M_T5, T5, M_T6, T6, M_T7, T7, M_T8, T8, M_T9, T9, S, Input, Output, Error> Service<Input> for MatcherRouter<((M_T1, T1), (M_T2, T2), (M_T3, T3), (M_T4, T4), (M_T5, T5), (M_T6, T6), (M_T7, T7), (M_T8, T8), (M_T9, T9), S)>

where Input: Send + ExtensionsRef + 'static, Output: Send + 'static, M_T1: Matcher<Input>, T1: Service<Input, Output = Output, Error = Error>, M_T2: Matcher<Input>, T2: Service<Input, Output = Output, Error = Error>, M_T3: Matcher<Input>, T3: Service<Input, Output = Output, Error = Error>, M_T4: Matcher<Input>, T4: Service<Input, Output = Output, Error = Error>, M_T5: Matcher<Input>, T5: Service<Input, Output = Output, Error = Error>, M_T6: Matcher<Input>, T6: Service<Input, Output = Output, Error = Error>, M_T7: Matcher<Input>, T7: Service<Input, Output = Output, Error = Error>, M_T8: Matcher<Input>, T8: Service<Input, Output = Output, Error = Error>, M_T9: Matcher<Input>, T9: Service<Input, Output = Output, Error = Error>, S: Service<Input, Output = Output, Error = Error>, Error: Send + 'static,

type Output = Output

type Error = Error

impl<M_T1, T1, M_T2, T2, M_T3, T3, M_T4, T4, M_T5, T5, M_T6, T6, M_T7, T7, M_T8, T8, S, Input, Output, Error> Service<Input> for MatcherRouter<((M_T1, T1), (M_T2, T2), (M_T3, T3), (M_T4, T4), (M_T5, T5), (M_T6, T6), (M_T7, T7), (M_T8, T8), S)>

where Input: Send + ExtensionsRef + 'static, Output: Send + 'static, M_T1: Matcher<Input>, T1: Service<Input, Output = Output, Error = Error>, M_T2: Matcher<Input>, T2: Service<Input, Output = Output, Error = Error>, M_T3: Matcher<Input>, T3: Service<Input, Output = Output, Error = Error>, M_T4: Matcher<Input>, T4: Service<Input, Output = Output, Error = Error>, M_T5: Matcher<Input>, T5: Service<Input, Output = Output, Error = Error>, M_T6: Matcher<Input>, T6: Service<Input, Output = Output, Error = Error>, M_T7: Matcher<Input>, T7: Service<Input, Output = Output, Error = Error>, M_T8: Matcher<Input>, T8: Service<Input, Output = Output, Error = Error>, S: Service<Input, Output = Output, Error = Error>, Error: Send + 'static,

type Output = Output

type Error = Error

impl<M_T1, T1, M_T2, T2, M_T3, T3, M_T4, T4, M_T5, T5, M_T6, T6, M_T7, T7, S, Input, Output, Error> Service<Input> for MatcherRouter<((M_T1, T1), (M_T2, T2), (M_T3, T3), (M_T4, T4), (M_T5, T5), (M_T6, T6), (M_T7, T7), S)>

where Input: Send + ExtensionsRef + 'static, Output: Send + 'static, M_T1: Matcher<Input>, T1: Service<Input, Output = Output, Error = Error>, M_T2: Matcher<Input>, T2: Service<Input, Output = Output, Error = Error>, M_T3: Matcher<Input>, T3: Service<Input, Output = Output, Error = Error>, M_T4: Matcher<Input>, T4: Service<Input, Output = Output, Error = Error>, M_T5: Matcher<Input>, T5: Service<Input, Output = Output, Error = Error>, M_T6: Matcher<Input>, T6: Service<Input, Output = Output, Error = Error>, M_T7: Matcher<Input>, T7: Service<Input, Output = Output, Error = Error>, S: Service<Input, Output = Output, Error = Error>, Error: Send + 'static,

type Output = Output

type Error = Error

impl<M_T1, T1, M_T2, T2, M_T3, T3, M_T4, T4, M_T5, T5, M_T6, T6, S, Input, Output, Error> Service<Input> for MatcherRouter<((M_T1, T1), (M_T2, T2), (M_T3, T3), (M_T4, T4), (M_T5, T5), (M_T6, T6), S)>

where Input: Send + ExtensionsRef + 'static, Output: Send + 'static, M_T1: Matcher<Input>, T1: Service<Input, Output = Output, Error = Error>, M_T2: Matcher<Input>, T2: Service<Input, Output = Output, Error = Error>, M_T3: Matcher<Input>, T3: Service<Input, Output = Output, Error = Error>, M_T4: Matcher<Input>, T4: Service<Input, Output = Output, Error = Error>, M_T5: Matcher<Input>, T5: Service<Input, Output = Output, Error = Error>, M_T6: Matcher<Input>, T6: Service<Input, Output = Output, Error = Error>, S: Service<Input, Output = Output, Error = Error>, Error: Send + 'static,

type Output = Output

type Error = Error

impl<M_T1, T1, M_T2, T2, M_T3, T3, M_T4, T4, M_T5, T5, S, Input, Output, Error> Service<Input> for MatcherRouter<((M_T1, T1), (M_T2, T2), (M_T3, T3), (M_T4, T4), (M_T5, T5), S)>

where Input: Send + ExtensionsRef + 'static, Output: Send + 'static, M_T1: Matcher<Input>, T1: Service<Input, Output = Output, Error = Error>, M_T2: Matcher<Input>, T2: Service<Input, Output = Output, Error = Error>, M_T3: Matcher<Input>, T3: Service<Input, Output = Output, Error = Error>, M_T4: Matcher<Input>, T4: Service<Input, Output = Output, Error = Error>, M_T5: Matcher<Input>, T5: Service<Input, Output = Output, Error = Error>, S: Service<Input, Output = Output, Error = Error>, Error: Send + 'static,

type Output = Output

type Error = Error

impl<M_T1, T1, M_T2, T2, M_T3, T3, M_T4, T4, S, Input, Output, Error> Service<Input> for MatcherRouter<((M_T1, T1), (M_T2, T2), (M_T3, T3), (M_T4, T4), S)>

where Input: Send + ExtensionsRef + 'static, Output: Send + 'static, M_T1: Matcher<Input>, T1: Service<Input, Output = Output, Error = Error>, M_T2: Matcher<Input>, T2: Service<Input, Output = Output, Error = Error>, M_T3: Matcher<Input>, T3: Service<Input, Output = Output, Error = Error>, M_T4: Matcher<Input>, T4: Service<Input, Output = Output, Error = Error>, S: Service<Input, Output = Output, Error = Error>, Error: Send + 'static,

type Output = Output

type Error = Error

impl<M_T1, T1, M_T2, T2, M_T3, T3, S, Input, Output, Error> Service<Input> for MatcherRouter<((M_T1, T1), (M_T2, T2), (M_T3, T3), S)>

where Input: Send + ExtensionsRef + 'static, Output: Send + 'static, M_T1: Matcher<Input>, T1: Service<Input, Output = Output, Error = Error>, M_T2: Matcher<Input>, T2: Service<Input, Output = Output, Error = Error>, M_T3: Matcher<Input>, T3: Service<Input, Output = Output, Error = Error>, S: Service<Input, Output = Output, Error = Error>, Error: Send + 'static,

type Output = Output

type Error = Error

impl<M_T1, T1, M_T2, T2, S, Input, Output, Error> Service<Input> for MatcherRouter<((M_T1, T1), (M_T2, T2), S)>

where Input: Send + ExtensionsRef + 'static, Output: Send + 'static, M_T1: Matcher<Input>, T1: Service<Input, Output = Output, Error = Error>, M_T2: Matcher<Input>, T2: Service<Input, Output = Output, Error = Error>, S: Service<Input, Output = Output, Error = Error>, Error: Send + 'static,

type Output = Output

type Error = Error

impl<M_T1, T1, S, Input, Output, Error> Service<Input> for MatcherRouter<((M_T1, T1), S)>

where Input: Send + ExtensionsRef + 'static, Output: Send + 'static, M_T1: Matcher<Input>, T1: Service<Input, Output = Output, Error = Error>, S: Service<Input, Output = Output, Error = Error>, Error: Send + 'static,

type Output = Output

type Error = Error

impl<P, R, C, F, S> Service<Request> for ConnectUdpService<P, R, C, F>

where P: ConnectUdpPolicy, R: DnsAddressResolver, C: ConnectorService<ConnectRequest, Connection = S>, S: DatagramSocket, F: Service<BridgeIo<ConnectUdpSocket, S>, Output = ()>, <F as Service<BridgeIo<ConnectUdpSocket, S>>>::Error: Into<Box<dyn Error + Send + Sync>>,

type Output = Response

type Error = !

impl<P, S, Body> Service<Request<Body>> for Retry<P, S>

where P: Policy<<S as Service<Request<RetryBody>>>::Output, <S as Service<Request<RetryBody>>>::Error>, S: Service<Request<RetryBody>>, <S as Service<Request<RetryBody>>>::Error: Into<Box<dyn Error + Send + Sync>>, Body: Body + Send + 'static, <Body as Body>::Data: Send + 'static, <Body as Body>::Error: Into<Box<dyn Error + Send + Sync>>,

type Output = <S as Service<Request<RetryBody>>>::Output

type Error = RetryError

impl<PeekableInput, Output, P, T, F> Service<PeekableInput> for PeekRouter<P, T, F>

where PeekableInput: PeekIoProvider, <PeekableInput as PeekIoProvider>::PeekIo: Unpin, Output: Send + 'static, P: Fn(&[u8]) -> PeekVerdict<()> + Send + Sync + 'static, T: Service<<PeekableInput as PeekIoProvider>::Mapped<PrefixedIo<ReplayReader, <PeekableInput as PeekIoProvider>::PeekIo>>, Output = Output>, <T as Service<<PeekableInput as PeekIoProvider>::Mapped<PrefixedIo<ReplayReader, <PeekableInput as PeekIoProvider>::PeekIo>>>>::Error: Into<Box<dyn Error + Send + Sync>>, F: Service<<PeekableInput as PeekIoProvider>::Mapped<PrefixedIo<ReplayReader, <PeekableInput as PeekIoProvider>::PeekIo>>, Output = Output>, <F as Service<<PeekableInput as PeekIoProvider>::Mapped<PrefixedIo<ReplayReader, <PeekableInput as PeekIoProvider>::PeekIo>>>>::Error: Into<Box<dyn Error + Send + Sync>>,

type Output = Output

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

impl<PeekableInput, Output, S, F> Service<PeekableInput> for PeekTlsClientHelloService<S, F>

where PeekableInput: PeekIoProvider + ExtensionsRef, <PeekableInput as PeekIoProvider>::PeekIo: Unpin, Output: Send + 'static, S: Service<InputWithClientHello<<PeekableInput as PeekIoProvider>::Mapped<PrefixedIo<HeapReader, <PeekableInput as PeekIoProvider>::PeekIo>>>, Output = Output>, <S as Service<InputWithClientHello<<PeekableInput as PeekIoProvider>::Mapped<PrefixedIo<HeapReader, <PeekableInput as PeekIoProvider>::PeekIo>>>>>::Error: Into<Box<dyn Error + Send + Sync>>, F: Service<<PeekableInput as PeekIoProvider>::Mapped<PrefixedIo<HeapReader, <PeekableInput as PeekIoProvider>::PeekIo>>, Output = Output>, <F as Service<<PeekableInput as PeekIoProvider>::Mapped<PrefixedIo<HeapReader, <PeekableInput as PeekIoProvider>::PeekIo>>>>::Error: Into<Box<dyn Error + Send + Sync>>,

type Output = Output

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

impl<PeekableInput, Output, T, F> Service<PeekableInput> for HttpPeekRouter<H2Acceptor<T>, F>

where PeekableInput: PeekIoProvider, <PeekableInput as PeekIoProvider>::PeekIo: Unpin, Output: Send + 'static, T: Service<<PeekableInput as PeekIoProvider>::Mapped<PrefixedIo<ReplayReader, <PeekableInput as PeekIoProvider>::PeekIo>>, Output = Output>, <T as Service<<PeekableInput as PeekIoProvider>::Mapped<PrefixedIo<ReplayReader, <PeekableInput as PeekIoProvider>::PeekIo>>>>::Error: Into<Box<dyn Error + Send + Sync>>, F: Service<<PeekableInput as PeekIoProvider>::Mapped<PrefixedIo<ReplayReader, <PeekableInput as PeekIoProvider>::PeekIo>>, Output = Output>, <F as Service<<PeekableInput as PeekIoProvider>::Mapped<PrefixedIo<ReplayReader, <PeekableInput as PeekIoProvider>::PeekIo>>>>::Error: Into<Box<dyn Error + Send + Sync>>,

type Output = Output

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

impl<PeekableInput, Output, T, F> Service<PeekableInput> for HttpPeekRouter<Http1Acceptor<T>, F>

where PeekableInput: PeekIoProvider, <PeekableInput as PeekIoProvider>::PeekIo: Unpin, Output: Send + 'static, T: Service<<PeekableInput as PeekIoProvider>::Mapped<PrefixedIo<ReplayReader, <PeekableInput as PeekIoProvider>::PeekIo>>, Output = Output>, <T as Service<<PeekableInput as PeekIoProvider>::Mapped<PrefixedIo<ReplayReader, <PeekableInput as PeekIoProvider>::PeekIo>>>>::Error: Into<Box<dyn Error + Send + Sync>>, F: Service<<PeekableInput as PeekIoProvider>::Mapped<PrefixedIo<ReplayReader, <PeekableInput as PeekIoProvider>::PeekIo>>, Output = Output>, <F as Service<<PeekableInput as PeekIoProvider>::Mapped<PrefixedIo<ReplayReader, <PeekableInput as PeekIoProvider>::PeekIo>>>>::Error: Into<Box<dyn Error + Send + Sync>>,

type Output = Output

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

impl<PeekableInput, Output, T, F> Service<PeekableInput> for HttpPeekRouter<HttpAutoAcceptor<T>, F>

where PeekableInput: PeekIoProvider, <PeekableInput as PeekIoProvider>::PeekIo: Unpin, Output: Send + 'static, T: Service<<PeekableInput as PeekIoProvider>::Mapped<PrefixedIo<ReplayReader, <PeekableInput as PeekIoProvider>::PeekIo>>, Output = Output>, <T as Service<<PeekableInput as PeekIoProvider>::Mapped<PrefixedIo<ReplayReader, <PeekableInput as PeekIoProvider>::PeekIo>>>>::Error: Into<Box<dyn Error + Send + Sync>>, F: Service<<PeekableInput as PeekIoProvider>::Mapped<PrefixedIo<ReplayReader, <PeekableInput as PeekIoProvider>::PeekIo>>, Output = Output>, <F as Service<<PeekableInput as PeekIoProvider>::Mapped<PrefixedIo<ReplayReader, <PeekableInput as PeekIoProvider>::PeekIo>>>>::Error: Into<Box<dyn Error + Send + Sync>>,

type Output = Output

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

impl<PeekableInput, Output, T, F> Service<PeekableInput> for Socks5PeekRouter<T, F>

where PeekableInput: PeekIoProvider, <PeekableInput as PeekIoProvider>::PeekIo: Unpin, Output: Send + 'static, T: Service<<PeekableInput as PeekIoProvider>::Mapped<PrefixedIo<StackReader<rama_socks5::::server::peek::Socks5PrefixedIo::{constant#0}>, <PeekableInput as PeekIoProvider>::PeekIo>>, Output = Output>, <T as Service<<PeekableInput as PeekIoProvider>::Mapped<PrefixedIo<StackReader<rama_socks5::::server::peek::Socks5PrefixedIo::{constant#0}>, <PeekableInput as PeekIoProvider>::PeekIo>>>>::Error: Into<Box<dyn Error + Send + Sync>>, F: Service<<PeekableInput as PeekIoProvider>::Mapped<PrefixedIo<StackReader<rama_socks5::::server::peek::Socks5PrefixedIo::{constant#0}>, <PeekableInput as PeekIoProvider>::PeekIo>>, Output = Output>, <F as Service<<PeekableInput as PeekIoProvider>::Mapped<PrefixedIo<StackReader<rama_socks5::::server::peek::Socks5PrefixedIo::{constant#0}>, <PeekableInput as PeekIoProvider>::PeekIo>>>>::Error: Into<Box<dyn Error + Send + Sync>>,

type Output = Output

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

impl<PeekableInput, Output, T, F> Service<PeekableInput> for TlsPeekRouter<T, F>

where PeekableInput: PeekIoProvider, <PeekableInput as PeekIoProvider>::PeekIo: Unpin, Output: Send + 'static, T: Service<<PeekableInput as PeekIoProvider>::Mapped<PrefixedIo<StackReader<rama_tls::::server::peek::TlsPrefixedIo::{constant#0}>, <PeekableInput as PeekIoProvider>::PeekIo>>, Output = Output>, <T as Service<<PeekableInput as PeekIoProvider>::Mapped<PrefixedIo<StackReader<rama_tls::::server::peek::TlsPrefixedIo::{constant#0}>, <PeekableInput as PeekIoProvider>::PeekIo>>>>::Error: Into<Box<dyn Error + Send + Sync>>, F: Service<<PeekableInput as PeekIoProvider>::Mapped<PrefixedIo<StackReader<rama_tls::::server::peek::TlsPrefixedIo::{constant#0}>, <PeekableInput as PeekIoProvider>::PeekIo>>, Output = Output>, <F as Service<<PeekableInput as PeekIoProvider>::Mapped<PrefixedIo<StackReader<rama_tls::::server::peek::TlsPrefixedIo::{constant#0}>, <PeekableInput as PeekIoProvider>::PeekIo>>>>::Error: Into<Box<dyn Error + Send + Sync>>,

type Output = Output

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

impl<PeekableInput, Output, T, U, F> Service<PeekableInput> for HttpPeekRouter<HttpDualAcceptor<T, U>, F>

where PeekableInput: PeekIoProvider, <PeekableInput as PeekIoProvider>::PeekIo: Unpin, Output: Send + 'static, T: Service<<PeekableInput as PeekIoProvider>::Mapped<PrefixedIo<ReplayReader, <PeekableInput as PeekIoProvider>::PeekIo>>, Output = Output>, <T as Service<<PeekableInput as PeekIoProvider>::Mapped<PrefixedIo<ReplayReader, <PeekableInput as PeekIoProvider>::PeekIo>>>>::Error: Into<Box<dyn Error + Send + Sync>>, U: Service<<PeekableInput as PeekIoProvider>::Mapped<PrefixedIo<ReplayReader, <PeekableInput as PeekIoProvider>::PeekIo>>, Output = Output>, <U as Service<<PeekableInput as PeekIoProvider>::Mapped<PrefixedIo<ReplayReader, <PeekableInput as PeekIoProvider>::PeekIo>>>>::Error: Into<Box<dyn Error + Send + Sync>>, F: Service<<PeekableInput as PeekIoProvider>::Mapped<PrefixedIo<ReplayReader, <PeekableInput as PeekIoProvider>::PeekIo>>, Output = Output>, <F as Service<<PeekableInput as PeekIoProvider>::Mapped<PrefixedIo<ReplayReader, <PeekableInput as PeekIoProvider>::PeekIo>>>>::Error: Into<Box<dyn Error + Send + Sync>>,

type Output = Output

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

impl<R, Body> Service<Request<Body>> for RedirectHttpToHttps<R>

where R: UriMatchReplace + Send + Sync + 'static, Body: Send + 'static,

type Output = Response

type Error = !

impl<R, S, W, ReqBody, ResBody> Service<Request<ReqBody>> for HARExportService<R, S, W>

where R: StreamingRecorder, S: Service<Request, Output = Response<ResBody>>, <S as Service<Request>>::Error: Into<Box<dyn Error + Send + Sync>> + Send + Sync + 'static, W: Toggle, ReqBody: Body<Data = Bytes> + Send + Sync + 'static, <ReqBody as Body>::Error: Into<Box<dyn Error + Send + Sync>>, ResBody: Body<Data = Bytes> + Send + Sync + 'static, <ResBody as Body>::Error: Into<Box<dyn Error + Send + Sync>>,

type Output = Response

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

impl<Req, S, T> Service<Req> for Layered<S, T>

where S: Service<Req>, Req: Send + 'static, T: Send + Sync + 'static,

type Output = <S as Service<Req>>::Output

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

impl<ReqBody, F, FResBody> Service<Request<ReqBody>> for ServeDir<F>

where ReqBody: Send + 'static, F: Service<Request<ReqBody>, Output = Response<FResBody>, Error = !> + Clone, FResBody: Body<Data = Bytes> + Send + Sync + 'static, <FResBody as Body>::Error: Into<Box<dyn Error + Send + Sync>>,

type Output = Response

type Error = !

impl<ReqBody, R, S> Service<Request<ReqBody>> for RewriteUriService<R, S>

where S: Service<Request<ReqBody>>, R: UriMatchReplace + Send + Sync + 'static, ReqBody: Send + 'static,

type Output = <S as Service<Request<ReqBody>>>::Output

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

impl<ReqBody, ResBody, R, S> Service<Request<ReqBody>> for UriMatchRedirectService<R, S>

where S: Service<Request<ReqBody>, Output = Response<ResBody>>, R: UriMatchReplace + Send + Sync + 'static, ReqBody: Send + 'static, ResBody: Body<Data = Bytes> + Send + Sync + 'static, <ResBody as Body>::Error: Into<Box<dyn Error + Send + Sync>>,

type Output = Response

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

impl<ReqBody, ResBody, S, M> Service<Request<ReqBody>> for SetRequestHeader<S, M>

where ReqBody: Send + 'static, ResBody: Send + 'static, S: Service<Request<ReqBody>, Output = Response<ResBody>>, M: MakeHeaderValue<ReqBody>,

type Output = <S as Service<Request<ReqBody>>>::Output

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

impl<ReqBody, ResBody, S, M> Service<Request<ReqBody>> for SetResponseHeader<S, M>

where ReqBody: Send + 'static, ResBody: Send + 'static, S: Service<Request<ReqBody>, Output = Response<ResBody>>, M: MakeHeaderValueFactory<ReqBody, ResBody>,

type Output = <S as Service<Request<ReqBody>>>::Output

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

impl<ReqBody, ResBody, S, P> Service<Request<ReqBody>> for Compression<S, P>

where S: Service<Request<ReqBody>, Output = Response<ResBody>>, ResBody: Body + Send + 'static, <ResBody as Body>::Data: Send + 'static, <ResBody as Body>::Error: Send + 'static, P: Predicate + Send + Sync + 'static, ReqBody: Send + 'static,

type Output = Response<CompressionBody<ResBody>>

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

impl<ReqBody, ResBody, S, P> Service<Request<ReqBody>> for FollowRedirect<S, P>

where S: Service<Request<ReqBody>, Output = Response<ResBody>>, ReqBody: Body + Default + Send + 'static, ResBody: Send + 'static, P: Policy<ReqBody, <S as Service<Request<ReqBody>>>::Error> + Clone,

type Output = Response<ResBody>

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

impl<ReqBody, ResBody, S, P> Service<Request<ReqBody>> for StreamCompression<S, P>

where S: Service<Request<ReqBody>, Output = Response<ResBody>>, ResBody: Body + Send + 'static, <ResBody as Body>::Data: Send + 'static, <ResBody as Body>::Error: Send + 'static, P: Predicate + Send + Sync + 'static, ReqBody: Send + 'static,

type Output = Response<StreamCompressionBody<ResBody>>

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

impl<ReqBody, ResBody, S> Service<Request<ReqBody>> for AddRequiredRequestHeaders<S>

where ReqBody: Send + 'static, ResBody: Send + 'static, S: Service<Request<ReqBody>, Output = Response<ResBody>>, <S as Service<Request<ReqBody>>>::Error: Into<Box<dyn Error + Send + Sync>>,

type Output = <S as Service<Request<ReqBody>>>::Output

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

impl<ReqBody, ResBody, S> Service<Request<ReqBody>> for AddRequiredResponseHeaders<S>

where ReqBody: Send + 'static, ResBody: Send + 'static, S: Service<Request<ReqBody>, Output = Response<ResBody>>,

type Output = <S as Service<Request<ReqBody>>>::Output

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

impl<ReqBody, ResBody, S> Service<Request<ReqBody>> for PropagateHeader<S>

where S: Service<Request<ReqBody>, Output = Response<ResBody>>, ReqBody: Send + 'static, ResBody: Send + 'static,

type Output = <S as Service<Request<ReqBody>>>::Output

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

impl<ReqBody, ResBody, S> Service<Request<ReqBody>> for RemoveRequestHeader<S>

where ReqBody: Send + 'static, ResBody: Send + 'static, S: Service<Request<ReqBody>, Output = Response<ResBody>>,

type Output = <S as Service<Request<ReqBody>>>::Output

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

impl<ReqBody, ResBody, S> Service<Request<ReqBody>> for RemoveResponseHeader<S>

where ReqBody: Send + 'static, ResBody: Send + 'static, S: Service<Request<ReqBody>, Output = Response<ResBody>>,

type Output = <S as Service<Request<ReqBody>>>::Output

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

impl<ReqBody, ResBody, S> Service<Request<ReqBody>> for SetSensitiveRequestHeaders<S>

where S: Service<Request<ReqBody>, Output = Response<ResBody>>, ReqBody: Send + 'static, ResBody: Send + 'static,

type Output = <S as Service<Request<ReqBody>>>::Output

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

impl<ReqBody, ResBody, S> Service<Request<ReqBody>> for SetSensitiveResponseHeaders<S>

where S: Service<Request<ReqBody>, Output = Response<ResBody>>, ReqBody: Send + 'static, ResBody: Send + 'static,

type Output = <S as Service<Request<ReqBody>>>::Output

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

impl<ReqBody, ServiceResBody, ValidateResBody, S, V> Service<Request<ReqBody>> for ValidateRequestHeader<S, V>

where ReqBody: Send + 'static, ServiceResBody: Send + 'static, ValidateResBody: From<ServiceResBody> + Send + 'static, V: ValidateRequest<ReqBody, ResponseBody = ValidateResBody>, S: Service<Request<ReqBody>, Output = Response<ServiceResBody>>,

type Output = Response<ValidateResBody>

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

impl<ReqBody> Service<Request<ReqBody>> for DefaultServeDirFallback

where ReqBody: Send + 'static,

type Output = Response

type Error = !

impl<ReqBody> Service<Request<ReqBody>> for ServeFile

where ReqBody: Send + 'static,

type Error = <ServeDir as Service<Request<ReqBody>>>::Error

type Output = <ServeDir as Service<Request<ReqBody>>>::Output

impl<S, B1, B2> Service<Request<B1>> for GrpcWebClientService<S>

where S: Service<Request<GrpcWebCall<B1>>, Output = Response<B2>>, <S as Service<Request<GrpcWebCall<B1>>>>::Error: Into<Box<dyn Error + Send + Sync>>, B1: Send + 'static, B2: Send + 'static,

type Output = Response<GrpcWebCall<B2>>

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

impl<S, B> Service<ConnectIpRequestBuilder> for ConnectIpConnector<S>

where S: Service<Request, Output = Response<B>>, <S as Service<Request>>::Error: Into<Box<dyn Error + Send + Sync>>, B: Send + 'static,

type Output = ConnectIpSession

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

impl<S, B> Service<Request<B>> for Dial9<S>

where S: Service<Request<B>>, <S as Service<Request<B>>>::Output: IntoResponse, B: Send + 'static,

type Output = Response

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

impl<S, Body> Service<Request<Body>> for ErrorHandler<S>

where S: Service<Request<Body>>, <S as Service<Request<Body>>>::Output: IntoResponse, <S as Service<Request<Body>>>::Error: Into<ErrorResponse>, Body: Send + 'static,

type Output = Response

type Error = !

impl<S, Body> Service<Request<Body>> for HttpConnectRequestAdapter<S>

where S: ConnectorService<ConnectRequest>, Body: Send + 'static,

type Output = EstablishedClientConnection<<S as ConnectorService<ConnectRequest>>::Connection, Request<Body>>

type Error = ConnectionError

impl<S, Body> Service<Request<Body>> for PacProxyRoutesService<S>

where S: Service<Request<Body>>, <S as Service<Request<Body>>>::Error: Into<Box<dyn Error + Send + Sync>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

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

impl<S, Body> Service<Request<Body>> for ProfileEmulateHttpRequestModifier<S>

where S: Service<Request<Body>> + ExtensionsRef, <S as Service<Request<Body>>>::Error: Into<Box<dyn Error + Send + Sync>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

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

impl<S, Body> Service<Request<Body>> for ProfileEmulateRelayRequestModifier<S>

where S: Service<Request<Body>>, <S as Service<Request<Body>>>::Error: Into<Box<dyn Error + Send + Sync>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

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

impl<S, Body> Service<Request<Body>> for RequestVersionAdapter<S>

where S: ConnectorService<Request<Body>>, Body: Send + 'static,

type Output = EstablishedClientConnection<<S as ConnectorService<Request<Body>>>::Connection, Request<Body>>

type Error = ConnectionError

impl<S, Body> Service<Request<Body>> for ResponseVersionAdapter<S>

where S: Service<Request<Body>, Output = Response>, <S as Service<Request<Body>>>::Error: Into<Box<dyn Error + Send + Sync>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

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

impl<S, Body> Service<Request<Body>> for UserAgentClassifier<S>

where S: Service<Request<Body>>,

type Output = <S as Service<Request<Body>>>::Output

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

impl<S, Body> Service<Request<Body>> for WebSocketAcceptorService<S>

where S: Clone + Service<ServerWebSocket, Output = ()>, Body: Send + 'static,

type Output = Response

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

impl<S, C, D, IO, RequestBody, ResponseBody> Service<Request<RequestBody>> for Adaptation<S, C, D>

where S: Service<Request, Output = Response<ResponseBody>>, <S as Service<Request>>::Error: Into<Box<dyn Error + Send + Sync>>, C: ConnectorService<ConnectRequest, Connection = ClientConnection<IO>>, D: Service<OptionsRequest>, <D as Service<OptionsRequest>>::Output: Into<Arc<ServiceCapabilities>>, <D as Service<OptionsRequest>>::Error: Into<Box<dyn Error + Send + Sync>>, IO: Io + Unpin + ExtensionsRef, RequestBody: Body<Data = Bytes> + Send + Sync + 'static, <RequestBody as Body>::Error: Into<Box<dyn Error + Send + Sync>>, ResponseBody: Body<Data = Bytes> + Send + Sync + 'static, <ResponseBody as Body>::Error: Into<Box<dyn Error + Send + Sync>>,

type Output = Response

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

impl<S, C, Input> Service<Input> for CountInput<S, C>

where S: Service<Input>, C: InputCounter, Input: ExtensionsRef + Send + 'static,

type Output = <S as Service<Input>>::Output

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

impl<S, C, Input> Service<Input> for ProfileEmulateHttpConnectModifier<S, C>

where S: ConnectorService<Input>, C: ConnectionProfileCompiler<Input>, <C as ConnectionProfileCompiler<Input>>::Compiled: InstalledConnectionProfile<Input>, Input: ExtensionsRef + HttpVersionInputExt + TargetHttpVersionInputExt + Send + 'static,

type Error = ConnectionError

type Output = EstablishedClientConnection<<S as ConnectorService<Input>>::Connection, Input>

impl<S, C> Service<ConnectRequest> for ConnectUdpConnector<S, C>

where S: Service<Request, Output = Response>, <S as Service<Request>>::Error: Into<Box<dyn Error + Send + Sync>>, C: ConnectorService<ConnectRequest>, <C as ConnectorService<ConnectRequest>>::Connection: DatagramSocket,

type Output = EstablishedClientConnection<MaybeTunneledSocket<<C as ConnectorService<ConnectRequest>>::Connection>, ConnectRequest>

type Error = ConnectionError

impl<S, D, P, F, Input> Service<Input> for ProxyDBService<S, D, P, F>

where S: Service<Input>, <S as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>> + Send + Sync + 'static, D: ProxyDB, <D as ProxyDB>::Error: Into<Box<dyn Error + Send + Sync>> + Send + Sync + 'static, P: ProxyQueryPredicate, F: UsernameFormatter, Input: TransportProtocolInputExt + ExtensionsRef + Send + 'static,

type Output = <S as Service<Input>>::Output

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

impl<S, F, Body> Service<Request<Body>> for RequestMetricsService<S, F>

where S: Service<Request>, <S as Service<Request>>::Output: IntoResponse, F: AttributesFactory, Body: Body<Data = Bytes> + Send + Sync + 'static, <Body as Body>::Error: Into<Box<dyn Error + Send + Sync>>,

type Output = Response

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

impl<S, F, Input1, Input2> Service<Input1> for MapInput<S, F>

where S: Service<Input2>, F: Fn(Input1) -> Input2 + Send + Sync + 'static,

type Output = <S as Service<Input2>>::Output

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

impl<S, F, Input, Error> Service<Input> for MapErr<S, F>

where S: Service<Input>, F: Fn(<S as Service<Input>>::Error) -> Error + Send + Sync + 'static, Input: Send + 'static, Error: Send + 'static,

type Output = <S as Service<Input>>::Output

type Error = Error

impl<S, F, Input, Output, Error> Service<Input> for MapResult<S, F>

where S: Service<Input>, F: Fn(Result<<S as Service<Input>>::Output, <S as Service<Input>>::Error>) -> Result<Output, Error> + Send + Sync + 'static, Input: Send + 'static, Output: Send + 'static, Error: Send + 'static,

type Output = Output

type Error = Error

impl<S, F, Input, Output> Service<Input> for MapOutput<S, F>

where S: Service<Input>, F: Fn(<S as Service<Input>>::Output) -> Output + Send + Sync + 'static, Input: Send + 'static, Output: Send + 'static,

type Output = Output

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

impl<S, F, Input, R> Service<Input> for ConsumeErr<S, F, StaticOutput<R>>

where S: Service<Input>, F: Fn(<S as Service<Input>>::Error) + Send + Sync + 'static, R: Into<<S as Service<Input>>::Output> + Clone + Send + Sync + 'static, Input: Send + 'static,

type Output = <S as Service<Input>>::Output

type Error = !

impl<S, F, Input> Service<Input> for ConsumeErr<S, F>

where S: Service<Input>, <S as Service<Input>>::Output: Default, F: Fn(<S as Service<Input>>::Error) + Send + Sync + 'static, Input: Send + 'static,

type Output = <S as Service<Input>>::Output

type Error = !

impl<S, F, R, Body> Service<Request<Body>> for ErrorHandler<S, F>

where S: Service<Request<Body>>, <S as Service<Request<Body>>>::Output: IntoResponse, F: Fn(<S as Service<Request<Body>>>::Error) -> R + Clone + Send + Sync + 'static, R: IntoResponse + 'static, Body: Send + 'static,

type Output = Response

type Error = !

impl<S, F, Stream> Service<Stream> for NetworkMetricsService<S, F>

where S: Service<Stream>, F: AttributesFactory, Stream: Io + ExtensionsRef,

type Output = <S as Service<Stream>>::Output

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

impl<S, H, Body> Service<Request<Body>> for SetForwardedHeaderService<S, H>

where S: Service<Request<Body>>, <S as Service<Request<Body>>>::Error: Into<Box<dyn Error + Send + Sync>>, H: ForwardHeader + Send + Sync + 'static, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

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

impl<S, H, M, Input> Service<Input> for HijackService<S, H, M>

where S: Service<Input>, H: Service<Input>, <H as Service<Input>>::Output: Into<<S as Service<Input>>::Output>, <H as Service<Input>>::Error: Into<<S as Service<Input>>::Error>, M: Matcher<Input>, Input: Send + ExtensionsRef + 'static,

type Output = <S as Service<Input>>::Output

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

impl<S, H, ReqBody, ResBody> Service<Request<ReqBody>> for HtmlRewrite<S, H>

where S: Service<Request<ReqBody>, Output = Response<ResBody>>, ResBody: Body + Send + 'static, <ResBody as Body>::Data: Send + 'static, <ResBody as Body>::Error: Into<Box<dyn Error + Send + Sync>> + Send + 'static, H: ElementContentHandler + Clone + Send + Sync + 'static, ReqBody: Send + 'static,

type Output = Response<HtmlRewriteBody<ResBody, H>>

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

impl<S, H, ReqBody, ResBody> Service<Request<ReqBody>> for JsonRewrite<S, H>

where S: Service<Request<ReqBody>, Output = Response<ResBody>>, ResBody: Body + Send + 'static, <ResBody as Body>::Data: Send + 'static, <ResBody as Body>::Error: Into<Box<dyn Error + Send + Sync>> + Send + 'static, H: JsonValueHandler + Clone + Send + Sync + 'static, ReqBody: Send + 'static,

type Output = Response<JsonRewriteBody<ResBody, H>>

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

impl<S, H, ReqBody> Service<Request<ReqBody>> for JsonRequestRewrite<S, H>

where S: Service<Request<JsonRewriteBody<ReqBody, H>>>, ReqBody: Body + Send + 'static, <ReqBody as Body>::Data: Send + 'static, <ReqBody as Body>::Error: Into<Box<dyn Error + Send + Sync>> + Send + 'static, H: JsonValueHandler + Clone + Send + Sync + 'static,

type Output = <S as Service<Request<JsonRewriteBody<ReqBody, H>>>>::Output

type Error = <S as Service<Request<JsonRewriteBody<ReqBody, H>>>>::Error

impl<S, I, E> Service<I> for IntoErr<S, E>

where S: Service<I>, <S as Service<I>>::Error: Into<E>, I: Send + 'static, E: Send + 'static,

type Output = <S as Service<I>>::Output

type Error = E

impl<S, I, ReqBody, ResBody> Service<Request<ReqBody>> for InterceptedService<S, I>

where S: Service<Request<ReqBody>, Output = Response<ResBody>>, I: Service<Request<()>, Output = Request<()>, Error = Status>, ReqBody: Send + 'static, ResBody: Send + 'static,

type Output = Response<OptionalBody<ResBody>>

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

impl<S, I> Service<I> for IntoResponseService<S>

where S: Service<I>, <S as Service<I>>::Output: IntoResponse, I: Send + 'static,

type Output = Response

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

impl<S, IO> Service<FastCgiClientRequest> for FastCgiClient<S>

where S: Service<FastCgiClientRequest, Output = EstablishedClientConnection<IO, FastCgiClientRequest>>, <S as Service<FastCgiClientRequest>>::Error: Into<Box<dyn Error + Send + Sync>>, IO: AsyncRead + AsyncWrite + Unpin + Send + 'static,

type Output = FastCgiClientResponse

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

impl<S, IO> Service<IO> for rama::http::BodyLimitService<S>

where S: Service<IO>, IO: ExtensionsRef + Send + 'static,

type Output = <S as Service<IO>>::Output

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

impl<S, IO> Service<IO> for FastCgiServer<S>

where S: Service<FastCgiRequest, Output = FastCgiResponse>, <S as Service<FastCgiRequest>>::Error: Into<Box<dyn Error + Send + Sync>>, IO: Io + Unpin + Send + 'static,

type Output = ()

type Error = Error

impl<S, IO> Service<IO> for GracefulIoService<S>

where S: Service<GracefulIo<WaitForCancellationFutureOwned, IO>>, IO: Io + ExtensionsRef,

type Output = <S as Service<GracefulIo<WaitForCancellationFutureOwned, IO>>>::Output

type Error = <S as Service<GracefulIo<WaitForCancellationFutureOwned, IO>>>::Error

impl<S, IO> Service<IO> for rama::proxy::haproxy::server::HaProxyService<S>

where S: Service<PrefixedIo<HeapReader, IO>>, <S as Service<PrefixedIo<HeapReader, IO>>>::Error: Into<Box<dyn Error + Send + Sync>>, IO: Io + Unpin + ExtensionsRef,

type Output = <S as Service<PrefixedIo<HeapReader, IO>>>::Output

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

impl<S, IO> Service<IO> for IncomingBytesTrackerService<S>

where S: Service<BytesRWTracker<IO>>, IO: Io + ExtensionsRef,

type Output = <S as Service<BytesRWTracker<IO>>>::Output

type Error = <S as Service<BytesRWTracker<IO>>>::Error

impl<S, IO> Service<IO> for Server<S>

where IO: Io + Unpin + ExtensionsRef, S: Service<IncomingRequest, Output = OutgoingResponse>, <S as Service<IncomingRequest>>::Error: Into<Box<dyn Error + Send + Sync>>,

type Output = ()

type Error = ServerError

impl<S, IO> Service<IO> for TcpStreamOptionsService<S>

where S: Service<IO>, <S as Service<IO>>::Error: Into<Box<dyn Error + Send + Sync>>, IO: AsSocketRef + Send + 'static,

type Output = <S as Service<IO>>::Output

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

impl<S, IO> Service<IO> for rama::tls::boring::server::TlsAcceptorService<S>

where IO: Io + Unpin + ExtensionsRef + 'static, S: Service<TlsStream<IO>>, <S as Service<TlsStream<IO>>>::Error: Into<Box<dyn Error + Send + Sync>>,

type Output = <S as Service<TlsStream<IO>>>::Output

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

impl<S, IO> Service<IO> for rama::tls::rustls::server::TlsAcceptorService<S>

where IO: Io + Unpin + ExtensionsRef + 'static, S: Service<TlsStream<IO>>, <S as Service<TlsStream<IO>>>::Error: Into<Box<dyn Error + Send + Sync>>,

type Output = <S as Service<TlsStream<IO>>>::Output

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

impl<S, IO> Service<Request> for FastCgiHttpClient<S>

where S: Service<FastCgiClientRequest, Output = EstablishedClientConnection<IO, FastCgiClientRequest>>, <S as Service<FastCgiClientRequest>>::Error: Into<Box<dyn Error + Send + Sync>>, IO: AsyncRead + AsyncWrite + Unpin + Send + 'static,

type Output = Response

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

impl<S, IO> Service<Request> for FastCgiHttpClientConnector<S>

where S: Service<FastCgiClientRequest, Output = EstablishedClientConnection<IO, FastCgiClientRequest>>, <S as Service<FastCgiClientRequest>>::Error: Into<Box<dyn Error + Send + Sync>>, IO: AsyncRead + AsyncWrite + Unpin + Send + 'static,

type Output = EstablishedClientConnection<IO, FastCgiClientRequest>

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

impl<S, Ingress, C> Service<Ingress> for IoToProxyBridgeIo<S, C>

where S: Service<BridgeIo<Ingress, <C as ConnectorService<ConnectRequest>>::Connection>>, <S as Service<BridgeIo<Ingress, <C as ConnectorService<ConnectRequest>>::Connection>>>::Error: Into<Box<dyn Error + Send + Sync>>, Ingress: Io + ExtensionsRef, C: ConnectorService<ConnectRequest>, <C as ConnectorService<ConnectRequest>>::Connection: Io + Unpin,

type Output = <S as Service<BridgeIo<Ingress, <C as ConnectorService<ConnectRequest>>::Connection>>>::Output

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

impl<S, Ingress, Egress> Service<BridgeIo<Ingress, Egress>> for WebSocketRelayEventService<S>

where S: Service<WebSocketRelayEventInput>, <S as Service<WebSocketRelayEventInput>>::Output: Into<WebSocketRelayEventOutput>, <S as Service<WebSocketRelayEventInput>>::Error: Into<Box<dyn Error + Send + Sync>>, Ingress: Io + Unpin + ExtensionsRef, Egress: Io + Unpin + ExtensionsRef,

type Output = ()

type Error = !

impl<S, Ingress, Egress> Service<BridgeIo<Ingress, Egress>> for WebSocketRelayIoService<S>

where S: Service<WebSocketBridge<AsyncWebSocket<Ingress>, AsyncWebSocket<Egress>>>, Ingress: Io + Unpin + ExtensionsRef, Egress: Io + Unpin + ExtensionsRef,

type Output = <S as Service<WebSocketBridge<AsyncWebSocket<Ingress>, AsyncWebSocket<Egress>>>>::Output

type Error = <S as Service<WebSocketBridge<AsyncWebSocket<Ingress>, AsyncWebSocket<Egress>>>>::Error

impl<S, Ingress, Egress> Service<BridgeIo<Ingress, Egress>> for WebSocketRelayService<S>

where S: Service<WebSocketRelayInput>, <S as Service<WebSocketRelayInput>>::Output: Into<WebSocketRelayOutput>, <S as Service<WebSocketRelayInput>>::Error: Into<Box<dyn Error + Send + Sync>>, Ingress: Io + Unpin + ExtensionsRef, Egress: Io + Unpin + ExtensionsRef,

type Output = ()

type Error = !

impl<S, Ingress, Egress> Service<WebSocketBridge<Ingress, Egress>> for CaptureWebSocketService<S>

where S: Service<WebSocketBridge<Ingress, Egress>>, Ingress: ExtensionsRef + Send + 'static, Egress: ExtensionsRef + Send + 'static,

type Output = <S as Service<WebSocketBridge<Ingress, Egress>>>::Output

type Error = <S as Service<WebSocketBridge<Ingress, Egress>>>::Error

impl<S, Ingress, Egress> Service<WebSocketBridge<Ingress, Egress>> for WebSocketRelayEventService<S>

where S: Service<WebSocketRelayEventInput>, <S as Service<WebSocketRelayEventInput>>::Output: Into<WebSocketRelayEventOutput>, <S as Service<WebSocketRelayEventInput>>::Error: Into<Box<dyn Error + Send + Sync>>, Ingress: WebSocketIo, Egress: WebSocketIo,

type Output = ()

type Error = !

impl<S, Ingress, Egress> Service<WebSocketBridge<Ingress, Egress>> for WebSocketRelayService<S>

where S: Service<WebSocketRelayInput>, <S as Service<WebSocketRelayInput>>::Output: Into<WebSocketRelayOutput>, <S as Service<WebSocketRelayInput>>::Error: Into<Box<dyn Error + Send + Sync>>, Ingress: WebSocketIo, Egress: WebSocketIo,

type Output = ()

type Error = !

impl<S, Input, BodyConnection> Service<Input> for HttpConnector<S, BodyConnection>

where S: ConnectorService<Input>, <S as ConnectorService<Input>>::Connection: IntoHttpTransport, Input: AuthorityInputExt + ProtocolInputExt + ExtensionsRef + HttpVersionInputExt + TargetHttpVersionInputExt + Send + 'static, BodyConnection: Body + Unpin + Send + 'static, <BodyConnection as Body>::Data: Send + 'static, <BodyConnection as Body>::Error: Into<Box<dyn Error + Send + Sync>>,

type Output = EstablishedClientConnection<HttpClientService<BodyConnection>, Input>

type Error = ConnectionError

impl<S, Input, C> Service<Input> for DatagramToProxyBridge<S, C>

where S: Service<<Input as DatagramBridgeInput>::Bridged<<C as ConnectorService<ConnectRequest>>::Connection>>, <S as Service<<Input as DatagramBridgeInput>::Bridged<<C as ConnectorService<ConnectRequest>>::Connection>>>::Error: Into<Box<dyn Error + Send + Sync>>, Input: DatagramBridgeInput, C: ConnectorService<ConnectRequest>, <C as ConnectorService<ConnectRequest>>::Connection: DatagramSocket + Send + 'static,

type Output = <S as Service<<Input as DatagramBridgeInput>::Bridged<<C as ConnectorService<ConnectRequest>>::Connection>>>::Output

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

impl<S, Input, R> Service<Input> for ConsumeErr<S, Trace, StaticOutput<R>>

where S: Service<Input>, <S as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, R: Into<<S as Service<Input>>::Output> + Clone + Send + Sync + 'static, Input: Send + 'static,

type Output = <S as Service<Input>>::Output

type Error = !

impl<S, Input, Server> Service<Input> for MockConnectorService<S>

where S: Fn() -> Server + Send + Sync + 'static, Server: Service<MockSocket>, <Server as Service<MockSocket>>::Error: Into<Box<dyn Error + Send + Sync>>, Input: Send + 'static,

type Error = !

type Output = EstablishedClientConnection<MockSocket, Input>

impl<S, Input, Stream> Service<Input> for PostedRecvConnector<S>

where S: ConnectorService<Input, Connection = Stream>, Stream: RawTcpStream, Input: Send + 'static,

type Output = EstablishedClientConnection<PostedRecv<Stream>, Input>

type Error = ConnectionError

impl<S, Input, Svc> Service<Input> for BoxedConnectorService<S>

where S: ConnectorService<Input, Connection = Svc>, Svc: Service<Input>, Input: Send + 'static,

type Output = EstablishedClientConnection<BoxService<Input, <Svc as Service<Input>>::Output, <Svc as Service<Input>>::Error>, Input>

type Error = ConnectionError

impl<S, Input> Service<Input> for Arc<S>

where S: Service<Input>,

type Output = <S as Service<Input>>::Output

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

impl<S, Input> Service<Input> for BindBodyToConnector<S>

where S: ConnectorService<Input>, Input: Send + 'static,

type Output = EstablishedClientConnection<BindBodyToConn<<S as ConnectorService<Input>>::Connection>, Input>

type Error = ConnectionError

impl<S, Input> Service<Input> for Box<S>

where S: Service<Input>,

type Output = <S as Service<Input>>::Output

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

impl<S, Input> Service<Input> for Client<S>

where S: ConnectorService<Input>, <S as ConnectorService<Input>>::Connection: Io + Unpin + ExtensionsRef, Input: Send + 'static,

type Output = EstablishedClientConnection<ClientConnection<<S as ConnectorService<Input>>::Connection>, Input>

type Error = ConnectionError

impl<S, Input> Service<Input> for ConnectorTargetFromGetSocketname<S>

where S: Service<Input>, <S as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, Input: AsRawFd + ExtensionsRef + Send + 'static,

type Output = <S as Service<Input>>::Output

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

impl<S, Input> Service<Input> for ConsumeErr<S, Trace>

where S: Service<Input>, <S as Service<Input>>::Output: Default, <S as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, Input: Send + 'static,

type Output = <S as Service<Input>>::Output

type Error = !

impl<S, Input> Service<Input> for EmulateTlsProfileService<S>

where Input: ProtocolInputExt + Send + ExtensionsRef + 'static, S: Service<Input>, <S as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>,

type Output = <S as Service<Input>>::Output

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

impl<S, Input> Service<Input> for GracefulConnectorService<S>

where S: ConnectorService<Input>, <S as ConnectorService<Input>>::Connection: Io + ExtensionsRef, Input: Send + 'static,

type Output = EstablishedClientConnection<GracefulIo<WaitForCancellationFutureOwned, <S as ConnectorService<Input>>::Connection>, Input>

type Error = ConnectionError

impl<S, Input> Service<Input> for HttpProxyConnector<S>

where S: ConnectorService<Input>, <S as ConnectorService<Input>>::Connection: Io + Unpin, Input: AuthorityInputExt + ProtocolInputExt + HttpVersionInputExt + TargetHttpVersionInputExt + Send + ExtensionsRef + 'static,

type Output = EstablishedClientConnection<MaybeHttpProxiedConnection<<S as ConnectorService<Input>>::Connection>, Input>

type Error = ConnectionError

impl<S, Input> Service<Input> for LazyProxyAddressService<S>

where S: Service<Input>, <S as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, Input: ExtensionsRef + Send + 'static,

type Output = <S as Service<Input>>::Output

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

impl<S, Input> Service<Input> for NoProxyEnvService<S>

where S: Service<Input>, <S as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, Input: AuthorityInputExt + ProtocolInputExt + ExtensionsRef + Send + 'static,

type Output = <S as Service<Input>>::Output

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

impl<S, Input> Service<Input> for OutgoingBytesTrackerService<S>

where S: ConnectorService<Input>, <S as ConnectorService<Input>>::Connection: Io + Unpin, Input: Send + 'static,

type Output = EstablishedClientConnection<BytesRWTracker<<S as ConnectorService<Input>>::Connection>, Input>

type Error = ConnectionError

impl<S, Input> Service<Input> for OutgoingThrottleService<S>

where S: ConnectorService<Input>, <S as ConnectorService<Input>>::Connection: Throttleable, <<S as ConnectorService<Input>>::Connection as Throttleable>::Throttled: Send + 'static, Input: Send + 'static,

type Output = EstablishedClientConnection<<<S as ConnectorService<Input>>::Connection as Throttleable>::Throttled, Input>

type Error = ConnectionError

impl<S, Input> Service<Input> for ProxyAddressService<S>

where S: Service<Input>, Input: ExtensionsRef + Send + 'static,

type Output = <S as Service<Input>>::Output

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

impl<S, Input> Service<Input> for ProxyBypassService<S>

where S: Service<Input>, <S as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, Input: AuthorityInputExt + ProtocolInputExt + ExtensionsRef + Send + 'static,

type Output = <S as Service<Input>>::Output

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

impl<S, Input> Service<Input> for ProxyEnvService<S>

where S: Service<Input>, <S as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, Input: UriInputExt + ProtocolInputExt + ExtensionsRef + Send + 'static,

type Output = <S as Service<Input>>::Output

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

impl<S, Input> Service<Input> for ProxyRouteFailureCacheConnector<S>

where S: ConnectorService<Input>, Input: AuthorityInputExt + ConnectorTransportProtocolInputExt + ProtocolInputExt + Send + 'static,

type Output = EstablishedClientConnection<<S as ConnectorService<Input>>::Connection, Input>

type Error = ConnectionError

impl<S, Input> Service<Input> for ProxyRoutesConnector<S>

where S: ConnectorService<Input>, Input: Fork + ExtensionsRef + Send + 'static,

type Output = EstablishedClientConnection<<S as ConnectorService<Input>>::Connection, Input>

type Error = ConnectionError

impl<S, Input> Service<Input> for ProxyRoutesService<S>

where S: Service<Input>, Input: ExtensionsRef + Send + 'static,

type Output = <S as Service<Input>>::Output

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

impl<S, Input> Service<Input> for Socks5ProxyConnector<S>

where S: ConnectorService<Input>, <S as ConnectorService<Input>>::Connection: Io + Unpin, Input: ConnectorTargetInputExt + Send + 'static,

type Output = EstablishedClientConnection<<S as ConnectorService<Input>>::Connection, Input>

type Error = ConnectionError

impl<S, Input> Service<Input> for ThrottleService<S>

where S: Service<<Input as Throttleable>::Throttled>, Input: Throttleable,

type Output = <S as Service<<Input as Throttleable>::Throttled>>::Output

type Error = <S as Service<<Input as Throttleable>::Throttled>>::Error

impl<S, Input> Service<Input> for rama::tls::boring::client::TlsConnector<S, ConnectorKindSecure>

where S: ConnectorService<Input>, <S as ConnectorService<Input>>::Connection: Io + Unpin, Input: AuthorityInputExt + ProtocolInputExt + Send + ExtensionsRef + 'static,

type Output = EstablishedClientConnection<TlsStream<<S as ConnectorService<Input>>::Connection>, Input>

type Error = ConnectionError

impl<S, Input> Service<Input> for rama::tls::rustls::client::TlsConnector<S, ConnectorKindSecure>

where S: ConnectorService<Input>, <S as ConnectorService<Input>>::Connection: Io + Unpin, Input: AuthorityInputExt + ProtocolInputExt + Send + ExtensionsRef + 'static,

type Output = EstablishedClientConnection<TlsStream<<S as ConnectorService<Input>>::Connection>, Input>

type Error = ConnectionError

impl<S, Input> Service<Input> for rama::tls::boring::client::TlsConnector<S, ConnectorKindTunnel>

where S: ConnectorService<Input>, <S as ConnectorService<Input>>::Connection: Io + Unpin, Input: Send + ExtensionsRef + 'static,

type Output = EstablishedClientConnection<AutoTlsStream<<S as ConnectorService<Input>>::Connection>, Input>

type Error = ConnectionError

impl<S, Input> Service<Input> for rama::tls::rustls::client::TlsConnector<S, ConnectorKindTunnel>

where S: ConnectorService<Input>, <S as ConnectorService<Input>>::Connection: Io + Unpin, Input: Send + ExtensionsRef + 'static,

type Output = EstablishedClientConnection<AutoTlsStream<<S as ConnectorService<Input>>::Connection>, Input>

type Error = ConnectionError

impl<S, Input> Service<Input> for rama::tls::rustls::client::TlsConnector<S>

where S: ConnectorService<Input>, <S as ConnectorService<Input>>::Connection: Io + Unpin, Input: AuthorityInputExt + ProtocolInputExt + ExtensionsRef + Send + 'static,

type Output = EstablishedClientConnection<AutoTlsStream<<S as ConnectorService<Input>>::Connection>, Input>

type Error = ConnectionError

impl<S, Input> Service<Input> for rama::tls::boring::client::TlsConnector<S>

where S: ConnectorService<Input>, <S as ConnectorService<Input>>::Connection: Io + Unpin, Input: AuthorityInputExt + ProtocolInputExt + Send + ExtensionsRef + 'static,

type Output = EstablishedClientConnection<AutoTlsStream<<S as ConnectorService<Input>>::Connection>, Input>

type Error = ConnectionError

impl<S, Input> Service<Input> for TraceErr<S>

where Input: Send + 'static, S: Service<Input>, <S as Service<Input>>::Error: Display + Send + Sync + 'static,

type Output = <S as Service<Input>>::Output

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

impl<S, L, Input> Service<Input> for MapEstablishedConnection<S, L>

where S: ConnectorService<Input>, L: Layer<<S as ConnectorService<Input>>::Connection> + Send + Sync + 'static, <L as Layer<<S as ConnectorService<Input>>::Connection>>::Service: ExtensionsRef + Send + 'static, Input: Send + 'static,

type Output = EstablishedClientConnection<<L as Layer<<S as ConnectorService<Input>>::Connection>>::Service, Input>

type Error = ConnectionError

impl<S, L, Input> Service<Input> for MaybeLayeredService<S, L>

where S: Service<Input>, L: Layer<S> + 'static, <L as Layer<S>>::Service: Service<Input, Output = <S as Service<Input>>::Output>, <<L as Layer<S>>::Service as Service<Input>>::Error: Into<<S as Service<Input>>::Error>, Input: Send + 'static,

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

type Output = <S as Service<Input>>::Output

impl<S, M, B, R> Service<Request<B>> for ConnectUdpMitm<S, M>

where B: Send + 'static, R: Send + 'static, M: Matcher<Request<B>>, S: Service<Request<B>, Output = Response<R>>, <S as Service<Request<B>>>::Error: Into<Box<dyn Error + Send + Sync>>,

type Output = Response<R>

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

impl<S, M, ReqBody, ResBody> Service<Request<ReqBody>> for Decompression<S, M>

where S: Service<Request<ReqBody>, Output = Response<ResBody>>, <S as Service<Request<ReqBody>>>::Error: Into<Box<dyn Error + Send + Sync>>, M: ServiceMatcher<Request<ReqBody>, ModifiedInput = Request<ReqBody>>, <M as ServiceMatcher<Request<ReqBody>>>::Service: ServiceMatcher<Response<ResBody>, ModifiedInput = Response<ResBody>, Service = ()>, <<M as ServiceMatcher<Request<ReqBody>>>::Service as ServiceMatcher<Response<ResBody>>>::Error: Into<Box<dyn Error + Send + Sync>>, <M as ServiceMatcher<Request<ReqBody>>>::Error: Into<Box<dyn Error + Send + Sync>>, ReqBody: Send + 'static, ResBody: Body + Send + 'static, <ResBody as Body>::Data: Send + 'static, <ResBody as Body>::Error: Send + 'static,

type Output = Response<DecompressionBody<ResBody>>

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

impl<S, M, ReqBody, ResBody> Service<Request<ReqBody>> for SetRequestId<S, M>

where S: Service<Request<ReqBody>, Output = Response<ResBody>>, M: MakeRequestId, ReqBody: Send + 'static, ResBody: Send + 'static,

type Output = <S as Service<Request<ReqBody>>>::Output

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

impl<S, O> Service<Request> for UpgradeService<S, O>

where S: Service<Request, Output = O>, O: Send + 'static,

type Output = O

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

impl<S, P, Body> Service<Request<Body>> for ProfileEmulateService<S, P>

where S: Service<Request<Body>>, <S as Service<Request<Body>>>::Error: Into<Box<dyn Error + Send + Sync>>, P: ProfileSource, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

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

impl<S, P, Input> Service<Input> for rama::proxy::haproxy::client::HaProxyService<S, P, One>

where S: ConnectorService<Input>, <S as ConnectorService<Input>>::Connection: Io + Socket + Unpin, P: Send + 'static, Input: Send + ExtensionsRef + 'static,

type Output = EstablishedClientConnection<<S as ConnectorService<Input>>::Connection, Input>

type Error = ConnectionError

impl<S, P, Input> Service<Input> for rama::proxy::haproxy::client::HaProxyService<S, P>

where S: ConnectorService<Input>, <S as ConnectorService<Input>>::Connection: Io + Socket + Unpin, P: Protocol + Send + 'static, Input: Send + ExtensionsRef + 'static,

type Output = EstablishedClientConnection<<S as ConnectorService<Input>>::Connection, Input>

type Error = ConnectionError

impl<S, P, Input> Service<Input> for SystemProxyService<S, P>

where S: Service<Input>, <S as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, P: SystemProxyPacService, Input: UriInputExt + AuthorityInputExt + ProtocolInputExt + ExtensionsRef + Send + 'static,

type Output = <S as Service<Input>>::Output

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

impl<S, P, Input> Service<Input> for UsernameLabelParserService<S, P>

where S: Service<Input>, P: UsernameLabelParser, Input: ExtensionsRef,

type Output = <S as Service<Input>>::Output

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

impl<S, P> Service<ConnectRequest> for SystemProxyConnectService<S, P>

where S: Service<ConnectRequest>, <S as Service<ConnectRequest>>::Error: Into<Box<dyn Error + Send + Sync>>, P: SystemProxyPacService,

type Output = <S as Service<ConnectRequest>>::Output

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

impl<S, Q, Input> Service<Input> for HttpTransportConnector<S, Q>

where S: ConnectorService<Input>, <S as ConnectorService<Input>>::Connection: IntoHttpTransport, Q: ConnectorService<Input, Connection = Http3Transport>, Input: ExtensionsRef + HttpVersionInputExt + TargetHttpVersionInputExt + Send + 'static,

Available on crate feature quic only.

type Output = EstablishedClientConnection<HttpTransport<<<S as ConnectorService<Input>>::Connection as IntoHttpTransport>::Stream>, Input>

type Error = ConnectionError

impl<S, R, Input> Service<Input> for DnsConnector<S, R>

where S: ConnectorService<Input>, Input: ConnectorTargetInputExt + Send + 'static, R: DnsAddressResolver + Clone,

type Output = EstablishedClientConnection<<S as ConnectorService<Input>>::Connection, Input>

type Error = ConnectionError

impl<S, R, P, Input> Service<Input> for DnsLoadBalancer<S, R, P>

where S: Service<Input>, <S as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>> + Send + Sync + 'static, Input: ConnectorTargetInputExt + ExtensionsRef + Send + 'static, R: DnsAddressResolver + Clone, P: DnsIpPicker,

type Output = <S as Service<Input>>::Output

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

impl<S, Req, ResBody> Service<Req> for RecoverError<S>

where S: Service<Req, Output = Response<ResBody>>, <S as Service<Req>>::Error: Into<Box<dyn Error + Send + Sync>>, Req: Send + 'static, ResBody: Send + Sync + 'static,

type Output = Response<OptionalBody<ResBody>>

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

impl<S, ReqBody, R> Service<Request<ReqBody>> for RamaHttpService<S>

where S: Service<Request, Output = R, Error = !>, ReqBody: Body<Data = Bytes> + Send + Sync + 'static, <ReqBody as Body>::Error: Into<Box<dyn Error + Send + Sync>>, R: IntoResponse + Send + 'static,

type Output = Response

type Error = !

impl<S, ReqBody, ResBody, M, OnRequestT, OnResponseT, OnFailureT, OnBodyChunkT, OnEosT, MakeSpanT> Service<Request<ReqBody>> for Trace<S, M, MakeSpanT, OnRequestT, OnResponseT, OnBodyChunkT, OnEosT, OnFailureT>

where S: Service<Request<ReqBody>, Output = Response<ResBody>>, <S as Service<Request<ReqBody>>>::Error: Display, ReqBody: Body + Send + 'static, ResBody: Body + Send + Sync + 'static, <ResBody as Body>::Error: Display, M: MakeClassifier, <M as MakeClassifier>::Classifier: Clone, MakeSpanT: MakeSpan<ReqBody>, OnRequestT: OnRequest<ReqBody>, OnResponseT: OnResponse<ResBody> + Clone, OnBodyChunkT: OnBodyChunk<<ResBody as Body>::Data> + Clone, OnEosT: OnEos + Clone, OnFailureT: OnFailure<<M as MakeClassifier>::FailureClass> + Clone,

type Output = Response<ResponseBody<ResBody, <M as MakeClassifier>::ClassifyEos, OnBodyChunkT, OnEosT, OnFailureT>>

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

impl<S, ReqBody, ResBody> Service<Request<ReqBody>> for AddAuthorization<S>

where S: Service<Request<ReqBody>, Output = Response<ResBody>>, ReqBody: Send + 'static, ResBody: Send + 'static,

type Output = <S as Service<Request<ReqBody>>>::Output

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

impl<S, ReqBody, ResBody> Service<Request<ReqBody>> for AltSvc<S>

where S: Service<Request<ReqBody>, Output = Response<ResBody>> + ExtensionsRef, ReqBody: Send + 'static, ResBody: Body + Send + 'static,

type Output = Response<AltSvcBody<ResBody>>

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

impl<S, ReqBody, ResBody> Service<Request<ReqBody>> for CollectBody<S>

where S: Service<Request<ReqBody>, Output = Response<ResBody>>, <S as Service<Request<ReqBody>>>::Error: Into<Box<dyn Error + Send + Sync>>, ReqBody: Send + 'static, ResBody: Body + Send + Sync + 'static, <ResBody as Body>::Data: Send, <ResBody as Body>::Error: Error + Send + Sync + 'static,

type Output = Response

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

impl<S, ReqBody, ResBody> Service<Request<ReqBody>> for Cors<S>

where S: Service<Request<ReqBody>, Output = Response<ResBody>>, ReqBody: Send + 'static, ResBody: Send + 'static,

type Output = Response<OptionalBody<ResBody>>

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

impl<S, ReqBody, ResBody> Service<Request<ReqBody>> for GrpcWebService<S>

where S: Service<Request, Output = Response<ResBody>>, ReqBody: Body<Data = Bytes> + Send + Sync + 'static, <ReqBody as Body>::Error: Into<Box<dyn Error + Send + Sync>> + Display, ResBody: Body<Data = Bytes> + Send + Sync + 'static, <ResBody as Body>::Error: Into<Box<dyn Error + Send + Sync>> + Display,

type Output = Response

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

impl<S, ReqBody, ResBody> Service<Request<ReqBody>> for HttpForwardProxyService<S>

where S: Service<Request<ReqBody>, Output = Response<ResBody>> + ExtensionsRef, <S as Service<Request<ReqBody>>>::Error: Into<Box<dyn Error + Send + Sync>>, ReqBody: Send + 'static, ResBody: Send + 'static,

type Output = Response<ResBody>

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

impl<S, ReqBody, ResBody> Service<Request<ReqBody>> for NormalizePath<S>

where S: Service<Request<ReqBody>, Output = Response<ResBody>>, ReqBody: Send + 'static, ResBody: Send + 'static,

type Output = <S as Service<Request<ReqBody>>>::Output

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

impl<S, ReqBody, ResBody> Service<Request<ReqBody>> for PropagateRequestId<S>

where S: Service<Request<ReqBody>, Output = Response<ResBody>>, ReqBody: Send + 'static, ResBody: Send + 'static,

type Output = <S as Service<Request<ReqBody>>>::Output

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

impl<S, ReqBody, ResBody> Service<Request<ReqBody>> for RequestDecompression<S>

where S: Service<Request<DecompressionBody<ReqBody>>, Output = Response<ResBody>>, <S as Service<Request<DecompressionBody<ReqBody>>>>::Error: Into<Box<dyn Error + Send + Sync>>, ReqBody: Body + Send + 'static, ResBody: Body<Data = Bytes> + Send + Sync + 'static, <ResBody as Body>::Error: Into<Box<dyn Error + Send + Sync>>,

type Output = Response

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

impl<S, ReqBody, ResBody> Service<Request<ReqBody>> for ResponseBodyDeadline<S>

where S: Service<Request<ReqBody>, Output = Response<ResBody>>, ReqBody: Send + 'static, ResBody: Send + 'static,

type Output = Response<DeadlineBody<ResBody>>

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

impl<S, ReqBody, ResBody> Service<Request<ReqBody>> for ResponseBodyTimeout<S>

where S: Service<Request<ReqBody>, Output = Response<ResBody>>, ReqBody: Send + 'static, ResBody: Send + 'static,

type Output = Response<TimeoutBody<ResBody>>

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

impl<S, ReqBody, ResBody> Service<Request<ReqBody>> for SetStatus<S>

where S: Service<Request<ReqBody>, Output = Response<ResBody>>, ReqBody: Send + 'static, ResBody: Send + 'static,

type Output = <S as Service<Request<ReqBody>>>::Output

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

impl<S, ReqBody, ResBody> Service<Request<ReqBody>> for rama::http::layer::timeout::Timeout<S>

where S: Service<Request<ReqBody>, Output = Response<ResBody>>, ReqBody: Send + 'static, ResBody: Send + 'static,

type Output = Response<OptionalBody<ResBody>>

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

impl<S, ReqBody> Service<Request<ReqBody>> for rama::http::layer::body_limit::BodyLimitService<S>

where S: Service<Request>, ReqBody: Body<Data = Bytes> + Send + Sync + 'static, <ReqBody as Body>::Error: Into<Box<dyn Error + Send + Sync>>,

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

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

impl<S, ReqBody> Service<Request<ReqBody>> for DataUriService<S>

where S: Service<Request<ReqBody>, Output = Response>, <S as Service<Request<ReqBody>>>::Error: Into<Box<dyn Error + Send + Sync>>, ReqBody: Send + 'static,

type Output = Response

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

impl<S, ReqBody> Service<Request<ReqBody>> for DpiProxyCredentialExtractor<S>

where S: Service<Request<ReqBody>>, ReqBody: Send + 'static,

type Output = <S as Service<Request<ReqBody>>>::Output

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

impl<S, ReqBody> Service<Request<ReqBody>> for FileUriService<S>

where S: Service<Request<ReqBody>, Output = Response>, <S as Service<Request<ReqBody>>>::Error: Into<Box<dyn Error + Send + Sync>>, ReqBody: Send + 'static,

type Output = Response

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

impl<S, ReqBody> Service<Request<ReqBody>> for GrpcTimeout<S>

where S: Service<Request<ReqBody>>, <S as Service<Request<ReqBody>>>::Error: Into<Box<dyn Error + Send + Sync>>, ReqBody: Send + 'static,

type Output = <S as Service<Request<ReqBody>>>::Output

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

impl<S, ReqBody> Service<Request<ReqBody>> for RequestBodyDeadline<S>

where S: Service<Request<DeadlineBody<ReqBody>>>, ReqBody: Send + 'static,

type Output = <S as Service<Request<DeadlineBody<ReqBody>>>>::Output

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

impl<S, ReqBody> Service<Request<ReqBody>> for RequestBodyTimeout<S>

where S: Service<Request<TimeoutBody<ReqBody>>>, ReqBody: Send + 'static,

type Output = <S as Service<Request<TimeoutBody<ReqBody>>>>::Output

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

impl<S, T1, Body> Service<Request<Body>> for SetForwardedHeadersService<S, (T1,)>

where T1: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>>, <S as Service<Request<Body>>>::Error: Into<Box<dyn Error + Send + Sync>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

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

impl<S, T1, T2, Body> Service<Request<Body>> for SetForwardedHeadersService<S, (T1, T2)>

where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>>, <S as Service<Request<Body>>>::Error: Into<Box<dyn Error + Send + Sync>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

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

impl<S, T1, T2, T3, Body> Service<Request<Body>> for SetForwardedHeadersService<S, (T1, T2, T3)>

where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>>, <S as Service<Request<Body>>>::Error: Into<Box<dyn Error + Send + Sync>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

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

impl<S, T1, T2, T3, T4, Body> Service<Request<Body>> for SetForwardedHeadersService<S, (T1, T2, T3, T4)>

where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, T4: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>>, <S as Service<Request<Body>>>::Error: Into<Box<dyn Error + Send + Sync>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

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

impl<S, T1, T2, T3, T4, T5, Body> Service<Request<Body>> for SetForwardedHeadersService<S, (T1, T2, T3, T4, T5)>

where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, T4: ForwardHeader + Send + Sync + 'static, T5: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>>, <S as Service<Request<Body>>>::Error: Into<Box<dyn Error + Send + Sync>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

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

impl<S, T1, T2, T3, T4, T5, T6, Body> Service<Request<Body>> for SetForwardedHeadersService<S, (T1, T2, T3, T4, T5, T6)>

where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, T4: ForwardHeader + Send + Sync + 'static, T5: ForwardHeader + Send + Sync + 'static, T6: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>>, <S as Service<Request<Body>>>::Error: Into<Box<dyn Error + Send + Sync>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

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

impl<S, T1, T2, T3, T4, T5, T6, T7, Body> Service<Request<Body>> for SetForwardedHeadersService<S, (T1, T2, T3, T4, T5, T6, T7)>

where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, T4: ForwardHeader + Send + Sync + 'static, T5: ForwardHeader + Send + Sync + 'static, T6: ForwardHeader + Send + Sync + 'static, T7: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>>, <S as Service<Request<Body>>>::Error: Into<Box<dyn Error + Send + Sync>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

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

impl<S, T1, T2, T3, T4, T5, T6, T7, T8, Body> Service<Request<Body>> for SetForwardedHeadersService<S, (T1, T2, T3, T4, T5, T6, T7, T8)>

where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, T4: ForwardHeader + Send + Sync + 'static, T5: ForwardHeader + Send + Sync + 'static, T6: ForwardHeader + Send + Sync + 'static, T7: ForwardHeader + Send + Sync + 'static, T8: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>>, <S as Service<Request<Body>>>::Error: Into<Box<dyn Error + Send + Sync>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

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

impl<S, T1, T2, T3, T4, T5, T6, T7, T8, T9, Body> Service<Request<Body>> for SetForwardedHeadersService<S, (T1, T2, T3, T4, T5, T6, T7, T8, T9)>

where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, T4: ForwardHeader + Send + Sync + 'static, T5: ForwardHeader + Send + Sync + 'static, T6: ForwardHeader + Send + Sync + 'static, T7: ForwardHeader + Send + Sync + 'static, T8: ForwardHeader + Send + Sync + 'static, T9: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>>, <S as Service<Request<Body>>>::Error: Into<Box<dyn Error + Send + Sync>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

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

impl<S, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, Body> Service<Request<Body>> for SetForwardedHeadersService<S, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>

where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, T4: ForwardHeader + Send + Sync + 'static, T5: ForwardHeader + Send + Sync + 'static, T6: ForwardHeader + Send + Sync + 'static, T7: ForwardHeader + Send + Sync + 'static, T8: ForwardHeader + Send + Sync + 'static, T9: ForwardHeader + Send + Sync + 'static, T10: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>>, <S as Service<Request<Body>>>::Error: Into<Box<dyn Error + Send + Sync>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

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

impl<S, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, Body> Service<Request<Body>> for SetForwardedHeadersService<S, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>

where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, T4: ForwardHeader + Send + Sync + 'static, T5: ForwardHeader + Send + Sync + 'static, T6: ForwardHeader + Send + Sync + 'static, T7: ForwardHeader + Send + Sync + 'static, T8: ForwardHeader + Send + Sync + 'static, T9: ForwardHeader + Send + Sync + 'static, T10: ForwardHeader + Send + Sync + 'static, T11: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>>, <S as Service<Request<Body>>>::Error: Into<Box<dyn Error + Send + Sync>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

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

impl<S, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, Body> Service<Request<Body>> for SetForwardedHeadersService<S, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>

where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, T4: ForwardHeader + Send + Sync + 'static, T5: ForwardHeader + Send + Sync + 'static, T6: ForwardHeader + Send + Sync + 'static, T7: ForwardHeader + Send + Sync + 'static, T8: ForwardHeader + Send + Sync + 'static, T9: ForwardHeader + Send + Sync + 'static, T10: ForwardHeader + Send + Sync + 'static, T11: ForwardHeader + Send + Sync + 'static, T12: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>>, <S as Service<Request<Body>>>::Error: Into<Box<dyn Error + Send + Sync>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

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

impl<S, T, ReqBody, ResBody> Service<Request<ReqBody>> for CatchPanic<S, T>

where S: Service<Request<ReqBody>, Output = Response<ResBody>>, ResBody: Into<Body> + Send + 'static, T: ResponseForPanic + Clone + Send + Sync + 'static, ReqBody: Send + 'static,

type Output = Response

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

impl<S, T, ReqBody, ResBody> Service<Request<ReqBody>> for Csrf<S, T>

where S: Service<Request<ReqBody>, Output = Response<ResBody>>, T: ResponseForProtectionError<ResBody>, ReqBody: Send + 'static, ResBody: Send + 'static,

type Output = Response<ResBody>

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

impl<S, T> Service<BridgeIo<S, T>> for IoForwardService

where S: Io + Unpin + ExtensionsRef, T: Io + Unpin + ExtensionsRef,

type Output = IoForwardOutcome

type Error = IoForwardError

impl<S, W, ReqBody, ResBody> Service<Request<ReqBody>> for ResponseWriterService<S, W>

where S: Service<Request<ReqBody>, Output = Response<ResBody>>, <S as Service<Request<ReqBody>>>::Error: Into<Box<dyn Error + Send + Sync>>, W: ResponseWriter, ReqBody: Send + 'static, ResBody: Body<Data = Bytes> + Send + Sync + 'static, <ResBody as Body>::Error: Into<Box<dyn Error + Send + Sync>>,

type Output = Response

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

impl<S, W, ReqBody> Service<Request<ReqBody>> for RequestWriterService<S, W>

where S: Service<Request>, <S as Service<Request>>::Error: Into<Box<dyn Error + Send + Sync>>, ReqBody: Body<Data = Bytes> + Send + Sync + 'static, <ReqBody as Body>::Error: Into<Box<dyn Error + Send + Sync>>, W: RequestWriter,

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

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

impl<S> Service<ConnectRequest> for HttpServiceConnector<S>

where S: ConnectorService<ConnectRequest>, <S as ConnectorService<ConnectRequest>>::Connection: ExtensionsRef,

type Output = EstablishedClientConnection<<S as ConnectorService<ConnectRequest>>::Connection, ConnectRequest>

type Error = ConnectionError

impl<S> Service<CreateCollection> for EncryptStore<S>

where S: Service<CreateCollection, Output = Collection, Error = Box<dyn Error + Send + Sync>>,

type Output = Collection

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

impl<S> Service<FastCgiRequest> for FastCgiHttpService<S>

where S: Service<Request, Output = Response>, <S as Service<Request>>::Error: Into<Box<dyn Error + Send + Sync>>,

type Output = FastCgiResponse

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

impl<S> Service<IncomingRequest> for rama::icap::http::HttpService<S>

where S: Service<IncomingRequest, Output = OutgoingResponse>, <S as Service<IncomingRequest>>::Error: Into<Box<dyn Error + Send + Sync>>,

type Output = OutgoingResponse

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

impl<S> Service<OptionsRequest> for OptionsCache<S>

where S: Service<OptionsRequest, Output = ServiceCapabilities>, <S as Service<OptionsRequest>>::Error: Into<Box<dyn Error + Send + Sync>>,

type Output = Arc<ServiceCapabilities>

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

impl<S> Service<S> for DiscardService

where S: Io + 'static,

type Output = u64

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

impl<S> Service<S> for rama::net::stream::service::EchoService

where S: Io + 'static,

type Output = u64

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

impl<S> Service<ServerWebSocket<S>> for WebSocketEchoService

where S: WebSocketIo,

type Output = ()

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

impl<S> Service<Uri> for PacScriptCache<S>

where S: Service<Uri, Output = PacScript>, <S as Service<Uri>>::Error: Into<Box<dyn Error + Send + Sync>>,

type Output = PacScript

type Error = OpaqueError

impl<State, L, O, E> Service<Request> for Router<State, L, O, E>

where O: Send + 'static, E: Send + From<RouterError> + 'static, L: Send + Sync + 'static, State: Send + Sync + Clone + 'static,

type Output = O

type Error = E

impl<State> Service<Request> for WebService<State>

where State: Send + Sync + Clone + 'static,

type Output = Response

type Error = !

impl<Stream, Output, S, F> Service<Stream> for SniRouter<S, F>

where Stream: Io + Unpin + ExtensionsRef, Output: Send + 'static, S: Service<SniRequest<Stream>, Output = Output>, <S as Service<SniRequest<Stream>>>::Error: Into<Box<dyn Error + Send + Sync>>, F: Service<PrefixedIo<HeapReader, Stream>, Output = Output>, <F as Service<PrefixedIo<HeapReader, Stream>>>::Error: Into<Box<dyn Error + Send + Sync>>,

type Output = Output

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

impl<T1, S, Body> Service<Request<Body>> for GetForwardedHeadersService<S, (T1,)>

where T1: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

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

impl<T1, T2, S, Body> Service<Request<Body>> for GetForwardedHeadersService<S, (T1, T2)>

where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

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

impl<T1, T2, T3, S, Body> Service<Request<Body>> for GetForwardedHeadersService<S, (T1, T2, T3)>

where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

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

impl<T1, T2, T3, T4, S, Body> Service<Request<Body>> for GetForwardedHeadersService<S, (T1, T2, T3, T4)>

where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, T4: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

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

impl<T1, T2, T3, T4, T5, S, Body> Service<Request<Body>> for GetForwardedHeadersService<S, (T1, T2, T3, T4, T5)>

where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, T4: ForwardHeader + Send + Sync + 'static, T5: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

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

impl<T1, T2, T3, T4, T5, T6, S, Body> Service<Request<Body>> for GetForwardedHeadersService<S, (T1, T2, T3, T4, T5, T6)>

where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, T4: ForwardHeader + Send + Sync + 'static, T5: ForwardHeader + Send + Sync + 'static, T6: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

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

impl<T1, T2, T3, T4, T5, T6, T7, S, Body> Service<Request<Body>> for GetForwardedHeadersService<S, (T1, T2, T3, T4, T5, T6, T7)>

where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, T4: ForwardHeader + Send + Sync + 'static, T5: ForwardHeader + Send + Sync + 'static, T6: ForwardHeader + Send + Sync + 'static, T7: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

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

impl<T1, T2, T3, T4, T5, T6, T7, T8, S, Body> Service<Request<Body>> for GetForwardedHeadersService<S, (T1, T2, T3, T4, T5, T6, T7, T8)>

where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, T4: ForwardHeader + Send + Sync + 'static, T5: ForwardHeader + Send + Sync + 'static, T6: ForwardHeader + Send + Sync + 'static, T7: ForwardHeader + Send + Sync + 'static, T8: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

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

impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, S, Body> Service<Request<Body>> for GetForwardedHeadersService<S, (T1, T2, T3, T4, T5, T6, T7, T8, T9)>

where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, T4: ForwardHeader + Send + Sync + 'static, T5: ForwardHeader + Send + Sync + 'static, T6: ForwardHeader + Send + Sync + 'static, T7: ForwardHeader + Send + Sync + 'static, T8: ForwardHeader + Send + Sync + 'static, T9: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

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

impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, S, Body> Service<Request<Body>> for GetForwardedHeadersService<S, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>

where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, T4: ForwardHeader + Send + Sync + 'static, T5: ForwardHeader + Send + Sync + 'static, T6: ForwardHeader + Send + Sync + 'static, T7: ForwardHeader + Send + Sync + 'static, T8: ForwardHeader + Send + Sync + 'static, T9: ForwardHeader + Send + Sync + 'static, T10: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

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

impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, S, Body> Service<Request<Body>> for GetForwardedHeadersService<S, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>

where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, T4: ForwardHeader + Send + Sync + 'static, T5: ForwardHeader + Send + Sync + 'static, T6: ForwardHeader + Send + Sync + 'static, T7: ForwardHeader + Send + Sync + 'static, T8: ForwardHeader + Send + Sync + 'static, T9: ForwardHeader + Send + Sync + 'static, T10: ForwardHeader + Send + Sync + 'static, T11: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

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

impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, S, Body> Service<Request<Body>> for GetForwardedHeadersService<S, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>

where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, T4: ForwardHeader + Send + Sync + 'static, T5: ForwardHeader + Send + Sync + 'static, T6: ForwardHeader + Send + Sync + 'static, T7: ForwardHeader + Send + Sync + 'static, T8: ForwardHeader + Send + Sync + 'static, T9: ForwardHeader + Send + Sync + 'static, T10: ForwardHeader + Send + Sync + 'static, T11: ForwardHeader + Send + Sync + 'static, T12: ForwardHeader + Send + Sync + 'static, S: Service<Request<Body>>, Body: Send + 'static,

type Output = <S as Service<Request<Body>>>::Output

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

impl<T, B> Service<Request<B>> for HealthServer<T>

where T: Health, B: Body + Send + Sync + 'static, <B as Body>::Error: Into<Box<dyn Error + Send + Sync>> + Send + 'static,

type Output = Response

type Error = !

impl<T, B> Service<Request<B>> for LogsServiceServer<T>

where T: LogsService, B: Body + Send + Sync + 'static, <B as Body>::Error: Into<Box<dyn Error + Send + Sync>> + Send + 'static,

type Output = Response

type Error = !

impl<T, B> Service<Request<B>> for MetricsServiceServer<T>

where T: MetricsService, B: Body + Send + Sync + 'static, <B as Body>::Error: Into<Box<dyn Error + Send + Sync>> + Send + 'static,

type Output = Response

type Error = !

impl<T, B> Service<Request<B>> for TraceServiceServer<T>

where T: TraceService, B: Body + Send + Sync + 'static, <B as Body>::Error: Into<Box<dyn Error + Send + Sync>> + Send + 'static,

type Output = Response

type Error = !

impl<T, F, Input, E> Service<Input> for Abortable<T, F>

where Input: ExtensionsRef + Send + 'static, F: MakeLayerError<Error = E>, E: Into<<T as Service<Input>>::Error> + Send + 'static, T: Service<Input>,

type Output = <T as Service<Input>>::Output

type Error = <T as Service<Input>>::Error

impl<T, F, Input, E> Service<Input> for rama::layer::Timeout<T, F>

where Input: Send + 'static, F: MakeLayerError<Error = E>, E: Into<Box<dyn Error + Send + Sync>> + Send + 'static, T: Service<Input>, <T as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>,

type Output = <T as Service<Input>>::Output

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

impl<T, Input> Service<Input> for LayerAdapterService<T>

where T: Service<Input> + Clone + Send + Sync + 'static, <T as Service<Input>>::Response: Send + 'static, <T as Service<Input>>::Error: Send + 'static, <T as Service<Input>>::Future: Send, Input: Send + 'static,

type Output = <T as Service<Input>>::Response

type Error = <T as Service<Input>>::Error

impl<T, Input> Service<Input> for ServiceAdapter<T>

where T: Service<Input> + Clone + Send + Sync + 'static, <T as Service<Input>>::Response: Send + 'static, <T as Service<Input>>::Error: Send + 'static, <T as Service<Input>>::Future: Send, Input: Send + 'static,

type Output = <T as Service<Input>>::Response

type Error = <T as Service<Input>>::Error

impl<T, Input> Service<Input> for SharedServiceAdapter<T>

where T: Service<Input> + Send + Sync + 'static, <T as Service<Input>>::Response: Send + 'static, <T as Service<Input>>::Error: Send + 'static, <T as Service<Input>>::Future: Send, Input: Send + 'static,

type Output = <T as Service<Input>>::Response

type Error = <T as Service<Input>>::Error

impl<T, P, F, Input, FnOutput, FnError> Service<Input> for Limit<T, P, ErrorIntoOutputFn<F>>

where T: Service<Input>, P: Policy<Input>, F: Fn(<P as Policy<Input>>::Error) -> Result<FnOutput, FnError> + Send + Sync + 'static, FnOutput: Into<<T as Service<Input>>::Output> + Send + 'static, FnError: Into<<T as Service<Input>>::Error> + Send + Sync + 'static, Input: Send + Sync + 'static,

type Output = <T as Service<Input>>::Output

type Error = <T as Service<Input>>::Error

impl<T, P, Input> Service<Input> for Limit<T, P>

where T: Service<Input>, <T as Service<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, P: Policy<Input>, <P as Policy<Input>>::Error: Into<Box<dyn Error + Send + Sync>>, Input: Send + Sync + 'static,

type Output = <T as Service<Input>>::Output

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

impl<T, ReqBody, ResBody> Service<Request<ReqBody>> for TowerHttpServiceAdapter<T>

where T: Service<Request<HyperiumBody<ReqBody>>, Response = Response<ResBody>> + Clone + Send + Sync + 'static, <T as Service<Request<HyperiumBody<ReqBody>>>>::Error: Error + Send + Sync + 'static, <T as Service<Request<HyperiumBody<ReqBody>>>>::Future: Send, ReqBody: Body + Send + 'static, ResBody: Body + Send + 'static,

type Output = Response<RamaBody<ResBody>>

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

impl<T, S, Body, E, C> Service<Request<Body>> for HeaderFromStrConfigService<T, S, C>

where S: Service<Request<Body>, Error = E>, T: FromStr + Send + Sync + Clone + Debug + Extension + 'static, <T as FromStr>::Err: Into<Box<dyn Error + Send + Sync>> + Send + Sync + 'static, C: FromIterator<T> + Send + Sync + Clone + Debug + Extension + 'static, Body: Send + Sync + 'static, E: Into<Box<dyn Error + Send + Sync>> + Send + Sync + 'static,

type Output = <S as Service<Request<Body>>>::Output

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

impl<T, S, Body, E> Service<Request<Body>> for HeaderConfigService<T, S>

where S: Service<Request<Body>, Error = E>, T: DeserializeOwned + Extension, Body: Send + Sync + 'static, E: Into<Box<dyn Error + Send + Sync>> + Send + Sync + 'static,

type Output = <S as Service<Request<Body>>>::Output

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

impl<T, S, Body, E> Service<Request<Body>> for HeaderOptionValueService<T, S>

where S: Service<Request<Body>, Error = E>, T: Default + Extension, Body: Send + Sync + 'static, E: Into<Box<dyn Error + Send + Sync>> + Send + Sync + 'static,

type Output = <S as Service<Request<Body>>>::Output

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