BlockStorage/repertory
1
0
Fork 0
Code Issues 7 Pull Requests Releases 6 Wiki Activity

refactor app config
All checks were successful
BlockStorage/repertory/pipeline/head This commit looks good
Details

Browse Source
This commit is contained in:
Scott E. Graves 2024-12-18 20:21:18 -06:00
parent 65b7428bdf
commit ba5f6a62c8
2 changed files with 251 additions and 171 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

193
repertory/librepertory/include/app_config.hpp
View File

@ -88,26 +88,26 @@ using atomic_string = atomic<std::string>;
class app_config final { class app_config final {
public: public:
[[nodiscard]] static auto default_agent_name(const provider_type &prov) [[nodiscard]] static auto
-> std::string; default_agent_name(const provider_type &prov) -> std::string;
[[nodiscard]] static auto default_api_port(const provider_type &prov) [[nodiscard]] static auto
-> std::uint16_t; default_api_port(const provider_type &prov) -> std::uint16_t;
[[nodiscard]] static auto default_data_directory(const provider_type &prov) [[nodiscard]] static auto
-> std::string; default_data_directory(const provider_type &prov) -> std::string;
[[nodiscard]] static auto default_remote_port(const provider_type &prov) [[nodiscard]] static auto
-> std::uint16_t; default_remote_port(const provider_type &prov) -> std::uint16_t;
[[nodiscard]] static auto default_rpc_port(const provider_type &prov) [[nodiscard]] static auto
-> std::uint16_t; default_rpc_port(const provider_type &prov) -> std::uint16_t;
[[nodiscard]] static auto get_provider_display_name(const provider_type &prov) [[nodiscard]] static auto
-> std::string; get_provider_display_name(const provider_type &prov) -> std::string;
[[nodiscard]] static auto get_provider_name(const provider_type &prov) [[nodiscard]] static auto
-> std::string; get_provider_name(const provider_type &prov) -> std::string;
public: public:
app_config(const provider_type &prov, std::string_view data_directory = ""); app_config(const provider_type &prov, std::string_view data_directory = "");
@ -115,12 +115,12 @@ public:
~app_config() { save(); } ~app_config() { save(); }
private: private:
std::atomic<provider_type> prov_; provider_type prov_;
atomic_string api_auth_; atomic_string api_auth_;
std::atomic<std::uint16_t> api_port_; std::atomic<std::uint16_t> api_port_;
atomic_string api_user_; atomic_string api_user_;
std::atomic<bool> config_changed_; std::atomic<bool> config_changed_;
std::atomic<database_type> db_type_{database_type::rocksdb}; database_type db_type_{database_type::rocksdb};
std::atomic<std::uint8_t> download_timeout_secs_; std::atomic<std::uint8_t> download_timeout_secs_;
std::atomic<bool> enable_chunk_downloader_timeout_; std::atomic<bool> enable_chunk_downloader_timeout_;
std::atomic<bool> enable_comm_duration_events_; std::atomic<bool> enable_comm_duration_events_;
@ -131,55 +131,55 @@ private:
#endif // defined(_WIN32) #endif // defined(_WIN32)
std::atomic<bool> enable_remote_mount_; std::atomic<bool> enable_remote_mount_;
std::atomic<event_level> event_level_; std::atomic<event_level> event_level_;
std::atomic<std::uint32_t> eviction_delay_mins_; std::uint32_t eviction_delay_mins_;
std::atomic<bool> eviction_uses_accessed_time_; std::atomic<bool> eviction_uses_accessed_time_;
std::atomic<std::uint16_t> high_freq_interval_secs_; std::uint16_t high_freq_interval_secs_;
std::atomic<bool> is_remote_mount_; std::atomic<bool> is_remote_mount_;
std::atomic<std::uint16_t> low_freq_interval_secs_; std::uint16_t low_freq_interval_secs_;
std::atomic<std::uint64_t> max_cache_size_bytes_; std::uint64_t max_cache_size_bytes_;
std::atomic<std::uint8_t> max_upload_count_; std::atomic<std::uint8_t> max_upload_count_;
std::atomic<std::uint16_t> med_freq_interval_secs_; std::uint16_t med_freq_interval_secs_;
std::atomic<std::uint8_t> min_download_timeout_secs_; std::atomic<std::uint8_t> min_download_timeout_secs_;
std::atomic<std::uint16_t> online_check_retry_secs_; std::uint16_t online_check_retry_secs_;
std::atomic<std::uint16_t> orphaned_file_retention_days_; std::uint16_t orphaned_file_retention_days_;
atomic_string preferred_download_type_; atomic_string preferred_download_type_;
std::atomic<std::uint8_t> read_ahead_count_; std::atomic<std::uint8_t> read_ahead_count_;
std::atomic<std::uint8_t> remote_client_pool_size_; std::atomic<std::uint8_t> remote_client_pool_size_;
atomic_string remote_host_name_or_ip_; atomic_string remote_host_name_or_ip_;
std::atomic<std::uint8_t> remote_max_connections_; std::atomic<std::uint8_t> remote_max_connections_;
std::atomic<std::uint16_t> remote_port_; std::uint16_t remote_port_;
std::atomic<std::uint16_t> remote_receive_timeout_secs_; std::uint16_t remote_receive_timeout_secs_;
std::atomic<std::uint16_t> remote_send_timeout_secs_; std::uint16_t remote_send_timeout_secs_;
atomic_string remote_token_; atomic_string remote_token_;
std::atomic<std::uint16_t> retry_read_count_; std::uint16_t retry_read_count_;
std::atomic<std::uint16_t> ring_buffer_file_size_; std::uint16_t ring_buffer_file_size_;
std::atomic<std::uint16_t> task_wait_ms_; std::uint16_t task_wait_ms_;
private: private:
atomic_string cache_directory_; std::string cache_directory_;
atomic_string data_directory_; std::string data_directory_;
atomic<encrypt_config> encrypt_config_; encrypt_config encrypt_config_;
atomic<host_config> hc_; host_config hc_{};
atomic<s3_config> s3_config_; std::string log_directory_;
atomic<sia_config> sia_config_;
std::uint64_t version_{REPERTORY_CONFIG_VERSION};
atomic_string log_directory_;
mutable std::recursive_mutex read_write_mutex_; 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: private:
auto get_database_value(const json &json_document, const std::string &name, auto get_database_value(const json &json_document, const std::string &name,
std::atomic<database_type> &dst, bool &success_flag) database_type &dst, bool &success_flag) -> bool;
-> bool;
template <typename dest_t> template <typename dest>
auto get_value(const json &json_document, const std::string &name, auto get_value(const json &json_document, const std::string &name, dest &dst,
dest_t &dst, bool &success_flag) -> bool { bool &success_flag) -> bool {
REPERTORY_USES_FUNCTION_NAME(); REPERTORY_USES_FUNCTION_NAME();
auto ret{false}; auto ret{false};
try { try {
if (json_document.find(name) != json_document.end()) { if (json_document.find(name) != json_document.end()) {
dst = json_document[name].get<dest_t>(); json_document.at(name).get_to(dst);
ret = true; ret = true;
} else { } else {
success_flag = false; success_flag = false;
@ -195,8 +195,8 @@ private:
[[nodiscard]] auto load() -> bool; [[nodiscard]] auto load() -> bool;
template <typename dst_t, typename src_t> template <typename dest, typename source>
auto set_value(dst_t &dst, const src_t &src) -> bool { auto set_value(dest &dst, const source &src) -> bool {
auto ret{false}; auto ret{false};
recur_mutex_lock lock(read_write_mutex_); recur_mutex_lock lock(read_write_mutex_);
if (dst != src) { if (dst != src) {
@ -277,8 +277,7 @@ public:
} }
[[nodiscard]] auto get_high_frequency_interval_secs() const -> std::uint16_t { [[nodiscard]] auto get_high_frequency_interval_secs() const -> std::uint16_t {
return std::max(static_cast<std::uint16_t>(1U), return std::max(static_cast<std::uint16_t>(1U), high_freq_interval_secs_);
static_cast<std::uint16_t>(high_freq_interval_secs_));
} }
[[nodiscard]] auto get_host_config() const -> host_config { return hc_; } [[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 { [[nodiscard]] auto get_low_frequency_interval_secs() const -> std::uint16_t {
return std::max(static_cast<std::uint16_t>(1U), return std::max(static_cast<std::uint16_t>(1U), low_freq_interval_secs_);
static_cast<std::uint16_t>(low_freq_interval_secs_));
} }
[[nodiscard]] auto get_max_cache_size_bytes() const -> std::uint64_t; [[nodiscard]] auto get_max_cache_size_bytes() const -> std::uint64_t;
[[nodiscard]] auto get_max_upload_count() const -> std::uint8_t { [[nodiscard]] auto get_max_upload_count() const -> std::uint8_t {
return std::max(std::uint8_t(1U), return std::max(std::uint8_t(1U), max_upload_count_.load());
static_cast<std::uint8_t>(max_upload_count_));
} }
[[nodiscard]] auto get_med_frequency_interval_secs() const -> std::uint16_t { [[nodiscard]] auto get_med_frequency_interval_secs() const -> std::uint16_t {
return std::max(static_cast<std::uint16_t>(1U), return std::max(static_cast<std::uint16_t>(1U), med_freq_interval_secs_);
static_cast<std::uint16_t>(med_freq_interval_secs_));
} }
[[nodiscard]] auto get_online_check_retry_secs() const -> std::uint16_t { [[nodiscard]] auto get_online_check_retry_secs() const -> std::uint16_t {
return std::max(std::uint16_t(15U), return std::max(std::uint16_t(15U), online_check_retry_secs_);
static_cast<std::uint16_t>(online_check_retry_secs_));
} }
[[nodiscard]] auto get_orphaned_file_retention_days() const -> std::uint16_t { [[nodiscard]] auto get_orphaned_file_retention_days() const -> std::uint16_t {
return std::min( return std::min(static_cast<std::uint16_t>(31U),
static_cast<std::uint16_t>(31U), std::max(static_cast<std::uint16_t>(1U),
std::max(static_cast<std::uint16_t>(1U), orphaned_file_retention_days_));
static_cast<std::uint16_t>(orphaned_file_retention_days_)));
} }
[[nodiscard]] auto get_preferred_download_type() const -> download_type { [[nodiscard]] auto get_preferred_download_type() const -> download_type {
@ -332,13 +326,12 @@ public:
} }
[[nodiscard]] auto get_read_ahead_count() const -> std::uint8_t { [[nodiscard]] auto get_read_ahead_count() const -> std::uint8_t {
return std::max(static_cast<std::uint8_t>(1U), return std::max(static_cast<std::uint8_t>(1U), read_ahead_count_.load());
static_cast<std::uint8_t>(read_ahead_count_));
} }
[[nodiscard]] auto get_remote_client_pool_size() const -> std::uint8_t { [[nodiscard]] auto get_remote_client_pool_size() const -> std::uint8_t {
return std::max(static_cast<std::uint8_t>(5U), return std::max(static_cast<std::uint8_t>(5U),
static_cast<std::uint8_t>(remote_client_pool_size_)); remote_client_pool_size_.load());
} }
[[nodiscard]] auto get_remote_host_name_or_ip() const -> std::string { [[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 { [[nodiscard]] auto get_remote_max_connections() const -> std::uint8_t {
return std::max(static_cast<std::uint8_t>(1U), return std::max(static_cast<std::uint8_t>(1U),
static_cast<std::uint8_t>(remote_max_connections_)); remote_max_connections_.load());
} }
[[nodiscard]] auto get_remote_port() const -> std::uint16_t { [[nodiscard]] auto get_remote_port() const -> std::uint16_t {
@ -367,15 +360,13 @@ public:
} }
[[nodiscard]] auto get_retry_read_count() const -> std::uint16_t { [[nodiscard]] auto get_retry_read_count() const -> std::uint16_t {
return std::max(std::uint16_t(2), return std::max(std::uint16_t(2), retry_read_count_);
static_cast<std::uint16_t>(retry_read_count_));
} }
[[nodiscard]] auto get_ring_buffer_file_size() const -> std::uint16_t { [[nodiscard]] auto get_ring_buffer_file_size() const -> std::uint16_t {
return std::max( return std::max(
static_cast<std::uint16_t>(64U), static_cast<std::uint16_t>(64U),
std::min(static_cast<std::uint16_t>(1024U), std::min(static_cast<std::uint16_t>(1024U), ring_buffer_file_size_));
static_cast<std::uint16_t>(ring_buffer_file_size_)));
} }
[[nodiscard]] auto get_s3_config() const -> s3_config { return s3_config_; } [[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 { [[nodiscard]] auto get_task_wait_ms() const -> std::uint16_t {
return std::max(static_cast<std::uint16_t>(50U), return std::max(static_cast<std::uint16_t>(50U), task_wait_ms_);
static_cast<std::uint16_t>(task_wait_ms_));
} }
[[nodiscard]] auto get_value_by_name(const std::string &name) -> std::string; [[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_enable_remote_mount(bool enable_remote_mount);
void set_encrypt_config(encrypt_config cfg);
void set_event_level(const event_level &level) { void set_event_level(const event_level &level) {
if (set_value(event_level_, level)) { if (set_value(event_level_, level)) {
event_system::instance().raise<event_level_changed>( event_system::instance().raise<event_level_changed>(
@ -462,7 +450,25 @@ public:
set_value(high_freq_interval_secs_, high_frequency_interval_secs); 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); void set_is_remote_mount(bool is_remote_mount);
@ -493,8 +499,8 @@ public:
set_value(orphaned_file_retention_days_, orphaned_file_retention_days); set_value(orphaned_file_retention_days_, orphaned_file_retention_days);
} }
void set_preferred_download_type(const download_type &type) { void set_preferred_download_type(const download_type &dt) {
set_value(preferred_download_type_, download_type_to_string(type)); set_value(preferred_download_type_, download_type_to_string(dt));
} }
void set_read_ahead_count(std::uint8_t read_ahead_count) { void set_read_ahead_count(std::uint8_t read_ahead_count) {
@ -538,10 +544,6 @@ public:
set_value(retry_read_count_, retry_read_count); 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) { void set_task_wait_ms(std::uint16_t task_wait_ms) {
set_value(task_wait_ms_, task_wait_ms); set_value(task_wait_ms_, task_wait_ms);
} }
@ -551,4 +553,39 @@ public:
}; };
} // namespace repertory } // namespace repertory
NLOHMANN_JSON_NAMESPACE_BEGIN
template <> struct adl_serializer<repertory::atomic_string> {
static void to_json(json &data, const repertory::atomic_string &value) {
data = static_cast<std::string>(value);
}
static void from_json(const json &data, repertory::atomic_string &value) {
value = data.get<std::string>();
}
};
template <typename primitive_t>
struct adl_serializer<std::atomic<primitive_t>> {
static void to_json(json &data, const std::atomic<primitive_t> &value) {
data = value.load();
}
static void from_json(const json &data, std::atomic<primitive_t> &value) {
value.store(data.get<primitive_t>());
}
};
template <> struct adl_serializer<std::atomic<repertory::event_level>> {
static void to_json(json &data,
const std::atomic<repertory::event_level> &value) {
data = repertory::event_level_to_string(value.load());
}
static void from_json(const json &data,
std::atomic<repertory::event_level> &value) {
value.store(repertory::event_level_from_string(data.get<std::string>()));
}
};
NLOHMANN_JSON_NAMESPACE_END
#endif // REPERTORY_INCLUDE_APP_CONFIG_HPP_ #endif // REPERTORY_INCLUDE_APP_CONFIG_HPP_

229
repertory/librepertory/src/app_config.cpp
View File

@ -30,30 +30,29 @@
#include "utils/utils.hpp" #include "utils/utils.hpp"
namespace { namespace {
constexpr const auto default_api_auth_size{48U}; constexpr const auto default_api_auth_size = 48U;
constexpr const auto default_download_timeout_ces{30U}; constexpr const auto default_download_timeout_ces = 30U;
constexpr const auto default_eviction_delay_mins{10U}; constexpr const auto default_eviction_delay_mins = 10U;
constexpr const auto default_high_freq_interval_secs{30U}; constexpr const auto default_high_freq_interval_secs = 30U;
constexpr const auto default_low_freq_interval_secs{60U * 60U}; constexpr const auto default_low_freq_interval_secs = 60U * 60U;
constexpr const std::uint64_t default_max_cache_size_bytes = { constexpr const auto default_max_cache_size_bytes =
20ULL * 1024ULL * 1024ULL * 1024ULL, 20ULL * 1024ULL * 1024ULL * 1024ULL;
}; constexpr const auto default_max_upload_count = 5U;
constexpr const auto default_max_upload_count{5U}; constexpr const auto default_med_freq_interval_secs = 2U * 60U;
constexpr const auto default_med_freq_interval_secs{2U * 60U}; constexpr const auto default_min_download_timeout_secs = 5U;
constexpr const auto default_min_download_timeout_secs{5U}; constexpr const auto default_online_check_retry_secs = 60U;
constexpr const auto default_online_check_retry_secs{60U}; constexpr const auto default_orphaned_file_retention_days = 15U;
constexpr const auto default_orphaned_file_retention_days{15U}; constexpr const auto default_read_ahead_count = 4U;
constexpr const auto default_read_ahead_count{4U}; constexpr const auto default_remote_client_pool_size = 10U;
constexpr const auto default_remote_client_pool_size{10U}; constexpr const auto default_remote_host_name_or_ip = "";
constexpr const auto default_remote_host_name_or_ip{""}; constexpr const auto default_remote_max_connections = 20U;
constexpr const auto default_remote_max_connections{20U}; constexpr const auto default_remote_receive_timeout_secs = 120U;
constexpr const auto default_remote_receive_timeout_secs{120U}; constexpr const auto default_remote_send_timeout_secs = 30U;
constexpr const auto default_remote_send_timeout_secs{30U}; constexpr const auto default_remote_token = "";
constexpr const auto default_remote_token{""}; constexpr const auto default_retry_read_count = 6U;
constexpr const auto default_retry_read_count{6U}; constexpr const auto default_ring_buffer_file_size = 512U;
constexpr const auto default_ring_buffer_file_size{512U}; constexpr const auto default_task_wait_ms = 100U;
constexpr const auto default_task_wait_ms{100U}; constexpr const auto retry_save_count = 5U;
constexpr const auto retry_save_count{5U};
} // namespace } // namespace
namespace repertory { namespace repertory {
@ -104,10 +103,8 @@ app_config::app_config(const provider_type &prov,
cache_directory_ = utils::path::combine(data_directory_, {"cache"}); cache_directory_ = utils::path::combine(data_directory_, {"cache"});
log_directory_ = utils::path::combine(data_directory_, {"logs"}); log_directory_ = utils::path::combine(data_directory_, {"logs"});
host_config host_cfg{hc_}; hc_.agent_string = default_agent_name(prov_);
host_cfg.agent_string = default_agent_name(prov_); hc_.api_port = default_api_port(prov_);
host_cfg.api_port = default_api_port(prov_);
hc_ = host_cfg;
if (not utils::file::directory(data_directory_).create_directory()) { if (not utils::file::directory(data_directory_).create_directory()) {
throw startup_exception("unable to create: " + data_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, auto app_config::get_database_value(const json &json_document,
const std::string &name, const std::string &name, database_type &dst,
std::atomic<database_type> &dst,
bool &success_flag) -> bool { bool &success_flag) -> bool {
REPERTORY_USES_FUNCTION_NAME(); REPERTORY_USES_FUNCTION_NAME();
@ -247,12 +243,23 @@ auto app_config::get_json() const -> json {
{"EnableMountManager", enable_mount_manager_}, {"EnableMountManager", enable_mount_manager_},
#endif // defined(_WIN32) #endif // defined(_WIN32)
{"EnableMaxCacheSize", enable_max_cache_size_}, {"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_)}, {"EventLevel", event_level_to_string(event_level_)},
{"EvictionDelayMinutes", eviction_delay_mins_}, {"EvictionDelayMinutes", eviction_delay_mins_},
{"EvictionUsesAccessedTime", eviction_uses_accessed_time_}, {"EvictionUsesAccessedTime", eviction_uses_accessed_time_},
{"HighFreqIntervalSeconds", high_freq_interval_secs_}, {"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_}, {"LowFreqIntervalSeconds", low_freq_interval_secs_},
{"MaxCacheSizeBytes", max_cache_size_bytes_}, {"MaxCacheSizeBytes", max_cache_size_bytes_},
{"MaxUploadCount", max_upload_count_}, {"MaxUploadCount", max_upload_count_},
@ -277,8 +284,22 @@ auto app_config::get_json() const -> json {
}, },
{"RetryReadCount", retry_read_count_}, {"RetryReadCount", retry_read_count_},
{"RingBufferFileSize", ring_buffer_file_size_}, {"RingBufferFileSize", ring_buffer_file_size_},
{"S3Config", get_s3_config()}, {"S3Config",
{"SiaConfig", get_sia_config()}, {
{"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_}, {"TaskWaitMillis", task_wait_ms_},
{"Version", version_}}; {"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 app_config::get_max_cache_size_bytes() const -> std::uint64_t {
auto max_space = auto max_space =
std::max(static_cast<std::uint64_t>(100ULL * 1024ULL * 1024ULL), std::max(static_cast<std::uint64_t>(100ULL * 1024ULL * 1024ULL),
static_cast<std::uint64_t>(max_cache_size_bytes_)); max_cache_size_bytes_);
auto free_space = utils::file::get_free_drive_space(get_cache_directory()); auto free_space = utils::file::get_free_drive_space(get_cache_directory());
return free_space.has_value() ? std::min(free_space.value(), max_space) return free_space.has_value() ? std::min(free_space.value(), max_space)
: 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 defined(_WIN32)
} }
if (name == "EnableMountManager") { if (name == "EnableMountManager") {
return utils::string::from_bool(get_enable_mount_manager()); return std::to_string(get_enable_mount_manager());
#endif // defined(_WIN32) #endif // defined(_WIN32)
} }
if (name == "EncryptConfig.Path") { if (name == "EncryptConfig.Path") {
return utils::path::absolute(get_encrypt_config().path); return utils::path::absolute(encrypt_config_.path);
} }
if (name == "EncryptConfig.EncryptionToken") { if (name == "EncryptConfig.EncryptionToken") {
return get_encrypt_config().encryption_token; return encrypt_config_.encryption_token;
} }
if (name == "EventLevel") { if (name == "EventLevel") {
return event_level_to_string(get_event_level()); 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()); return std::to_string(get_high_frequency_interval_secs());
} }
if (name == "HostConfig.AgentString") { if (name == "HostConfig.AgentString") {
return get_host_config().agent_string; return hc_.agent_string;
} }
if (name == "HostConfig.ApiPassword") { if (name == "HostConfig.ApiPassword") {
return get_host_config().api_password; return hc_.api_password;
} }
if (name == "HostConfig.ApiPort") { if (name == "HostConfig.ApiPort") {
return std::to_string(get_host_config().api_port); return std::to_string(hc_.api_port);
} }
if (name == "HostConfig.HostNameOrIp") { if (name == "HostConfig.HostNameOrIp") {
return get_host_config().host_name_or_ip; return hc_.host_name_or_ip;
} }
if (name == "HostConfig.TimeoutMs") { if (name == "HostConfig.TimeoutMs") {
return std::to_string(get_host_config().timeout_ms); return std::to_string(hc_.timeout_ms);
} }
if (name == "LowFreqIntervalSeconds") { if (name == "LowFreqIntervalSeconds") {
return std::to_string(get_low_frequency_interval_secs()); 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()); return std::to_string(get_ring_buffer_file_size());
} }
if (name == "S3Config.AccessKey") { if (name == "S3Config.AccessKey") {
return get_s3_config().access_key; return s3_config_.access_key;
} }
if (name == "S3Config.Bucket") { if (name == "S3Config.Bucket") {
return get_s3_config().bucket; return s3_config_.bucket;
} }
if (name == "S3Config.EncryptionToken") { if (name == "S3Config.EncryptionToken") {
return get_s3_config().encryption_token; return s3_config_.encryption_token;
} }
if (name == "S3Config.Region") { if (name == "S3Config.Region") {
return get_s3_config().region; return s3_config_.region;
} }
if (name == "S3Config.SecretKey") { if (name == "S3Config.SecretKey") {
return get_s3_config().secret_key; return s3_config_.secret_key;
} }
if (name == "S3Config.URL") { if (name == "S3Config.URL") {
return get_s3_config().url; return s3_config_.url;
} }
if (name == "S3Config.UsePathStyle") { 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") { 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") { 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") { if (name == "SiaConfig.Bucket") {
return get_sia_config().bucket; return sia_config_.bucket;
} }
if (name == "TaskWaitMillis") { if (name == "TaskWaitMillis") {
return std::to_string(get_task_wait_ms()); return std::to_string(get_task_wait_ms());
@ -538,7 +559,7 @@ auto app_config::load() -> bool {
auto ret{false}; 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_); recur_mutex_lock lock(read_write_mutex_);
if (utils::file::file(config_file_path).exists()) { if (utils::file::file(config_file_path).exists()) {
try { try {
@ -546,11 +567,11 @@ auto app_config::load() -> bool {
if (config_file.is_open()) { if (config_file.is_open()) {
std::stringstream stream; std::stringstream stream;
stream << config_file.rdbuf(); stream << config_file.rdbuf();
auto json_text = stream.str(); const auto json_text = stream.str();
config_file.close(); config_file.close();
ret = not json_text.empty(); ret = not json_text.empty();
if (ret) { 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, "ApiAuth", api_auth_, ret);
get_value(json_document, "ApiPort", api_port_, ret); get_value(json_document, "ApiPort", api_port_, ret);
@ -570,8 +591,13 @@ auto app_config::load() -> bool {
ret); ret);
if (json_document.find("EncryptConfig") != json_document.end()) { if (json_document.find("EncryptConfig") != json_document.end()) {
encrypt_config_ = auto encrypt_config_json = json_document["EncryptConfig"];
json_document["EncryptConfig"].get<encrypt_config>(); 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 { } else {
ret = false; ret = false;
} }
@ -582,19 +608,44 @@ auto app_config::load() -> bool {
} }
if (json_document.find("HostConfig") != json_document.end()) { if (json_document.find("HostConfig") != json_document.end()) {
hc_ = json_document["HostConfig"].get<host_config>(); 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 { } else {
ret = false; ret = false;
} }
if (json_document.find("S3Config") != json_document.end()) { if (json_document.find("S3Config") != json_document.end()) {
s3_config_ = json_document["S3Config"].get<s3_config>(); 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 { } else {
ret = false; ret = false;
} }
if (json_document.find("SiaConfig") != json_document.end()) { if (json_document.find("SiaConfig") != json_document.end()) {
sia_config_ = json_document["SiaConfig"].get<sia_config>(); 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 { } else {
ret = false; ret = false;
} }
@ -676,7 +727,7 @@ auto app_config::load() -> bool {
void app_config::save() { void app_config::save() {
REPERTORY_USES_FUNCTION_NAME(); 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_); recur_mutex_lock lock(read_write_mutex_);
if (config_changed_ || not utils::file::file(file_path).exists()) { if (config_changed_ || not utils::file::file(file_path).exists()) {
if (not utils::file::directory(data_directory_).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) { void app_config::set_enable_remote_mount(bool enable_remote_mount) {
recur_mutex_lock remote_lock(remote_mount_mutex_);
if (get_is_remote_mount()) { if (get_is_remote_mount()) {
set_value(enable_remote_mount_, false); 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) { void app_config::set_is_remote_mount(bool is_remote_mount) {
recur_mutex_lock remote_lock(remote_mount_mutex_);
if (get_enable_remote_mount()) { if (get_enable_remote_mount()) {
set_value(is_remote_mount_, false); set_value(is_remote_mount_, false);
return; return;
@ -723,10 +770,6 @@ void app_config::set_is_remote_mount(bool is_remote_mount) {
set_value(is_remote_mount_, 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, auto app_config::set_value_by_name(const std::string &name,
const std::string &value) -> std::string { const std::string &value) -> std::string {
REPERTORY_USES_FUNCTION_NAME(); REPERTORY_USES_FUNCTION_NAME();
@ -751,7 +794,7 @@ auto app_config::set_value_by_name(const std::string &name,
if (name == "DatabaseType") { if (name == "DatabaseType") {
set_database_type( set_database_type(
database_type_from_string(value, database_type::rocksdb)); 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") { if (name == "EnableChunkDownloaderTimeout") {
set_enable_chunk_downloader_timeout(utils::string::to_bool(value)); 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") { if (name == "EncryptConfig.EncryptionToken") {
set_value(encrypt_config_.encryption_token, value); set_value(encrypt_config_.encryption_token, value);
return get_encrypt_config().encryption_token; return encrypt_config_.encryption_token;
} }
if (name == "EncryptConfig.Path") { if (name == "EncryptConfig.Path") {
set_value(encrypt_config_.path, utils::path::absolute(value)); set_value(encrypt_config_.path, utils::path::absolute(value));
return get_encrypt_config().path; return encrypt_config_.path;
} }
if (name == "EventLevel") { if (name == "EventLevel") {
set_event_level(event_level_from_string(value)); 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") { if (name == "HostConfig.AgentString") {
set_value(hc_.agent_string, value); set_value(hc_.agent_string, value);
return get_host_config().agent_string; return hc_.agent_string;
} }
if (name == "HostConfig.ApiPassword") { if (name == "HostConfig.ApiPassword") {
set_value(hc_.api_password, value); set_value(hc_.api_password, value);
return get_host_config().api_password; return hc_.api_password;
} }
if (name == "HostConfig.ApiPort") { if (name == "HostConfig.ApiPort") {
set_value(hc_.api_port, utils::string::to_uint16(value)); 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") { if (name == "HostConfig.HostNameOrIp") {
set_value(hc_.host_name_or_ip, value); 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") { if (name == "HostConfig.TimeoutMs") {
set_value(hc_.timeout_ms, utils::string::to_uint32(value)); 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") { if (name == "LowFreqIntervalSeconds") {
set_low_frequency_interval_secs(utils::string::to_uint16(value)); 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") { if (name == "S3Config.AccessKey") {
set_value(s3_config_.access_key, value); set_value(s3_config_.access_key, value);
return get_s3_config().access_key; return s3_config_.access_key;
} }
if (name == "S3Config.Bucket") { if (name == "S3Config.Bucket") {
set_value(s3_config_.bucket, value); set_value(s3_config_.bucket, value);
return get_s3_config().bucket; return s3_config_.bucket;
} }
if (name == "S3Config.Region") { if (name == "S3Config.Region") {
set_value(s3_config_.region, value); set_value(s3_config_.region, value);
return get_s3_config().region; return s3_config_.region;
} }
if (name == "S3Config.SecretKey") { if (name == "S3Config.SecretKey") {
set_value(s3_config_.secret_key, value); set_value(s3_config_.secret_key, value);
return get_s3_config().secret_key; return s3_config_.secret_key;
} }
if (name == "S3Config.URL") { if (name == "S3Config.URL") {
set_value(s3_config_.url, value); set_value(s3_config_.url, value);
return get_s3_config().url; return s3_config_.url;
} }
if (name == "S3Config.UsePathStyle") { if (name == "S3Config.UsePathStyle") {
set_value(s3_config_.use_path_style, utils::string::to_bool(value)); 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") { if (name == "S3Config.UseRegionInURL") {
set_value(s3_config_.use_region_in_url, utils::string::to_bool(value)); 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") { if (name == "S3Config.TimeoutMs") {
set_value(s3_config_.timeout_ms, utils::string::to_uint32(value)); 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") { if (name == "S3Config.EncryptionToken") {
set_value(s3_config_.encryption_token, value); set_value(s3_config_.encryption_token, value);
return get_s3_config().encryption_token; return s3_config_.encryption_token;
} }
if (name == "SiaConfig.Bucket") { if (name == "SiaConfig.Bucket") {
set_value(sia_config_.bucket, value); set_value(sia_config_.bucket, value);
return get_sia_config().bucket; return sia_config_.bucket;
} }
if (name == "TaskWaitMillis") { if (name == "TaskWaitMillis") {
set_task_wait_ms(utils::string::to_uint16(value)); set_task_wait_ms(utils::string::to_uint16(value));