add test for rotate

AliceLanniste · AliceLanniste · commit 97c77e38a4ae · 2020-05-26T20:02:13.000+08:00
diff --git a/src/db/mod.rs b/src/db/mod.rs
@@ -177,7 +177,7 @@ impl<S: Storage + Clone> DB for WickDB<S> {
 impl<S: Storage + Clone> WickDB<S> {
     /// Create a new WickDB
     pub fn open_db(mut options: Options, db_name: &'static str, storage: S) -> Result<Self> {
-        options.initialize(db_name.to_owned(), &storage);
+        options.initialize(db_name, &storage);
         debug!("Open db: '{}'", db_name);
         let mut db = DBImpl::new(options, db_name, storage);
         let (mut edit, should_save_manifest) = db.recover()?;
diff --git a/src/logger.rs b/src/logger.rs
@@ -15,22 +15,23 @@ use crate::db::filename::{generate_filename, FileType};
 use crate::error::Result;
 use crate::storage::{File, Storage};
 
+
 use log::{LevelFilter, Log, Metadata, Record};
 use slog::{o, Drain, Level};
 
 use chrono::prelude::*;
 use std::sync::Mutex;
+
 /// A `slog` based logger which can be used with `log` crate
 ///
 /// See `slog` at https://github.com/slog-rs/slog
 /// See `log` at https://github.com/rust-lang/log
 /// 
 
-fn create_file<S:Storage>(storage:&S,dp_path:&str,timestamp:i64) -> Result<S::F> {
-     let new_path = generate_filename(dp_path, FileType::OldInfoLog, timestamp as u64);
-     storage.rename(dp_path, new_path.as_str())?;
-     storage.create(dp_path)
-   
+pub fn create_file<S:Storage>(storage:&S,db_path:&str,timestamp:i64) -> Result<S::F> {
+     let new_path = generate_filename(db_path, FileType::Log, timestamp as u64);
+     storage.create(new_path)
+    
 }
 
 pub struct Logger {
@@ -49,7 +50,7 @@ impl Logger {
         inner: Option<slog::Logger>,
         level: LevelFilter,
         storage:S,
-        db_path: String,
+        db_path: &'static str,
     ) -> Self {
         let inner = match inner {
             Some(l) => l,
@@ -62,12 +63,13 @@ impl Logger {
                 } else {
                     // Use a file `Log` to record all logs
                     // TODO: add file rotation
-                    let file = create_file(&storage, db_path.as_str(), Local::now().timestamp()).unwrap();
-                    let file_fn =    move|path:String| {create_file(&storage, 
+                    //db_path 是generate_filename
+                    let file = create_file(&storage, db_path,Local::now().timestamp()).unwrap();
+                    let file_fn =  move |path: String| {create_file(&storage, 
                         path.as_str(),Local::now().timestamp())};
-                   let drain =FileBasedDrain::new(file,db_path.clone(), 
+                    let drain =FileBasedDrain::new(file,db_path, 
                                              file_fn)
-                                                .add_rotator(RotatedFileBySize::new(0));
+                                                .add_rotator(RotatedFileBySize::new(1));
                     let drain = slog_async::Async::new(drain).build().fuse();
                     slog::Logger::root(drain, o!())
                 }
@@ -131,46 +133,52 @@ fn log_to_slog_level(level: log::Level) -> Level {
 struct FileBasedDrain<F: File>  {
     inner: Mutex<F>,
     rotators: Vec<Box<dyn Rotator>>,
-    dp_path:String,
+    db_path:String,
     new_file:Box<dyn Send+Fn(String)->Result<F>>
 }
 
 impl<F: File> FileBasedDrain<F>  {
-    fn new<H>(f:F,path:String,new_file: H) -> Self
+    fn new<H>(f:F,path:&str,new_file: H) -> Self
     where H:'static+Send+Fn(String)->Result<F>
      {
         FileBasedDrain {
-            dp_path: path.clone(),
+            db_path: path.to_string(),
             inner: Mutex::new(f),
             rotators: vec![],
             new_file:Box::new(new_file)
         }
     }
 
+
     fn add_rotator<R: 'static+Rotator>(mut self, rotator: R) -> Self {
         if rotator.is_enabled() {
             self.rotators.push(Box::new(rotator));
         }
-        for rotator in (&self).rotators.iter() {
+        for rotator in (&self).rotators.iter()  {
             rotator.prepare(&*self.inner.lock().unwrap()).unwrap();
         }
         self
     }
 
-    fn flush(&self) ->Result<()>{
-        self.inner.lock().unwrap().flush()?;
-        let new_file = (self.new_file)(self.dp_path.clone()).unwrap();
-
-        let mut old_file = self.inner.lock().unwrap();
-        std::mem::replace(&mut *old_file, new_file);
+    fn flush(&self) -> Result<()>{
+        // use crate::storage::file::FileStorage;
+        // let storage = FileStorage::default();
         for rotator in self.rotators.iter() {
-            rotator.on_rotate()?;
-        }
-        return Ok(());
-
+            if rotator.should_rotate() {        
+                // let _ = storage.rename("log/000000.log","log/000000.log");
+                let new_file = (self.new_file)(self.db_path.clone()).unwrap();
+                let mut old_file = self.inner.lock().unwrap();
+                *old_file =new_file;
+                
+                for rotator in self.rotators.iter() {
+                    rotator.on_rotate();
+                }
+                return Ok(());
+                }
+            }
+        self.inner.lock().unwrap().flush()
     }
 }
-
 impl<F:File> Drain for FileBasedDrain<F> {
     type Ok = ();
     type Err = slog::Never;
@@ -186,19 +194,17 @@ impl<F:File> Drain for FileBasedDrain<F> {
             record.msg(),
             values
         );
-      for rotator in self.rotators.iter() {
-          if rotator.should_rotate() {
-              self.flush().unwrap();
-              return Ok(());
-          }
-      }
-                
-        for rotator in self.rotators.iter() {
-            rotator.on_write(by.as_bytes()).unwrap();
+       
+
+        for rotator in self.rotators.iter() {    
+            rotator.on_write(by.as_bytes()).unwrap();    
         }
-        // Ignore errors here
-        let _ = self.inner.lock().unwrap().write(by.as_bytes());
+               
+        let _f = self.flush().unwrap();
 
+        //Ignore errors here
+        let _ = self.inner.lock().unwrap().write(by.as_bytes());
+        
         Ok(())
     }
 }
@@ -218,7 +224,7 @@ trait Rotator: Send {
 
     fn on_write(&self, buf: &[u8]) -> Result<()>;
     // Call by operator, update rotators' state while the operator execute a rotation.
-    fn on_rotate(&self) -> Result<()>;
+    fn on_rotate(&self) ;
 }
 
 struct RotatedFileBySize {
@@ -253,9 +259,8 @@ impl Rotator for RotatedFileBySize {
         Ok(())
     }
 
-    fn on_rotate(&self) -> Result<()> {
+    fn on_rotate(&self)  {
         *self.file_size.lock().unwrap() = 0;
-        Ok(())
     }
 }
 
@@ -264,21 +269,51 @@ mod tests {
 
     use super::*;
     use crate::storage::mem::MemStorage;
-
+    use crate::storage::file::FileStorage;
+    use slog::info;
+    use std::fs;
     use std::thread;
     use std::time::Duration; 
-    
+    use std::path::Path;
+
+    fn file_exists(file: impl AsRef<Path>,storage:FileStorage) -> bool {
+        storage.exists(file)
+    }
+    // #[test]
+    // fn test_default_logger() {
+    //     let s =MemStorage::default();
+    //     // let s = &'static s;
+    //     let db_path = "test";
+    //     let logger = Logger::new(None, LevelFilter::Debug, s, db_path);
+    //     // Ignore the error if the logger have been set
+    //     let _ = log::set_logger(Box::leak(Box::new(logger)));
+    //     log::set_max_level(LevelFilter::Debug);
+    //     self::info!(,"Hello World");
+    //     // Wait for the async logger print the result
+    //     thread::sleep(Duration::from_millis(100));
+    // }
+   
     #[test]
-    fn test_default_logger() {
-        let s =MemStorage::default();
-        // let s = &'static s;
-        let db_path = "test";
-        let logger = Logger::new(None, LevelFilter::Debug, s, db_path.to_string());
-        // Ignore the error if the logger have been set
-        let _ = log::set_logger(Box::leak(Box::new(logger)));
-        log::set_max_level(LevelFilter::Debug);
-        info!("Hello World");
-        // Wait for the async logger print the result
-        thread::sleep(Duration::from_millis(100));
+    fn test_rotate_by_size()  {
+        let db_path = "log";
+    
+        let storage = FileStorage::default();
+        let _= storage.mkdir_all(db_path);
+        let storage2 = storage.clone();
+        let file= create_file(&storage,db_path, 0).unwrap();
+        let new_path = generate_filename(db_path, FileType::Log, 1 );
+        
+       
+        
+        let file_fn =  move |path: String| {create_file(&storage, 
+            path.as_str(), 1)};    
+    
+        let drain =FileBasedDrain::new(file,db_path, file_fn)
+                                        .add_rotator(RotatedFileBySize::new(1));
+        let drain = slog_async::Async::new(drain).build().fuse();
+        let _log = slog::Logger::root(drain, o!());
+        self::info!(_log,"Test log file rotated by size");
+       
+        assert!(file_exists(new_path,FileStorage::default()));
     }
 }
diff --git a/src/options.rs b/src/options.rs
@@ -207,15 +207,15 @@ impl Options {
     /// Initialize Options by limiting ranges of some flags, applying customized Logger and etc.
     pub(crate) fn initialize<O: File + 'static, S:Storage<F = O>+Clone+'static>(
         &mut self,
-        db_name: String,
+        db_name: &'static str,
         storage:  &S,
     ) {
         self.max_open_files =
             Self::clip_range(self.max_open_files, 64 + self.non_table_cache_files, 50000);
         self.write_buffer_size = Self::clip_range(self.write_buffer_size, 64 << 10, 1 << 30);
         self.max_file_size = Self::clip_range(self.max_file_size, 1 << 20, 1 << 30);
         self.block_size = Self::clip_range(self.block_size, 1 << 10, 4 << 20);
-        self.apply_logger(storage, &db_name);
+        self.apply_logger(storage, db_name);
         if self.block_cache.is_none() {
             self.block_cache = Some(Arc::new(LRUCache::new(8 << 20, None)))
         }
@@ -225,9 +225,9 @@ impl Options {
     }
 
     #[allow(unused_must_use)]
-    fn apply_logger<S: 'static+Storage+Clone>(&mut self, storage: &S, db_path: &str) {
+    fn apply_logger<S: 'static+Storage+Clone>(&mut self, storage: &S, db_path: &'static str) {
         let user_logger = std::mem::replace(&mut self.logger, None);
-        let logger = Logger::new(user_logger, self.logger_level, storage.clone(), db_path.to_string());
+        let logger = Logger::new(user_logger, self.logger_level, storage.clone(), db_path);
         let static_logger: &'static dyn Log = Box::leak(Box::new(logger));
         log::set_logger(static_logger);
         log::set_max_level(self.logger_level);
