Struct http_service_hyper::Builder

pub struct Builder<I: TryStream, Sp> { /* fields omitted */ }

A builder for a Server.

Methods

impl<I: TryStream, Sp> Builder<I, Sp>

pub fn with_spawner<Sp2>(self, new_spawner: Sp2) -> Builder<I, Sp2>

Sets the Spawn to deal with starting connection tasks.

Important traits for Server<I, S, Sp>

impl<I, S, Sp> Future for Server<I, S, Sp> where
    I: TryStream + Unpin,
    I::Ok: AsyncRead + AsyncWrite + Send + Unpin + 'static,
    I::Error: Into<Box<dyn Error + Send + Sync>>,
    S: HttpService,
    Sp: Clone + Send + 'static,
    &'a Sp: Spawn,  type Output = Result<()>;

pub fn serve<S: HttpService>(self, service: S) -> Server<I, S, Sp> where
    I: TryStream + Unpin,
    I::Ok: AsyncRead + AsyncWrite + Send + Unpin + 'static,
    I::Error: Into<Box<dyn Error + Send + Sync>>,
    Sp: Clone + Send + 'static,
    &'a Sp: Spawn, 

Consume this Builder, creating a Server.

Examples

use http_service::{Response, Body};
use http_service_hyper::Server;
use romio::TcpListener;

// Construct an executor to run our tasks on
let mut pool = futures::executor::ThreadPool::new()?;

// And an HttpService to handle each connection...
let service = |req| {
    futures::future::ok::<_, ()>(Response::new(Body::from("Hello World")))
};

// Then bind, configure the spawner to our pool, and serve...
let addr = "127.0.0.1:3000".parse()?;
let mut listener = TcpListener::bind(&addr)?;
let server = Server::builder(listener.incoming())
    .with_spawner(pool.clone())
    .serve(service);

// Finally, spawn `server` onto our executor...
pool.run(server)?;

Trait Implementations

impl<I: TryStream, Sp> Debug for Builder<I, Sp>

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.