add repo.destroy() function, fix #57

Author: burmecia

src/fs/fs.rs

@@ -609,6 +609,13 @@ impl Fs {
             Fnode::add_child(&tgt_parent, &src, &name)
         })
     }
+
+    /// Destroy the whole file system
+    #[inline]
+    pub fn destroy(uri: &str) -> Result<()> {
+        let mut vol = Volume::new(uri)?;
+        vol.destroy()
+    }
 }
 
 impl Drop for Fs {

src/repo.rs

@@ -727,6 +727,7 @@ impl Repo {
     /// damaged. If it is the case, use
     /// [repair_super_block](struct.Repo.html#method.repair_super_block)
     /// to restore super block before re-opening the repo.
+    #[inline]
     pub fn reset_password(
         &mut self,
         old_pwd: &str,
@@ -959,6 +960,15 @@ impl Repo {
     ) -> Result<()> {
         self.fs.rename(from.as_ref(), to.as_ref())
     }
+
+    /// Permanently destroy a repository specified by `uri`.
+    ///
+    /// This will permanently delete all files and directories in a repository
+    /// regardless it is opened or not. Use it with caution.
+    #[inline]
+    pub fn destroy(uri: &str) -> Result<()> {
+        Fs::destroy(uri)
+    }
 }
 
 impl Debug for Repo {

src/volume/storage/faulty/faulty.rs

@@ -58,7 +58,7 @@ impl Storable for FaultyStorage {
     fn init(&mut self, _crypto: Crypto, _key: Key) -> Result<()> {
         let mut inner = self.inner.write().unwrap();
         assert!(!inner.contains_key(&self.loc));
-        inner.insert(self.loc.to_string(), MemStorage::new());
+        inner.insert(self.loc.to_string(), MemStorage::new("faulty"));
         Ok(())
     }
 
@@ -165,6 +165,11 @@ impl Storable for FaultyStorage {
         let ms = inner.get_refresh(&self.loc).unwrap();
         ms.flush()
     }
+
+    #[inline]
+    fn destroy(&mut self) -> Result<()> {
+        unimplemented!()
+    }
 }
 
 impl Debug for FaultyStorage {

src/volume/storage/file/file.rs

@@ -233,6 +233,15 @@ impl Storable for FileStorage {
     fn flush(&mut self) -> Result<()> {
         self.idx_mgr.flush()
     }
+
+    #[inline]
+    fn destroy(&mut self) -> Result<()> {
+        if self.lock_path().exists() {
+            warn!("Destroy an opened repo");
+        }
+        let _ = vio::remove_dir_all(&self.base)?;
+        Ok(())
+    }
 }
 
 impl Drop for FileStorage {

src/volume/storage/mem/mem.rs

@@ -57,7 +57,7 @@ impl MemStorage {
         let depot = storages.get_mut(&self.loc).unwrap();
         if depot.is_opened {
             if force {
-                warn!("Repo was locked, forced to open");
+                warn!("Repo is locked, forced to open");
             } else {
                 return Err(Error::RepoOpened);
             }
@@ -194,6 +194,16 @@ impl Storable for MemStorage {
     fn flush(&mut self) -> Result<()> {
         Ok(())
     }
+
+    fn destroy(&mut self) -> Result<()> {
+        let mut storages = STORAGES.lock().unwrap();
+        if let Some(depot) = storages.remove(&self.loc) {
+            if depot.is_opened {
+                warn!("Destroyed an opened repo");
+            }
+        }
+        Ok(())
+    }
 }
 
 impl Drop for MemStorage {

src/volume/storage/mod.rs

@@ -83,6 +83,9 @@ pub trait Storable: Debug + Send + Sync {
     // flush possibly buffered wal, address and block to storage,
     // storage must gurantee write is persistent
     fn flush(&mut self) -> Result<()>;
+
+    // permanently destroy this storage
+    fn destroy(&mut self) -> Result<()>;
 }
 
 /// Dummy storage
@@ -173,4 +176,9 @@ impl Storable for DummyStorage {
     fn flush(&mut self) -> Result<()> {
         unimplemented!()
     }
+
+    #[inline]
+    fn destroy(&mut self) -> Result<()> {
+        unimplemented!()
+    }
 }

src/volume/storage/redis/redis.rs

@@ -1,7 +1,7 @@
 use std::fmt::{self, Debug};
 use std::sync::Mutex;
 
-use redis::{Client, Commands, Connection};
+use redis::{self, Client, Commands, Connection};
 
 use base::crypto::{Crypto, Key};
 use base::IntoRef;
@@ -230,6 +230,22 @@ impl Storable for RedisStorage {
     fn flush(&mut self) -> Result<()> {
         Ok(())
     }
+
+    fn destroy(&mut self) -> Result<()> {
+        let key = repo_lock_key();
+        if self.get_bytes(&key).is_ok() {
+            // repo is locked
+            warn!("Destroy an opened repo");
+        }
+        match self.conn {
+            Some(ref conn) => {
+                let mut conn = conn.lock().unwrap();
+                redis::cmd("FLUSHDB").execute(&mut *conn);
+                Ok(())
+            }
+            None => unreachable!(),
+        }
+    }
 }
 
 impl Drop for RedisStorage {

src/volume/storage/sqlite/sqlite.rs

@@ -7,6 +7,7 @@ use std::thread::panicking;
 use libsqlite3_sys as ffi;
 
 use base::crypto::{Crypto, Key};
+use base::vio;
 use error::{Error, Result};
 use trans::Eid;
 use volume::address::Span;
@@ -117,8 +118,8 @@ fn run_select_blob(stmt: *mut ffi::sqlite3_stmt) -> Result<Vec<u8>> {
 
 /// Sqlite Storage
 pub struct SqliteStorage {
-    is_attached: bool, // attached to sqlite db
-    filename: CString,
+    is_attached: bool,  // attached to sqlite db
+    file_path: CString, // database file path
     db: *mut ffi::sqlite3,
     stmts: Vec<*mut ffi::sqlite3_stmt>,
 }
@@ -131,10 +132,10 @@ impl SqliteStorage {
     const TBL_ADDRESSES: &'static str = "addresses";
     const TBL_BLOCKS: &'static str = "blocks";
 
-    pub fn new(filename: &str) -> Self {
+    pub fn new(file_path: &str) -> Self {
         SqliteStorage {
             is_attached: false,
-            filename: CString::new(filename).unwrap(),
+            file_path: CString::new(file_path).unwrap(),
             db: ptr::null_mut(),
             stmts: Vec::with_capacity(14),
         }
@@ -196,7 +197,7 @@ impl SqliteStorage {
         ))?;
         self.prepare_sql(format!(
             "
-            INSERT INTO {}(suffix, data) VALUES (?, ?)
+            INSERT OR REPLACE INTO {}(suffix, data) VALUES (?, ?)
         ",
             Self::TBL_SUPER_BLOCK
         ))?;
@@ -297,7 +298,7 @@ impl Storable for SqliteStorage {
         let mut db: *mut ffi::sqlite3 = ptr::null_mut();
         let result = unsafe {
             ffi::sqlite3_open_v2(
-                self.filename.as_ptr(),
+                self.file_path.as_ptr(),
                 &mut db,
                 ffi::SQLITE_OPEN_READONLY,
                 ptr::null(),
@@ -312,7 +313,7 @@ impl Storable for SqliteStorage {
     fn connect(&mut self, _force: bool) -> Result<()> {
         let result = unsafe {
             ffi::sqlite3_open_v2(
-                self.filename.as_ptr(),
+                self.file_path.as_ptr(),
                 &mut self.db,
                 ffi::SQLITE_OPEN_READWRITE
                     | ffi::SQLITE_OPEN_CREATE
@@ -524,6 +525,23 @@ impl Storable for SqliteStorage {
     fn flush(&mut self) -> Result<()> {
         Ok(())
     }
+
+    #[inline]
+    fn destroy(&mut self) -> Result<()> {
+        if self.prepare_stmts().is_ok() {
+            let stmt = self.stmts[0];
+            reset_stmt(stmt)?;
+            match unsafe { ffi::sqlite3_step(stmt) } {
+                ffi::SQLITE_ROW => {
+                    // repo is locked
+                    warn!("Destroy an opened repo");
+                }
+                _ => {}
+            }
+        }
+        let _ = vio::remove_file(self.file_path.to_str().unwrap())?;
+        Ok(())
+    }
 }
 
 impl Drop for SqliteStorage {
@@ -560,7 +578,7 @@ impl Drop for SqliteStorage {
 impl Debug for SqliteStorage {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         f.debug_struct("SqliteStorage")
-            .field("filename", &self.filename)
+            .field("file_path", &self.file_path)
             .finish()
     }
 }

src/volume/storage/storage.rs

@@ -303,6 +303,11 @@ impl Storage {
     pub fn flush(&mut self) -> Result<()> {
         self.depot.flush()
     }
+
+    #[inline]
+    pub fn destroy(&mut self) -> Result<()> {
+        self.depot.destroy()
+    }
 }
 
 impl Default for Storage {

src/volume/storage/zbox/zbox.rs

@@ -270,6 +270,11 @@ impl Storable for ZboxStorage {
         let mut local_cache = self.local_cache.write().unwrap();
         local_cache.flush()
     }
+
+    #[inline]
+    fn destroy(&mut self) -> Result<()> {
+        unimplemented!()
+    }
 }
 
 impl Debug for ZboxStorage {

src/volume/volume.rs

@@ -174,6 +174,7 @@ impl Volume {
         storage.get_allocator()
     }
 
+    // delete a wal
     #[inline]
     pub fn del_wal(&mut self, id: &Eid) -> Result<()> {
         let mut storage = self.storage.write().unwrap();
@@ -192,6 +193,14 @@ impl Volume {
         let mut storage = self.storage.write().unwrap();
         storage.flush()
     }
+
+    // permanently destroy a volume
+    #[inline]
+    pub fn destroy(&mut self) -> Result<()> {
+        let mut storage = self.storage.write().unwrap();
+        storage.connect(false)?;
+        storage.destroy()
+    }
 }
 
 impl IntoRef for Volume {}