224 lines
7.4 KiB
C++
224 lines
7.4 KiB
C++
#ifndef CONFIG_H_H
|
|
#define CONFIG_H_H
|
|
#include "../DSP/export.h"
|
|
#include "../Data_Feed/export.h"
|
|
#include "../Data_Source/export.h"
|
|
#include "Core/spdlog/export.h"
|
|
#include "MLAT.h"
|
|
#include "Source_Feed_Relation.h"
|
|
#include <fstream>
|
|
inline bool delete_log = false;
|
|
extern std::string default_config_path;
|
|
std::string get_config_path();
|
|
struct Log_Config {
|
|
~Log_Config() {
|
|
if (delete_log)
|
|
std::cout << "~Log_Config()" << std::endl;
|
|
}
|
|
enum class Open_Mode { Append, Delete, Rename };
|
|
Open_Mode open_mode = Open_Mode::Rename;
|
|
std::uint16_t piece_num{};
|
|
std::uint16_t size_MB{};
|
|
PSC_USE_JSON
|
|
};
|
|
struct Console_Config {
|
|
~Console_Config() {
|
|
if (delete_log)
|
|
std::cout << "~Console_Config()" << std::endl;
|
|
}
|
|
bool record_playback;
|
|
bool mode_s_console;
|
|
bool post_request;
|
|
bool mlat_server;
|
|
PSC_USE_JSON
|
|
};
|
|
struct Http_Monitor_Config {
|
|
bool access_log = true;
|
|
std::size_t slow_request_threshold_ms = 1000;
|
|
std::size_t slow_scope_threshold_ms = 100;
|
|
PSC_USE_JSON
|
|
};
|
|
|
|
struct Mode_ACS_Config_Base_Data {
|
|
Psc::Copyable_Atomic<std::size_t> timeout_seconds{};
|
|
Psc::Copyable_Atomic<std::size_t> max_speed_m_s{};
|
|
Psc::Copyable_Atomic<std::size_t> air_pos_timeout = 8;
|
|
Psc::Copyable_Atomic<std::size_t> surface_pos_timeout = 32;
|
|
Psc::Copyable_Atomic<std::size_t> read_milliseconds{};
|
|
PSC_USE_JSON
|
|
};
|
|
|
|
struct Mode_ACS_Config_Data {
|
|
Psc::Copyable_Atomic<std::size_t> max_track_point_size{};
|
|
Psc::Copyable_Atomic<std::size_t> mode_s_max_num{};
|
|
Psc::Copyable_Atomic<std::size_t> mode_other_max_num{};
|
|
Psc::Copyable_Atomic<std::size_t> report_data_feed_msg_mum{};
|
|
Psc::Copyable_Atomic<std::size_t> default_min_aircraft_list_num{};
|
|
Psc::Copyable_Atomic<bool> ignore_df_11{};
|
|
Psc::Copyable_Atomic<bool> monitor_msg_live{};
|
|
PSC_USE_JSON
|
|
};
|
|
|
|
|
|
struct Mode_ACS_Config : Mode_ACS_Config_Base_Data, Mode_ACS_Config_Data {
|
|
DELETE_COPY(Mode_ACS_Config)
|
|
Data_feed_Config data_feed_config;
|
|
Data_Source_Config data_source_config;
|
|
Source_Feed_Relation_Config source_feed_relation_config;
|
|
Psc::Copyable_Atomic<std::size_t> Report_Data_Feed_Message_Num{};
|
|
Mode_ACS_Config() = default;
|
|
~Mode_ACS_Config() {
|
|
if (delete_log)
|
|
std::cout << " ~Mode_S_Config()" << std::endl;
|
|
}
|
|
Psc::JSON to_base_json() const {
|
|
return Mode_ACS_Config_Base_Data::to_base_json();
|
|
}
|
|
void init_base_json(const Psc::JSON* that_json) {
|
|
Mode_ACS_Config_Base_Data::from_base_json(that_json);
|
|
}
|
|
void init(const Psc::JSON* that_json) {
|
|
Mode_ACS_Config_Base_Data::from_base_json(that_json);
|
|
Mode_ACS_Config_Data::from_base_json(that_json);
|
|
data_feed_config.init(that_json->get("data_feed"));
|
|
data_source_config.init(that_json->get("data_source"));
|
|
source_feed_relation_config.from_json(
|
|
that_json->get("source_feed_relation"));
|
|
if (monitor_msg_live) {
|
|
SSR::Monitor_Mode_ACS_Message_Num = this->monitor_msg_live;
|
|
}
|
|
}
|
|
Psc::JSON to_base_json() {
|
|
Psc::JSON ret = Mode_ACS_Config_Base_Data::to_base_json();
|
|
ret += Mode_ACS_Config_Data::to_base_json();
|
|
ret.append(Psc::JSON("data_feed", data_feed_config.to_json()));
|
|
ret.append(Psc::JSON("data_source", data_source_config.to_json()));
|
|
ret.append(Psc::JSON("source_feed_relation",
|
|
source_feed_relation_config.to_json()));
|
|
return ret;
|
|
}
|
|
void server(Global* g);
|
|
};
|
|
|
|
struct Web_Server_Config {
|
|
[[nodiscard]] std::string get_true_webapp() const {
|
|
return Psc::get_abs_path(webapp);
|
|
}
|
|
[[nodiscard]] std::string get_true_tiles() const {
|
|
return Psc::get_abs_path(tiles);
|
|
}
|
|
PSC_USE_JSON
|
|
std::string webapp;
|
|
std::string tiles;
|
|
};
|
|
struct Net_Config {
|
|
std::string key{};
|
|
std::string ip{};
|
|
std::uint16_t port{};
|
|
std::string netmask{};
|
|
std::string gateway{};
|
|
PSC_USE_JSON
|
|
};
|
|
struct Device_Config {
|
|
Ordered_Map<std::string, Net_Config*> list;
|
|
~Device_Config() {
|
|
if (delete_log)
|
|
std::cout << "~Device_Config()" << std::endl;
|
|
for (auto it : list.list()) {
|
|
delete it;
|
|
}
|
|
list.clear();
|
|
}
|
|
Psc::JSON to_base_json() {
|
|
Psc::JSON ret = Psc::JSON::object();
|
|
Psc::JSON net = Psc::JSON::array();
|
|
for (auto& li : list.list()) {
|
|
net.append(li->to_base_json());
|
|
}
|
|
ret.append({"net", net});
|
|
return ret;
|
|
}
|
|
Device_Config() = default;
|
|
void init(const Psc::JSON* that_json) {
|
|
for (auto& li : that_json->get("net")->children) {
|
|
auto cur = new Net_Config();
|
|
cur->from_base_json(&li);
|
|
list.push_back(cur);
|
|
}
|
|
}
|
|
Psc::JSON to_net_json() {
|
|
Psc::JSON ret = Psc::JSON::object();
|
|
Psc::JSON net = Psc::JSON::array();
|
|
for (auto& li : list.list()) {
|
|
net.append(li->to_base_json());
|
|
}
|
|
ret.append({"net", net});
|
|
return ret;
|
|
}
|
|
void server(Global* g);
|
|
};
|
|
class Config {
|
|
public:
|
|
Config() = default;
|
|
DELETE_COPY(Config)
|
|
MLAT_Config mlat;
|
|
Device_Config device_config;
|
|
Web_Server_Config web_server_config;
|
|
Mode_ACS_Config mode_acs;
|
|
Log_Config log_config;
|
|
Console_Config console_config{};
|
|
DSP_Config dsp_config;
|
|
Psc::JSON drogon_config;
|
|
Http_Monitor_Config http_monitor_config;
|
|
std::string version;
|
|
External_Resources_Manager external_resources_manager;
|
|
static Psc::JSON load() {
|
|
std::string config_path = get_config_path();
|
|
std::ifstream iso(config_path);
|
|
if (!iso.is_open()) {
|
|
std::cerr << config_path << " can not open!" << std::endl;
|
|
Psc::fail_fast();
|
|
}
|
|
else {
|
|
std::cout << get_current_date_string() << " 启动加载配置文件: 【"
|
|
<< config_path << "】" << std::endl;
|
|
}
|
|
std::stringstream ss;
|
|
std::stringstream buffer;
|
|
buffer << iso.rdbuf();
|
|
std::string fileContents = buffer.str();
|
|
return Psc::parse_json(fileContents);
|
|
}
|
|
void fromJson(Psc::JSON* that_json) {
|
|
Get_J(version)
|
|
mlat.init(that_json->get("mlat"));
|
|
web_server_config.from_base_json(that_json->get("web_server"));
|
|
device_config.init(that_json->get("device"));
|
|
mode_acs.init(that_json->get("mode_acs"));
|
|
console_config.from_base_json(that_json->get("console"));
|
|
dsp_config.from_json(that_json->get("dsp"));
|
|
drogon_config = *that_json->get("drogon");
|
|
http_monitor_config.from_base_json(that_json->get("http_monitor"));
|
|
external_resources_manager.init(that_json->get("external_database"));
|
|
}
|
|
Psc::JSON toJson() {
|
|
auto ret = Psc::JSON::object({
|
|
{"version", version},
|
|
{"dsp", dsp_config.to_base_json()},
|
|
{"drogon", drogon_config},
|
|
{"http_monitor", http_monitor_config.to_base_json()},
|
|
{"mlat", mlat.to_base_json()},
|
|
{"web_server", web_server_config.to_base_json()},
|
|
{"device", device_config.to_base_json()},
|
|
{"mode_acs", mode_acs.to_base_json()},
|
|
//{"ais", ais.to_json()},
|
|
{"log", log_config.to_base_json()},
|
|
{"console", console_config.to_base_json()},
|
|
{"external_database", external_resources_manager.to_base_json()},
|
|
});
|
|
return ret;
|
|
}
|
|
static void save();
|
|
};
|
|
#endif
|