Struct 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) -> Self

Available on crate feature runtime only.

Construct app with default runtime.

impl App<(), ()>

pub fn new() -> Self

Available on crate feature runtime only.

Construct app with default runtime.

impl<S> App<S, ()>

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

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, Self, Executor>

where S: State, IO: 'static + Send + Sync + Unpin + AsyncRead + AsyncWrite, I: Accept<Conn = AddrStream<IO>>, I::Error: Into<Box<dyn Error + Send + Sync>>,

Construct a hyper server by an incoming.

Trait Implementations

impl Default for App<(), ()>

fn default() -> Self

Construct app with default runtime.

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>>

The future response value.

fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>>

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

fn call(&mut self, stream: &AddrStream<IO>) -> Self::Future

Process the request and return the response asynchronously.