patagia-control/controller/src/main.rs

use anyhow::{anyhow, Result};
use clap::Parser;
use dropshot::endpoint;
use dropshot::ApiDescription;
use dropshot::ConfigDropshot;
use dropshot::HttpError;
use dropshot::HttpResponseOk;
use dropshot::RequestContext;
use dropshot::ServerBuilder;
use schemars::JsonSchema;
use serde::Serialize;
use slog::Drain;
use tracing_slog::TracingSlogDrain;
use tracing_subscriber::prelude::*;

use std::net::SocketAddr;
use std::str::FromStr;
use std::sync::Arc;

#[derive(Parser, Debug)]
#[command(version, about, long_about = None)]
struct Cli {}

/// Represents a project in our API.
#[derive(Serialize, JsonSchema)]
struct VersionInfo {
    name: String,
}

/// Fetch version info.
#[endpoint {
    method = GET,
    path = "/version",
}]
async fn api_version(rqctx: RequestContext<Arc<()>>) -> Result<HttpResponseOk<VersionInfo>, HttpError> {
    let ver = VersionInfo {
        name: String::from("patagia-controller"),
    };
    Ok(HttpResponseOk(ver))
}

#[tokio::main]
async fn main() -> Result<()> {
    let _args = Cli::parse();
    let fmt_layer = tracing_subscriber::fmt::layer();

    let mut config_dropshot = ConfigDropshot::default();
    config_dropshot.bind_address = SocketAddr::from_str("0.0.0.0:9474").unwrap();
    config_dropshot.request_body_max_bytes = 1024 * 1024;

    // Adapt the Dropshot logger to tracing
    let dropshot_logger = {
        let level_drain = slog::LevelFilter(TracingSlogDrain, slog::Level::Debug).fuse();
        let async_drain = slog_async::Async::new(level_drain).build().fuse();
        slog::Logger::root(async_drain, slog::o!())
    };

    tracing_subscriber::registry()
        .with(tracing_subscriber::EnvFilter::from_default_env())
        .with(fmt_layer)
        .init();

    tracing::info!("Patagia Controller");

    let mut api = ApiDescription::new();
    api.register(api_version).unwrap();

    let server =ServerBuilder::new(api, Arc::new(()), dropshot_logger)
        .config(config_dropshot)
        .start()
        .map_err(|e| anyhow!("Error starting server: {:?}", e))?;

    server.await.map_err(|e| anyhow!("Error running server: {}", e))
}