set permission for kvs file

- set permission for kvs file

Fixes #99

Author: Ahmed-Elsaka-JC

.vscode/settings.json

@@ -0,0 +1,5 @@
+{
+    "files.associations": {
+        "*.rst": "cpp"
+    }
+}

src/cpp/src/kvs.cpp

@@ -38,6 +38,7 @@ Kvs::Kvs()
     , parser(std::make_unique<score::json::JsonParser>())
     , writer(std::make_unique<score::json::JsonWriter>())
     , logger(std::make_unique<score::mw::log::Logger>("SKVS"))
+    , storage_mode_(score::os::Stat::Mode::kReadUser|score::os::Stat::Mode::kWriteUser|score::os::Stat::Mode::kReadGroup|score::os::Stat::Mode::kReadOthers) /* Default storage mode */
 {
 }
 
@@ -48,6 +49,7 @@ Kvs::Kvs(Kvs&& other) noexcept
     , parser(std::move(other.parser)) /* Not absolutely necessary, because a new JSON writer/parser object would also be okay*/
     , writer(std::move(other.writer))
     , logger(std::move(other.logger))
+    , storage_mode_(other.storage_mode_)
 {
     {
         std::lock_guard<std::mutex> lock(other.kvs_mutex);
@@ -88,6 +90,7 @@ Kvs& Kvs::operator=(Kvs&& other) noexcept
         parser = std::move(other.parser);
         writer = std::move(other.writer);
         logger = std::move(other.logger);
+        storage_mode_ = other.storage_mode_;
     }
     return *this;
 }
@@ -194,7 +197,7 @@ score::Result<std::unordered_map<string, KvsValue>> Kvs::open_json(const score::
 }
 
 /* Open KVS Instance */
