From e3aef69f380c893c2ae6a8ce64aade3ae8b5f2b4 Mon Sep 17 00:00:00 2001 From: Rohit Joshi Date: Sun, 24 Feb 2019 20:53:59 -0500 Subject: [PATCH 01/10] issue#135 Expose API to restore database from backups --- src/backup.rs | 54 +++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 54 insertions(+) diff --git a/src/backup.rs b/src/backup.rs index 56901a0..f53e918 100644 --- a/src/backup.rs +++ b/src/backup.rs @@ -78,6 +78,60 @@ impl BackupEngine { Ok(()) } } + /// Restore from the latest backup + /// db_dir: input db directory + /// wal_dir: input wal directory + /// opts: restore options + /// example: + /// use rocksdb::backup::{BackupEngine, BackupEngineOptions}; + /// let backup_opts = BackupEngineOptions::default(); + /// let backup_engine = BackupEngine::open(&backup_opts, &backup_path).unwrap(); + /// let mut restore_option = rocksdb::backup::RestoreOptions::default(); + /// restore_option.set_keep_log_files(true); /// true to keep log files + /// if let Err(e) = backup_engine.restore_from_latest_backup(&db_path, &wal_dir, &restore_option) { + /// error!("Failed to restore from the backup. Error:{:?}", e); + /// return Err(e.to_string()); + /// } + pub fn restore_from_latest_backup>( + &mut self, + db_dir: P, + wal_dir: P, + opts: &RestoreOptions, + ) -> Result<(), Error> { + let db_dir = db_dir.as_ref(); + let c_db_dir = match CString::new(db_dir.to_string_lossy().as_bytes()) { + Ok(c) => c, + Err(_) => { + return Err(Error::new( + "Failed to convert db_dir to CString \ + when restoring from latest backup" + .to_owned(), + )); + } + }; + + let wal_dir = wal_dir.as_ref(); + let c_wal_dir = match CString::new(wal_dir.to_string_lossy().as_bytes()) { + Ok(c) => c, + Err(_) => { + return Err(Error::new( + "Failed to convert wal_dir to CString \ + when restoring from latest backup" + .to_owned(), + )); + } + }; + + unsafe { + ffi_try!(ffi::rocksdb_backup_engine_restore_db_from_latest_backup( + self.inner, + c_db_dir.as_ptr(), + c_wal_dir.as_ptr(), + opts.inner, + )); + } + Ok(()) + } } impl BackupEngineOptions { From 0a4cedc0a31db1f2a4e7203c1ac76570b638376d Mon Sep 17 00:00:00 2001 From: Rohit Joshi Date: Sun, 24 Feb 2019 23:26:14 -0500 Subject: [PATCH 02/10] Specifying two separate Path Replacing single path `P` with `D: AsRef, W: AsRef` --- src/backup.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/backup.rs b/src/backup.rs index f53e918..0f324bf 100644 --- a/src/backup.rs +++ b/src/backup.rs @@ -92,10 +92,10 @@ impl BackupEngine { /// error!("Failed to restore from the backup. Error:{:?}", e); /// return Err(e.to_string()); /// } - pub fn restore_from_latest_backup>( + pub fn restore_from_latest_backup, W: AsRef>( &mut self, - db_dir: P, - wal_dir: P, + db_dir: D, + wal_dir: W, opts: &RestoreOptions, ) -> Result<(), Error> { let db_dir = db_dir.as_ref(); From f8267c8303c7393391eae28d2c528fd89ea98040 Mon Sep 17 00:00:00 2001 From: Rohit Joshi Date: Mon, 25 Feb 2019 12:02:24 -0500 Subject: [PATCH 03/10] updating rust doc --- src/backup.rs | 22 +++++++++++++++------- 1 file changed, 15 insertions(+), 7 deletions(-) diff --git a/src/backup.rs b/src/backup.rs index f53e918..4106818 100644 --- a/src/backup.rs +++ b/src/backup.rs @@ -78,11 +78,18 @@ impl BackupEngine { Ok(()) } } + /// Restore from the latest backup - /// db_dir: input db directory - /// wal_dir: input wal directory - /// opts: restore options - /// example: + /// + /// # Arguments + /// + /// * `db_dir` - A path to the database directory + /// * `wal_dir` - A path to the wal directory + /// * `opts` - Restore options + /// + /// # Example + /// + /// ```ignore /// use rocksdb::backup::{BackupEngine, BackupEngineOptions}; /// let backup_opts = BackupEngineOptions::default(); /// let backup_engine = BackupEngine::open(&backup_opts, &backup_path).unwrap(); @@ -92,10 +99,11 @@ impl BackupEngine { /// error!("Failed to restore from the backup. Error:{:?}", e); /// return Err(e.to_string()); /// } - pub fn restore_from_latest_backup>( + /// ``` + pub fn restore_from_latest_backup,W: AsRef>( &mut self, - db_dir: P, - wal_dir: P, + db_dir: D, + wal_dir: W, opts: &RestoreOptions, ) -> Result<(), Error> { let db_dir = db_dir.as_ref(); From 7b7cf00cf618e5cd3301989086f97232fb0534ca Mon Sep 17 00:00:00 2001 From: Rohit Joshi Date: Mon, 25 Feb 2019 12:05:16 -0500 Subject: [PATCH 04/10] Updating rust doc MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit ``` Restore from the latest backup Arguments ``` db_dir - A path to the database directory wal_dir - A path to the wal directory opts - Restore options ``` Example ``` ⓘ use rocksdb::backup::{BackupEngine, BackupEngineOptions}; let backup_opts = BackupEngineOptions::default(); let backup_engine = BackupEngine::open(&backup_opts, &backup_path).unwrap(); let mut restore_option = rocksdb::backup::RestoreOptions::default(); restore_option.set_keep_log_files(true); /// true to keep log files if let Err(e) = backup_engine.restore_from_latest_backup(&db_path, &wal_dir, &restore_option) { error!("Failed to restore from the backup. Error:{:?}", e); return Err(e.to_string()); } ``` --- src/backup.rs | 15 +++++++++++---- 1 file changed, 11 insertions(+), 4 deletions(-) diff --git a/src/backup.rs b/src/backup.rs index 0f324bf..78840d6 100644 --- a/src/backup.rs +++ b/src/backup.rs @@ -79,10 +79,16 @@ impl BackupEngine { } } /// Restore from the latest backup - /// db_dir: input db directory - /// wal_dir: input wal directory - /// opts: restore options - /// example: + /// + /// # Arguments + /// + /// * `db_dir` - A path to the database directory + /// * `wal_dir` - A path to the wal directory + /// * `opts` - Restore options + /// + /// # Example + /// + /// ```ignore /// use rocksdb::backup::{BackupEngine, BackupEngineOptions}; /// let backup_opts = BackupEngineOptions::default(); /// let backup_engine = BackupEngine::open(&backup_opts, &backup_path).unwrap(); @@ -92,6 +98,7 @@ impl BackupEngine { /// error!("Failed to restore from the backup. Error:{:?}", e); /// return Err(e.to_string()); /// } + /// ``` pub fn restore_from_latest_backup, W: AsRef>( &mut self, db_dir: D, From 419084cf0fdec36e5ada9df65f1af1f3b12f134e Mon Sep 17 00:00:00 2001 From: Rohit Joshi Date: Sat, 2 Mar 2019 18:58:33 -0500 Subject: [PATCH 05/10] adding backup & restore test case --- src/backup.rs | 43 +++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 41 insertions(+), 2 deletions(-) diff --git a/src/backup.rs b/src/backup.rs index 4106818..0b85bc7 100644 --- a/src/backup.rs +++ b/src/backup.rs @@ -78,7 +78,7 @@ impl BackupEngine { Ok(()) } } - + /// Restore from the latest backup /// /// # Arguments @@ -92,7 +92,7 @@ impl BackupEngine { /// ```ignore /// use rocksdb::backup::{BackupEngine, BackupEngineOptions}; /// let backup_opts = BackupEngineOptions::default(); - /// let backup_engine = BackupEngine::open(&backup_opts, &backup_path).unwrap(); + /// let mut backup_engine = BackupEngine::open(&backup_opts, &backup_path).unwrap(); /// let mut restore_option = rocksdb::backup::RestoreOptions::default(); /// restore_option.set_keep_log_files(true); /// true to keep log files /// if let Err(e) = backup_engine.restore_from_latest_backup(&db_path, &wal_dir, &restore_option) { @@ -201,3 +201,42 @@ impl Drop for RestoreOptions { } } } + +#[test] +fn backup_restore() { + + use db::DBVector; + // create backup + let path = "_rust_rocksdb_backup_restore_test"; + { + let db = DB::open_default(path).unwrap(); + let p = db.put(b"k1", b"v1111"); + assert!(p.is_ok()); + let r: Result, Error> = db.get(b"k1"); + assert!(r.unwrap().unwrap().to_utf8().unwrap() == "v1111"); + + let backup_path = "_rust_rocksdb_backup_path"; + { + let backup_opts = BackupEngineOptions::default(); + let mut backup_engine = BackupEngine::open(&backup_opts, &backup_path).unwrap(); + + let r = backup_engine.create_new_backup(&db); + assert!(r.is_ok()); + + let restore_path = "_rust_rocksdb_restore_from_backup_path"; + { + let mut restore_option = RestoreOptions::default(); + restore_option.set_keep_log_files(true); // true to keep log files + let restore_status = backup_engine.restore_from_latest_backup(&restore_path, &restore_path, &restore_option); + assert!(restore_status.is_ok()); + + let db = DB::open_default(restore_path).unwrap(); + + let r: Result, Error> = db.get(b"k1"); + assert!(r.unwrap().unwrap().to_utf8().unwrap() == "v1111"); + } + } + } + + +} From dfdabd08e8508d349fe7585d832e7aba22a3b3f5 Mon Sep 17 00:00:00 2001 From: Rohit Joshi Date: Sat, 2 Mar 2019 23:07:24 -0500 Subject: [PATCH 06/10] cargo fmt check --- src/backup.rs | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/src/backup.rs b/src/backup.rs index 68b7b92..f5b9bec 100644 --- a/src/backup.rs +++ b/src/backup.rs @@ -100,9 +100,8 @@ impl BackupEngine { /// return Err(e.to_string()); /// } /// ``` - - pub fn restore_from_latest_backup, W: AsRef>( + pub fn restore_from_latest_backup, W: AsRef>( &mut self, db_dir: D, wal_dir: W, @@ -206,7 +205,6 @@ impl Drop for RestoreOptions { #[test] fn backup_restore() { - use db::DBVector; // create backup let path = "_rust_rocksdb_backup_restore_test"; @@ -229,9 +227,13 @@ fn backup_restore() { { let mut restore_option = RestoreOptions::default(); restore_option.set_keep_log_files(true); // true to keep log files - let restore_status = backup_engine.restore_from_latest_backup(&restore_path, &restore_path, &restore_option); + let restore_status = backup_engine.restore_from_latest_backup( + &restore_path, + &restore_path, + &restore_option, + ); assert!(restore_status.is_ok()); - + let db = DB::open_default(restore_path).unwrap(); let r: Result, Error> = db.get(b"k1"); @@ -239,6 +241,4 @@ fn backup_restore() { } } } - - } From ae8281d7faade696aac11c40d61aa5ebf00d337a Mon Sep 17 00:00:00 2001 From: Rohit Joshi Date: Sun, 3 Mar 2019 01:08:36 -0500 Subject: [PATCH 07/10] Update Cargo.toml --- Cargo.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Cargo.toml b/Cargo.toml index de2764d..0f12019 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,7 +1,7 @@ [package] name = "rocksdb" description = "Rust wrapper for Facebook's RocksDB embeddable database" -version = "0.11.0" +version = "0.11.1" authors = ["Tyler Neely ", "David Greenberg "] license = "Apache-2.0" keywords = ["database", "embedded", "LSM-tree", "persistence"] From 3460474c82a802fa8ae90b7874785153738bbc1b Mon Sep 17 00:00:00 2001 From: Rohit Joshi Date: Sun, 3 Mar 2019 01:39:25 -0500 Subject: [PATCH 08/10] Update Cargo.toml --- Cargo.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Cargo.toml b/Cargo.toml index 0f12019..de2764d 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,7 +1,7 @@ [package] name = "rocksdb" description = "Rust wrapper for Facebook's RocksDB embeddable database" -version = "0.11.1" +version = "0.11.0" authors = ["Tyler Neely ", "David Greenberg "] license = "Apache-2.0" keywords = ["database", "embedded", "LSM-tree", "persistence"] From a0b707ca30d325f1d3f8472ab2388eb126fbe3b5 Mon Sep 17 00:00:00 2001 From: Rohit Joshi Date: Wed, 6 Mar 2019 20:49:46 -0500 Subject: [PATCH 09/10] adding DB::destroy() --- src/backup.rs | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/src/backup.rs b/src/backup.rs index f5b9bec..ef8a798 100644 --- a/src/backup.rs +++ b/src/backup.rs @@ -206,6 +206,7 @@ impl Drop for RestoreOptions { #[test] fn backup_restore() { use db::DBVector; + use Options; // create backup let path = "_rust_rocksdb_backup_restore_test"; { @@ -234,11 +235,18 @@ fn backup_restore() { ); assert!(restore_status.is_ok()); - let db = DB::open_default(restore_path).unwrap(); + let db_restore = DB::open_default(restore_path).unwrap(); - let r: Result, Error> = db.get(b"k1"); + let r: Result, Error> = db_restore.get(b"k1"); assert!(r.unwrap().unwrap().to_utf8().unwrap() == "v1111"); + } + assert!(DB::destroy(&Options::default(), restore_path).is_ok()); + } + assert!(DB::destroy(&Options::default(), backup_path).is_ok()); + } + assert!(DB::destroy(&Options::default(), path).is_ok()); + } From b0160daacace41d494df054a97e6ccdd1604fb9b Mon Sep 17 00:00:00 2001 From: Rohit Joshi Date: Wed, 6 Mar 2019 20:51:27 -0500 Subject: [PATCH 10/10] fixing cargo fmt --all --- src/backup.rs | 4 ---- 1 file changed, 4 deletions(-) diff --git a/src/backup.rs b/src/backup.rs index ef8a798..19f065c 100644 --- a/src/backup.rs +++ b/src/backup.rs @@ -239,14 +239,10 @@ fn backup_restore() { let r: Result, Error> = db_restore.get(b"k1"); assert!(r.unwrap().unwrap().to_utf8().unwrap() == "v1111"); - } assert!(DB::destroy(&Options::default(), restore_path).is_ok()); - } assert!(DB::destroy(&Options::default(), backup_path).is_ok()); - } assert!(DB::destroy(&Options::default(), path).is_ok()); - }