uidc/src/server.rs

use crate::{config, UIDCError};

mod oidc;
mod session;

pub struct ServerState {
    config: config::Config,
    pool: microrm::DBPool<'static>,
    templates: handlebars::Handlebars<'static>,
}

#[derive(Clone)]
struct ServerStateWrapper {
    core: &'static ServerState,
}

async fn index(req: tide::Request<ServerStateWrapper>) -> tide::Result<tide::Response> {
    let shelper = session::SessionHelper::new(&req);

    let realm = shelper.get_realm()?;
    let sid = shelper.get_session(&req);
    let auth = sid.and_then(|sid| shelper.get_auth_for_session(realm, sid));

    let response = tide::Response::builder(200)
        .content_type(tide::http::mime::PLAIN)
        .body(format!(
            r#"
            realm: {realm:?}
            session: {sid:?}
            auth: {auth:?}
        "#
        ))
        .build();
    Ok(response)
}

pub async fn run_server(
    db: microrm::DB,
    config: config::Config,
    port: u16,
) -> Result<(), UIDCError> {
    let db_box = Box::new(db);
    let db: &'static mut microrm::DB = Box::leak(db_box);
    let pool = microrm::DBPool::new(db);

    let core_state = Box::leak(Box::new(ServerState {
        config,
        pool,
        templates: handlebars::Handlebars::new(),
    }));

    core_state.templates.set_dev_mode(true);

    core_state
        .templates
        .register_templates_directory(".tmpl", "tmpl/")
        .expect("Couldn't open templates directory?");

    let state = ServerStateWrapper { core: core_state };

    let mut app = tide::with_state(state);

    app.with(tide::log::LogMiddleware::new());

    app.at("/:realm/").get(index);

    app.at("/static")
        .serve_dir("static/")
        .expect("Can't serve static files");

    session::session_v1_server(app.at("/:realm/v1/session/"));
    oidc::oidc_server(app.at("/:realm/"));

    app.listen(("127.0.0.1", port))
        .await
        .map_err(|_| UIDCError::Abort("couldn't listen on port"))
}