diff --git a/Cargo.lock b/Cargo.lock index fc340287..d26734cf 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1829,11 +1829,11 @@ dependencies = [ [[package]] name = "hashlink" -version = "0.9.1" +version = "0.10.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6ba4ff7128dee98c7dc9794b6a411377e1404dba1c97deb8d1a55297bd25d8af" +checksum = "7382cf6263419f2d8df38c55d7da83da5c18aef87fc7a7fc1fb1e344edfe14c1" dependencies = [ - "hashbrown 0.14.5", + "hashbrown 0.15.2", ] [[package]] @@ -2639,9 +2639,9 @@ dependencies = [ [[package]] name = "libsqlite3-sys" -version = "0.28.0" +version = "0.35.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0c10584274047cb335c23d3e61bcef8e323adae7c5c8c760540f73610177fc3f" +checksum = "133c182a6a2c87864fe97778797e46c7e999672690dc9fa3ee8e241aa4a9c13f" dependencies = [ "cc", "pkg-config", @@ -3498,9 +3498,9 @@ dependencies = [ [[package]] name = "r2d2_sqlite" -version = "0.24.0" +version = "0.31.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6a982edf65c129796dba72f8775b292ef482b40d035e827a9825b3bc07ccc5f2" +checksum = "63417e83dc891797eea3ad379f52a5986da4bca0d6ef28baf4d14034dd111b0c" dependencies = [ "r2d2", "rusqlite", @@ -3718,9 +3718,9 @@ checksum = "3cd14fd5e3b777a7422cca79358c57a8f6e3a703d9ac187448d0daf220c2407f" [[package]] name = "rusqlite" -version = "0.31.0" +version = "0.37.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b838eba278d213a8beaf485bd313fd580ca4505a00d5871caeb1457c55322cae" +checksum = "165ca6e57b20e1351573e3729b958bc62f0e48025386970b6e4d29e7a7e71f3f" dependencies = [ "bitflags 2.9.0", "fallible-iterator", diff --git a/Cargo.toml b/Cargo.toml index 50e4bad3..f4b0e1f2 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -88,9 +88,9 @@ tracing-journald = "0.3.1" tracing-subscriber = { version = "0.3", features = ["env-filter"] } heed = { version = "0.11", default-features = false, features = ["lmdb"] } -rusqlite = "0.31.0" +rusqlite = "0.37" r2d2 = "0.8" -r2d2_sqlite = "0.24" +r2d2_sqlite = "0.31" fjall = "2.4" async-compression = { version = "0.4", features = ["tokio", "zstd"] } diff --git a/doc/book/connect/backup.md b/doc/book/connect/backup.md index f39cc3b6..7e97d777 100644 --- a/doc/book/connect/backup.md +++ b/doc/book/connect/backup.md @@ -161,3 +161,49 @@ kopia repository validate-provider You can then run all the standard kopia commands: `kopia snapshot create`, `kopia mount`... Everything should work out-of-the-box. + +## Plakar + +Create your key and bucket on Garage server: + +```bash +garage key create my-plakar-key +garage bucket create plakar-backups +garage bucket allow plakar-backups --read --write --key my-plakar-key +… +``` + +On Plakar server, add your Garage as a storage location: +```bash +plakar store add garageS3 s3://my-garage.tld/plakar-backups \ +region=garage # Or as you've specified in garage.toml \ +access_key= \ +secret_access_key= +``` + +Then create the repository. +```bash +plakar at @garageS3 create -plaintext # Unencrypted +# or +plakar at @garageS3 create #encrypted +``` + +If you encrypt your backups (Plakar default), you will need to define a strong passphrase. Do not forget to save your password safely. It will be needed to decrypt your backups. + + +After the repository has been created, check that everything works as expected (that might give an empty result as no file has been added yet, but no error message): +```bash +plakar at @garageS3 check +``` + +Now that everything is configure, you can use Garage as your backups storage. For instance sync it with a local backup storage: +```bash +$ plakar at ~/backups sync to @garageS3 +``` + +Or list the S3 storage content: +```bash +$ plakar at @garageS3 ls +``` + +More information in Plakar documentation: https://www.plakar.io/docs/main/quickstart/ diff --git a/src/api/admin/api.rs b/src/api/admin/api.rs index 89adbee9..2fd72698 100644 --- a/src/api/admin/api.rs +++ b/src/api/admin/api.rs @@ -1132,6 +1132,7 @@ pub enum RepairType { Rebalance, Scrub(ScrubCommand), Aliases, + ClearResyncQueue, } #[derive(Debug, Clone, Serialize, Deserialize, ToSchema)] diff --git a/src/api/admin/repair.rs b/src/api/admin/repair.rs index 95bec980..a94ca9a6 100644 --- a/src/api/admin/repair.rs +++ b/src/api/admin/repair.rs @@ -93,6 +93,15 @@ impl RequestHandler for LocalLaunchRepairOperationRequest { info!("Repairing bucket aliases (foreground)"); garage.locked_helper().await.repair_aliases().await?; } + RepairType::ClearResyncQueue => { + info!("Clearing resync queue (foreground)"); + let garage = garage.clone(); + tokio::task::spawn_blocking(move || { + garage.block_manager.resync.clear_resync_queue() + }) + .await + .map_err(garage_util::error::Error::from)??; + } } Ok(LocalLaunchRepairOperationResponse) } diff --git a/src/block/resync.rs b/src/block/resync.rs index 7d43ab1e..f60b540f 100644 --- a/src/block/resync.rs +++ b/src/block/resync.rs @@ -131,6 +131,14 @@ impl BlockResyncManager { ))) } + /// Clear the entire resync queue and list of errored blocks + /// Corresponds to `garage repair clear-resync-queue` + pub fn clear_resync_queue(&self) -> Result<(), Error> { + self.queue.clear()?; + self.errors.clear()?; + Ok(()) + } + pub fn register_bg_vars(&self, vars: &mut vars::BgVars) { let notify = self.notify.clone(); vars.register_rw( diff --git a/src/db/lib.rs b/src/db/lib.rs index 5ac16da8..71826255 100644 --- a/src/db/lib.rs +++ b/src/db/lib.rs @@ -106,32 +106,44 @@ impl Db { result: Cell::new(None), }; let tx_res = self.0.transaction(&f); - let ret = f - .result - .into_inner() - .expect("Transaction did not store result"); + let fn_res = f.result.into_inner(); - match tx_res { - Ok(on_commit) => match ret { - Ok(value) => { - on_commit.into_iter().for_each(|f| f()); - Ok(value) - } - _ => unreachable!(), - }, - Err(TxError::Abort(())) => match ret { - Err(TxError::Abort(e)) => Err(TxError::Abort(e)), - _ => unreachable!(), - }, - Err(TxError::Db(e2)) => match ret { - // Ok was stored -> the error occurred when finalizing - // transaction - Ok(_) => Err(TxError::Db(e2)), - // An error was already stored: that's the one we want to - // return - Err(TxError::Db(e)) => Err(TxError::Db(e)), - _ => unreachable!(), - }, + match (tx_res, fn_res) { + (Ok(on_commit), Some(Ok(value))) => { + // Transaction succeeded + // TxFn stored the value to return to the user in fn_res + // tx_res contains the on_commit list of callbacks, run them now + on_commit.into_iter().for_each(|f| f()); + Ok(value) + } + (Err(TxError::Abort(())), Some(Err(TxError::Abort(e)))) => { + // Transaction was aborted by user code + // The abort error value is stored in fn_res + Err(TxError::Abort(e)) + } + (Err(TxError::Db(_tx_e)), Some(Err(TxError::Db(fn_e)))) => { + // Transaction encountered a DB error in user code + // The error value encountered is the one in fn_res, + // tx_res contains only a dummy error message + Err(TxError::Db(fn_e)) + } + (Err(TxError::Db(tx_e)), None) => { + // Transaction encounterred a DB error when initializing the transaction, + // before user code was called + Err(TxError::Db(tx_e)) + } + (Err(TxError::Db(tx_e)), Some(Ok(_))) => { + // Transaction encounterred a DB error when commiting the transaction, + // after user code was called + Err(TxError::Db(tx_e)) + } + (tx_res, fn_res) => { + panic!( + "unexpected error case: tx_res={:?}, fn_res={:?}", + tx_res.map(|_| "..."), + fn_res.map(|x| x.map(|_| "...").map_err(|_| "...")) + ); + } } } diff --git a/src/db/sqlite_adapter.rs b/src/db/sqlite_adapter.rs index d645c64e..a03ee8ef 100644 --- a/src/db/sqlite_adapter.rs +++ b/src/db/sqlite_adapter.rs @@ -151,30 +151,16 @@ impl IDb for SqliteDb { } fn snapshot(&self, base_path: &PathBuf) -> Result<()> { - fn progress(p: rusqlite::backup::Progress) { - use std::sync::atomic::{AtomicU64, Ordering}; - use std::time::{SystemTime, UNIX_EPOCH}; - - static LAST_LOG_TIME: AtomicU64 = AtomicU64::new(0); - - let now = SystemTime::now() - .duration_since(UNIX_EPOCH) - .expect("Fix your clock :o") - .as_millis() as u64; - if now >= LAST_LOG_TIME.load(Ordering::Relaxed) + 10 * 1000 { - let percent = (p.pagecount - p.remaining) * 100 / p.pagecount; - info!("Sqlite snapshot progress: {}%", percent); - - LAST_LOG_TIME.fetch_max(now, Ordering::Relaxed); - } - } - std::fs::create_dir_all(base_path)?; - let path = Engine::Sqlite.db_path(&base_path); + let path = Engine::Sqlite + .db_path(&base_path) + .into_os_string() + .into_string() + .map_err(|_| Error("invalid sqlite path string".into()))?; - self.db - .get()? - .backup(rusqlite::DatabaseName::Main, path, Some(progress))?; + info!("Start sqlite VACUUM INTO `{}`", path); + self.db.get()?.execute("VACUUM INTO ?1", params![path])?; + info!("Finished sqlite VACUUM INTO `{}`", path); Ok(()) } diff --git a/src/garage/cli/remote/node.rs b/src/garage/cli/remote/node.rs index 2ca8843f..482f239d 100644 --- a/src/garage/cli/remote/node.rs +++ b/src/garage/cli/remote/node.rs @@ -92,6 +92,7 @@ impl Cli { ScrubCmd::Resume => ScrubCommand::Resume, }), RepairWhat::Aliases => RepairType::Aliases, + RepairWhat::ClearResyncQueue => RepairType::ClearResyncQueue, }; let res = self diff --git a/src/garage/cli/structs.rs b/src/garage/cli/structs.rs index e4c8f001..7fd2defa 100644 --- a/src/garage/cli/structs.rs +++ b/src/garage/cli/structs.rs @@ -645,6 +645,10 @@ pub enum RepairWhat { /// Repair (resync/rebalance) the set of stored blocks in the cluster #[structopt(name = "blocks", version = garage_version())] Blocks, + /// Clear the block resync queue. The list of blocks in errored state + /// is cleared as well. You MUST run `garage repair blocks` after invoking this. + #[structopt(name = "clear-resync-queue", version = garage_version())] + ClearResyncQueue, /// Repropagate object deletions to the version table #[structopt(name = "versions", version = garage_version())] Versions,