Add Read only Mode, does not allow inserts

Author: movitto

examples/example.cpp

@@ -27,7 +27,7 @@ int main()
         0.5f,
         ec);
     store db;
-    db.open(dat_path, key_path, log_path, ec);
+    db.open(dat_path, key_path, log_path, store::open_mode::read_write, ec);
     char data = 0;
     // Insert
     for(key_type i = 0; i < N; ++i)

include/nudb/_experimental/test/test_store.hpp

@@ -286,7 +286,7 @@ basic_test_store<File>::basic_test_store(
         , openf_(
             [this, args...](error_code& ec)
             {
-                db.open(dp, kp, lp, ec, args...);
+                db.open(dp, kp, lp, basic_store<Hasher, File>::open_mode::read_write, ec, args...);
             })
         , dirp(td_.path())
         , dp(td_.file("nudb.dat"))

include/nudb/basic_store.hpp

@@ -52,6 +52,14 @@ class basic_store
     using hash_type = Hasher;
     using file_type = File;
 
+    enum class open_mode {
+      /// Open the database for both read and write access
+      read_write,
+
+      /// Open the database for reach access only
+      read
+    };
+
 private:
     using clock_type =
         std::chrono::steady_clock;
@@ -90,9 +98,14 @@ class basic_store
             path_type const& dp_, path_type const& kp_,
                 path_type const& lp_,
                     detail::key_file_header const& kh_);
+
+        state(File&& df_, File&& kf_,
+            path_type const& dp_, path_type const& kp_,
+                detail::key_file_header const& kh_);
     };
 
     bool open_ = false;
+    bool is_writable_;
 
     // Use optional because some
     // members cannot be default-constructed.
@@ -173,6 +186,19 @@ class basic_store
         return open_;
     }
 
+    /** Returns `true` if the database is writable
+
+        @par Thread safety
+
+        Safe to call concurrently with any function
+        except @ref open.
+    */
+    bool
+    is_writable() const
+    {
+        return is_writable_;
+    }
+
     /** Return the path to the data file.
 
         @par Requirements
@@ -329,6 +355,8 @@ class basic_store
 
         @param log_path The path to the log file.
 
+        @param open_mode Mode of database access
+
         @param ec Set to the error, if any occurred.
 
         @param args Optional arguments passed to @b File constructors.
@@ -340,6 +368,7 @@ class basic_store
         path_type const& dat_path,
         path_type const& key_path,
         path_type const& log_path,
+        open_mode mode,
         error_code& ec,
         Args&&... args);
 

include/nudb/impl/basic_store.ipp

@@ -46,6 +46,25 @@ state(File&& df_, File&& kf_, File&& lf_,
         "File requirements not met");
 }
 
+template<class Hasher, class File>
+basic_store<Hasher, File>::state::
+state(File&& df_, File&& kf_,
+    path_type const& dp_, path_type const& kp_,
+        detail::key_file_header const& kh_)
+    : df(std::move(df_))
+    , kf(std::move(kf_))
+    , dp(dp_)
+    , kp(kp_)
+    , hasher(kh_.salt)
+    , p0(kh_.key_size, "p0")
+    , p1(kh_.key_size, "p1")
+    , c1(kh_.key_size, kh_.block_size, "c1")
+    , kh(kh_)
+{
+    BOOST_STATIC_ASSERT_MSG(is_File<File>::value,
+        "File requirements not met");
+}
+
 //------------------------------------------------------------------------------
 
 template<class Hasher, class File>
@@ -122,9 +141,12 @@ open(
     path_type const& dat_path,
     path_type const& key_path,
     path_type const& log_path,
+    open_mode mode,
     error_code& ec,
     Args&&... args)
 {
+    bool writable = mode == open_mode::read_write;
+
     static_assert(is_Hasher<Hasher>::value,
         "Hasher requirements not met");
     using namespace detail;
@@ -138,17 +160,23 @@ open(
     File df(args...);
     File kf(args...);
     File lf(args...);
-    df.open(file_mode::append, dat_path, ec);
-    if(ec)
-        return;
-    kf.open(file_mode::write, key_path, ec);
+    df.open(writable ? file_mode::append : file_mode::read,
+        dat_path, ec);
     if(ec)
         return;
-    lf.create(file_mode::append, log_path, ec);
+    kf.open(writable ? file_mode::write : file_mode::read,
+        key_path, ec);
     if(ec)
         return;
-    // VFALCO TODO Erase empty log file if this
-    //             function subsequently fails.
+
+    if(writable){
+        lf.create(file_mode::append, log_path, ec);
+        if(ec)
+            return;
+        // VFALCO TODO Erase empty log file if this
+        //             function subsequently fails.
+    }
+
     dat_file_header dh;
     read(df, dh, ec);
     if(ec)
@@ -167,8 +195,12 @@ open(
     if(ec)
         return;
     boost::optional<state> s;
-    s.emplace(std::move(df), std::move(kf), std::move(lf),
-        dat_path, key_path, log_path, kh);
+    if(writable)
+        s.emplace(std::move(df), std::move(kf), std::move(lf),
+            dat_path, key_path, log_path, kh);
+    else
+        s.emplace(std::move(df), std::move(kf),
+            dat_path, key_path, kh);
     thresh_ = std::max<std::size_t>(65536UL,
         kh.load_factor * kh.capacity);
     frac_ = thresh_ / 2;
@@ -180,10 +212,13 @@ open(
         ec = error::short_key_file;
         return;
     }
-    dataWriteSize_ = 32 * nudb::block_size(dat_path);
-    logWriteSize_ = 32 * nudb::block_size(log_path);
+    if(writable){
+        dataWriteSize_ = 32 * nudb::block_size(dat_path);
+        logWriteSize_ = 32 * nudb::block_size(log_path);
+    }
     s_.emplace(std::move(*s));
     open_ = true;
+    is_writable_ = writable;
     ctx_->insert(*this);
 }
 

test/recover.cpp

@@ -60,7 +60,9 @@ class basic_recover_test : public boost::beast::unit_test::suite
         if(ec)
             return;
         basic_store<xxhasher, fail_file<native_file>> db;
-        db.open(ts.dp, ts.kp, ts.lp, ec, c);
+        db.open(ts.dp, ts.kp, ts.lp,
+            basic_store<xxhasher, fail_file<native_file>>::open_mode::read_write,
+            ec, c);
         if(ec)
             return;
         if(! BEAST_EXPECT(db.appnum() == ts.appnum))