Struct Server 

pub struct Server<A, P, S, R, E> { /* private fields */ }

A server that can accept connections, and run each connection using a tower::Service.

To use the server, call .await on it. This will start the server and serve until the future is cancelled or the acceptor encounters an error. To cancel the server, drop the future.

The server also supports graceful shutdown. Provide a future which will resolve when the server should shut down to Server::with_graceful_shutdown to enable this behavior. In graceful shutdown mode, individual connections will have an opportunity to finish processing before the server stops.

The generic parameters can be a bit tricky. They are as follows:

• A is the type that can accept connections. This must implement Accept.
• P is the protocol to use for serving connections. This must implement Protocol.
• S is the “make service” which generates a service to handle each connection. This must implement MakeServiceRef, and will be passed a reference to the connection stream (to facilitate connection information).
• R is the request type for the service.
• E is the executor to use for running the server. This is used to spawn the connection futures.

Implementations

impl<P, S, B, E> Server<NeedsAcceptor, P, S, B, E>

pub fn with_acceptor<A>(self, acceptor: A) -> Server<A, P, S, B, E>

where A: Accept,

Set the acceptor to use for incoming connections.

impl<A, S, B, E> Server<A, NeedsProtocol, S, B, E>

pub fn with_protocol<P>(self, protocol: P) -> Server<A, P, S, B, E>

Set the protocol to use for incoming connections.

impl<A, P, B, E> Server<A, P, NeedsService, B, E>

pub fn with_make_service<S>(self, make_service: S) -> Server<A, P, S, B, E>

Set the make service to use for handling incoming connections.

A MakeService is a factory for creating Service instances. It is used to create a new Service for each incoming connection.

If you have a service that is Clone, you can use with_shared_service to wrap it in a Shared and avoid constructing a new make service.

pub fn with_shared_service<S>(self, service: S) -> Server<A, P, Shared<S>, B, E>

Wrap a Clone service in a Shared to use as a make service.

impl<A, P, S, B> Server<A, P, S, B, NeedsExecutor>

pub fn with_executor<E>(self, executor: E) -> Server<A, P, S, B, E>

Set the executor for this server

The executor is used to drive connections to completion asynchronously.

pub fn with_tokio(self) -> Server<A, P, S, B, TokioExecutor>

Use a tokio multi-threaded excutor via tokio::task::spawn

This executor is a suitable default, but does require Send and ’static bounds in some places to allow futures to be moved between threads.

Con

impl<A, P, S, B, E> Server<A, P, S, B, E>

pub fn with_request<B2>(self) -> Server<A, P, S, B2, E>

Set the body to use for handling requests.

Usually this method can be called with inferred types.

impl<A, P, S, B, E> Server<A, P, S, B, E>

where A: Accept,

pub fn with_tls( self, config: Arc<ServerConfig>, ) -> Server<TlsAcceptor<A>, P, S, B, E>

Add TLS to this server

impl<A, P, S, B, E> Server<A, P, S, B, E>

pub fn map_service<F, U>(self, f: F) -> Server<A, P, U, B, E>

where F: FnOnce(S) -> U,

Map the service to a new value.

impl Server<(), (), (), (), ()>

pub fn builder<R>() -> Server<NeedsAcceptor, NeedsProtocol, NeedsService, R, NeedsExecutor>

Create a new server builder.

impl<A, P, S, R, E> Server<A, P, S, R, E>

pub fn new( acceptor: A, protocol: P, make_service: S, executor: E, ) -> Server<A, P, S, R, E>

Create a new server with the given tower::make::MakeService and Accept, and Protocol.

pub fn with_graceful_shutdown<F>( self, signal: F, ) -> GracefulShutdown<A, P, S, R, E, F>

where S: MakeServiceRef<<A as Accept>::Connection, R>, P: Protocol<<S as MakeServiceRef<<A as Accept>::Connection, R>>::Service, <A as Accept>::Connection, R>, A: Accept + Unpin, F: Future<Output = ()> + Send + 'static, E: ServerExecutor<P, S, A, R>,

Shutdown the server gracefully when the given future resolves.

Trait Implementations

impl<A, P, S, R, E> Debug for Server<A, P, S, R, E>

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

Formats the value using the given formatter.

impl<A, P, S, R, E> IntoFuture for Server<A, P, S, R, E>

where S: MakeServiceRef<<A as Accept>::Connection, R>, P: Protocol<<S as MakeServiceRef<<A as Accept>::Connection, R>>::Service, <A as Accept>::Connection, R>, A: Accept + Unpin, E: ServerExecutor<P, S, A, R>,

type IntoFuture = Serving<A, P, S, R, E>

Which kind of future are we turning this into?

type Output = Result<(), ServerError>

The output that the future will produce on completion.

fn into_future(self) -> <Server<A, P, S, R, E> as IntoFuture>::IntoFuture

Creates a future from a value.

impl<P, S, B, E> ServerAcceptorExt<P, S, B, E> for Server<NeedsAcceptor, P, S, B, E>

fn with_incoming<I>(self, incoming: I) -> Server<Acceptor, P, S, B, E>

where I: Into<Acceptor> + Into<AcceptorCore>,

Use an incoming stream of connections as the acceptor.

async fn with_bind( self, addr: &SocketAddr, ) -> Result<Server<Acceptor, P, S, B, E>, Error>

Bind to the provided address and use it as the acceptor.

async fn with_listener( self, listener: TcpListener, ) -> Server<Acceptor, P, S, B, E>

Use the provided listener as the acceptor.

impl<A, P, S, B, E> ServerConnectionInfoExt<A, P, S, B, E> for Server<A, P, S, B, E>

where S: MakeServiceRef<A::Connection, B>, A: Accept,

fn with_connection_info( self, ) -> Server<A, P, MakeServiceConnectionInfoService<S>, B, E>

Wrap the make service in a service that provides connection information.

fn with_tls_connection_info( self, ) -> Server<A, P, TlsConnectionInfoService<S>, B, E>

Wrap the make service in a service that provides TLS connection information.

impl<A, S, B, E> ServerProtocolExt<A, S, B, E> for Server<A, NeedsProtocol, S, B, E>

fn with_auto_http(self) -> Server<A, Builder, S, B, E>

Use a protocol that automatically detects and selects between HTTP/1.1 and HTTP/2, by looking for the HTTP/2 header in the initial bytes of the connection.

fn with_http1(self) -> Server<A, Http1Builder, S, B, E>

Use HTTP/1.1 for all incoming connections.

fn with_http2(self) -> Server<A, Http2Builder<TokioExecutor>, S, B, E>

Use HTTP/2 for all incoming connections.