Struct TowerService03HttpServiceAsHyper1HttpService

pub struct TowerService03HttpServiceAsHyper1HttpService<S, B> { /* private fields */ }

Available on (crate features http1 or http2) and (crate features server or client) only.

Converts a tower-service 0.3 HTTP Service to a hyper 1.0 HTTP Service.

An HTTP Service is a Service where the request is http::Request<_> and the response is http::Response<_>.

Example

use http::{Request, Response, StatusCode};
use hyper_1::{server::conn::http1, service::service_fn, body, body::Bytes};
use std::{net::SocketAddr, convert::Infallible};
use tokio::net::TcpListener;
use tower_hyper_http_body_compat::TowerService03HttpServiceAsHyper1HttpService;

// a service function that uses hyper 0.14, tower-service 0.3, and http-body 0.4
async fn handler<B>(req: Request<B>) -> Result<Response<hyper_014::body::Body>, Infallible>
where
    B: hyper_014::body::HttpBody<Data = hyper_014::body::Bytes>,
    B::Error: Into<Box<dyn std::error::Error + Send + Sync>>,
{
   let body = req.into_body();
   let body = http_body_04::Limited::new(body, 1024);
   let bytes = match hyper_014::body::to_bytes(body).await {
       Ok(bytes) => bytes,
       Err(err) => {
           let res = Response::builder()
               .status(StatusCode::BAD_REQUEST)
               .body(hyper_014::body::Body::empty())
               .unwrap();
           return Ok(res)
       }
   };

   let res = Response::builder()
       .body(hyper_014::body::Body::from(format!("Received {} bytes", bytes.len())))
       .unwrap();
   Ok(res)
}

// run `handler` on hyper 1.0
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
    let addr: SocketAddr = ([127, 0, 0, 1], 8080).into();

    let service = tower::service_fn(handler);
    let service = TowerService03HttpServiceAsHyper1HttpService::new(service);

    let mut tcp_listener = TcpListener::bind(addr).await?;
    loop {
        let (tcp_stream, _) = tcp_listener.accept().await?;
        let tcp_stream = hyper_util::rt::TokioIo::new(tcp_stream);
        let service = service.clone();
        tokio::task::spawn(async move {
            if let Err(http_err) = http1::Builder::new()
                    .keep_alive(true)
                    .serve_connection(tcp_stream, service)
                    .await {
                eprintln!("Error while serving HTTP connection: {}", http_err);
            }
        });
    }
}

Implementations

impl<S, B> TowerService03HttpServiceAsHyper1HttpService<S, B>

pub fn new(service: S) -> Self

Create a new TowerService03HttpServiceAsHyper1HttpService.

Trait Implementations

impl<S, B> Clone for TowerService03HttpServiceAsHyper1HttpService<S, B>

where S: Clone,

fn clone(&self) -> Self

Returns a duplicate of the value.

const fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<S, B> Debug for TowerService03HttpServiceAsHyper1HttpService<S, B>

where S: Debug,

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

Formats the value using the given formatter.

impl<S, ReqBody, ResBody> Service<Request<ReqBody>> for TowerService03HttpServiceAsHyper1HttpService<S, HttpBody1ToHttpBody04<ReqBody>>

where S: Service<Request<HttpBody1ToHttpBody04<ReqBody>>, Response = Response<ResBody>> + Clone,

type Response = Response<HttpBody04ToHttpBody1<ResBody>>

Responses given by the service.

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

Errors produced by the service.

type Future = TowerService03HttpServiceAsHyper1HttpServiceFuture<S, Request<HttpBody1ToHttpBody04<ReqBody>>>

The future response value.

fn call(&self, req: Request<ReqBody>) -> Self::Future

Process the request and return the response asynchronously. call takes &self instead of mut &self because:

impl<S, B> Copy for TowerService03HttpServiceAsHyper1HttpService<S, B>

where S: Copy,