[broken build] refactor app_config
Some checks failed
BlockStorage/repertory/pipeline/head There was a failure building this commit
Some checks failed
BlockStorage/repertory/pipeline/head There was a failure building this commit
This commit is contained in:
parent
f68917c8cc
commit
65b7428bdf
@ -28,6 +28,64 @@
|
||||
#include "utils/error_utils.hpp"
|
||||
|
||||
namespace repertory {
|
||||
template <typename data_t> class atomic final {
|
||||
public:
|
||||
atomic() : mtx_(std::make_shared<std::mutex>()) {}
|
||||
atomic(const atomic &) = default;
|
||||
atomic(data_t data)
|
||||
: data_(std::move(data)), mtx_(std::make_shared<std::mutex>()) {}
|
||||
atomic(data_t data, std::unique_ptr<std::mutex> mtx)
|
||||
: data_(std::move(data)), mtx_(std::move(mtx)) {}
|
||||
atomic(atomic &&) = default;
|
||||
|
||||
~atomic() = default;
|
||||
|
||||
private:
|
||||
data_t data_;
|
||||
std::shared_ptr<std::mutex> mtx_;
|
||||
|
||||
public:
|
||||
auto operator=(const atomic &) -> atomic & = default;
|
||||
|
||||
auto operator=(atomic &&) -> atomic & = default;
|
||||
|
||||
auto operator==(const atomic &at_data) const -> bool {
|
||||
mutex_lock lock(*mtx_);
|
||||
return static_cast<data_t>(at_data) == data_;
|
||||
}
|
||||
|
||||
auto operator==(const data_t &data) const -> bool {
|
||||
mutex_lock lock(*mtx_);
|
||||
return data == data_;
|
||||
}
|
||||
|
||||
auto operator!=(const atomic &at_data) const -> bool {
|
||||
mutex_lock lock(*mtx_);
|
||||
return static_cast<data_t>(at_data) != data_;
|
||||
}
|
||||
|
||||
auto operator!=(const data_t &data) const -> bool {
|
||||
mutex_lock lock(*mtx_);
|
||||
return data != data_;
|
||||
}
|
||||
|
||||
auto operator=(const data_t &data) -> atomic & {
|
||||
mutex_lock lock(*mtx_);
|
||||
if (&data != &data_) {
|
||||
data_ = data;
|
||||
}
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
operator data_t() const {
|
||||
mutex_lock lock(*mtx_);
|
||||
return data_;
|
||||
}
|
||||
};
|
||||
|
||||
using atomic_string = atomic<std::string>;
|
||||
|
||||
class app_config final {
|
||||
public:
|
||||
[[nodiscard]] static auto default_agent_name(const provider_type &prov)
|
||||
@ -57,71 +115,71 @@ public:
|
||||
~app_config() { save(); }
|
||||
|
||||
private:
|
||||
provider_type prov_;
|
||||
std::string api_auth_;
|
||||
std::uint16_t api_port_;
|
||||
std::string api_user_;
|
||||
bool config_changed_;
|
||||
std::string data_directory_;
|
||||
database_type db_type_{database_type::rocksdb};
|
||||
std::uint8_t download_timeout_secs_;
|
||||
bool enable_chunk_downloader_timeout_;
|
||||
bool enable_comm_duration_events_;
|
||||
bool enable_drive_events_;
|
||||
bool enable_max_cache_size_;
|
||||
std::atomic<provider_type> prov_;
|
||||
atomic_string api_auth_;
|
||||
std::atomic<std::uint16_t> api_port_;
|
||||
atomic_string api_user_;
|
||||
std::atomic<bool> config_changed_;
|
||||
std::atomic<database_type> db_type_{database_type::rocksdb};
|
||||
std::atomic<std::uint8_t> download_timeout_secs_;
|
||||
std::atomic<bool> enable_chunk_downloader_timeout_;
|
||||
std::atomic<bool> enable_comm_duration_events_;
|
||||
std::atomic<bool> enable_drive_events_;
|
||||
std::atomic<bool> enable_max_cache_size_;
|
||||
#if defined(_WIN32)
|
||||
bool enable_mount_manager_;
|
||||
std::atomic<bool> enable_mount_manager_;
|
||||
#endif // defined(_WIN32)
|
||||
bool enable_remote_mount_;
|
||||
encrypt_config encrypt_config_;
|
||||
event_level event_level_;
|
||||
std::uint32_t eviction_delay_mins_;
|
||||
bool eviction_uses_accessed_time_;
|
||||
std::uint16_t high_freq_interval_secs_;
|
||||
bool is_remote_mount_;
|
||||
std::uint16_t low_freq_interval_secs_;
|
||||
std::uint64_t max_cache_size_bytes_;
|
||||
std::uint8_t max_upload_count_;
|
||||
std::uint16_t med_freq_interval_secs_;
|
||||
std::uint8_t min_download_timeout_secs_;
|
||||
std::uint16_t online_check_retry_secs_;
|
||||
std::uint16_t orphaned_file_retention_days_;
|
||||
std::string preferred_download_type_;
|
||||
std::uint8_t read_ahead_count_;
|
||||
std::uint8_t remote_client_pool_size_;
|
||||
std::string remote_host_name_or_ip_;
|
||||
std::uint8_t remote_max_connections_;
|
||||
std::uint16_t remote_port_;
|
||||
std::uint16_t remote_receive_timeout_secs_;
|
||||
std::uint16_t remote_send_timeout_secs_;
|
||||
std::string remote_token_;
|
||||
std::uint16_t retry_read_count_;
|
||||
std::uint16_t ring_buffer_file_size_;
|
||||
std::uint16_t task_wait_ms_;
|
||||
std::atomic<bool> enable_remote_mount_;
|
||||
std::atomic<event_level> event_level_;
|
||||
std::atomic<std::uint32_t> eviction_delay_mins_;
|
||||
std::atomic<bool> eviction_uses_accessed_time_;
|
||||
std::atomic<std::uint16_t> high_freq_interval_secs_;
|
||||
std::atomic<bool> is_remote_mount_;
|
||||
std::atomic<std::uint16_t> low_freq_interval_secs_;
|
||||
std::atomic<std::uint64_t> max_cache_size_bytes_;
|
||||
std::atomic<std::uint8_t> max_upload_count_;
|
||||
std::atomic<std::uint16_t> med_freq_interval_secs_;
|
||||
std::atomic<std::uint8_t> min_download_timeout_secs_;
|
||||
std::atomic<std::uint16_t> online_check_retry_secs_;
|
||||
std::atomic<std::uint16_t> orphaned_file_retention_days_;
|
||||
atomic_string preferred_download_type_;
|
||||
std::atomic<std::uint8_t> read_ahead_count_;
|
||||
std::atomic<std::uint8_t> remote_client_pool_size_;
|
||||
atomic_string remote_host_name_or_ip_;
|
||||
std::atomic<std::uint8_t> remote_max_connections_;
|
||||
std::atomic<std::uint16_t> remote_port_;
|
||||
std::atomic<std::uint16_t> remote_receive_timeout_secs_;
|
||||
std::atomic<std::uint16_t> remote_send_timeout_secs_;
|
||||
atomic_string remote_token_;
|
||||
std::atomic<std::uint16_t> retry_read_count_;
|
||||
std::atomic<std::uint16_t> ring_buffer_file_size_;
|
||||
std::atomic<std::uint16_t> task_wait_ms_;
|
||||
|
||||
private:
|
||||
std::string cache_directory_;
|
||||
host_config hc_{};
|
||||
s3_config s3_config_{};
|
||||
sia_config sia_config_{};
|
||||
atomic_string cache_directory_;
|
||||
atomic_string data_directory_;
|
||||
atomic<encrypt_config> encrypt_config_;
|
||||
atomic<host_config> hc_;
|
||||
atomic<s3_config> s3_config_;
|
||||
atomic<sia_config> sia_config_;
|
||||
std::uint64_t version_{REPERTORY_CONFIG_VERSION};
|
||||
std::string log_directory_;
|
||||
atomic_string log_directory_;
|
||||
mutable std::recursive_mutex read_write_mutex_;
|
||||
mutable std::recursive_mutex remote_mount_mutex_;
|
||||
|
||||
private:
|
||||
auto get_database_value(const json &json_document, const std::string &name,
|
||||
database_type &dst, bool &success_flag) -> bool;
|
||||
std::atomic<database_type> &dst, bool &success_flag)
|
||||
-> bool;
|
||||
|
||||
template <typename dest>
|
||||
auto get_value(const json &json_document, const std::string &name, dest &dst,
|
||||
bool &success_flag) -> bool {
|
||||
template <typename dest_t>
|
||||
auto get_value(const json &json_document, const std::string &name,
|
||||
dest_t &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<dest>();
|
||||
dst = json_document[name].get<dest_t>();
|
||||
ret = true;
|
||||
} else {
|
||||
success_flag = false;
|
||||
@ -137,8 +195,8 @@ private:
|
||||
|
||||
[[nodiscard]] auto load() -> bool;
|
||||
|
||||
template <typename dest, typename source>
|
||||
auto set_value(dest &dst, const source &src) -> bool {
|
||||
template <typename dst_t, typename src_t>
|
||||
auto set_value(dst_t &dst, const src_t &src) -> bool {
|
||||
auto ret{false};
|
||||
recur_mutex_lock lock(read_write_mutex_);
|
||||
if (dst != src) {
|
||||
@ -219,7 +277,8 @@ public:
|
||||
}
|
||||
|
||||
[[nodiscard]] auto get_high_frequency_interval_secs() const -> std::uint16_t {
|
||||
return std::max(static_cast<std::uint16_t>(1U), high_freq_interval_secs_);
|
||||
return std::max(static_cast<std::uint16_t>(1U),
|
||||
static_cast<std::uint16_t>(high_freq_interval_secs_));
|
||||
}
|
||||
|
||||
[[nodiscard]] auto get_host_config() const -> host_config { return hc_; }
|
||||
@ -235,27 +294,32 @@ public:
|
||||
}
|
||||
|
||||
[[nodiscard]] auto get_low_frequency_interval_secs() const -> std::uint16_t {
|
||||
return std::max(static_cast<std::uint16_t>(1U), low_freq_interval_secs_);
|
||||
return std::max(static_cast<std::uint16_t>(1U),
|
||||
static_cast<std::uint16_t>(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), max_upload_count_);
|
||||
return std::max(std::uint8_t(1U),
|
||||
static_cast<std::uint8_t>(max_upload_count_));
|
||||
}
|
||||
|
||||
[[nodiscard]] auto get_med_frequency_interval_secs() const -> std::uint16_t {
|
||||
return std::max(static_cast<std::uint16_t>(1U), med_freq_interval_secs_);
|
||||
return std::max(static_cast<std::uint16_t>(1U),
|
||||
static_cast<std::uint16_t>(med_freq_interval_secs_));
|
||||
}
|
||||
|
||||
[[nodiscard]] auto get_online_check_retry_secs() const -> std::uint16_t {
|
||||
return std::max(std::uint16_t(15U), online_check_retry_secs_);
|
||||
return std::max(std::uint16_t(15U),
|
||||
static_cast<std::uint16_t>(online_check_retry_secs_));
|
||||
}
|
||||
|
||||
[[nodiscard]] auto get_orphaned_file_retention_days() const -> std::uint16_t {
|
||||
return std::min(static_cast<std::uint16_t>(31U),
|
||||
return std::min(
|
||||
static_cast<std::uint16_t>(31U),
|
||||
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 {
|
||||
@ -268,11 +332,13 @@ public:
|
||||
}
|
||||
|
||||
[[nodiscard]] auto get_read_ahead_count() const -> std::uint8_t {
|
||||
return std::max(static_cast<std::uint8_t>(1U), read_ahead_count_);
|
||||
return std::max(static_cast<std::uint8_t>(1U),
|
||||
static_cast<std::uint8_t>(read_ahead_count_));
|
||||
}
|
||||
|
||||
[[nodiscard]] auto get_remote_client_pool_size() const -> std::uint8_t {
|
||||
return std::max(static_cast<std::uint8_t>(5U), remote_client_pool_size_);
|
||||
return std::max(static_cast<std::uint8_t>(5U),
|
||||
static_cast<std::uint8_t>(remote_client_pool_size_));
|
||||
}
|
||||
|
||||
[[nodiscard]] auto get_remote_host_name_or_ip() const -> std::string {
|
||||
@ -280,7 +346,8 @@ public:
|
||||
}
|
||||
|
||||
[[nodiscard]] auto get_remote_max_connections() const -> std::uint8_t {
|
||||
return std::max(static_cast<std::uint8_t>(1U), remote_max_connections_);
|
||||
return std::max(static_cast<std::uint8_t>(1U),
|
||||
static_cast<std::uint8_t>(remote_max_connections_));
|
||||
}
|
||||
|
||||
[[nodiscard]] auto get_remote_port() const -> std::uint16_t {
|
||||
@ -300,13 +367,15 @@ public:
|
||||
}
|
||||
|
||||
[[nodiscard]] auto get_retry_read_count() const -> std::uint16_t {
|
||||
return std::max(std::uint16_t(2), retry_read_count_);
|
||||
return std::max(std::uint16_t(2),
|
||||
static_cast<std::uint16_t>(retry_read_count_));
|
||||
}
|
||||
|
||||
[[nodiscard]] auto get_ring_buffer_file_size() const -> std::uint16_t {
|
||||
return std::max(
|
||||
static_cast<std::uint16_t>(64U),
|
||||
std::min(static_cast<std::uint16_t>(1024U), ring_buffer_file_size_));
|
||||
std::min(static_cast<std::uint16_t>(1024U),
|
||||
static_cast<std::uint16_t>(ring_buffer_file_size_)));
|
||||
}
|
||||
|
||||
[[nodiscard]] auto get_s3_config() const -> s3_config { return s3_config_; }
|
||||
@ -316,7 +385,8 @@ public:
|
||||
}
|
||||
|
||||
[[nodiscard]] auto get_task_wait_ms() const -> std::uint16_t {
|
||||
return std::max(static_cast<std::uint16_t>(50U), task_wait_ms_);
|
||||
return std::max(static_cast<std::uint16_t>(50U),
|
||||
static_cast<std::uint16_t>(task_wait_ms_));
|
||||
}
|
||||
|
||||
[[nodiscard]] auto get_value_by_name(const std::string &name) -> std::string;
|
||||
@ -370,6 +440,8 @@ 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<event_level_changed>(
|
||||
@ -390,25 +462,7 @@ public:
|
||||
set_value(high_freq_interval_secs_, high_frequency_interval_secs);
|
||||
}
|
||||
|
||||
#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_host_config(host_config cfg);
|
||||
|
||||
void set_is_remote_mount(bool is_remote_mount);
|
||||
|
||||
@ -439,8 +493,8 @@ public:
|
||||
set_value(orphaned_file_retention_days_, orphaned_file_retention_days);
|
||||
}
|
||||
|
||||
void set_preferred_download_type(const download_type &dt) {
|
||||
set_value(preferred_download_type_, download_type_to_string(dt));
|
||||
void set_preferred_download_type(const download_type &type) {
|
||||
set_value(preferred_download_type_, download_type_to_string(type));
|
||||
}
|
||||
|
||||
void set_read_ahead_count(std::uint8_t read_ahead_count) {
|
||||
@ -484,6 +538,10 @@ 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);
|
||||
}
|
||||
|
||||
@ -30,29 +30,30 @@
|
||||
#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 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;
|
||||
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};
|
||||
} // namespace
|
||||
|
||||
namespace repertory {
|
||||
@ -63,9 +64,6 @@ app_config::app_config(const provider_type &prov,
|
||||
api_port_(default_rpc_port(prov)),
|
||||
api_user_(std::string{REPERTORY}),
|
||||
config_changed_(false),
|
||||
data_directory_(data_directory.empty()
|
||||
? default_data_directory(prov)
|
||||
: utils::path::absolute(data_directory)),
|
||||
download_timeout_secs_(default_download_timeout_ces),
|
||||
enable_chunk_downloader_timeout_(true),
|
||||
enable_comm_duration_events_(false),
|
||||
@ -100,11 +98,16 @@ app_config::app_config(const provider_type &prov,
|
||||
retry_read_count_(default_retry_read_count),
|
||||
ring_buffer_file_size_(default_ring_buffer_file_size),
|
||||
task_wait_ms_(default_task_wait_ms) {
|
||||
data_directory_ = data_directory.empty()
|
||||
? default_data_directory(prov)
|
||||
: utils::path::absolute(data_directory);
|
||||
cache_directory_ = utils::path::combine(data_directory_, {"cache"});
|
||||
log_directory_ = utils::path::combine(data_directory_, {"logs"});
|
||||
|
||||
hc_.agent_string = default_agent_name(prov_);
|
||||
hc_.api_port = default_api_port(prov_);
|
||||
host_config host_cfg{hc_};
|
||||
host_cfg.agent_string = default_agent_name(prov_);
|
||||
host_cfg.api_port = default_api_port(prov_);
|
||||
hc_ = host_cfg;
|
||||
|
||||
if (not utils::file::directory(data_directory_).create_directory()) {
|
||||
throw startup_exception("unable to create: " + data_directory_);
|
||||
@ -128,7 +131,8 @@ auto app_config::get_config_file_path() const -> std::string {
|
||||
}
|
||||
|
||||
auto app_config::get_database_value(const json &json_document,
|
||||
const std::string &name, database_type &dst,
|
||||
const std::string &name,
|
||||
std::atomic<database_type> &dst,
|
||||
bool &success_flag) -> bool {
|
||||
REPERTORY_USES_FUNCTION_NAME();
|
||||
|
||||
@ -243,23 +247,12 @@ auto app_config::get_json() const -> json {
|
||||
{"EnableMountManager", enable_mount_manager_},
|
||||
#endif // defined(_WIN32)
|
||||
{"EnableMaxCacheSize", enable_max_cache_size_},
|
||||
{"EncryptConfig",
|
||||
{
|
||||
{"EncryptionToken", encrypt_config_.encryption_token},
|
||||
{"Path", encrypt_config_.path},
|
||||
}},
|
||||
{"EncryptConfig", get_encrypt_config()},
|
||||
{"EventLevel", event_level_to_string(event_level_)},
|
||||
{"EvictionDelayMinutes", eviction_delay_mins_},
|
||||
{"EvictionUsesAccessedTime", eviction_uses_accessed_time_},
|
||||
{"HighFreqIntervalSeconds", high_freq_interval_secs_},
|
||||
{"HostConfig",
|
||||
{
|
||||
{"AgentString", hc_.agent_string},
|
||||
{"ApiPassword", hc_.api_password},
|
||||
{"ApiPort", hc_.api_port},
|
||||
{"HostNameOrIp", hc_.host_name_or_ip},
|
||||
{"TimeoutMs", hc_.timeout_ms},
|
||||
}},
|
||||
{"HostConfig", get_host_config()},
|
||||
{"LowFreqIntervalSeconds", low_freq_interval_secs_},
|
||||
{"MaxCacheSizeBytes", max_cache_size_bytes_},
|
||||
{"MaxUploadCount", max_upload_count_},
|
||||
@ -284,22 +277,8 @@ auto app_config::get_json() const -> json {
|
||||
},
|
||||
{"RetryReadCount", retry_read_count_},
|
||||
{"RingBufferFileSize", ring_buffer_file_size_},
|
||||
{"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},
|
||||
}},
|
||||
{"S3Config", get_s3_config()},
|
||||
{"SiaConfig", get_sia_config()},
|
||||
{"TaskWaitMillis", task_wait_ms_},
|
||||
{"Version", version_}};
|
||||
|
||||
@ -357,7 +336,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<std::uint64_t>(100ULL * 1024ULL * 1024ULL),
|
||||
max_cache_size_bytes_);
|
||||
static_cast<std::uint64_t>(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;
|
||||
@ -393,13 +372,13 @@ auto app_config::get_value_by_name(const std::string &name) -> std::string {
|
||||
|
||||
try {
|
||||
if (name == "ApiAuth") {
|
||||
return api_auth_;
|
||||
return get_api_auth();
|
||||
}
|
||||
if (name == "ApiPort") {
|
||||
return std::to_string(get_api_port());
|
||||
}
|
||||
if (name == "ApiUser") {
|
||||
return api_user_;
|
||||
return get_api_user();
|
||||
}
|
||||
if (name == "DatabaseType") {
|
||||
return database_type_to_string(get_database_type());
|
||||
@ -421,14 +400,14 @@ auto app_config::get_value_by_name(const std::string &name) -> std::string {
|
||||
#if defined(_WIN32)
|
||||
}
|
||||
if (name == "EnableMountManager") {
|
||||
return std::to_string(get_enable_mount_manager());
|
||||
return utils::string::from_bool(get_enable_mount_manager());
|
||||
#endif // defined(_WIN32)
|
||||
}
|
||||
if (name == "EncryptConfig.Path") {
|
||||
return utils::path::absolute(encrypt_config_.path);
|
||||
return utils::path::absolute(get_encrypt_config().path);
|
||||
}
|
||||
if (name == "EncryptConfig.EncryptionToken") {
|
||||
return encrypt_config_.encryption_token;
|
||||
return get_encrypt_config().encryption_token;
|
||||
}
|
||||
if (name == "EventLevel") {
|
||||
return event_level_to_string(get_event_level());
|
||||
@ -443,19 +422,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 hc_.agent_string;
|
||||
return get_host_config().agent_string;
|
||||
}
|
||||
if (name == "HostConfig.ApiPassword") {
|
||||
return hc_.api_password;
|
||||
return get_host_config().api_password;
|
||||
}
|
||||
if (name == "HostConfig.ApiPort") {
|
||||
return std::to_string(hc_.api_port);
|
||||
return std::to_string(get_host_config().api_port);
|
||||
}
|
||||
if (name == "HostConfig.HostNameOrIp") {
|
||||
return hc_.host_name_or_ip;
|
||||
return get_host_config().host_name_or_ip;
|
||||
}
|
||||
if (name == "HostConfig.TimeoutMs") {
|
||||
return std::to_string(hc_.timeout_ms);
|
||||
return std::to_string(get_host_config().timeout_ms);
|
||||
}
|
||||
if (name == "LowFreqIntervalSeconds") {
|
||||
return std::to_string(get_low_frequency_interval_secs());
|
||||
@ -516,34 +495,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 s3_config_.access_key;
|
||||
return get_s3_config().access_key;
|
||||
}
|
||||
if (name == "S3Config.Bucket") {
|
||||
return s3_config_.bucket;
|
||||
return get_s3_config().bucket;
|
||||
}
|
||||
if (name == "S3Config.EncryptionToken") {
|
||||
return s3_config_.encryption_token;
|
||||
return get_s3_config().encryption_token;
|
||||
}
|
||||
if (name == "S3Config.Region") {
|
||||
return s3_config_.region;
|
||||
return get_s3_config().region;
|
||||
}
|
||||
if (name == "S3Config.SecretKey") {
|
||||
return s3_config_.secret_key;
|
||||
return get_s3_config().secret_key;
|
||||
}
|
||||
if (name == "S3Config.URL") {
|
||||
return s3_config_.url;
|
||||
return get_s3_config().url;
|
||||
}
|
||||
if (name == "S3Config.UsePathStyle") {
|
||||
return utils::string::from_bool(s3_config_.use_path_style);
|
||||
return utils::string::from_bool(get_s3_config().use_path_style);
|
||||
}
|
||||
if (name == "S3Config.UseRegionInURL") {
|
||||
return utils::string::from_bool(s3_config_.use_region_in_url);
|
||||
return utils::string::from_bool(get_s3_config().use_region_in_url);
|
||||
}
|
||||
if (name == "S3Config.TimeoutMs") {
|
||||
return std::to_string(s3_config_.timeout_ms);
|
||||
return std::to_string(get_s3_config().timeout_ms);
|
||||
}
|
||||
if (name == "SiaConfig.Bucket") {
|
||||
return sia_config_.bucket;
|
||||
return get_sia_config().bucket;
|
||||
}
|
||||
if (name == "TaskWaitMillis") {
|
||||
return std::to_string(get_task_wait_ms());
|
||||
@ -559,7 +538,7 @@ auto app_config::load() -> bool {
|
||||
|
||||
auto ret{false};
|
||||
|
||||
const auto config_file_path = get_config_file_path();
|
||||
auto config_file_path = get_config_file_path();
|
||||
recur_mutex_lock lock(read_write_mutex_);
|
||||
if (utils::file::file(config_file_path).exists()) {
|
||||
try {
|
||||
@ -567,11 +546,11 @@ auto app_config::load() -> bool {
|
||||
if (config_file.is_open()) {
|
||||
std::stringstream stream;
|
||||
stream << config_file.rdbuf();
|
||||
const auto json_text = stream.str();
|
||||
auto json_text = stream.str();
|
||||
config_file.close();
|
||||
ret = not json_text.empty();
|
||||
if (ret) {
|
||||
const auto json_document = json::parse(json_text);
|
||||
auto json_document = json::parse(json_text);
|
||||
|
||||
get_value(json_document, "ApiAuth", api_auth_, ret);
|
||||
get_value(json_document, "ApiPort", api_port_, ret);
|
||||
@ -591,13 +570,8 @@ auto app_config::load() -> bool {
|
||||
ret);
|
||||
|
||||
if (json_document.find("EncryptConfig") != json_document.end()) {
|
||||
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;
|
||||
encrypt_config_ =
|
||||
json_document["EncryptConfig"].get<encrypt_config>();
|
||||
} else {
|
||||
ret = false;
|
||||
}
|
||||
@ -608,44 +582,19 @@ auto app_config::load() -> bool {
|
||||
}
|
||||
|
||||
if (json_document.find("HostConfig") != json_document.end()) {
|
||||
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;
|
||||
hc_ = json_document["HostConfig"].get<host_config>();
|
||||
} else {
|
||||
ret = false;
|
||||
}
|
||||
|
||||
if (json_document.find("S3Config") != json_document.end()) {
|
||||
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;
|
||||
s3_config_ = json_document["S3Config"].get<s3_config>();
|
||||
} else {
|
||||
ret = false;
|
||||
}
|
||||
|
||||
if (json_document.find("SiaConfig") != json_document.end()) {
|
||||
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;
|
||||
sia_config_ = json_document["SiaConfig"].get<sia_config>();
|
||||
} else {
|
||||
ret = false;
|
||||
}
|
||||
@ -727,7 +676,7 @@ auto app_config::load() -> bool {
|
||||
void app_config::save() {
|
||||
REPERTORY_USES_FUNCTION_NAME();
|
||||
|
||||
const auto file_path = get_config_file_path();
|
||||
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()) {
|
||||
@ -751,17 +700,21 @@ 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);
|
||||
} else {
|
||||
return;
|
||||
}
|
||||
|
||||
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_is_remote_mount(bool is_remote_mount) {
|
||||
recur_mutex_lock remote_lock(remote_mount_mutex_);
|
||||
void app_config::set_host_config(host_config cfg) { set_value(hc_, cfg); }
|
||||
|
||||
void app_config::set_is_remote_mount(bool is_remote_mount) {
|
||||
if (get_enable_remote_mount()) {
|
||||
set_value(is_remote_mount_, false);
|
||||
return;
|
||||
@ -770,6 +723,10 @@ 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();
|
||||
@ -794,7 +751,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(db_type_);
|
||||
return database_type_to_string(get_database_type());
|
||||
}
|
||||
if (name == "EnableChunkDownloaderTimeout") {
|
||||
set_enable_chunk_downloader_timeout(utils::string::to_bool(value));
|
||||
@ -820,11 +777,11 @@ auto app_config::set_value_by_name(const std::string &name,
|
||||
}
|
||||
if (name == "EncryptConfig.EncryptionToken") {
|
||||
set_value(encrypt_config_.encryption_token, value);
|
||||
return encrypt_config_.encryption_token;
|
||||
return get_encrypt_config().encryption_token;
|
||||
}
|
||||
if (name == "EncryptConfig.Path") {
|
||||
set_value(encrypt_config_.path, utils::path::absolute(value));
|
||||
return encrypt_config_.path;
|
||||
return get_encrypt_config().path;
|
||||
}
|
||||
if (name == "EventLevel") {
|
||||
set_event_level(event_level_from_string(value));
|
||||
@ -844,23 +801,23 @@ auto app_config::set_value_by_name(const std::string &name,
|
||||
}
|
||||
if (name == "HostConfig.AgentString") {
|
||||
set_value(hc_.agent_string, value);
|
||||
return hc_.agent_string;
|
||||
return get_host_config().agent_string;
|
||||
}
|
||||
if (name == "HostConfig.ApiPassword") {
|
||||
set_value(hc_.api_password, value);
|
||||
return hc_.api_password;
|
||||
return get_host_config().api_password;
|
||||
}
|
||||
if (name == "HostConfig.ApiPort") {
|
||||
set_value(hc_.api_port, utils::string::to_uint16(value));
|
||||
return std::to_string(hc_.api_port);
|
||||
return std::to_string(get_host_config().api_port);
|
||||
}
|
||||
if (name == "HostConfig.HostNameOrIp") {
|
||||
set_value(hc_.host_name_or_ip, value);
|
||||
return hc_.host_name_or_ip;
|
||||
return get_host_config().host_name_or_ip;
|
||||
}
|
||||
if (name == "HostConfig.TimeoutMs") {
|
||||
set_value(hc_.timeout_ms, utils::string::to_uint32(value));
|
||||
return std::to_string(hc_.timeout_ms);
|
||||
return std::to_string(get_host_config().timeout_ms);
|
||||
}
|
||||
if (name == "LowFreqIntervalSeconds") {
|
||||
set_low_frequency_interval_secs(utils::string::to_uint16(value));
|
||||
@ -941,43 +898,43 @@ auto app_config::set_value_by_name(const std::string &name,
|
||||
}
|
||||
if (name == "S3Config.AccessKey") {
|
||||
set_value(s3_config_.access_key, value);
|
||||
return s3_config_.access_key;
|
||||
return get_s3_config().access_key;
|
||||
}
|
||||
if (name == "S3Config.Bucket") {
|
||||
set_value(s3_config_.bucket, value);
|
||||
return s3_config_.bucket;
|
||||
return get_s3_config().bucket;
|
||||
}
|
||||
if (name == "S3Config.Region") {
|
||||
set_value(s3_config_.region, value);
|
||||
return s3_config_.region;
|
||||
return get_s3_config().region;
|
||||
}
|
||||
if (name == "S3Config.SecretKey") {
|
||||
set_value(s3_config_.secret_key, value);
|
||||
return s3_config_.secret_key;
|
||||
return get_s3_config().secret_key;
|
||||
}
|
||||
if (name == "S3Config.URL") {
|
||||
set_value(s3_config_.url, value);
|
||||
return s3_config_.url;
|
||||
return get_s3_config().url;
|
||||
}
|
||||
if (name == "S3Config.UsePathStyle") {
|
||||
set_value(s3_config_.use_path_style, utils::string::to_bool(value));
|
||||
return utils::string::from_bool(s3_config_.use_path_style);
|
||||
return utils::string::from_bool(get_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(s3_config_.use_region_in_url);
|
||||
return utils::string::from_bool(get_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(s3_config_.timeout_ms);
|
||||
return std::to_string(get_s3_config().timeout_ms);
|
||||
}
|
||||
if (name == "S3Config.EncryptionToken") {
|
||||
set_value(s3_config_.encryption_token, value);
|
||||
return s3_config_.encryption_token;
|
||||
return get_s3_config().encryption_token;
|
||||
}
|
||||
if (name == "SiaConfig.Bucket") {
|
||||
set_value(sia_config_.bucket, value);
|
||||
return sia_config_.bucket;
|
||||
return get_sia_config().bucket;
|
||||
}
|
||||
if (name == "TaskWaitMillis") {
|
||||
set_task_wait_ms(utils::string::to_uint16(value));
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user