Struct roa::App

pub struct App<S, T> { /* private fields */ }

The Application of roa.

Example

use roa_core::{App, Context, Next, Result, MiddlewareExt};
use tracing::info;
use tokio::fs::File;

let app = App::new().gate(gate).end(end);
async fn gate(ctx: &mut Context, next: Next<'_>) -> Result {
    info!("{} {}", ctx.method(), ctx.uri());
    next.await
}

async fn end(ctx: &mut Context) -> Result {
    ctx.resp.write_reader(File::open("assets/welcome.html").await?);
    Ok(())
}

State

The State is designed to share data or handler between middlewares. The only one type implemented State by this crate is (), you can implement your custom state if neccassary.

use roa_core::{App, Context, Next, Result};
use tracing::info;
use futures::lock::Mutex;

use std::sync::Arc;
use std::collections::HashMap;

#[derive(Clone)]
struct State {
    id: u64,
    database: Arc<Mutex<HashMap<u64, String>>>,
}

impl State {
    fn new() -> Self {
        Self {
            id: 0,
            database: Arc::new(Mutex::new(HashMap::new()))
        }
    }
}

let app = App::state(State::new()).gate(gate).end(end);
async fn gate(ctx: &mut Context<State>, next: Next<'_>) -> Result {
    ctx.id = 1;
    next.await
}

async fn end(ctx: &mut Context<State>) -> Result {
    let id = ctx.id;
    ctx.database.lock().await.get(&id);
    Ok(())
}

Implementations

impl<S> App<S, ()>

pub fn state(state: S) -> App<S, ()>

This is supported on crate feature runtime only.

Construct app with default runtime.

impl App<(), ()>

pub fn new() -> App<(), ()>

This is supported on crate feature runtime only.

Construct app with default runtime.

impl<S> App<S, ()>

pub fn with_exec(
    state: S,
    exec: impl Send + Sync + Spawn + 'static
) -> App<S, ()>

Construct an application with custom runtime.

impl<S, T> App<S, T> where
    T: for<'a> Middleware<'a, S>, 

pub fn gate<M>(self, middleware: M) -> App<S, Chain<T, M>> where
    M: for<'a> Middleware<'a, S>, 

Use a middleware.

pub fn end<E>(self, endpoint: E) -> App<S, Arc<Chain<T, E>>> where
    E: for<'a> Endpoint<'a, S>, 

Set endpoint, then app can only be used to serve http request.

impl<S, E> App<S, Arc<E>> where
    E: for<'a> Endpoint<'a, S>, 

pub fn accept<I, IO>(self, incoming: I) -> Server<I, App<S, Arc<E>>, Executor> where
    S: State,
    IO: 'static + Send + Sync + Unpin + AsyncRead + AsyncWrite,
    I: Accept<Conn = AddrStream<IO>>,
    <I as Accept>::Error: Into<Box<dyn Error + Send + Sync + 'static, Global>>, 

Construct a hyper server by an incoming.

Trait Implementations

impl Default for App<(), ()>

pub fn default() -> App<(), ()>

Construct app with default runtime.

impl<S, E> Listener for App<S, Arc<E>> where
    S: State,
    E: for<'a> Endpoint<'a, S>, 

This is supported on crate feature tcp only.

type Server = Server<TcpIncoming, Self, Executor>

http server

fn bind(self, addr: impl ToSocketAddrs) -> Result<(SocketAddr, Self::Server)>

Listen on a socket addr, return a server and the real addr it binds.

fn listen(
    self,
    addr: impl ToSocketAddrs,
    callback: impl Fn(SocketAddr)
) -> Result<Self::Server>

Listen on a socket addr, return a server, and pass real addr to the callback.

fn run(self) -> Result<(SocketAddr, Self::Server)>

Listen on an unused port of 127.0.0.1, return a server and the real addr it binds.

impl<'_, S, E, IO> Service<&'_ AddrStream<IO>> for App<S, Arc<E>> where
    S: State,
    E: for<'a> Endpoint<'a, S>,
    IO: 'static + Send + Sync + Unpin + AsyncRead + AsyncWrite, 

type Response = HttpService<S, E>

Responses given by the service.

type Error = Error

Errors produced by the service.

type Future = Pin<Box<dyn Future<Output = Result<HttpService<S, E>, Error>> + Send + 'static, Global>>

The future response value.

pub fn poll_ready(
    &mut self,
    _cx: &mut Context<'_>
) -> Poll<Result<(), <App<S, Arc<E>> as Service<&'_ AddrStream<IO>>>::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

pub fn call(
    &mut self,
    stream: &AddrStream<IO>
) -> <App<S, Arc<E>> as Service<&'_ AddrStream<IO>>>::Future

Process the request and return the response asynchronously.

impl<S, E> TlsListener for App<S, Arc<E>> where
    S: State,
    E: for<'a> Endpoint<'a, S>, 

This is supported on crate feature tls only.

type Server = Server<TlsIncoming<TcpIncoming>, Self, Executor>

http server

fn bind_tls(
    self,
    addr: impl ToSocketAddrs,
    config: ServerConfig
) -> Result<(SocketAddr, Self::Server)>

Listen on a socket addr, return a server and the real addr it binds.

fn listen_tls(
    self,
    addr: impl ToSocketAddrs,
    config: ServerConfig,
    callback: impl Fn(SocketAddr)
) -> Result<Self::Server>

Listen on a socket addr, return a server, and pass real addr to the callback.

fn run_tls(self, config: ServerConfig) -> Result<(SocketAddr, Self::Server)>

Listen on an unused port of 127.0.0.1, return a server and the real addr it binds.