-score::Result<Kvs> Kvs::open(const InstanceId& instance_id, OpenNeedDefaults need_defaults, OpenNeedKvs need_kvs, const std::string&& dir)
+score::Result<Kvs> Kvs::open(const InstanceId& instance_id, OpenNeedDefaults need_defaults, OpenNeedKvs need_kvs, const std::string&& dir, score::os::Stat::Mode storage_mode)
 {
     score::Result<Kvs> result = score::MakeUnexpected(ErrorCode::UnmappedError); /* Redundant initialization needed, since Resul<KVS> would call the implicitly-deleted default constructor of KVS */
 
@@ -221,6 +224,7 @@ score::Result<Kvs> Kvs::open(const InstanceId& instance_id, OpenNeedDefaults nee
             kvs.default_values = std::move(default_res.value());
             kvs.filename_prefix = filename_prefix;
             kvs.flush_on_exit.store(true, std::memory_order_relaxed);
+            kvs.storage_mode_ = storage_mode;
             kvs.logger->LogInfo() << "opened KVS: instance '" << instance_id.id << "'";
             kvs.logger->LogInfo() << "max snapshot count: " << KVS_MAX_SNAPSHOTS;
             result = std::move(kvs);
@@ -397,6 +401,33 @@ score::ResultBlank Kvs::remove_key(const std::string_view key) {
     return result;
 }
 
+score::Result<bool> Kvs::create_file_if_not_exist(const std::string& path)
+{
+    score::Result<bool> result = score::MakeUnexpected(ErrorCode::UnmappedError);
+    std::unique_lock<std::mutex> lock(kvs_mutex, std::try_to_lock);
+    if (lock.owns_lock()) {
+        auto isFileExist = filesystem->standard->Exists(path);
+        if (!isFileExist.value()) {
+            std::ofstream out(path, std::ios::binary);
+            if (out) {
+                out.close();
+                filesystem->standard->Permissions(path, this->storage_mode_);
+                result = true;
+            } else {
+                logger->LogError() << "Failed to create file '" << path << "'";
+                result = score::MakeUnexpected(ErrorCode::PhysicalStorageFailure);
+            }
+        } else {
+            logger->LogInfo() << "File '" << path << "' already exists. Skipping creation.";
+            result = false;
+        }
+    } else {
+        result = score::MakeUnexpected(ErrorCode::MutexLockFailed);
+    }
+    return result;
+}
+
+
 /* Helper Function to write JSON data to a file for flush process (also adds Hash file)*/
 score::ResultBlank Kvs::write_json_data(const std::string& buf)
 {
@@ -408,13 +439,32 @@ score::ResultBlank Kvs::write_json_data(const std::string& buf)
         if(!create_path_res.has_value()) {
             result = score::MakeUnexpected(ErrorCode::PhysicalStorageFailure);
         } else {
+            auto create_file_res = create_file_if_not_exist(json_path.Native());
+            if (!create_file_res) {
+                logger->LogError() << "Failed to create KVS file '" << json_path << "'";
+                result = score::MakeUnexpected(static_cast<ErrorCode>(*create_file_res.error()));
+            } else {
+                if (create_file_res.value()) {
+                    logger->LogInfo() << "Created new KVS file '" << json_path << "'";
+                }
+            }
             std::ofstream out(json_path.CStr(), std::ios::binary);
             if (!out.write(buf.data(), buf.size())) {
                 result = score::MakeUnexpected(ErrorCode::PhysicalStorageFailure);
             } else {
                 /* Write Hash File */
                 std::array<uint8_t, 4> hash_bytes = get_hash_bytes(buf);
                 score::filesystem::Path fn_hash = filename_prefix.Native() + "_0.hash";
+                auto create_hash_file_res = create_file_if_not_exist(fn_hash.Native());
+                if(!create_hash_file_res) {
+                    logger->LogError() << "Failed to create KVS hash file '" << fn_hash << "'";
+                    result = score::MakeUnexpected(static_cast<ErrorCode>(*create_hash_file_res.error()));
+                }
+                else {
+                    if (create_hash_file_res.value()) {
+                        logger->LogInfo() << "Created new KVS hash file '" << fn_hash << "'";
+                    }
+                }
                 std::ofstream hout(fn_hash.CStr(), std::ios::binary);
                 if (!hout.write(reinterpret_cast<const char*>(hash_bytes.data()), hash_bytes.size())) {
                     result = score::MakeUnexpected(ErrorCode::PhysicalStorageFailure);

src/cpp/src/kvs.hpp

@@ -157,7 +157,7 @@ class Kvs final {
          * IMPORTANT: Instead of using the Kvs::open method directly, it is recommended to use the KvsBuilder class.
          *
          */
-        static score::Result<Kvs> open(const InstanceId& instance_id, OpenNeedDefaults need_defaults, OpenNeedKvs need_kvs, const std::string&& dir);
+        static score::Result<Kvs> open(const InstanceId& instance_id, OpenNeedDefaults need_defaults, OpenNeedKvs need_kvs, const std::string&& dir, score::os::Stat::Mode storage_mode);
 
         /**
          * @brief Sets whether the key-value store should flush its contents to
@@ -383,12 +383,14 @@ class Kvs final {
 
         /* Logging */
         std::unique_ptr<score::mw::log::Logger> logger;
+        score::os::Stat::Mode storage_mode_;
 
         /* Private Methods */
         score::ResultBlank snapshot_rotate();
         score::Result<std::unordered_map<std::string, KvsValue>> parse_json_data(const std::string& data);
         score::Result<std::unordered_map<std::string, KvsValue>> open_json(const score::filesystem::Path& prefix, OpenJsonNeedFile need_file);
         score::ResultBlank write_json_data(const std::string& buf);
+        score::Result<bool> create_file_if_not_exist(const std::string& path);
 
 };
 

src/cpp/src/kvsbuilder.cpp

@@ -20,6 +20,7 @@ KvsBuilder::KvsBuilder(const InstanceId& instance_id)
     , need_defaults(false)
     , need_kvs(false)
     , directory("./data_folder/") /* Default Directory */
+    , storage_mode_(score::os::Stat::Mode::kReadUser|score::os::Stat::Mode::kWriteUser|score::os::Stat::Mode::kReadGroup|score::os::Stat::Mode::kReadOthers) /* Default storage mode */
 {}
 
 KvsBuilder& KvsBuilder::need_defaults_flag(bool flag) {
@@ -37,6 +38,10 @@ KvsBuilder& KvsBuilder::dir(std::string&& dir_path) {
     return *this;
 }
 
+KvsBuilder& KvsBuilder::storage_mode(score::os::Stat::Mode mode) {
+    storage_mode_ = mode;
+    return *this;
+}
 
 score::Result<Kvs> KvsBuilder::build() {
     score::Result<Kvs> result = score::MakeUnexpected(ErrorCode::UnmappedError);
@@ -50,7 +55,8 @@ score::Result<Kvs> KvsBuilder::build() {
         instance_id,
         need_defaults ? OpenNeedDefaults::Required : OpenNeedDefaults::Optional,
         need_kvs      ? OpenNeedKvs::Required      : OpenNeedKvs::Optional,
-        std::move(directory)
+        std::move(directory),
+        storage_mode_
     );
 
     return result;

src/cpp/src/kvsbuilder.hpp

@@ -87,6 +87,13 @@ class KvsBuilder final {
      */
     KvsBuilder& dir(std::string&& dir_path);
 
+    /**
+     * @brief Specify the storage mode for the KVS files.
+     * @param mode The storage mode to use (storage file permissions).
+     * @return Reference to this builder (for chaining).
+     */
+    KvsBuilder& storage_mode(score::os::Stat::Mode mode);
+
     /**
      * @brief Builds and opens the Kvs instance with the configured options.
      *
@@ -101,6 +108,7 @@ class KvsBuilder final {
     bool                               need_defaults; ///< Whether default values are required
     bool                               need_kvs;      ///< Whether an existing KVS is required
     std::string                        directory;     ///< Directory where to store the KVS Files
+    score::os::Stat::Mode              storage_mode_; ///< Storage mode for the KVS files
 };
 
 } /* namespace score::mw::per::kvs */