Struct Sites 

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

A table of applications, chosen per request by host and base path: an application that lists the request’s host (or an alias of it) wins over one that answers any host, and among those, the longest base path that holds the request’s path. A request no application claims goes to the first one added, which answers it by its own rules (421 for a host it does not serve, 404 outside its base).

use web_net::{App, Sites, get};

let blog = App::builder()
    .host("example.com")
    .base("/blog")
    .route(get("/", |cx| { cx.text(200, "blog"); Ok(()) }).public())
    .build()?;
let shop = App::builder()
    .host("shop.example.com")
    .route(get("/", |cx| { cx.text(200, "shop"); Ok(()) }).public())
    .build()?;
let main = App::builder()
    .host("example.com")
    .route(get("/", |cx| { cx.text(200, "home"); Ok(()) }).public())
    .build()?;
let sites = Sites::new().site(main).site(blog).site(shop);

use serve_net::testing::respond;
assert_eq!(respond(&sites, b"GET /blog/ HTTP/1.1\r\nHost: example.com\r\n\r\n").text(), "blog");
assert_eq!(respond(&sites, b"GET / HTTP/1.1\r\nHost: example.com\r\n\r\n").text(), "home");
assert_eq!(respond(&sites, b"GET / HTTP/1.1\r\nHost: shop.example.com\r\n\r\n").text(), "shop");
assert_eq!(respond(&sites, b"GET / HTTP/1.1\r\nHost: other.example\r\n\r\n").status, 421);

Implementations

impl<G: Gate> Sites<G>

pub fn new() -> Self

An empty table.

pub fn site(self, app: App<G>) -> Self

Adds an application. The first one added answers what no other claims.

pub fn pick(&self, req: &HttpRequest<'_>) -> Option<&App<G>>

The application for a request, if the table has any.

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

As App::serve on the chosen application.

Trait Implementations

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

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

Formats the value using the given formatter.

impl<G: Gate> Default for Sites<G>

fn default() -> Self

Returns the “default value” for a type.

impl<G: Gate> HttpService for Sites<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.