971c37c
use std::path::PathBuf;
use export::storage::AppStorage;
use gitbaby::archive::types::{ArchiveFormat, CreateArchiveRequest};
use serde::{Deserialize, Serialize};
use time::OffsetDateTime;
use crate::service::GitService;
use crate::service::cache::sanitize_key;
use crate::service::gitcmd::{run_git, run_git_capped};
use crate::share::errors::{GitError, map_baby};
use crate::share::validate::validate_revision;
#[derive(Debug, Clone, Serialize, utoipa::ToSchema)]
pub struct ArchiveResultDto {
pub format: String,
pub size: i64,
pub cache_key: String,
pub download_url: Option<String>,
}
#[derive(Debug, Clone, Deserialize)]
pub struct ArchiveOptionsDto {
pub format: ArchiveFormat,
#[serde(default)]
pub path_filter: Option<String>,
}
fn fmt_ext(f: ArchiveFormat) -> &'static str {
match f {
ArchiveFormat::Tar => "tar",
ArchiveFormat::TarGz => "tar.gz",
ArchiveFormat::TarBz2 => "tar.bz2",
ArchiveFormat::Zip => "zip",
}
}
impl GitService {
pub async fn archive_create(
&self,
space_name: String,
repo_name: String,
revision: String,
opts: ArchiveOptionsDto,
) -> Result<ArchiveResultDto, GitError> {
validate_revision(&revision)?;
let ctx = self.context(space_name, repo_name).await?;
let baby = self.baby(&ctx);
let ext = fmt_ext(opts.format);
let prefix_filter = opts.path_filter.clone();
let req = CreateArchiveRequest {
commit: revision.clone(),
format: opts.format,
prefix: Some(format!("{}-", ctx.model.id.simple())),
paths: prefix_filter.into_iter().collect(),
};
baby.create_archive(req).await.map_err(map_baby)?;
let key = format!(
"git/{}/{}.{}",
ctx.model.id.simple(),
sanitize_key(&revision),
ext
);
let out_dir = ctx.repo_dir();
let storage: &AppStorage = &self.state.storage;
let timeout = self.state.config.git.git_command_timeout_secs;
let bytes = read_archive_bytes(&out_dir, &revision, ext, timeout).await?;
let bytes_len = bytes.len() as i64;
storage
.client()
.put(&key, &bytes)
.await
.map_err(|e| GitError::Internal(format!("archive put failed: {e}")))?;
let download_url = storage.client().presign_get(&key, 3600).ok();
Ok(ArchiveResultDto {
format: ext.to_string(),
size: bytes_len,
cache_key: key,
download_url,
})
}
pub async fn archive_download(
&self,
space_name: String,
repo_name: String,
revision: String,
opts: ArchiveOptionsDto,
) -> Result<ArchiveResultDto, GitError> {
validate_revision(&revision)?;
let ctx = self.context(space_name, repo_name).await?;
let ext = fmt_ext(opts.format);
let key = format!(
"git/{}/{}.{}",
ctx.model.id.simple(),
sanitize_key(&revision),
ext
);
let storage: &AppStorage = &self.state.storage;
let head = storage
.client()
.head(&key)
.await
.map_err(|e| GitError::Internal(format!("storage head: {e}")))?;
let Some((size, _)) = head else {
return Err(GitError::NotFound);
};
let download_url = storage.client().presign_get(&key, 3600).ok();
Ok(ArchiveResultDto {
format: ext.to_string(),
size: size as i64,
cache_key: key,
download_url,
})
}
pub async fn archive_create_bundle(
&self,
space_name: String,
repo_name: String,
) -> Result<ArchiveResultDto, GitError> {
let ctx = self.context(space_name, repo_name).await?;
let bundle_path = std::env::temp_dir().join(format!(
"gitdata-bundle-{}-{}",
std::process::id(),
OffsetDateTime::now_utc().unix_timestamp_nanos()
));
let timeout = self.state.config.git.git_command_timeout_secs;
run_git(
"archives::bundle",
&ctx.repo_dir(),
vec![
"bundle".to_string(),
"create".to_string(),
bundle_path.to_string_lossy().into_owned(),
"--all".to_string(),
],
&[],
timeout,
)
.await?;
let key = format!("git/{}/bundle.git", ctx.model.id.simple());
let storage: &AppStorage = &self.state.storage;
let bytes = tokio::task::spawn_blocking({
let p = bundle_path.clone();
move || std::fs::read(&p)
})
.await
.map_err(|e| GitError::Internal(format!("bundle read task: {e}")))?
.map_err(|e| GitError::Internal(format!("bundle read: {e}")))?;
let bytes_len = bytes.len() as i64;
storage
.client()
.put(&key, &bytes)
.await
.map_err(|e| GitError::Internal(format!("bundle put failed: {e}")))?;
let download_url = storage.client().presign_get(&key, 3600).ok();
let _ = std::fs::remove_file(&bundle_path);
Ok(ArchiveResultDto {
format: "bundle".to_string(),
size: bytes_len,
cache_key: key,
download_url,
})
}
}
async fn read_archive_bytes(
dir: &PathBuf,
rev: &str,
ext: &str,
timeout_secs: u64,
) -> Result<Vec<u8>, GitError> {
let cap = 512 * 1024 * 1024;
let out = run_git_capped(
"archives::read",
dir,
vec![
"archive".to_string(),
"--format".to_string(),
ext.to_string(),
rev.to_string(),
],
&[],
timeout_secs,
cap,
)
.await?;
Ok(out.stdout)
}