Struct Server 

pub struct Server { /* private fields */ }

Implementations

impl Server

pub fn bind(addr: SocketAddr) -> Self

Examples found in repository

examples/admin_demo.rs (line 44)

async fn main() -> std::io::Result<()> {
    let db = Db::memory().await.expect("db connect");
    auth::ensure_core_tables(&db)
        .await
        .expect("create auth tables");

    auth::user::create(&db, "admin@example.com", "admin", "admin")
        .await
        .expect("seed admin user");

    seed_demo_data(&db).await;

    let router = with_defaults(Router::new()).wrap(authenticate(db.clone()));
    // No `.model::<T>()` calls: the new engine uses its own
    // `AdminUiModel` registry (Users + Orders are wired in by
    // `Admin::register`). The legacy AdminModel + macro path is
    // intentionally not exercised here so there is exactly one
    // admin surface in the demo.
    let router = Admin::new().register(router, &db);

    let addr: SocketAddr = ([127, 0, 0, 1], 3000).into();
    eprintln!("admin demo: open http://{addr}/admin and sign in as admin@example.com / admin");
    Server::bind(addr).serve_router(router).await
}

examples/homepage.rs (line 86)

async fn main() -> std::io::Result<()> {
    let addr: SocketAddr = ([127, 0, 0, 1], 3000).into();
    let db = Db::memory().await.expect("db connect");
    auth::ensure_core_tables(&db)
        .await
        .expect("create auth tables");
    auth::user::create(&db, "admin@example.com", "admin", "admin")
        .await
        .expect("seed admin user");

    let router = with_defaults(Router::new())
        .get("/whoami", |req, _params| async move {
            let id = req
                .ctx()
                .get::<RequestId>()
                .map(|r| r.0.to_string())
                .unwrap_or_else(|| "unknown".into());
            Ok::<Response, Error>(text(format!("your request id is req-{id}\n")))
        })
        .get("/me", |req, _params| async move {
            let id = require_auth(req.ctx())?;
            Ok::<Response, Error>(text(format!("hello {}\n", id.email)))
        })
        .get("/admin-only", |req, _params| async move {
            let id = require_admin(req.ctx())?;
            Ok::<Response, Error>(text(format!("hello admin {}\n", id.email)))
        })
        .get("/crash", |_req, _params| async {
            Err::<Response, Error>(Error::Internal("simulated failure".into()))
        })
        .get("/unauth", |_req, _params| async {
            Err::<Response, Error>(Error::Unauthorized)
        })
        .wrap(request_id)
        .wrap(authenticate(db))
        .wrap(logger);
    Server::bind(addr).serve_router(router).await
}

pub async fn serve<F, Fut>(self, handler: F) -> Result<()>

where F: Fn(Request) -> Fut + Clone + Send + Sync + 'static, Fut: Future<Output = Response> + Send + 'static,

pub async fn serve_router(self, router: Router) -> Result<()>

Examples found in repository

examples/admin_demo.rs (line 44)

async fn main() -> std::io::Result<()> {
    let db = Db::memory().await.expect("db connect");
    auth::ensure_core_tables(&db)
        .await
        .expect("create auth tables");

    auth::user::create(&db, "admin@example.com", "admin", "admin")
        .await
        .expect("seed admin user");

    seed_demo_data(&db).await;

    let router = with_defaults(Router::new()).wrap(authenticate(db.clone()));
    // No `.model::<T>()` calls: the new engine uses its own
    // `AdminUiModel` registry (Users + Orders are wired in by
    // `Admin::register`). The legacy AdminModel + macro path is
    // intentionally not exercised here so there is exactly one
    // admin surface in the demo.
    let router = Admin::new().register(router, &db);

    let addr: SocketAddr = ([127, 0, 0, 1], 3000).into();
    eprintln!("admin demo: open http://{addr}/admin and sign in as admin@example.com / admin");
    Server::bind(addr).serve_router(router).await
}

examples/homepage.rs (line 86)

async fn main() -> std::io::Result<()> {
    let addr: SocketAddr = ([127, 0, 0, 1], 3000).into();
    let db = Db::memory().await.expect("db connect");
    auth::ensure_core_tables(&db)
        .await
        .expect("create auth tables");
    auth::user::create(&db, "admin@example.com", "admin", "admin")
        .await
        .expect("seed admin user");

    let router = with_defaults(Router::new())
        .get("/whoami", |req, _params| async move {
            let id = req
                .ctx()
                .get::<RequestId>()
                .map(|r| r.0.to_string())
                .unwrap_or_else(|| "unknown".into());
            Ok::<Response, Error>(text(format!("your request id is req-{id}\n")))
        })
        .get("/me", |req, _params| async move {
            let id = require_auth(req.ctx())?;
            Ok::<Response, Error>(text(format!("hello {}\n", id.email)))
        })
        .get("/admin-only", |req, _params| async move {
            let id = require_admin(req.ctx())?;
            Ok::<Response, Error>(text(format!("hello admin {}\n", id.email)))
        })
        .get("/crash", |_req, _params| async {
            Err::<Response, Error>(Error::Internal("simulated failure".into()))
        })
        .get("/unauth", |_req, _params| async {
            Err::<Response, Error>(Error::Unauthorized)
        })
        .wrap(request_id)
        .wrap(authenticate(db))
        .wrap(logger);
    Server::bind(addr).serve_router(router).await
}

pub async fn serve_router_on( listener: TcpListener, router: Router, ) -> Result<()>

Serve a router on an already-bound TcpListener.

Use when the caller needs to own the socket — for example to bind to port 0 and read back the kernel-assigned address before spawning the server (integration tests, pre-fork servers that drop privileges after binding).