2023-07-12 18:05:10 +00:00
|
|
|
mod manager;
|
2023-07-12 21:51:07 +00:00
|
|
|
mod package;
|
2023-07-12 18:05:10 +00:00
|
|
|
|
2023-07-13 12:58:27 +00:00
|
|
|
pub use manager::RepoGroupManager;
|
|
|
|
|
|
2023-08-01 12:38:50 +00:00
|
|
|
use crate::db::entities::{package as db_package, repo as db_repo};
|
2023-08-02 20:41:23 +00:00
|
|
|
use axum::body::Body;
|
2023-07-12 09:04:31 +00:00
|
|
|
use axum::extract::{BodyStream, Path, State};
|
2023-08-02 19:15:12 +00:00
|
|
|
use axum::http::Request;
|
2023-07-12 09:04:31 +00:00
|
|
|
use axum::http::StatusCode;
|
2023-08-02 19:15:12 +00:00
|
|
|
use axum::response::IntoResponse;
|
|
|
|
|
use axum::routing::{delete, post};
|
2023-07-11 11:41:56 +00:00
|
|
|
use axum::Router;
|
2023-07-12 09:04:31 +00:00
|
|
|
use futures::StreamExt;
|
2023-08-01 12:38:50 +00:00
|
|
|
use sea_orm::{ActiveModelTrait, ColumnTrait, EntityTrait, QueryFilter};
|
2023-07-13 18:24:45 +00:00
|
|
|
use std::sync::Arc;
|
2023-07-16 17:59:47 +00:00
|
|
|
use tokio::{fs, io::AsyncWriteExt};
|
2023-08-02 19:15:12 +00:00
|
|
|
use tower::util::ServiceExt;
|
|
|
|
|
use tower_http::services::{ServeDir, ServeFile};
|
2023-08-03 07:34:33 +00:00
|
|
|
use tower_http::validate_request::ValidateRequestHeaderLayer;
|
2023-07-12 09:04:31 +00:00
|
|
|
use uuid::Uuid;
|
2023-07-11 11:41:56 +00:00
|
|
|
|
2023-08-03 09:08:38 +00:00
|
|
|
pub fn router(api_key: &str) -> Router<crate::Global> {
|
2023-07-11 11:41:56 +00:00
|
|
|
Router::new()
|
2023-08-03 07:34:33 +00:00
|
|
|
.route(
|
|
|
|
|
"/:repo",
|
|
|
|
|
post(post_package_archive)
|
|
|
|
|
.delete(delete_repo)
|
2023-08-03 09:08:38 +00:00
|
|
|
.route_layer(ValidateRequestHeaderLayer::bearer(api_key)),
|
2023-08-03 07:34:33 +00:00
|
|
|
)
|
|
|
|
|
.route(
|
|
|
|
|
"/:repo/:arch",
|
2023-08-03 09:08:38 +00:00
|
|
|
delete(delete_arch_repo).route_layer(ValidateRequestHeaderLayer::bearer(api_key)),
|
2023-08-03 07:34:33 +00:00
|
|
|
)
|
|
|
|
|
// Routes added after the layer do not get that layer applied, so the GET requests will not
|
|
|
|
|
// be authorized
|
2023-07-12 09:04:31 +00:00
|
|
|
.route(
|
2023-07-16 19:01:57 +00:00
|
|
|
"/:repo/:arch/:filename",
|
2023-08-03 07:34:33 +00:00
|
|
|
delete(delete_package)
|
2023-08-03 09:08:38 +00:00
|
|
|
.route_layer(ValidateRequestHeaderLayer::bearer(api_key))
|
2023-08-03 07:34:33 +00:00
|
|
|
.get(get_file),
|
2023-07-12 09:04:31 +00:00
|
|
|
)
|
2023-07-11 11:41:56 +00:00
|
|
|
}
|
2023-07-12 09:04:31 +00:00
|
|
|
|
|
|
|
|
async fn post_package_archive(
|
2023-07-13 12:58:27 +00:00
|
|
|
State(global): State<crate::Global>,
|
2023-07-12 09:04:31 +00:00
|
|
|
Path(repo): Path<String>,
|
2023-07-14 11:46:53 +00:00
|
|
|
mut body: BodyStream,
|
|
|
|
|
) -> crate::Result<()> {
|
2023-07-12 09:04:31 +00:00
|
|
|
// We first stream the uploaded file to disk
|
|
|
|
|
let uuid: uuid::fmt::Simple = Uuid::new_v4().into();
|
2023-07-13 12:58:27 +00:00
|
|
|
let path = global.config.pkg_dir.join(uuid.to_string());
|
2023-07-14 11:46:53 +00:00
|
|
|
let mut f = fs::File::create(&path).await?;
|
2023-07-12 09:04:31 +00:00
|
|
|
|
|
|
|
|
while let Some(chunk) = body.next().await {
|
2023-07-14 11:46:53 +00:00
|
|
|
f.write_all(&chunk?).await?;
|
2023-07-12 09:04:31 +00:00
|
|
|
}
|
|
|
|
|
|
2023-07-13 18:24:45 +00:00
|
|
|
let clone = Arc::clone(&global.repo_manager);
|
2023-08-02 19:15:12 +00:00
|
|
|
let path_clone = path.clone();
|
2023-08-01 13:30:38 +00:00
|
|
|
let repo_clone = repo.clone();
|
2023-08-02 19:15:12 +00:00
|
|
|
let res = tokio::task::spawn_blocking(move || {
|
2023-08-02 20:41:23 +00:00
|
|
|
clone
|
|
|
|
|
.write()
|
|
|
|
|
.unwrap()
|
|
|
|
|
.add_pkg_from_path(&repo_clone, &path_clone)
|
2023-08-02 19:15:12 +00:00
|
|
|
})
|
|
|
|
|
.await?;
|
2023-07-14 11:46:53 +00:00
|
|
|
|
2023-08-02 20:41:23 +00:00
|
|
|
match res {
|
|
|
|
|
// Insert the newly added package into the database
|
|
|
|
|
Ok(pkg) => {
|
2023-08-03 07:34:33 +00:00
|
|
|
tracing::info!("Added '{}' to repository '{}'", pkg.file_name(), repo);
|
|
|
|
|
|
2023-08-02 20:41:23 +00:00
|
|
|
// Query the repo for its ID, or create it if it does not already exist
|
|
|
|
|
let repo_entity = db_repo::Entity::find()
|
|
|
|
|
.filter(db_repo::Column::Name.eq(&repo))
|
|
|
|
|
.one(&global.db)
|
|
|
|
|
.await?;
|
|
|
|
|
|
|
|
|
|
let repo_id = if let Some(repo_entity) = repo_entity {
|
|
|
|
|
repo_entity.id
|
|
|
|
|
} else {
|
|
|
|
|
let model = db_repo::ActiveModel {
|
|
|
|
|
name: sea_orm::Set(repo.clone()),
|
|
|
|
|
..Default::default()
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
db_repo::Entity::insert(model)
|
|
|
|
|
.exec(&global.db)
|
|
|
|
|
.await?
|
|
|
|
|
.last_insert_id
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
// Insert the package's data into the database
|
|
|
|
|
let mut model: db_package::ActiveModel = pkg.into();
|
|
|
|
|
model.repo_id = sea_orm::Set(repo_id);
|
|
|
|
|
|
|
|
|
|
model.insert(&global.db).await?;
|
|
|
|
|
|
|
|
|
|
Ok(())
|
|
|
|
|
}
|
|
|
|
|
// Remove the uploaded file and return the error
|
|
|
|
|
Err(err) => {
|
|
|
|
|
tokio::fs::remove_file(path).await?;
|
|
|
|
|
|
|
|
|
|
Err(err.into())
|
|
|
|
|
}
|
2023-08-02 19:15:12 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// Serve the package archive files and database archives. If files are requested for an
|
|
|
|
|
/// architecture that does not have any explicit packages, a repository containing only "any" files
|
|
|
|
|
/// is returned.
|
|
|
|
|
async fn get_file(
|
|
|
|
|
State(global): State<crate::Global>,
|
|
|
|
|
Path((repo, arch, mut file_name)): Path<(String, String, String)>,
|
|
|
|
|
req: Request<Body>,
|
|
|
|
|
) -> crate::Result<impl IntoResponse> {
|
|
|
|
|
let repo_dir = global.config.repo_dir.join(&repo).join(&arch);
|
|
|
|
|
let repo_exists = tokio::fs::try_exists(&repo_dir).await?;
|
|
|
|
|
|
|
|
|
|
let res = if file_name.ends_with(".db") || file_name.ends_with(".db.tar.gz") {
|
|
|
|
|
// Append tar extension to ensure we find the file
|
|
|
|
|
if file_name.ends_with(".db") {
|
|
|
|
|
file_name.push_str(".tar.gz");
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
if repo_exists {
|
|
|
|
|
ServeFile::new(repo_dir.join(file_name)).oneshot(req).await
|
|
|
|
|
} else {
|
|
|
|
|
let path = global
|
|
|
|
|
.config
|
|
|
|
|
.repo_dir
|
|
|
|
|
.join(repo)
|
|
|
|
|
.join(manager::ANY_ARCH)
|
|
|
|
|
.join(file_name);
|
|
|
|
|
|
|
|
|
|
ServeFile::new(path).oneshot(req).await
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
let any_file = global
|
|
|
|
|
.config
|
|
|
|
|
.pkg_dir
|
|
|
|
|
.join(repo)
|
|
|
|
|
.join(manager::ANY_ARCH)
|
|
|
|
|
.join(file_name);
|
|
|
|
|
|
|
|
|
|
if repo_exists {
|
|
|
|
|
ServeDir::new(global.config.pkg_dir)
|
|
|
|
|
.fallback(ServeFile::new(any_file))
|
|
|
|
|
.oneshot(req)
|
|
|
|
|
.await
|
|
|
|
|
} else {
|
|
|
|
|
ServeFile::new(any_file).oneshot(req).await
|
|
|
|
|
}
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
Ok(res)
|
2023-07-12 09:04:31 +00:00
|
|
|
}
|
2023-07-16 17:59:47 +00:00
|
|
|
|
|
|
|
|
async fn delete_repo(
|
|
|
|
|
State(global): State<crate::Global>,
|
|
|
|
|
Path(repo): Path<String>,
|
|
|
|
|
) -> crate::Result<StatusCode> {
|
|
|
|
|
let clone = Arc::clone(&global.repo_manager);
|
|
|
|
|
|
2023-08-03 09:03:01 +00:00
|
|
|
let repo_clone = repo.clone();
|
2023-07-16 17:59:47 +00:00
|
|
|
let repo_removed =
|
2023-08-03 09:08:38 +00:00
|
|
|
tokio::task::spawn_blocking(move || clone.write().unwrap().remove_repo(&repo_clone))
|
|
|
|
|
.await??;
|
2023-07-16 17:59:47 +00:00
|
|
|
|
|
|
|
|
if repo_removed {
|
2023-08-03 09:08:38 +00:00
|
|
|
tracing::info!("Removed repository '{}'", repo);
|
2023-08-03 09:03:01 +00:00
|
|
|
|
2023-07-16 17:59:47 +00:00
|
|
|
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);
|
|
|
|
|
|
2023-08-03 09:08:38 +00:00
|
|
|
let log = format!("Removed architecture '{}' from repository '{}'", arch, repo);
|
2023-07-16 17:59:47 +00:00
|
|
|
let repo_removed =
|
2023-08-02 16:48:17 +00:00
|
|
|
tokio::task::spawn_blocking(move || clone.write().unwrap().remove_repo_arch(&repo, &arch))
|
2023-07-16 17:59:47 +00:00
|
|
|
.await??;
|
|
|
|
|
|
|
|
|
|
if repo_removed {
|
2023-08-03 09:03:01 +00:00
|
|
|
tracing::info!(log);
|
|
|
|
|
|
2023-07-16 17:59:47 +00:00
|
|
|
Ok(StatusCode::OK)
|
|
|
|
|
} else {
|
|
|
|
|
Ok(StatusCode::NOT_FOUND)
|
|
|
|
|
}
|
|
|
|
|
}
|
2023-07-16 18:22:58 +00:00
|
|
|
|
|
|
|
|
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("-");
|
2023-08-03 09:03:01 +00:00
|
|
|
let log = format!("Removed '{}' from repository '{}'", file_name, repo);
|
2023-07-16 18:22:58 +00:00
|
|
|
|
|
|
|
|
let clone = Arc::clone(&global.repo_manager);
|
|
|
|
|
|
|
|
|
|
let pkg_removed = tokio::task::spawn_blocking(move || {
|
2023-08-02 16:48:17 +00:00
|
|
|
clone.write().unwrap().remove_pkg(&repo, &arch, &name, true)
|
2023-07-16 18:22:58 +00:00
|
|
|
})
|
|
|
|
|
.await??;
|
|
|
|
|
|
|
|
|
|
if pkg_removed {
|
2023-08-03 09:03:01 +00:00
|
|
|
tracing::info!(log);
|
|
|
|
|
|
2023-07-16 18:22:58 +00:00
|
|
|
Ok(StatusCode::OK)
|
|
|
|
|
} else {
|
|
|
|
|
Ok(StatusCode::NOT_FOUND)
|
|
|
|
|
}
|
|
|
|
|
}
|
