Struct hyper::server::Server[][src]

pub struct Server<I, S, E = Exec> { /* fields omitted */ }

A listening HTTP server that accepts connections in both HTTP1 and HTTP2 by default.

Server is a Future mapping a bound listener with a set of service handlers. It is built using the Builder, and the future completes when the server has been shutdown. It should be run by an Executor.

Implementations

impl<I> Server<I, ()>[src]

pub fn builder(incoming: I) -> Builder<I>[src]

Starts a Builder with the provided incoming stream.

impl Server<AddrIncoming, ()>[src]

pub fn bind(addr: &SocketAddr) -> Builder<AddrIncoming>[src]

Binds to the provided address, and returns a Builder.

Panics

This method will panic if binding to the address fails. For a method to bind to an address and return a Result, see Server::try_bind.

pub fn try_bind(addr: &SocketAddr) -> Result<Builder<AddrIncoming>>[src]

Tries to bind to the provided address, and returns a Builder.

pub fn from_tcp(
    listener: StdTcpListener
) -> Result<Builder<AddrIncoming>, Error>
[src]

Create a new instance from a std::net::TcpListener instance.

impl<S, E> Server<AddrIncoming, S, E>[src]

pub fn local_addr(&self) -> SocketAddr[src]

Returns the local address that this server is bound to.

impl<I, IO, IE, S, E, B> Server<I, S, E> where
    I: Accept<Conn = IO, Error = IE>,
    IE: Into<Box<dyn StdError + Send + Sync>>,
    IO: AsyncRead + AsyncWrite + Unpin + Send + 'static,
    S: MakeServiceRef<IO, Body, ResBody = B>,
    S::Error: Into<Box<dyn StdError + Send + Sync>>,
    B: HttpBody + Send + Sync + 'static,
    B::Error: Into<Box<dyn StdError + Send + Sync>>,
    E: H2Exec<<S::Service as HttpService<Body>>::Future, B>,
    E: NewSvcExec<IO, S::Future, S::Service, E, GracefulWatcher>, 
[src]

pub fn with_graceful_shutdown<F>(self, signal: F) -> Graceful<I, S, F, E> where
    F: Future<Output = ()>, 
[src]

Prepares a server to handle graceful shutdown when the provided future completes.

Example

// Make a server from the previous examples...
let server = Server::bind(&([127, 0, 0, 1], 3000).into())
    .serve(make_service);

// Prepare some signal for when the server should start shutting down...
let (tx, rx) = tokio::sync::oneshot::channel::<()>();
let graceful = server
    .with_graceful_shutdown(async {
        rx.await.ok();
    });

// Await the `server` receiving the signal...
if let Err(e) = graceful.await {
    eprintln!("server error: {}", e);
}

// And later, trigger the signal by calling `tx.send(())`.
let _ = tx.send(());

Trait Implementations

impl<I: Debug, S: Debug> Debug for Server<I, S>[src]

impl<I, IO, IE, S, B, E> Future for Server<I, S, E> where
    I: Accept<Conn = IO, Error = IE>,
    IE: Into<Box<dyn StdError + Send + Sync>>,
    IO: AsyncRead + AsyncWrite + Unpin + Send + 'static,
    S: MakeServiceRef<IO, Body, ResBody = B>,
    S::Error: Into<Box<dyn StdError + Send + Sync>>,
    B: HttpBody + 'static,
    B::Error: Into<Box<dyn StdError + Send + Sync>>,
    E: H2Exec<<S::Service as HttpService<Body>>::Future, B>,
    E: NewSvcExec<IO, S::Future, S::Service, E, NoopWatcher>, 
[src]

type Output = Result<()>

The type of value produced on completion.

impl<'pin, I, S, E> Unpin for Server<I, S, E> where
    __Server<'pin, I, S, E>: Unpin
[src]

Auto Trait Implementations

impl<I, S, E> RefUnwindSafe for Server<I, S, E> where
    E: RefUnwindSafe,
    I: RefUnwindSafe,
    S: RefUnwindSafe

impl<I, S, E> Send for Server<I, S, E> where
    E: Send,
    I: Send,
    S: Send

impl<I, S, E> Sync for Server<I, S, E> where
    E: Sync,
    I: Sync,
    S: Sync

impl<I, S, E> UnwindSafe for Server<I, S, E> where
    E: UnwindSafe,
    I: UnwindSafe,
    S: UnwindSafe

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized
[src]

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

impl<T> BorrowMut<T> for T where
    T: ?Sized
[src]

impl<T> From<T> for T[src]

impl<T> FutureExt for T where
    T: Future + ?Sized
[src]

impl<T> Instrument for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, 
[src]

impl<F> IntoFuture for F where
    F: Future
[src]

type Output = <F as Future>::Output

🔬 This is a nightly-only experimental API. (into_future)

The output that the future will produce on completion.

type Future = F

🔬 This is a nightly-only experimental API. (into_future)

Which kind of future are we turning this into?

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<F, T, E> TryFuture for F where
    F: Future<Output = Result<T, E>> + ?Sized
[src]

type Ok = T

The type of successful values yielded by this future

type Error = E

The type of failures yielded by this future

impl<Fut> TryFutureExt for Fut where
    Fut: TryFuture + ?Sized
[src]

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.