Struct App 

pub struct App<G: Gate = Open> { /* private fields */ }

A web application: one site, its routes, and its gate. Built once at start-up with App::builder or App::with_gate; immutable after.

It is a serve_net::HttpService, so it runs on serve-net as it is, and it has respond and respond_identified for a wrapper that calls it from its own service.

use web_net::{App, get};

let app = App::builder()
    .route(get("/", |cx| { cx.html(200, "<h1>Hello</h1>"); Ok(()) }).public())
    .route(get("/users/:id", |cx| {
        let id: u64 = cx.param_as("id")?;
        cx.text(200, &format!("user {id}"));
        Ok(())
    }).public())
    .build()?;

let reply = serve_net::testing::respond(&app, b"GET /users/7 HTTP/1.1\r\nHost: a\r\n\r\n");
assert_eq!((reply.status, reply.text()), (200, "user 7"));

let reply = serve_net::testing::respond(&app, b"GET /users/7/ HTTP/1.1\r\nHost: a\r\n\r\n");
assert_eq!(reply.status, 301);
assert_eq!(reply.header("location"), Some(&b"/users/7"[..]));

Implementations

impl App<Open>

pub fn builder() -> Builder<Open>

A builder with the Open gate: every visitor is a guest and every route is declared public.

Examples found in repository

examples/hello.rs (line 15)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let app = App::builder()
        .host("127.0.0.1:8091")
        .development()
        .base("/app")
        .route(
            get("/", |cx| {
                let users = cx.url("/users/7");
                cx.html(
                    200,
                    &format!("<h1>Hello</h1><a href=\"{users}\">user 7</a>"),
                );
                Ok(())
            })
            .public(),
        )
        .route(
            get("/users/:id", |cx| {
                let id: u64 = cx.param_as("id")?;
                cx.text(200, &format!("user {id}"));
                Ok(())
            })
            .public(),
        )
        .route(
            Route::at("/contact")
                .get(|cx| {
                    cx.html(200, "<form method=post><button>Send</button></form>");
                    Ok(())
                })
                .post(|cx| cx.see_other("/"))
                .public()
                // A form that changes state gets Builder::csrf(..) and a gate
                // whose identities carry a CSRF binding instead.
                .csrf_exempt("demo: the POST changes nothing"),
        )
        .build()?;

    let server = serve_net::Server::builder()
        .listener(serve_net::ListenerSpec::tcp("web", "127.0.0.1:8091"))
        .serve(app)?;
    println!("listening on http://127.0.0.1:8091/app/");
    server.wait();
    Ok(())
}

impl<G: Gate> App<G>

pub fn with_gate(gate: G) -> Builder<G>

A builder with gate for authentication and authorization.

impl<G: Gate> App<G>

pub fn respond( &self, req: &HttpRequest<'_>, env: &Envelope, reply: &mut HttpReply, ) -> Outcome

Runs the whole pipeline for one request, authentication included.

pub fn serve( &self, req: &HttpRequest<'_>, env: &Envelope, who: Option<&G::Identity>, reply: &mut HttpReply, ) -> Served

Runs the pipeline and reports what ran and whether a cache in front may keep the reply for guests. who is Some when the caller authenticated already (as for respond_identified).

pub fn respond_identified( &self, req: &HttpRequest<'_>, env: &Envelope, who: &G::Identity, reply: &mut HttpReply, ) -> Outcome

Runs the pipeline for a request whose caller authenticated it already: web-net takes who as given and does not call the gate’s authenticate. Authorization still runs for every route that is not public.

pub fn classify(&self, head: &HttpHead<'_>) -> Classified

Looks at a head before admission: which route would run and how it behaves. Nothing is answered and no gate is called.

pub fn gate(&self) -> &G

The gate.

Trait Implementations

impl<G: Gate> Debug for App<G>

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

Formats the value using the given formatter.

impl<G: Gate> HttpService for App<G>

fn call( &self, request: &HttpRequest<'_>, env: &Envelope, reply: &mut HttpReply, ) -> Outcome

The request is complete.

const WORK: WorkClass = WorkClass::Quick

How the service behaves.

fn head(&self, head: &HttpHead<'_>, env: &mut Envelope) -> HeadAction

The head is complete; before admission and before any body byte.

fn upgraded(&self, env: &Envelope, conn: UpgradedConn)

After the 101 for an upgrade this service asked for in head left, and after done for that request. The conversation itself belongs to the upgrade target (a WebSocketService, feature ws).

fn done(&self, env: &Envelope, finished: &Finished)

Exactly once per request that reached head, on every path.