feat(backup): support cross-platform background database backups

This commit is contained in:
CSXFanMeng authored and GitHub committed 2026-09-23 12:29:56 +08:00
1 parent 250e0c0a10
commit 2f960f104c
56 files changed
+4195 -962

No files matched your search

+30 -5
View File
@@ -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;
}
+1
View File
@@ -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;
+1
View File
@@ -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?))
}
+310 -46
View File
@@ -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() {
+2
View File
@@ -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()),