rieter/server/src/main.rs

mod error;
mod repo;

pub use error::{Result, ServerError};

use axum::extract::FromRef;
use axum::Router;
use repo::RepoGroupManager;
use std::path::PathBuf;
use std::sync::{Arc, RwLock};
use tower_http::trace::TraceLayer;
use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};

#[derive(Clone)]
pub struct Config {
    data_dir: PathBuf,
    repo_dir: PathBuf,
    pkg_dir: PathBuf,
}

#[derive(Clone)]
pub struct Global {
    config: Config,
    repo_manager: Arc<RwLock<RepoGroupManager>>,
}

impl FromRef<Global> for Arc<RwLock<RepoGroupManager>> {
    fn from_ref(global: &Global) -> Self {
        Arc::clone(&global.repo_manager)
    }
}

#[tokio::main]
async fn main() {
    tracing_subscriber::registry()
        .with(tracing_subscriber::EnvFilter::new(
            std::env::var("RUST_LOG").unwrap_or_else(|_| "tower_http=debug,rieterd=debug".into()),
        ))
        .with(tracing_subscriber::fmt::layer())
        .init();

    let config = Config {
        data_dir: "./data".into(),
        repo_dir: "./data/repos".into(),
        pkg_dir: "./data/pkgs".into(),
    };
    let repo_manager = RepoGroupManager::new("./data/repos", "./data/pkgs", "x86_64");

    let global = Global {
        config,
        repo_manager: Arc::new(RwLock::new(repo_manager)),
    };

    // build our application with a single route
    let app = Router::new()
        .merge(repo::router(&global))
        .with_state(global)
        .layer(TraceLayer::new_for_http());

    // run it with hyper on localhost:3000
    axum::Server::bind(&"0.0.0.0:3000".parse().unwrap())
        .serve(app.into_make_service())
        .await
        .unwrap();
}