From ba5f6a62c86162cd90be0c5ed8650e298d161ed0 Mon Sep 17 00:00:00 2001 From: "Scott E. Graves" Date: Wed, 18 Dec 2024 20:21:18 -0600 Subject: [PATCH] refactor app config --- repertory/librepertory/include/app_config.hpp | 193 +++++++++------ repertory/librepertory/src/app_config.cpp | 229 +++++++++++------- 2 files changed, 251 insertions(+), 171 deletions(-) diff --git a/repertory/librepertory/include/app_config.hpp b/repertory/librepertory/include/app_config.hpp index d39d7f03..a3c3f8ec 100644 --- a/repertory/librepertory/include/app_config.hpp +++ b/repertory/librepertory/include/app_config.hpp @@ -88,26 +88,26 @@ using atomic_string = atomic; class app_config final { public: - [[nodiscard]] static auto default_agent_name(const provider_type &prov) - -> std::string; + [[nodiscard]] static auto + default_agent_name(const provider_type &prov) -> std::string; - [[nodiscard]] static auto default_api_port(const provider_type &prov) - -> std::uint16_t; + [[nodiscard]] static auto + default_api_port(const provider_type &prov) -> std::uint16_t; - [[nodiscard]] static auto default_data_directory(const provider_type &prov) - -> std::string; + [[nodiscard]] static auto + default_data_directory(const provider_type &prov) -> std::string; - [[nodiscard]] static auto default_remote_port(const provider_type &prov) - -> std::uint16_t; + [[nodiscard]] static auto + default_remote_port(const provider_type &prov) -> std::uint16_t; - [[nodiscard]] static auto default_rpc_port(const provider_type &prov) - -> std::uint16_t; + [[nodiscard]] static auto + default_rpc_port(const provider_type &prov) -> std::uint16_t; - [[nodiscard]] static auto get_provider_display_name(const provider_type &prov) - -> std::string; + [[nodiscard]] static auto + get_provider_display_name(const provider_type &prov) -> std::string; - [[nodiscard]] static auto get_provider_name(const provider_type &prov) - -> std::string; + [[nodiscard]] static auto + get_provider_name(const provider_type &prov) -> std::string; public: app_config(const provider_type &prov, std::string_view data_directory = ""); @@ -115,12 +115,12 @@ public: ~app_config() { save(); } private: - std::atomic prov_; + provider_type prov_; atomic_string api_auth_; std::atomic api_port_; atomic_string api_user_; std::atomic config_changed_; - std::atomic db_type_{database_type::rocksdb}; + database_type db_type_{database_type::rocksdb}; std::atomic download_timeout_secs_; std::atomic enable_chunk_downloader_timeout_; std::atomic enable_comm_duration_events_; @@ -131,55 +131,55 @@ private: #endif // defined(_WIN32) std::atomic enable_remote_mount_; std::atomic event_level_; - std::atomic eviction_delay_mins_; + std::uint32_t eviction_delay_mins_; std::atomic eviction_uses_accessed_time_; - std::atomic high_freq_interval_secs_; + std::uint16_t high_freq_interval_secs_; std::atomic is_remote_mount_; - std::atomic low_freq_interval_secs_; - std::atomic max_cache_size_bytes_; + std::uint16_t low_freq_interval_secs_; + std::uint64_t max_cache_size_bytes_; std::atomic max_upload_count_; - std::atomic med_freq_interval_secs_; + std::uint16_t med_freq_interval_secs_; std::atomic min_download_timeout_secs_; - std::atomic online_check_retry_secs_; - std::atomic orphaned_file_retention_days_; + std::uint16_t online_check_retry_secs_; + std::uint16_t orphaned_file_retention_days_; atomic_string preferred_download_type_; std::atomic read_ahead_count_; std::atomic remote_client_pool_size_; atomic_string remote_host_name_or_ip_; std::atomic remote_max_connections_; - std::atomic remote_port_; - std::atomic remote_receive_timeout_secs_; - std::atomic remote_send_timeout_secs_; + std::uint16_t remote_port_; + std::uint16_t remote_receive_timeout_secs_; + std::uint16_t remote_send_timeout_secs_; atomic_string remote_token_; - std::atomic retry_read_count_; - std::atomic ring_buffer_file_size_; - std::atomic task_wait_ms_; + std::uint16_t retry_read_count_; + std::uint16_t ring_buffer_file_size_; + std::uint16_t task_wait_ms_; private: - atomic_string cache_directory_; - atomic_string data_directory_; - atomic encrypt_config_; - atomic hc_; - atomic s3_config_; - atomic sia_config_; - std::uint64_t version_{REPERTORY_CONFIG_VERSION}; - atomic_string log_directory_; + std::string cache_directory_; + std::string data_directory_; + encrypt_config encrypt_config_; + host_config hc_{}; + std::string log_directory_; mutable std::recursive_mutex read_write_mutex_; + s3_config s3_config_{}; + sia_config sia_config_{}; + std::uint64_t version_{REPERTORY_CONFIG_VERSION}; + mutable std::recursive_mutex remote_mount_mutex_; private: auto get_database_value(const json &json_document, const std::string &name, - std::atomic &dst, bool &success_flag) - -> bool; + database_type &dst, bool &success_flag) -> bool; - template - auto get_value(const json &json_document, const std::string &name, - dest_t &dst, bool &success_flag) -> bool { + template + auto get_value(const json &json_document, const std::string &name, dest &dst, + bool &success_flag) -> bool { REPERTORY_USES_FUNCTION_NAME(); auto ret{false}; try { if (json_document.find(name) != json_document.end()) { - dst = json_document[name].get(); + json_document.at(name).get_to(dst); ret = true; } else { success_flag = false; @@ -195,8 +195,8 @@ private: [[nodiscard]] auto load() -> bool; - template - auto set_value(dst_t &dst, const src_t &src) -> bool { + template + auto set_value(dest &dst, const source &src) -> bool { auto ret{false}; recur_mutex_lock lock(read_write_mutex_); if (dst != src) { @@ -277,8 +277,7 @@ public: } [[nodiscard]] auto get_high_frequency_interval_secs() const -> std::uint16_t { - return std::max(static_cast(1U), - static_cast(high_freq_interval_secs_)); + return std::max(static_cast(1U), high_freq_interval_secs_); } [[nodiscard]] auto get_host_config() const -> host_config { return hc_; } @@ -294,32 +293,27 @@ public: } [[nodiscard]] auto get_low_frequency_interval_secs() const -> std::uint16_t { - return std::max(static_cast(1U), - static_cast(low_freq_interval_secs_)); + return std::max(static_cast(1U), low_freq_interval_secs_); } [[nodiscard]] auto get_max_cache_size_bytes() const -> std::uint64_t; [[nodiscard]] auto get_max_upload_count() const -> std::uint8_t { - return std::max(std::uint8_t(1U), - static_cast(max_upload_count_)); + return std::max(std::uint8_t(1U), max_upload_count_.load()); } [[nodiscard]] auto get_med_frequency_interval_secs() const -> std::uint16_t { - return std::max(static_cast(1U), - static_cast(med_freq_interval_secs_)); + return std::max(static_cast(1U), med_freq_interval_secs_); } [[nodiscard]] auto get_online_check_retry_secs() const -> std::uint16_t { - return std::max(std::uint16_t(15U), - static_cast(online_check_retry_secs_)); + return std::max(std::uint16_t(15U), online_check_retry_secs_); } [[nodiscard]] auto get_orphaned_file_retention_days() const -> std::uint16_t { - return std::min( - static_cast(31U), - std::max(static_cast(1U), - static_cast(orphaned_file_retention_days_))); + return std::min(static_cast(31U), + std::max(static_cast(1U), + orphaned_file_retention_days_)); } [[nodiscard]] auto get_preferred_download_type() const -> download_type { @@ -332,13 +326,12 @@ public: } [[nodiscard]] auto get_read_ahead_count() const -> std::uint8_t { - return std::max(static_cast(1U), - static_cast(read_ahead_count_)); + return std::max(static_cast(1U), read_ahead_count_.load()); } [[nodiscard]] auto get_remote_client_pool_size() const -> std::uint8_t { return std::max(static_cast(5U), - static_cast(remote_client_pool_size_)); + remote_client_pool_size_.load()); } [[nodiscard]] auto get_remote_host_name_or_ip() const -> std::string { @@ -347,7 +340,7 @@ public: [[nodiscard]] auto get_remote_max_connections() const -> std::uint8_t { return std::max(static_cast(1U), - static_cast(remote_max_connections_)); + remote_max_connections_.load()); } [[nodiscard]] auto get_remote_port() const -> std::uint16_t { @@ -367,15 +360,13 @@ public: } [[nodiscard]] auto get_retry_read_count() const -> std::uint16_t { - return std::max(std::uint16_t(2), - static_cast(retry_read_count_)); + return std::max(std::uint16_t(2), retry_read_count_); } [[nodiscard]] auto get_ring_buffer_file_size() const -> std::uint16_t { return std::max( static_cast(64U), - std::min(static_cast(1024U), - static_cast(ring_buffer_file_size_))); + std::min(static_cast(1024U), ring_buffer_file_size_)); } [[nodiscard]] auto get_s3_config() const -> s3_config { return s3_config_; } @@ -385,8 +376,7 @@ public: } [[nodiscard]] auto get_task_wait_ms() const -> std::uint16_t { - return std::max(static_cast(50U), - static_cast(task_wait_ms_)); + return std::max(static_cast(50U), task_wait_ms_); } [[nodiscard]] auto get_value_by_name(const std::string &name) -> std::string; @@ -440,8 +430,6 @@ public: void set_enable_remote_mount(bool enable_remote_mount); - void set_encrypt_config(encrypt_config cfg); - void set_event_level(const event_level &level) { if (set_value(event_level_, level)) { event_system::instance().raise( @@ -462,7 +450,25 @@ public: set_value(high_freq_interval_secs_, high_frequency_interval_secs); } - void set_host_config(host_config cfg); +#if defined(PROJECT_TESTING) + void set_host_config(host_config hc) { + config_changed_ = true; + hc_ = std::move(hc); + save(); + } + + void set_s3_config(s3_config s3) { + config_changed_ = true; + s3_config_ = std::move(s3); + save(); + } + + void set_sia_config(sia_config sia) { + config_changed_ = true; + sia_config_ = std::move(sia); + save(); + } +#endif // defined(PROJECT_TESTING) void set_is_remote_mount(bool is_remote_mount); @@ -493,8 +499,8 @@ public: set_value(orphaned_file_retention_days_, orphaned_file_retention_days); } - void set_preferred_download_type(const download_type &type) { - set_value(preferred_download_type_, download_type_to_string(type)); + void set_preferred_download_type(const download_type &dt) { + set_value(preferred_download_type_, download_type_to_string(dt)); } void set_read_ahead_count(std::uint8_t read_ahead_count) { @@ -538,10 +544,6 @@ public: set_value(retry_read_count_, retry_read_count); } - void set_s3_config(s3_config cfg); - - void set_sia_config(sia_config cfg); - void set_task_wait_ms(std::uint16_t task_wait_ms) { set_value(task_wait_ms_, task_wait_ms); } @@ -551,4 +553,39 @@ public: }; } // namespace repertory +NLOHMANN_JSON_NAMESPACE_BEGIN +template <> struct adl_serializer { + static void to_json(json &data, const repertory::atomic_string &value) { + data = static_cast(value); + } + + static void from_json(const json &data, repertory::atomic_string &value) { + value = data.get(); + } +}; + +template +struct adl_serializer> { + static void to_json(json &data, const std::atomic &value) { + data = value.load(); + } + + static void from_json(const json &data, std::atomic &value) { + value.store(data.get()); + } +}; + +template <> struct adl_serializer> { + static void to_json(json &data, + const std::atomic &value) { + data = repertory::event_level_to_string(value.load()); + } + + static void from_json(const json &data, + std::atomic &value) { + value.store(repertory::event_level_from_string(data.get())); + } +}; +NLOHMANN_JSON_NAMESPACE_END + #endif // REPERTORY_INCLUDE_APP_CONFIG_HPP_ diff --git a/repertory/librepertory/src/app_config.cpp b/repertory/librepertory/src/app_config.cpp index 72872249..2847ec60 100644 --- a/repertory/librepertory/src/app_config.cpp +++ b/repertory/librepertory/src/app_config.cpp @@ -30,30 +30,29 @@ #include "utils/utils.hpp" namespace { -constexpr const auto default_api_auth_size{48U}; -constexpr const auto default_download_timeout_ces{30U}; -constexpr const auto default_eviction_delay_mins{10U}; -constexpr const auto default_high_freq_interval_secs{30U}; -constexpr const auto default_low_freq_interval_secs{60U * 60U}; -constexpr const std::uint64_t default_max_cache_size_bytes = { - 20ULL * 1024ULL * 1024ULL * 1024ULL, -}; -constexpr const auto default_max_upload_count{5U}; -constexpr const auto default_med_freq_interval_secs{2U * 60U}; -constexpr const auto default_min_download_timeout_secs{5U}; -constexpr const auto default_online_check_retry_secs{60U}; -constexpr const auto default_orphaned_file_retention_days{15U}; -constexpr const auto default_read_ahead_count{4U}; -constexpr const auto default_remote_client_pool_size{10U}; -constexpr const auto default_remote_host_name_or_ip{""}; -constexpr const auto default_remote_max_connections{20U}; -constexpr const auto default_remote_receive_timeout_secs{120U}; -constexpr const auto default_remote_send_timeout_secs{30U}; -constexpr const auto default_remote_token{""}; -constexpr const auto default_retry_read_count{6U}; -constexpr const auto default_ring_buffer_file_size{512U}; -constexpr const auto default_task_wait_ms{100U}; -constexpr const auto retry_save_count{5U}; +constexpr const auto default_api_auth_size = 48U; +constexpr const auto default_download_timeout_ces = 30U; +constexpr const auto default_eviction_delay_mins = 10U; +constexpr const auto default_high_freq_interval_secs = 30U; +constexpr const auto default_low_freq_interval_secs = 60U * 60U; +constexpr const auto default_max_cache_size_bytes = + 20ULL * 1024ULL * 1024ULL * 1024ULL; +constexpr const auto default_max_upload_count = 5U; +constexpr const auto default_med_freq_interval_secs = 2U * 60U; +constexpr const auto default_min_download_timeout_secs = 5U; +constexpr const auto default_online_check_retry_secs = 60U; +constexpr const auto default_orphaned_file_retention_days = 15U; +constexpr const auto default_read_ahead_count = 4U; +constexpr const auto default_remote_client_pool_size = 10U; +constexpr const auto default_remote_host_name_or_ip = ""; +constexpr const auto default_remote_max_connections = 20U; +constexpr const auto default_remote_receive_timeout_secs = 120U; +constexpr const auto default_remote_send_timeout_secs = 30U; +constexpr const auto default_remote_token = ""; +constexpr const auto default_retry_read_count = 6U; +constexpr const auto default_ring_buffer_file_size = 512U; +constexpr const auto default_task_wait_ms = 100U; +constexpr const auto retry_save_count = 5U; } // namespace namespace repertory { @@ -104,10 +103,8 @@ app_config::app_config(const provider_type &prov, cache_directory_ = utils::path::combine(data_directory_, {"cache"}); log_directory_ = utils::path::combine(data_directory_, {"logs"}); - host_config host_cfg{hc_}; - host_cfg.agent_string = default_agent_name(prov_); - host_cfg.api_port = default_api_port(prov_); - hc_ = host_cfg; + hc_.agent_string = default_agent_name(prov_); + hc_.api_port = default_api_port(prov_); if (not utils::file::directory(data_directory_).create_directory()) { throw startup_exception("unable to create: " + data_directory_); @@ -131,8 +128,7 @@ auto app_config::get_config_file_path() const -> std::string { } auto app_config::get_database_value(const json &json_document, - const std::string &name, - std::atomic &dst, + const std::string &name, database_type &dst, bool &success_flag) -> bool { REPERTORY_USES_FUNCTION_NAME(); @@ -247,12 +243,23 @@ auto app_config::get_json() const -> json { {"EnableMountManager", enable_mount_manager_}, #endif // defined(_WIN32) {"EnableMaxCacheSize", enable_max_cache_size_}, - {"EncryptConfig", get_encrypt_config()}, + {"EncryptConfig", + { + {"EncryptionToken", encrypt_config_.encryption_token}, + {"Path", encrypt_config_.path}, + }}, {"EventLevel", event_level_to_string(event_level_)}, {"EvictionDelayMinutes", eviction_delay_mins_}, {"EvictionUsesAccessedTime", eviction_uses_accessed_time_}, {"HighFreqIntervalSeconds", high_freq_interval_secs_}, - {"HostConfig", get_host_config()}, + {"HostConfig", + { + {"AgentString", hc_.agent_string}, + {"ApiPassword", hc_.api_password}, + {"ApiPort", hc_.api_port}, + {"HostNameOrIp", hc_.host_name_or_ip}, + {"TimeoutMs", hc_.timeout_ms}, + }}, {"LowFreqIntervalSeconds", low_freq_interval_secs_}, {"MaxCacheSizeBytes", max_cache_size_bytes_}, {"MaxUploadCount", max_upload_count_}, @@ -277,8 +284,22 @@ auto app_config::get_json() const -> json { }, {"RetryReadCount", retry_read_count_}, {"RingBufferFileSize", ring_buffer_file_size_}, - {"S3Config", get_s3_config()}, - {"SiaConfig", get_sia_config()}, + {"S3Config", + { + {"AccessKey", s3_config_.access_key}, + {"Bucket", s3_config_.bucket}, + {"EncryptionToken", s3_config_.encryption_token}, + {"Region", s3_config_.region}, + {"SecretKey", s3_config_.secret_key}, + {"TimeoutMs", s3_config_.timeout_ms}, + {"URL", s3_config_.url}, + {"UsePathStyle", s3_config_.use_path_style}, + {"UseRegionInURL", s3_config_.use_region_in_url}, + }}, + {"SiaConfig", + { + {"Bucket", sia_config_.bucket}, + }}, {"TaskWaitMillis", task_wait_ms_}, {"Version", version_}}; @@ -336,7 +357,7 @@ auto app_config::get_json() const -> json { auto app_config::get_max_cache_size_bytes() const -> std::uint64_t { auto max_space = std::max(static_cast(100ULL * 1024ULL * 1024ULL), - static_cast(max_cache_size_bytes_)); + max_cache_size_bytes_); auto free_space = utils::file::get_free_drive_space(get_cache_directory()); return free_space.has_value() ? std::min(free_space.value(), max_space) : max_space; @@ -400,14 +421,14 @@ auto app_config::get_value_by_name(const std::string &name) -> std::string { #if defined(_WIN32) } if (name == "EnableMountManager") { - return utils::string::from_bool(get_enable_mount_manager()); + return std::to_string(get_enable_mount_manager()); #endif // defined(_WIN32) } if (name == "EncryptConfig.Path") { - return utils::path::absolute(get_encrypt_config().path); + return utils::path::absolute(encrypt_config_.path); } if (name == "EncryptConfig.EncryptionToken") { - return get_encrypt_config().encryption_token; + return encrypt_config_.encryption_token; } if (name == "EventLevel") { return event_level_to_string(get_event_level()); @@ -422,19 +443,19 @@ auto app_config::get_value_by_name(const std::string &name) -> std::string { return std::to_string(get_high_frequency_interval_secs()); } if (name == "HostConfig.AgentString") { - return get_host_config().agent_string; + return hc_.agent_string; } if (name == "HostConfig.ApiPassword") { - return get_host_config().api_password; + return hc_.api_password; } if (name == "HostConfig.ApiPort") { - return std::to_string(get_host_config().api_port); + return std::to_string(hc_.api_port); } if (name == "HostConfig.HostNameOrIp") { - return get_host_config().host_name_or_ip; + return hc_.host_name_or_ip; } if (name == "HostConfig.TimeoutMs") { - return std::to_string(get_host_config().timeout_ms); + return std::to_string(hc_.timeout_ms); } if (name == "LowFreqIntervalSeconds") { return std::to_string(get_low_frequency_interval_secs()); @@ -495,34 +516,34 @@ auto app_config::get_value_by_name(const std::string &name) -> std::string { return std::to_string(get_ring_buffer_file_size()); } if (name == "S3Config.AccessKey") { - return get_s3_config().access_key; + return s3_config_.access_key; } if (name == "S3Config.Bucket") { - return get_s3_config().bucket; + return s3_config_.bucket; } if (name == "S3Config.EncryptionToken") { - return get_s3_config().encryption_token; + return s3_config_.encryption_token; } if (name == "S3Config.Region") { - return get_s3_config().region; + return s3_config_.region; } if (name == "S3Config.SecretKey") { - return get_s3_config().secret_key; + return s3_config_.secret_key; } if (name == "S3Config.URL") { - return get_s3_config().url; + return s3_config_.url; } if (name == "S3Config.UsePathStyle") { - return utils::string::from_bool(get_s3_config().use_path_style); + return utils::string::from_bool(s3_config_.use_path_style); } if (name == "S3Config.UseRegionInURL") { - return utils::string::from_bool(get_s3_config().use_region_in_url); + return utils::string::from_bool(s3_config_.use_region_in_url); } if (name == "S3Config.TimeoutMs") { - return std::to_string(get_s3_config().timeout_ms); + return std::to_string(s3_config_.timeout_ms); } if (name == "SiaConfig.Bucket") { - return get_sia_config().bucket; + return sia_config_.bucket; } if (name == "TaskWaitMillis") { return std::to_string(get_task_wait_ms()); @@ -538,7 +559,7 @@ auto app_config::load() -> bool { auto ret{false}; - auto config_file_path = get_config_file_path(); + const auto config_file_path = get_config_file_path(); recur_mutex_lock lock(read_write_mutex_); if (utils::file::file(config_file_path).exists()) { try { @@ -546,11 +567,11 @@ auto app_config::load() -> bool { if (config_file.is_open()) { std::stringstream stream; stream << config_file.rdbuf(); - auto json_text = stream.str(); + const auto json_text = stream.str(); config_file.close(); ret = not json_text.empty(); if (ret) { - auto json_document = json::parse(json_text); + const auto json_document = json::parse(json_text); get_value(json_document, "ApiAuth", api_auth_, ret); get_value(json_document, "ApiPort", api_port_, ret); @@ -570,8 +591,13 @@ auto app_config::load() -> bool { ret); if (json_document.find("EncryptConfig") != json_document.end()) { - encrypt_config_ = - json_document["EncryptConfig"].get(); + auto encrypt_config_json = json_document["EncryptConfig"]; + auto encrypt = encrypt_config_; + get_value(encrypt_config_json, "Path", encrypt.path, ret); + encrypt_config_.path = utils::path::absolute(encrypt_config_.path); + get_value(encrypt_config_json, "EncryptionToken", + encrypt.encryption_token, ret); + encrypt_config_ = encrypt; } else { ret = false; } @@ -582,19 +608,44 @@ auto app_config::load() -> bool { } if (json_document.find("HostConfig") != json_document.end()) { - hc_ = json_document["HostConfig"].get(); + auto host_config_json = json_document["HostConfig"]; + auto cfg = hc_; + get_value(host_config_json, "AgentString", cfg.agent_string, ret); + get_value(host_config_json, "ApiPassword", cfg.api_password, ret); + get_value(host_config_json, "ApiPort", cfg.api_port, ret); + get_value(host_config_json, "HostNameOrIp", cfg.host_name_or_ip, + ret); + get_value(host_config_json, "TimeoutMs", cfg.timeout_ms, ret); + hc_ = cfg; } else { ret = false; } if (json_document.find("S3Config") != json_document.end()) { - s3_config_ = json_document["S3Config"].get(); + auto s3_config_json = json_document["S3Config"]; + auto s3_cfg = s3_config_; + get_value(s3_config_json, "AccessKey", s3_cfg.access_key, ret); + get_value(s3_config_json, "Bucket", s3_cfg.bucket, ret); + get_value(s3_config_json, "EncryptionToken", + s3_cfg.encryption_token, ret); + get_value(s3_config_json, "Region", s3_cfg.region, ret); + get_value(s3_config_json, "SecretKey", s3_cfg.secret_key, ret); + get_value(s3_config_json, "TimeoutMs", s3_cfg.timeout_ms, ret); + get_value(s3_config_json, "URL", s3_cfg.url, ret); + get_value(s3_config_json, "UsePathStyle", s3_cfg.use_path_style, + ret); + get_value(s3_config_json, "UseRegionInURL", + s3_cfg.use_region_in_url, ret); + s3_config_ = s3_cfg; } else { ret = false; } if (json_document.find("SiaConfig") != json_document.end()) { - sia_config_ = json_document["SiaConfig"].get(); + auto sia_config_json = json_document["SiaConfig"]; + auto sia_cfg = sia_config_; + get_value(sia_config_json, "Bucket", sia_cfg.bucket, ret); + sia_config_ = sia_cfg; } else { ret = false; } @@ -676,7 +727,7 @@ auto app_config::load() -> bool { void app_config::save() { REPERTORY_USES_FUNCTION_NAME(); - auto file_path = get_config_file_path(); + const auto file_path = get_config_file_path(); recur_mutex_lock lock(read_write_mutex_); if (config_changed_ || not utils::file::file(file_path).exists()) { if (not utils::file::directory(data_directory_).exists()) { @@ -700,21 +751,17 @@ void app_config::save() { } void app_config::set_enable_remote_mount(bool enable_remote_mount) { + recur_mutex_lock remote_lock(remote_mount_mutex_); if (get_is_remote_mount()) { set_value(enable_remote_mount_, false); - return; + } else { + set_value(enable_remote_mount_, enable_remote_mount); } - - set_value(enable_remote_mount_, enable_remote_mount); } -void app_config::set_encrypt_config(encrypt_config cfg) { - set_value(encrypt_config_, cfg); -} - -void app_config::set_host_config(host_config cfg) { set_value(hc_, cfg); } - void app_config::set_is_remote_mount(bool is_remote_mount) { + recur_mutex_lock remote_lock(remote_mount_mutex_); + if (get_enable_remote_mount()) { set_value(is_remote_mount_, false); return; @@ -723,10 +770,6 @@ void app_config::set_is_remote_mount(bool is_remote_mount) { set_value(is_remote_mount_, is_remote_mount); } -void app_config::set_s3_config(s3_config cfg) { set_value(s3_config_, cfg); } - -void app_config::set_sia_config(sia_config cfg) { set_value(sia_config_, cfg); } - auto app_config::set_value_by_name(const std::string &name, const std::string &value) -> std::string { REPERTORY_USES_FUNCTION_NAME(); @@ -751,7 +794,7 @@ auto app_config::set_value_by_name(const std::string &name, if (name == "DatabaseType") { set_database_type( database_type_from_string(value, database_type::rocksdb)); - return database_type_to_string(get_database_type()); + return database_type_to_string(db_type_); } if (name == "EnableChunkDownloaderTimeout") { set_enable_chunk_downloader_timeout(utils::string::to_bool(value)); @@ -777,11 +820,11 @@ auto app_config::set_value_by_name(const std::string &name, } if (name == "EncryptConfig.EncryptionToken") { set_value(encrypt_config_.encryption_token, value); - return get_encrypt_config().encryption_token; + return encrypt_config_.encryption_token; } if (name == "EncryptConfig.Path") { set_value(encrypt_config_.path, utils::path::absolute(value)); - return get_encrypt_config().path; + return encrypt_config_.path; } if (name == "EventLevel") { set_event_level(event_level_from_string(value)); @@ -801,23 +844,23 @@ auto app_config::set_value_by_name(const std::string &name, } if (name == "HostConfig.AgentString") { set_value(hc_.agent_string, value); - return get_host_config().agent_string; + return hc_.agent_string; } if (name == "HostConfig.ApiPassword") { set_value(hc_.api_password, value); - return get_host_config().api_password; + return hc_.api_password; } if (name == "HostConfig.ApiPort") { set_value(hc_.api_port, utils::string::to_uint16(value)); - return std::to_string(get_host_config().api_port); + return std::to_string(hc_.api_port); } if (name == "HostConfig.HostNameOrIp") { set_value(hc_.host_name_or_ip, value); - return get_host_config().host_name_or_ip; + return hc_.host_name_or_ip; } if (name == "HostConfig.TimeoutMs") { set_value(hc_.timeout_ms, utils::string::to_uint32(value)); - return std::to_string(get_host_config().timeout_ms); + return std::to_string(hc_.timeout_ms); } if (name == "LowFreqIntervalSeconds") { set_low_frequency_interval_secs(utils::string::to_uint16(value)); @@ -898,43 +941,43 @@ auto app_config::set_value_by_name(const std::string &name, } if (name == "S3Config.AccessKey") { set_value(s3_config_.access_key, value); - return get_s3_config().access_key; + return s3_config_.access_key; } if (name == "S3Config.Bucket") { set_value(s3_config_.bucket, value); - return get_s3_config().bucket; + return s3_config_.bucket; } if (name == "S3Config.Region") { set_value(s3_config_.region, value); - return get_s3_config().region; + return s3_config_.region; } if (name == "S3Config.SecretKey") { set_value(s3_config_.secret_key, value); - return get_s3_config().secret_key; + return s3_config_.secret_key; } if (name == "S3Config.URL") { set_value(s3_config_.url, value); - return get_s3_config().url; + return s3_config_.url; } if (name == "S3Config.UsePathStyle") { set_value(s3_config_.use_path_style, utils::string::to_bool(value)); - return utils::string::from_bool(get_s3_config().use_path_style); + return utils::string::from_bool(s3_config_.use_path_style); } if (name == "S3Config.UseRegionInURL") { set_value(s3_config_.use_region_in_url, utils::string::to_bool(value)); - return utils::string::from_bool(get_s3_config().use_region_in_url); + return utils::string::from_bool(s3_config_.use_region_in_url); } if (name == "S3Config.TimeoutMs") { set_value(s3_config_.timeout_ms, utils::string::to_uint32(value)); - return std::to_string(get_s3_config().timeout_ms); + return std::to_string(s3_config_.timeout_ms); } if (name == "S3Config.EncryptionToken") { set_value(s3_config_.encryption_token, value); - return get_s3_config().encryption_token; + return s3_config_.encryption_token; } if (name == "SiaConfig.Bucket") { set_value(sia_config_.bucket, value); - return get_sia_config().bucket; + return sia_config_.bucket; } if (name == "TaskWaitMillis") { set_task_wait_ms(utils::string::to_uint16(value));