create info log (#30)

librocksdb_sys/crocksdb/c.cc

@@ -2768,4 +2768,23 @@ void crocksdb_delete_file_in_range_cf(
 
 void crocksdb_free(void* ptr) { free(ptr); }
 
+crocksdb_logger_t* crocksdb_create_log_from_options(
+    const char* path, crocksdb_options_t* opts, char** errptr) {
+    crocksdb_logger_t* logger = new crocksdb_logger_t;
+    if(SaveError(
+      errptr,
+      CreateLoggerFromOptions(
+        std::string(path), opts->rep, &logger->rep))) {
+      delete logger;
+      return NULL;
+    }
+
+    return logger;
+}
+
+void crocksdb_log_destroy(
+    crocksdb_logger_t* logger) {
+    delete logger;
+}
+
 }  // end extern "C"

librocksdb_sys/crocksdb/rocksdb/c.h

@@ -1115,6 +1115,10 @@ extern C_ROCKSDB_LIBRARY_API void crocksdb_delete_file_in_range_cf(
 // to free memory that was malloc()ed
 extern C_ROCKSDB_LIBRARY_API void crocksdb_free(void* ptr);
 
+extern C_ROCKSDB_LIBRARY_API crocksdb_logger_t* crocksdb_create_log_from_options(
+    const char* path, crocksdb_options_t* opts, char** errptr);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_log_destroy(
+    crocksdb_logger_t*);
 #ifdef __cplusplus
 }  /* end extern "C" */
 #endif

librocksdb_sys/src/lib.rs

@@ -42,6 +42,7 @@ pub enum DBBackupEngine {}
 pub enum DBRestoreOptions {}
 pub enum DBSliceTransform {}
 pub enum DBRateLimiter {}
+pub enum DBLogger {}
 
 pub fn new_bloom_filter(bits: c_int) -> *mut DBFilterPolicy {
     unsafe { crocksdb_filterpolicy_create_bloom(bits) }
@@ -272,6 +273,7 @@ extern "C" {
     pub fn crocksdb_options_set_memtable_prefix_bloom_size_ratio(options: *mut DBOptions,
                                                                  ratio: c_double);
     pub fn crocksdb_options_set_ratelimiter(options: *mut DBOptions, limiter: *mut DBRateLimiter);
+    pub fn crocksdb_options_set_info_log(options: *mut DBOptions, logger: *mut DBLogger);
     pub fn crocksdb_ratelimiter_create(rate_bytes_per_sec: i64,
                                        refill_period_us: i64,
                                        fairness: i32)
@@ -702,6 +704,11 @@ extern "C" {
                                           name: extern "C" fn(*mut c_void) -> *const c_char)
                                           -> *mut DBSliceTransform;
     pub fn crocksdb_slicetransform_destroy(transform: *mut DBSliceTransform);
+    pub fn crocksdb_create_log_from_options(path: *const c_char,
+                                            options: *mut DBOptions,
+                                            err: *mut *mut c_char)
+                                            -> *mut DBLogger;
+    pub fn crocksdb_log_destroy(logger: *mut DBLogger);
 }
 
 #[cfg(test)]

src/rocksdb_options.rs

@@ -731,6 +731,27 @@ impl Options {
             crocksdb_ffi::crocksdb_options_set_ratelimiter(self.inner, rate_limiter.inner);
         }
     }
+
+    // Create a info log with `path` and save to options logger field directly.
+    // TODO: export more logger options like level, roll size, time, etc...
+    pub fn create_info_log(&self, path: &str) -> Result<(), String> {
+        let cpath = match CString::new(path.as_bytes()) {
+            Ok(c) => c,
+            Err(_) => {
+                return Err("Failed to convert path to CString when creating rocksdb info log"
+                    .to_owned())
+            }
+        };
+
+        unsafe {
+            let logger = ffi_try!(crocksdb_create_log_from_options(cpath.as_ptr(), self.inner));
+            crocksdb_ffi::crocksdb_options_set_info_log(self.inner, logger);
+            // logger uses shared_ptr, it is OK to destroy here.
+            crocksdb_ffi::crocksdb_log_destroy(logger);
+        }
+
+        Ok(())
+    }
 }
 
 pub struct FlushOptions {

tests/test_rocksdb_options.rs

@@ -14,6 +14,7 @@
 use rocksdb::{DB, Options, WriteOptions, SliceTransform};
 use rocksdb::crocksdb_ffi::{DBStatisticsHistogramType as HistogramType,
                             DBStatisticsTickerType as TickerType};
+use std::path::Path;
 use tempdir::TempDir;
 
 
@@ -132,3 +133,17 @@ fn test_set_wal_opt() {
     drop(db);
 }
 
+#[test]
+fn test_create_info_log() {
+    let path = TempDir::new("_rust_rocksdb_test_create_info_log_opt").expect("");
+    let mut opts = Options::new();
+    opts.create_if_missing(true);
+
+    let info_dir = TempDir::new("_rust_rocksdb_test_info_log_dir").expect("");
+    opts.create_info_log(info_dir.path().to_str().unwrap()).unwrap();
+    let db = DB::open(opts, path.path().to_str().unwrap()).unwrap();
+
+    assert!(Path::new(info_dir.path().join("LOG").to_str().unwrap()).is_file());
+
+    drop(db);
+}