Add Chio Middleware to Your HTTP Framework

mod database;
mod host;
mod receipts;
use axum::{
    error_handling::HandleErrorLayer,
    extract::State,
    http::StatusCode,
    routing::{get, post},
    Json, Router,
};
use serde::{Deserialize, Serialize};
use serde_json::json;
use tower::ServiceBuilder;

#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct QuoteRequest {
    sku: String,
    percent: f64,
}
#[derive(Serialize)]
struct Quotes {
    quotes: Vec<database::Quote>,
}
struct ApiError(database::Error);
impl From<database::Error> for ApiError {
    fn from(error: database::Error) -> Self {
        Self(error)
    }
}
impl axum::response::IntoResponse for ApiError {
    fn into_response(self) -> axum::response::Response {
        let (status, code) = match self.0 {
            database::Error::Busy | database::Error::Stopped => {
                (StatusCode::SERVICE_UNAVAILABLE, "database_unavailable")
            }
            database::Error::Storage(error) => {
                eprintln!("Storage failed: {error}");
                (StatusCode::INTERNAL_SERVER_ERROR, "database_failed")
            }
        };
        (status, Json(json!({"error":code}))).into_response()
    }
}
async fn list_quotes(State(database): State<database::Database>) -> Result<Json<Quotes>, ApiError> {
    Ok(Json(Quotes {
        quotes: database.list().await?,
    }))
}
async fn quote(
    State(database): State<database::Database>,
    Json(request): Json<QuoteRequest>,
) -> axum::response::Response {
    use axum::response::IntoResponse;
    let Some(cents) = database::list_price(&request.sku) else {
        return (
            StatusCode::BAD_REQUEST,
            Json(json!({"error":format!("unknown sku {}", request.sku)})),
        )
            .into_response();
    };
    if !(0.0..=100.0).contains(&request.percent) {
        return (
            StatusCode::BAD_REQUEST,
            Json(json!({"error":"percent must be between 0 and 100"})),
        )
            .into_response();
    }
    let price = database::discounted(cents, request.percent);
    match database.insert(request.sku, request.percent, price).await {
        Ok(quote) => (StatusCode::CREATED, Json(quote)).into_response(),
        Err(error) => ApiError(error).into_response(),
    }
}
#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let host = host::open()?;
    chio_example_runtime::files::private_directory(std::path::Path::new(".pricing/http-receipts"))?;
    let database = database::Database::open(std::path::Path::new(".pricing/quotes.db"))?;
    let retention = receipts::Retention::new();
    let app = Router::new()
        .route("/v1/quotes", get(list_quotes))
        .route("/v1/quote", post(quote))
        .with_state(database.clone())
        .layer(axum::extract::DefaultBodyLimit::max(8192))
        .layer(
            ServiceBuilder::new()
                .layer(HandleErrorLayer::new(|error: axum::BoxError| async move {
                    eprintln!("Chio evaluation failed: {error}");
                    (
                        StatusCode::BAD_GATEWAY,
                        Json(json!({"error":"chio_evaluation_failed"})),
                    )
                }))
                .layer(host.layer.clone()),
        )
        .layer(axum::middleware::from_fn_with_state(
            retention.clone(),
            receipts::retain,
        ));
    let address = std::env::var("CHIO_PRICING_LISTEN")
        .unwrap_or_else(|_| "127.0.0.1:8096".into())
        .parse::<std::net::SocketAddr>()?;
    anyhow::ensure!(
        address.ip().is_loopback(),
        "the example requires a loopback listener"
    );
    let listener = tokio::net::TcpListener::bind(address).await?;
    println!(
        "Rust pricing: http://{}; five-minute grant: .pricing/capability.json",
        listener.local_addr()?
    );
    let signal = chio_example_runtime::shutdown_signal()?;
    let draining = retention.clone();
    let served = axum::serve(listener, app)
        .with_graceful_shutdown(async move {
            signal.await;
            draining.close();
        })
        .await;
    let retained = retention.shutdown().await;
    let stopped = database.shutdown().await;
    drop(host);
    served?;
    retained?;
    stopped?;
    Ok(())
}

use chio_core::capability::{
    scope::ChioScope,
    token::{CapabilityToken, CapabilityTokenBody},
};
use chio_http_core::http_authority_tool_grant;
use chio_store_sqlite::{SqliteAuthorityStore, SqliteReceiptStore, SqliteRevocationStore};
use chio_tower::{ChioEvaluator, ChioLayer};
use std::{path::Path, sync::Arc};

pub struct Host {
    pub layer: ChioLayer,
    _authority: SqliteAuthorityStore,
}

pub fn open() -> anyhow::Result<Host> {
    let directory = Path::new(".pricing");
    chio_control_plane::ensure_private_directory(directory)?;
    let key =
        chio_control_plane::load_or_create_authority_keypair(&directory.join("authority.hex"))?;
    let locks = directory.join("authority-locks");
    chio_control_plane::ensure_private_directory(&locks)?;
    let path = directory.join("admission.db");
    SqliteAuthorityStore::provision(&path, &locks)?;
    let authority = SqliteAuthorityStore::open_serving(&path, &locks)?;
    let receipts = Arc::new(SqliteReceiptStore::open(directory.join("receipts.db"))?);
    let revocations = Arc::new(SqliteRevocationStore::open(
        directory.join("revocations.db"),
    )?);
    // Fingerprint this host configuration, not an unparsed policy document.
    let policy_hash = chio_core::sha256_hex(include_bytes!("host.rs"));
    let evaluator = ChioEvaluator::builder(key.clone(), policy_hash)
        .receipt_store(receipts)
        .revocation_store(revocations)
        .durable_admission_stores(
            Arc::new(authority.admission_operation_store()),
            Arc::new(authority.tool_outcome_store()),
            authority.mutation_fence(),
        )
        .build()?;
    // Starting this local application explicitly issues a five-minute HTTP grant.
    let now = chrono::Utc::now().timestamp() as u64;
    let capability = CapabilityToken::sign(
        CapabilityTokenBody {
            id: uuid::Uuid::now_v7().to_string(),
            issuer: key.public_key(),
            subject: key.public_key(),
            scope: ChioScope {
                grants: vec![http_authority_tool_grant()],
                ..ChioScope::default()
            },
            issued_at: now,
            expires_at: now + 300,
            delegation_chain: Vec::new(),
            aggregate_invocation_budget: None,
        },
        &key,
    )?;
    std::fs::write(
        directory.join("capability.json"),
        serde_json::to_vec_pretty(&capability)?,
    )?;
    std::fs::write(
        directory.join("kernel-public-key.txt"),
        key.public_key().to_hex(),
    )?;
    Ok(Host {
        layer: ChioLayer::from_evaluator(evaluator).with_max_body_bytes(8192),
        _authority: authority,
    })
}