rieter/server/src/repo/mod.rs

mod manager;
mod package;

pub use manager::RepoGroupManager;

use axum::extract::{BodyStream, Path, State};
use axum::http::StatusCode;
use axum::routing::{delete, get_service, post};
use axum::Router;
use futures::StreamExt;
use std::sync::Arc;
use tokio::{fs, io::AsyncWriteExt};
use tower_http::services::ServeDir;
use uuid::Uuid;

pub fn router(global: &crate::Global) -> Router<crate::Global> {
    // Try to serve packages by default, and try the database files instead if not found
    let serve_repos = get_service(
        ServeDir::new(&global.config.pkg_dir).fallback(ServeDir::new(&global.config.repo_dir)),
    );
    Router::new()
        .route(
            "/:repo",
            post(post_package_archive)
                .delete(delete_repo)
                .get(serve_repos.clone()),
        )
        .route("/:repo/:arch", delete(delete_arch_repo))
        .route("/:repo/:arch/:filename", delete(delete_package))
        .fallback(serve_repos)
        .with_state(global.clone())
}

async fn post_package_archive(
    State(global): State<crate::Global>,
    Path(repo): Path<String>,
    mut body: BodyStream,
) -> crate::Result<()> {
    // We first stream the uploaded file to disk
    let uuid: uuid::fmt::Simple = Uuid::new_v4().into();
    let path = global.config.pkg_dir.join(uuid.to_string());
    let mut f = fs::File::create(&path).await?;

    while let Some(chunk) = body.next().await {
        f.write_all(&chunk?).await?;
    }

    let clone = Arc::clone(&global.repo_manager);
    tokio::task::spawn_blocking(move || clone.write().unwrap().add_pkg_from_path(&repo, &path))
        .await??;

    Ok(())
}

async fn delete_repo(
    State(global): State<crate::Global>,
    Path(repo): Path<String>,
) -> crate::Result<StatusCode> {
    let clone = Arc::clone(&global.repo_manager);

    let repo_removed =
        tokio::task::spawn_blocking(move || clone.write().unwrap().remove_repo(&repo)).await??;

    if repo_removed {
        Ok(StatusCode::OK)
    } else {
        Ok(StatusCode::NOT_FOUND)
    }
}

async fn delete_arch_repo(
    State(global): State<crate::Global>,
    Path((repo, arch)): Path<(String, String)>,
) -> crate::Result<StatusCode> {
    let clone = Arc::clone(&global.repo_manager);

    let repo_removed =
        tokio::task::spawn_blocking(move || clone.write().unwrap().remove_arch_repo(&repo, &arch))
            .await??;

    if repo_removed {
        Ok(StatusCode::OK)
    } else {
        Ok(StatusCode::NOT_FOUND)
    }
}

async fn delete_package(
    State(global): State<crate::Global>,
    Path((repo, arch, file_name)): Path<(String, String, String)>,
) -> crate::Result<StatusCode> {
    let name_parts = file_name.split('-').collect::<Vec<_>>();

    // Package archive files use the naming scheme pkgname-pkgver-pkgrel-arch, so a valid
    // name contains at least 4 dash-separated sections
    if name_parts.len() < 4 {
        return Ok(StatusCode::NOT_FOUND);
    }

    let name = name_parts[..name_parts.len() - 3].join("-");

    let clone = Arc::clone(&global.repo_manager);

    let pkg_removed = tokio::task::spawn_blocking(move || {
        clone
            .write()
            .unwrap()
            .remove_pkg_from_arch_repo(&repo, &arch, &name, true)
    })
    .await??;

    if pkg_removed {
        Ok(StatusCode::OK)
    } else {
        Ok(StatusCode::NOT_FOUND)
    }
}