feat(backup): support cross-platform background database backups
This commit is contained in:
1 parent
250e0c0a10
commit
2f960f104c
56 files changed
+4195
-962
No files matched your search
@@ -312,8 +312,12 @@ fn add_mq_routes(router: Router<Arc<WebState>>) -> Router<Arc<WebState>> {
|
||||
router
|
||||
}
|
||||
|
||||
#[tokio::main]
|
||||
async fn main() {
|
||||
fn main() {
|
||||
let runtime = dbx_core::scheduled_backup::worker_runtime().expect("Failed to build tokio runtime");
|
||||
runtime.block_on(serve());
|
||||
}
|
||||
|
||||
async fn serve() {
|
||||
tracing_subscriber::fmt()
|
||||
.with_env_filter(
|
||||
tracing_subscriber::EnvFilter::try_from_default_env()
|
||||
@@ -394,6 +398,7 @@ async fn main() {
|
||||
transfer_progress_channels: RwLock::new(HashMap::new()),
|
||||
table_import_channels: RwLock::new(HashMap::new()),
|
||||
sql_file_executions: RwLock::new(HashMap::new()),
|
||||
managed_sql_previews: Default::default(),
|
||||
nacos_imports: RwLock::new(HashMap::new()),
|
||||
login_rate_limit: tokio::sync::Mutex::new(state::LoginRateLimit { fail_count: 0, locked_until: None }),
|
||||
export_files: RwLock::new(HashMap::new()),
|
||||
@@ -402,6 +407,15 @@ async fn main() {
|
||||
});
|
||||
|
||||
ssh_prompt::install_web_ssh_prompt_bridge(web_state.ssh_prompts.clone());
|
||||
routes::sql_file::start_sql_file_cleanup(&web_state);
|
||||
|
||||
let backup_root = std::env::var_os("DBX_BACKUP_ROOT")
|
||||
.map(std::path::PathBuf::from)
|
||||
.unwrap_or_else(|| web_state.data_dir.join("backups"));
|
||||
std::fs::create_dir_all(&backup_root).expect("Failed to create server backup root");
|
||||
let backup_service = routes::scheduled_backup::service(&web_state).expect("Failed to resolve server backup root");
|
||||
let backup_stop = tokio_util::sync::CancellationToken::new();
|
||||
let backup_worker = backup_service.start(backup_stop.clone());
|
||||
|
||||
// API routes
|
||||
let api = Router::new()
|
||||
@@ -409,6 +423,9 @@ async fn main() {
|
||||
.route("/migration/start", post(routes::migration::start))
|
||||
.route("/migration/retry", post(routes::migration::retry))
|
||||
.route("/migration/cleanup-backups", post(routes::migration::cleanup_backups))
|
||||
.route("/database-backups", post(routes::scheduled_backup::command))
|
||||
.route("/database-backups/{id}/files/{index}", get(routes::scheduled_backup::download))
|
||||
.route("/database-backups/{id}/files/{index}/restore", post(routes::scheduled_backup::prepare_restore))
|
||||
// Auth
|
||||
.route("/auth/login", post(auth::login))
|
||||
.route("/auth/check", get(auth::check))
|
||||
@@ -1137,6 +1154,7 @@ async fn main() {
|
||||
.layer(DefaultBodyLimit::max(routes::sql_file::sql_file_upload_hard_cap_bytes())),
|
||||
)
|
||||
.route("/sql-file/execute", post(routes::sql_file::execute_sql_file))
|
||||
.route("/sql-file/preview/release", post(routes::sql_file::release_sql_file_preview))
|
||||
.route("/sql-file/tables", post(routes::sql_file::inspect_sql_file_tables))
|
||||
.route("/sql-file/progress/{executionId}", get(routes::sql_file::sql_file_progress))
|
||||
.route("/sql-file/cancel", post(routes::sql_file::cancel_sql_file))
|
||||
@@ -1263,13 +1281,20 @@ async fn main() {
|
||||
let listener = tokio::net::TcpListener::bind(addr).await.expect("Failed to bind address");
|
||||
let shutdown_state = web_state.app.clone();
|
||||
axum::serve(listener, app)
|
||||
.with_graceful_shutdown(async {
|
||||
if let Err(error) = tokio::signal::ctrl_c().await {
|
||||
tracing::warn!("Failed to listen for shutdown signal: {error}");
|
||||
.with_graceful_shutdown(async move {
|
||||
#[cfg(unix)]
|
||||
{
|
||||
let mut terminate = tokio::signal::unix::signal(tokio::signal::unix::SignalKind::terminate())
|
||||
.expect("Failed to listen for SIGTERM");
|
||||
tokio::select! { _ = tokio::signal::ctrl_c() => {}, _ = terminate.recv() => {} }
|
||||
}
|
||||
#[cfg(not(unix))]
|
||||
let _ = tokio::signal::ctrl_c().await;
|
||||
backup_stop.cancel();
|
||||
})
|
||||
.await
|
||||
.expect("Server error");
|
||||
let _ = tokio::time::timeout(std::time::Duration::from_secs(60), backup_worker).await;
|
||||
shutdown_state.shutdown(std::time::Duration::from_secs(3)).await;
|
||||
}
|
||||
|
||||
|
||||
@@ -30,6 +30,7 @@ pub mod query_result_export;
|
||||
pub mod redis;
|
||||
pub mod redis_pubsub_ws;
|
||||
pub mod saved_sql;
|
||||
pub mod scheduled_backup;
|
||||
pub mod schema;
|
||||
pub mod schema_cache;
|
||||
pub mod schema_diff;
|
||||
|
||||
@@ -1567,6 +1567,7 @@ mod tests {
|
||||
transfer_progress_channels: RwLock::new(HashMap::new()),
|
||||
table_import_channels: RwLock::new(HashMap::new()),
|
||||
sql_file_executions: RwLock::new(HashMap::new()),
|
||||
managed_sql_previews: Default::default(),
|
||||
nacos_imports: RwLock::new(HashMap::new()),
|
||||
login_rate_limit: Mutex::new(LoginRateLimit { fail_count: 0, locked_until: None }),
|
||||
export_files: RwLock::new(HashMap::new()),
|
||||
|
||||
@@ -0,0 +1,48 @@
|
||||
use crate::{error::AppError, state::WebState};
|
||||
use axum::{
|
||||
body::Body,
|
||||
extract::{Path, State},
|
||||
http::header,
|
||||
response::Response,
|
||||
Json,
|
||||
};
|
||||
use dbx_core::scheduled_backup::{BackupCommand, BackupService};
|
||||
use std::{path::PathBuf, sync::Arc};
|
||||
use tokio_util::io::ReaderStream;
|
||||
|
||||
pub fn service(state: &WebState) -> Result<BackupService, String> {
|
||||
let root = std::env::var_os("DBX_BACKUP_ROOT").map(PathBuf::from).unwrap_or_else(|| state.data_dir.join("backups"));
|
||||
let root = root.canonicalize().map_err(|e| format!("Cannot resolve the server backup root: {e}"))?;
|
||||
Ok(BackupService::new(state.app.clone(), &state.data_dir, Some(root)))
|
||||
}
|
||||
|
||||
pub async fn command(
|
||||
State(state): State<Arc<WebState>>,
|
||||
Json(command): Json<BackupCommand>,
|
||||
) -> Result<Json<serde_json::Value>, AppError> {
|
||||
Ok(Json(service(&state)?.command(command).await?))
|
||||
}
|
||||
|
||||
pub async fn download(
|
||||
State(state): State<Arc<WebState>>,
|
||||
Path((id, index)): Path<(String, usize)>,
|
||||
) -> Result<Response, AppError> {
|
||||
let path = service(&state)?.file(&id, index).await?;
|
||||
let name = path.file_name().unwrap_or_default().to_string_lossy();
|
||||
let disposition = super::export_download::attachment_content_disposition(&name);
|
||||
let file = tokio::fs::File::open(&path).await.map_err(|e| AppError::from(e.to_string()))?;
|
||||
Response::builder()
|
||||
.header(header::CONTENT_TYPE, "application/octet-stream")
|
||||
.header(header::CONTENT_DISPOSITION, disposition)
|
||||
.header(header::CACHE_CONTROL, "no-store")
|
||||
.body(Body::from_stream(ReaderStream::new(file)))
|
||||
.map_err(|e| AppError::from(e.to_string()))
|
||||
}
|
||||
|
||||
pub async fn prepare_restore(
|
||||
State(state): State<Arc<WebState>>,
|
||||
Path((id, index)): Path<(String, usize)>,
|
||||
) -> Result<Json<serde_json::Value>, AppError> {
|
||||
let source = service(&state)?.file(&id, index).await?;
|
||||
Ok(Json(super::sql_file::prepare_backup_preview(&state, source).await?))
|
||||
}
|
||||
@@ -1,6 +1,7 @@
|
||||
use std::collections::{HashMap, HashSet};
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::sync::Arc;
|
||||
use std::time::Duration;
|
||||
use std::sync::{Arc, Mutex, Weak};
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
use axum::extract::{Multipart, Path as AxumPath, State};
|
||||
use axum::response::sse::{Event, Sse};
|
||||
@@ -25,6 +26,119 @@ pub const SQL_FILE_UPLOAD_MAX_BYTES: usize = 200 * 1024 * 1024;
|
||||
const SQL_FILE_UPLOAD_MIN_BYTES: usize = 1024 * 1024;
|
||||
const SQL_FILE_UPLOAD_MAX_BYTES_LIMIT: usize = 4096 * 1024 * 1024;
|
||||
|
||||
struct ManagedPreview {
|
||||
created: Instant,
|
||||
directory: Weak<tempfile::TempDir>,
|
||||
pending: Option<Arc<tempfile::TempDir>>,
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
pub struct ManagedSqlPreviews(Mutex<HashMap<String, ManagedPreview>>);
|
||||
|
||||
impl ManagedSqlPreviews {
|
||||
fn insert(&self, directory: tempfile::TempDir) -> String {
|
||||
let directory = Arc::new(directory);
|
||||
let token = directory.path().file_name().unwrap().to_string_lossy().into_owned();
|
||||
self.0.lock().unwrap().insert(
|
||||
token.clone(),
|
||||
ManagedPreview { created: Instant::now(), directory: Arc::downgrade(&directory), pending: Some(directory) },
|
||||
);
|
||||
token
|
||||
}
|
||||
|
||||
fn release(&self, token: &str) {
|
||||
let mut entries = self.0.lock().unwrap();
|
||||
if entries.get(token).is_some_and(|entry| entry.pending.is_some()) {
|
||||
entries.remove(token);
|
||||
}
|
||||
}
|
||||
|
||||
fn claim(&self, paths: &[PathBuf]) -> Result<Vec<Arc<tempfile::TempDir>>, AppError> {
|
||||
let mut entries = self.0.lock().unwrap();
|
||||
let mut tokens = HashSet::new();
|
||||
for path in paths {
|
||||
let Some(parent) = path.parent() else { continue };
|
||||
let Some(token) = parent.file_name().and_then(|name| name.to_str()) else { continue };
|
||||
if !token.starts_with("restore-") {
|
||||
continue;
|
||||
}
|
||||
let valid = entries
|
||||
.get(token)
|
||||
.and_then(|entry| entry.pending.as_ref())
|
||||
.is_some_and(|directory| directory.path().canonicalize().is_ok_and(|directory| directory == parent));
|
||||
if !valid {
|
||||
return Err(AppError::from("Backup preview expired or already consumed".to_string()));
|
||||
}
|
||||
tokens.insert(token.to_owned());
|
||||
}
|
||||
Ok(tokens.into_iter().map(|token| entries.get_mut(&token).unwrap().pending.take().unwrap()).collect())
|
||||
}
|
||||
|
||||
fn cleanup(&self, tmp_dir: &Path, max_age: Duration, managed_only: bool) {
|
||||
let mut entries = self.0.lock().unwrap();
|
||||
for entry in entries.values_mut() {
|
||||
if entry.created.elapsed() >= max_age {
|
||||
entry.pending = None;
|
||||
}
|
||||
}
|
||||
entries.retain(|_, entry| entry.directory.strong_count() > 0);
|
||||
cleanup_sql_file_uploads_except(tmp_dir, max_age, &entries.keys().cloned().collect(), managed_only);
|
||||
}
|
||||
}
|
||||
|
||||
pub fn start_sql_file_cleanup(state: &Arc<WebState>) {
|
||||
let state = Arc::downgrade(state);
|
||||
tokio::spawn(async move {
|
||||
loop {
|
||||
let Some(state) = state.upgrade() else { break };
|
||||
state.managed_sql_previews.cleanup(&state.data_dir.join("tmp/sql_file"), SQL_FILE_UPLOAD_MAX_AGE, true);
|
||||
drop(state);
|
||||
tokio::time::sleep(Duration::from_secs(60)).await;
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
#[derive(Deserialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct ReleaseSqlFilePreviewRequest {
|
||||
pub cleanup_token: String,
|
||||
}
|
||||
|
||||
pub async fn release_sql_file_preview(
|
||||
State(state): State<Arc<WebState>>,
|
||||
Json(body): Json<ReleaseSqlFilePreviewRequest>,
|
||||
) -> Json<()> {
|
||||
state.managed_sql_previews.release(&body.cleanup_token);
|
||||
Json(())
|
||||
}
|
||||
|
||||
pub(super) async fn prepare_backup_preview(state: &WebState, source: PathBuf) -> Result<serde_json::Value, AppError> {
|
||||
let tmp_dir = state.data_dir.join("tmp/sql_file");
|
||||
std::fs::create_dir_all(&tmp_dir).map_err(|error| AppError::from(error.to_string()))?;
|
||||
state.managed_sql_previews.cleanup(&tmp_dir, SQL_FILE_UPLOAD_MAX_AGE, true);
|
||||
let limit = sql_file_upload_limit(state).await as u64;
|
||||
let (directory, file_path, size) = tokio::task::spawn_blocking(move || {
|
||||
let directory = tempfile::Builder::new().prefix(&format!("restore-{}-", Uuid::new_v4())).tempdir_in(tmp_dir)?;
|
||||
let file_path =
|
||||
directory.path().join(source.file_name().ok_or_else(|| std::io::Error::other("Invalid backup name"))?);
|
||||
if std::fs::metadata(&source)?.len() > limit {
|
||||
return Err(std::io::Error::other("Backup exceeds the SQL file upload limit"));
|
||||
}
|
||||
let size = std::fs::copy(source, &file_path)?;
|
||||
if size > limit {
|
||||
return Err(std::io::Error::other("Backup exceeds the SQL file upload limit"));
|
||||
}
|
||||
Ok((directory, file_path, size))
|
||||
})
|
||||
.await
|
||||
.map_err(|error| AppError::from(error.to_string()))?
|
||||
.map_err(|error: std::io::Error| AppError::from(error.to_string()))?;
|
||||
let file_name = file_path.file_name().unwrap().to_string_lossy();
|
||||
let mut preview = preview_uploaded_sql_file(&file_path, &file_name, size).await?;
|
||||
preview["cleanupToken"] = state.managed_sql_previews.insert(directory).into();
|
||||
Ok(preview)
|
||||
}
|
||||
|
||||
pub fn sql_file_upload_max_bytes_from_value(value: Option<&str>) -> usize {
|
||||
let mb = value
|
||||
.and_then(|value| value.trim().parse::<usize>().ok())
|
||||
@@ -82,7 +196,7 @@ pub async fn preview_sql_file(
|
||||
) -> Result<Json<serde_json::Value>, AppError> {
|
||||
let tmp_dir = state.data_dir.join("tmp").join("sql_file");
|
||||
std::fs::create_dir_all(&tmp_dir).map_err(|e| AppError::from(e.to_string()))?;
|
||||
cleanup_expired_sql_file_uploads(&tmp_dir);
|
||||
state.managed_sql_previews.cleanup(&tmp_dir, SQL_FILE_UPLOAD_MAX_AGE, false);
|
||||
|
||||
if let Some(field) = multipart.next_field().await.map_err(|e| AppError::from(e.to_string()))? {
|
||||
let file_name = field.file_name().unwrap_or("upload.sql").to_string();
|
||||
@@ -95,48 +209,56 @@ pub async fn preview_sql_file(
|
||||
let file_path = safe_uploaded_sql_path(&tmp_dir, &file_name)?;
|
||||
std::fs::write(&file_path, &data).map_err(|e| AppError::from(e.to_string()))?;
|
||||
|
||||
if file_name.to_ascii_lowercase().ends_with(".zip") {
|
||||
let extraction_dir = tmp_dir.join(format!("package-{}", Uuid::new_v4()));
|
||||
let package = dbx_core::sql_file_zip_package::extract_sql_file_zip_package(&file_path, &extraction_dir)
|
||||
.map_err(AppError::from)?;
|
||||
let paths = dbx_core::sql_file_zip_package::extracted_sql_zip_paths(&extraction_dir, &package)
|
||||
.into_iter()
|
||||
.map(|path| path.to_string_lossy().to_string())
|
||||
.collect::<Vec<_>>();
|
||||
let content =
|
||||
sql::decode_sql_file_bytes(&std::fs::read(&paths[0]).map_err(|e| AppError::from(e.to_string()))?)
|
||||
.map_err(AppError::from)?;
|
||||
let preview: String = content.chars().take(20_000).collect();
|
||||
let bootstrap_analysis = dbx_core::sql_file_import::mysql_like_sql_file_bootstrap_analysis(&content);
|
||||
return Ok(Json(serde_json::json!({
|
||||
"fileName": file_name,
|
||||
"filePath": file_path.to_string_lossy(),
|
||||
"sizeBytes": data.len(),
|
||||
"preview": preview,
|
||||
"canExecuteWithoutSelectedDatabase": bootstrap_analysis.can_execute_without_selected_database,
|
||||
"establishesDatabaseContext": bootstrap_analysis.establishes_database_context,
|
||||
"packageFilePaths": paths,
|
||||
"packagePartCount": package.part_names.len(),
|
||||
})));
|
||||
}
|
||||
return preview_uploaded_sql_file(&file_path, &file_name, data.len() as u64).await.map(Json);
|
||||
}
|
||||
|
||||
let size_bytes = data.len() as u64;
|
||||
let content =
|
||||
dbx_core::sql_file_import::read_sql_file_preview(&file_path, 1_000_000).await.map_err(AppError::from)?;
|
||||
Err(AppError::from("No file uploaded".to_string()))
|
||||
}
|
||||
|
||||
async fn preview_uploaded_sql_file(
|
||||
file_path: &Path,
|
||||
file_name: &str,
|
||||
size_bytes: u64,
|
||||
) -> Result<serde_json::Value, AppError> {
|
||||
let tmp_dir = file_path.parent().ok_or_else(|| AppError::from("Invalid SQL file path".to_string()))?;
|
||||
|
||||
if file_name.to_ascii_lowercase().ends_with(".zip") {
|
||||
let extraction_dir = tmp_dir.join(format!("package-{}", Uuid::new_v4()));
|
||||
let package = dbx_core::sql_file_zip_package::extract_sql_file_zip_package(file_path, &extraction_dir)
|
||||
.map_err(AppError::from)?;
|
||||
let paths = dbx_core::sql_file_zip_package::extracted_sql_zip_paths(&extraction_dir, &package)
|
||||
.into_iter()
|
||||
.map(|path| path.to_string_lossy().to_string())
|
||||
.collect::<Vec<_>>();
|
||||
let content = sql::decode_sql_file_bytes(&std::fs::read(&paths[0]).map_err(|e| AppError::from(e.to_string()))?)
|
||||
.map_err(AppError::from)?;
|
||||
let preview: String = content.chars().take(20_000).collect();
|
||||
let bootstrap_analysis = dbx_core::sql_file_import::mysql_like_sql_file_bootstrap_analysis(&content);
|
||||
|
||||
return Ok(Json(serde_json::json!({
|
||||
return Ok(serde_json::json!({
|
||||
"fileName": file_name,
|
||||
"filePath": file_path.to_string_lossy(),
|
||||
"sizeBytes": size_bytes,
|
||||
"preview": preview,
|
||||
"canExecuteWithoutSelectedDatabase": bootstrap_analysis.can_execute_without_selected_database,
|
||||
"establishesDatabaseContext": bootstrap_analysis.establishes_database_context,
|
||||
})));
|
||||
"packageFilePaths": paths,
|
||||
"packagePartCount": package.part_names.len(),
|
||||
}));
|
||||
}
|
||||
|
||||
Err(AppError::from("No file uploaded".to_string()))
|
||||
let content =
|
||||
dbx_core::sql_file_import::read_sql_file_preview(file_path, 1_000_000).await.map_err(AppError::from)?;
|
||||
let preview: String = content.chars().take(20_000).collect();
|
||||
let bootstrap_analysis = dbx_core::sql_file_import::mysql_like_sql_file_bootstrap_analysis(&content);
|
||||
|
||||
Ok(serde_json::json!({
|
||||
"fileName": file_name,
|
||||
"filePath": file_path.to_string_lossy(),
|
||||
"sizeBytes": size_bytes,
|
||||
"preview": preview,
|
||||
"canExecuteWithoutSelectedDatabase": bootstrap_analysis.can_execute_without_selected_database,
|
||||
"establishesDatabaseContext": bootstrap_analysis.establishes_database_context,
|
||||
}))
|
||||
}
|
||||
|
||||
pub async fn execute_sql_file(
|
||||
@@ -145,6 +267,13 @@ pub async fn execute_sql_file(
|
||||
) -> Result<Json<serde_json::Value>, AppError> {
|
||||
let req = body.request;
|
||||
|
||||
let requested_paths = if body.file_paths.is_empty() { vec![req.file_path.clone()] } else { body.file_paths };
|
||||
let file_paths = requested_paths
|
||||
.iter()
|
||||
.map(|file_path| validated_uploaded_sql_path(&state.data_dir, file_path))
|
||||
.collect::<Result<Vec<_>, _>>()?;
|
||||
let managed_previews = state.managed_sql_previews.claim(&file_paths)?;
|
||||
|
||||
// Fast-fail: reject early if the connection is read-only (individual statements are also checked in do_execute)
|
||||
if let Some(name) = dbx_core::query::connection_readonly_name(&state.app, &req.connection_id).await {
|
||||
return Err(AppError::from(format!(
|
||||
@@ -154,14 +283,9 @@ pub async fn execute_sql_file(
|
||||
}
|
||||
|
||||
let execution_id = req.execution_id.clone();
|
||||
let requested_paths = if body.file_paths.is_empty() { vec![req.file_path.clone()] } else { body.file_paths };
|
||||
if requested_paths.is_empty() {
|
||||
return Err(AppError::from("No SQL files selected".to_string()));
|
||||
}
|
||||
let file_paths = requested_paths
|
||||
.iter()
|
||||
.map(|file_path| validated_uploaded_sql_path(&state.data_dir, file_path))
|
||||
.collect::<Result<Vec<_>, _>>()?;
|
||||
let token = CancellationToken::new();
|
||||
|
||||
{
|
||||
@@ -180,6 +304,7 @@ pub async fn execute_sql_file(
|
||||
let state_clone = state.clone();
|
||||
|
||||
tokio::spawn(async move {
|
||||
let _managed_previews = managed_previews;
|
||||
let started_at = std::time::Instant::now();
|
||||
let mut progress_emitter = SqlFileProgressEmitter::new(|progress| {
|
||||
send_sql_file_progress(&tx, progress);
|
||||
@@ -276,15 +401,22 @@ fn safe_uploaded_sql_path(tmp_dir: &Path, file_name: &str) -> Result<PathBuf, Ap
|
||||
Ok(tmp_dir.join(unique_name))
|
||||
}
|
||||
|
||||
fn cleanup_expired_sql_file_uploads(tmp_dir: &Path) {
|
||||
cleanup_sql_file_uploads_older_than(tmp_dir, SQL_FILE_UPLOAD_MAX_AGE);
|
||||
#[cfg(test)]
|
||||
fn cleanup_sql_file_uploads_older_than(tmp_dir: &Path, max_age: Duration) {
|
||||
cleanup_sql_file_uploads_except(tmp_dir, max_age, &HashSet::new(), false);
|
||||
}
|
||||
|
||||
fn cleanup_sql_file_uploads_older_than(tmp_dir: &Path, max_age: Duration) {
|
||||
fn cleanup_sql_file_uploads_except(tmp_dir: &Path, max_age: Duration, active: &HashSet<String>, managed_only: bool) {
|
||||
let Ok(entries) = std::fs::read_dir(tmp_dir) else {
|
||||
return;
|
||||
};
|
||||
for entry in entries.flatten() {
|
||||
if managed_only && !entry.file_name().to_string_lossy().starts_with("restore-") {
|
||||
continue;
|
||||
}
|
||||
if active.contains(&entry.file_name().to_string_lossy().into_owned()) {
|
||||
continue;
|
||||
}
|
||||
let path = entry.path();
|
||||
let Ok(metadata) = entry.metadata() else {
|
||||
continue;
|
||||
@@ -364,10 +496,142 @@ pub async fn cancel_sql_file(
|
||||
mod tests {
|
||||
use std::time::Duration;
|
||||
|
||||
use super::{
|
||||
cleanup_sql_file_uploads_older_than, safe_uploaded_sql_path, sql_file_upload_max_bytes_from_value,
|
||||
validated_uploaded_sql_path, SQL_FILE_UPLOAD_MAX_BYTES,
|
||||
};
|
||||
use super::*;
|
||||
|
||||
async fn restore_state(directory: &Path) -> WebState {
|
||||
let storage = dbx_core::storage::Storage::open(&directory.join("dbx.db")).await.unwrap();
|
||||
WebState::for_tests(Arc::new(dbx_core::connection::AppState::new(storage)), directory.to_path_buf())
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn restored_preview_uses_a_managed_copy_and_release_cannot_remove_the_backup() {
|
||||
let directory = tempfile::tempdir().unwrap();
|
||||
let state = restore_state(directory.path()).await;
|
||||
let source = directory.path().join("backup.sql");
|
||||
std::fs::write(&source, "SELECT 1;").unwrap();
|
||||
let preview = prepare_backup_preview(&state, source.clone()).await.unwrap();
|
||||
assert_eq!(preview["fileName"], "backup.sql");
|
||||
assert_eq!(preview["preview"], "SELECT 1;");
|
||||
let copy = PathBuf::from(preview["filePath"].as_str().unwrap());
|
||||
assert!(copy.starts_with(directory.path().join("tmp/sql_file")));
|
||||
assert_ne!(copy, source);
|
||||
assert!(validated_uploaded_sql_path(directory.path(), copy.to_str().unwrap()).is_ok());
|
||||
state.managed_sql_previews.release(source.to_str().unwrap());
|
||||
assert!(source.exists());
|
||||
assert!(copy.exists());
|
||||
state.managed_sql_previews.release(preview["cleanupToken"].as_str().unwrap());
|
||||
state.managed_sql_previews.release(preview["cleanupToken"].as_str().unwrap());
|
||||
assert!(!copy.exists());
|
||||
assert_eq!(std::fs::read_to_string(source).unwrap(), "SELECT 1;");
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn failed_backup_copy_and_gzip_preview_leave_no_managed_files() {
|
||||
let directory = tempfile::tempdir().unwrap();
|
||||
let state = restore_state(directory.path()).await;
|
||||
assert!(prepare_backup_preview(&state, directory.path().join("missing.sql")).await.is_err());
|
||||
let source = directory.path().join("invalid.sql.gz");
|
||||
std::fs::write(&source, "not gzip").unwrap();
|
||||
assert!(prepare_backup_preview(&state, source.clone()).await.is_err());
|
||||
let oversized = directory.path().join("oversized.sql");
|
||||
std::fs::File::create(&oversized).unwrap().set_len(sql_file_upload_limit(&state).await as u64 + 1).unwrap();
|
||||
assert!(prepare_backup_preview(&state, oversized.clone()).await.is_err());
|
||||
assert!(oversized.exists());
|
||||
assert_eq!(std::fs::read_dir(directory.path().join("tmp/sql_file")).unwrap().count(), 0);
|
||||
assert!(source.exists());
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn consumed_preview_survives_release_and_expiry_until_execution_finishes() {
|
||||
let directory = tempfile::tempdir().unwrap();
|
||||
let state = restore_state(directory.path()).await;
|
||||
let source = directory.path().join("backup.sql");
|
||||
std::fs::write(&source, "SELECT 1;").unwrap();
|
||||
let preview = prepare_backup_preview(&state, source.clone()).await.unwrap();
|
||||
let copy = PathBuf::from(preview["filePath"].as_str().unwrap());
|
||||
let paths = vec![copy.canonicalize().unwrap()];
|
||||
let execution = state.managed_sql_previews.claim(&paths).unwrap();
|
||||
assert!(state.managed_sql_previews.claim(&paths).is_err());
|
||||
state.managed_sql_previews.release(preview["cleanupToken"].as_str().unwrap());
|
||||
state.managed_sql_previews.cleanup(&directory.path().join("tmp/sql_file"), Duration::ZERO, true);
|
||||
assert!(copy.exists());
|
||||
drop(execution);
|
||||
assert!(!copy.exists());
|
||||
assert!(source.exists());
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn expired_and_abandoned_previews_are_removed_without_touching_ordinary_uploads() {
|
||||
let directory = tempfile::tempdir().unwrap();
|
||||
let state = restore_state(directory.path()).await;
|
||||
let source = directory.path().join("backup.sql");
|
||||
std::fs::write(&source, "SELECT 1;").unwrap();
|
||||
let preview = prepare_backup_preview(&state, source.clone()).await.unwrap();
|
||||
let tmp = directory.path().join("tmp/sql_file");
|
||||
let abandoned = tmp.join("restore-abandoned");
|
||||
std::fs::create_dir(&abandoned).unwrap();
|
||||
std::fs::write(abandoned.join("backup.sql"), "SELECT 2;").unwrap();
|
||||
let upload = tmp.join("upload.sql");
|
||||
std::fs::write(&upload, "SELECT 3;").unwrap();
|
||||
state.managed_sql_previews.cleanup(&tmp, Duration::ZERO, true);
|
||||
assert!(!Path::new(preview["filePath"].as_str().unwrap()).exists());
|
||||
assert!(!abandoned.exists());
|
||||
assert!(upload.exists());
|
||||
assert!(source.exists());
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn execution_failure_releases_the_managed_copy() {
|
||||
let directory = tempfile::tempdir().unwrap();
|
||||
let state = Arc::new(restore_state(directory.path()).await);
|
||||
let source = directory.path().join("backup.sql");
|
||||
std::fs::write(&source, "SELECT 1;").unwrap();
|
||||
let preview = prepare_backup_preview(&state, source.clone()).await.unwrap();
|
||||
let copy = PathBuf::from(preview["filePath"].as_str().unwrap());
|
||||
let request = serde_json::from_value(serde_json::json!({
|
||||
"executionId": "restore-error", "connectionId": "missing", "database": "app",
|
||||
"filePath": copy, "continueOnError": false
|
||||
}))
|
||||
.unwrap();
|
||||
let response =
|
||||
execute_sql_file(State(state.clone()), Json(SqlFileExecuteWrapper { request, file_paths: vec![] }))
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(response.0["executionId"], "restore-error");
|
||||
tokio::time::timeout(Duration::from_secs(5), async {
|
||||
while copy.exists() {
|
||||
tokio::time::sleep(Duration::from_millis(10)).await;
|
||||
}
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
assert!(source.exists());
|
||||
assert!(!state.sql_file_executions.read().await.contains_key("restore-error"));
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn duplicate_execution_releases_the_new_preview_without_cancelling_the_existing_job() {
|
||||
let directory = tempfile::tempdir().unwrap();
|
||||
let state = Arc::new(restore_state(directory.path()).await);
|
||||
let source = directory.path().join("backup.sql");
|
||||
std::fs::write(&source, "SELECT 1;").unwrap();
|
||||
let preview = prepare_backup_preview(&state, source.clone()).await.unwrap();
|
||||
let copy = PathBuf::from(preview["filePath"].as_str().unwrap());
|
||||
let token = CancellationToken::new();
|
||||
state.sql_file_executions.write().await.insert("existing-job".into(), token.clone());
|
||||
let request = serde_json::from_value(serde_json::json!({
|
||||
"executionId": "existing-job", "connectionId": "missing", "database": "app",
|
||||
"filePath": copy, "continueOnError": false
|
||||
}))
|
||||
.unwrap();
|
||||
assert!(execute_sql_file(State(state.clone()), Json(SqlFileExecuteWrapper { request, file_paths: vec![] }))
|
||||
.await
|
||||
.is_err());
|
||||
assert!(!copy.exists());
|
||||
assert!(source.exists());
|
||||
assert!(!token.is_cancelled());
|
||||
assert!(state.sql_file_executions.read().await.contains_key("existing-job"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn sql_file_upload_limit_defaults_and_clamps() {
|
||||
|
||||
@@ -39,6 +39,7 @@ pub struct WebState {
|
||||
pub transfer_progress_channels: RwLock<HashMap<String, Arc<TransferProgressChannel>>>,
|
||||
pub table_import_channels: RwLock<HashMap<String, watch::Sender<String>>>,
|
||||
pub sql_file_executions: RwLock<HashMap<String, CancellationToken>>,
|
||||
pub managed_sql_previews: crate::routes::sql_file::ManagedSqlPreviews,
|
||||
pub nacos_imports: RwLock<HashMap<String, NacosImportContext>>,
|
||||
pub login_rate_limit: Mutex<LoginRateLimit>,
|
||||
/// Completed Web export temp files waiting for the browser download.
|
||||
@@ -66,6 +67,7 @@ impl WebState {
|
||||
transfer_progress_channels: RwLock::new(HashMap::new()),
|
||||
table_import_channels: RwLock::new(HashMap::new()),
|
||||
sql_file_executions: RwLock::new(HashMap::new()),
|
||||
managed_sql_previews: Default::default(),
|
||||
nacos_imports: RwLock::new(HashMap::new()),
|
||||
login_rate_limit: Mutex::new(LoginRateLimit { fail_count: 0, locked_until: None }),
|
||||
export_files: RwLock::new(HashMap::new()),
|
||||
|
||||
Reference in new issue
Block a user