From 3e38e77069604de9507563ff0b6bf1e0ac184ca1 Mon Sep 17 00:00:00 2001 From: Vladislav Ostapov Date: Thu, 29 May 2025 18:56:19 +0300 Subject: [PATCH] =?UTF-8?q?=D0=BA=D0=B0=D0=BA=D0=B0=D1=8F-=D1=82=D0=BE=20?= =?UTF-8?q?=D0=BA=D1=83=D1=87=D0=B0=20=D0=B8=D0=B7=D0=BC=D0=B5=D0=BD=D0=B5?= =?UTF-8?q?=D0=BD=D0=B8=D0=B9=20(2).=20=D1=82=D1=83=D1=82=20=D1=83=D0=B6?= =?UTF-8?q?=D0=B5=20=D0=B2=D1=8B=D1=80=D0=B8=D1=81=D0=BE=D0=B2=D1=8B=D0=B2?= =?UTF-8?q?=D0=B0=D0=B5=D1=82=D1=81=D1=8F=20=D0=BD=D0=BE=D0=B2=D0=B0=D1=8F?= =?UTF-8?q?=20=D0=B0=D1=80=D1=85=D0=B8=D1=82=D0=B5=D0=BA=D1=82=D1=83=D1=80?= =?UTF-8?q?=D0=B0=20=D0=B1=D0=B5=D0=BA=D0=B5=D0=BD=D0=B4=D0=B0=20=D0=B4?= =?UTF-8?q?=D0=BB=D1=8F=20cp=20api?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- CMakeLists.txt | 3 + src/api-driver/daemon.cpp | 472 ++++++++++++++++++++++++ src/api-driver/daemon.h | 80 ++++ src/api-driver/proxy.cpp | 9 + src/api-driver/proxy.h | 57 +-- src/api-driver/stricts-enable.h | 8 + src/api-driver/structs.cpp | 373 ++++++++++++++++++- src/api-driver/structs.h | 203 +++++------ src/terminal_api_driver.cpp | 623 +------------------------------- 9 files changed, 1059 insertions(+), 769 deletions(-) create mode 100644 src/api-driver/daemon.cpp create mode 100644 src/api-driver/daemon.h create mode 100644 src/api-driver/stricts-enable.h diff --git a/CMakeLists.txt b/CMakeLists.txt index c92cea5..f250d0f 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -57,6 +57,8 @@ add_subdirectory(dependencies/control_system_client) include_directories(src/) add_executable(terminal-web-server + src/api-driver/daemon.h + src/api-driver/daemon.cpp src/api-driver/proxy.h src/api-driver/proxy.cpp src/api-driver/structs.h @@ -84,6 +86,7 @@ add_executable(terminal-web-server src/auth/utils.cpp src/auth/utils.h src/version.h + src/api-driver/stricts-enable.h ) add_definitions(-DBOOST_LOG_DYN_LINK) diff --git a/src/api-driver/daemon.cpp b/src/api-driver/daemon.cpp new file mode 100644 index 0000000..199d988 --- /dev/null +++ b/src/api-driver/daemon.cpp @@ -0,0 +1,472 @@ +// +// Created by vlad on 03.04.2025. +// + +#include "daemon.h" + +#include + + +void api_driver::TerminalApiDaemon::connectToApi() { + { + std::lock_guard _lock(this->stateMutex); + this->state.fInitState = "Not connected to API"; + } +#if defined(MODEM_IS_SCPC) || defined(MODEM_IS_TDMA) + { + std::lock_guard _lock(this->settingsMutex); + this->settingsNetwork.loadDefaults(); + } +#endif + + for (int connectAttempt = 0;; connectAttempt++) { + BOOST_LOG_TRIVIAL(info) << "api_driver::TerminalApiDaemon::connectToApi(): Try to connect api (attempt " << connectAttempt << ")..."; + try { + cp.connect(); + + std::string tmp = cp.getDmaDebug("status_init"); + { + std::lock_guard _lock(this->stateMutex); + this->state.fInitState = tmp; + } + BOOST_LOG_TRIVIAL(info) << "api_driver::TerminalApiDaemon::connectToApi(): Success connect!"; + BOOST_LOG_TRIVIAL(info) << "api_driver::TerminalApiDaemon::connectToApi(): API status: " << tmp; + + obj::TerminalFirmwareVersion f; + f.load(cp); + + { + std::lock_guard _lock(this->firmwareMutex); + this->firmware = f; + } + + cp.lastCpError = OK; + break; + } catch (std::exception& e) { + BOOST_LOG_TRIVIAL(error) << "api_driver::TerminalApiDaemon::connectToApi(): connect error " << e.what(); + } + boost::this_thread::sleep_for(boost::chrono::duration(boost::chrono::milliseconds(1000))); + } +} + +void api_driver::TerminalApiDaemon::run() { + // это демон, который в бесконечном цикле опрашивает API + this->connectToApi(); + + struct { + obj::CpUpdatebleObject* u; + std::function c; + } updaters[] = { +#if API_OBJECT_NETWORK_SETTINGS_ENABLE + // обновление логов + {.u = &statsLogs, .c = [this]() { + try { + { + std::lock_guard _alock(this->cpApiMutex); + this->statsLogs.updateCallback(cp); + } + BOOST_LOG_TRIVIAL(debug) << "api_driver::TerminalApiDaemon->statsLogs.putItem(): success write statistics state to log!"; + } catch (std::exception& e) { + BOOST_LOG_TRIVIAL(error) << "api_driver::TerminalApiDaemon->statsLogs.putItem() failed to log: " << e.what(); + } + }}, +#endif + // обновление статистики + {.u = state, .c = [this]() { + try { + std::lock_guard _alock(this->cpApiMutex); + std::lock_guard _slock(this->stateMutex); + state.updateCallback(cp); + stateDev.updateCallback(cp); + BOOST_LOG_TRIVIAL(debug) << "api_driver::TerminalApiDaemon::updateState(): success update!"; + } catch (std::exception& e) { + BOOST_LOG_TRIVIAL(error) << "api_driver::TerminalApiDaemon::updateState(): " << e.what(); + } + }}, + // обновление кеша настроек + {.lastUpdate = 0, .periodMs = CACHE_SETTINGS_UPDATE_MS, .c = [this]() { + try { + this->updateSettings(); + BOOST_LOG_TRIVIAL(debug) << "api_driver::TerminalApiDaemon::updateSettings(): success update!"; + } catch (std::exception& e) { + BOOST_LOG_TRIVIAL(error) << "api_driver::TerminalApiDaemon::updateSettings(): " << e.what(); + } + }}, + // обновление кеша настроек сети (делается отдельно) + {.lastUpdate = 0, .periodMs = CACHE_SETTINGS_UPDATE_MS, .c = [this]() { + try { + this->updateNetworkSettings(); + BOOST_LOG_TRIVIAL(debug) << "api_driver::TerminalApiDaemon::updateNetworkSettings(): success update!"; + } catch (std::exception& e) { + BOOST_LOG_TRIVIAL(error) << "api_driver::TerminalApiDaemon::updateNetworkSettings(): " << e.what(); + } + }}, + // обновление кеша QoS + {.lastUpdate = 0, .periodMs = CACHE_QOS_UPDATE_MS, .c = [this]() { + try { + this->updateQos(); + BOOST_LOG_TRIVIAL(debug) << "api_driver::TerminalApiDaemon::updateQos(): success update!"; + } catch (std::exception& e) { + BOOST_LOG_TRIVIAL(error) << "api_driver::TerminalApiDaemon::updateQos(): " << e.what(); + } + }} + }; + + while (true) { + if (this->lastCpError == ERROR || this->lastCpError == TIMEOUT) { + BOOST_LOG_TRIVIAL(error) << "api_driver::TerminalApiDaemon::run(): close current daemon session caused error " << this->lastCpError; + CP_Logout(this->sid); + this->connectToApi(); + } +#ifdef MODEM_IS_SCPC + updaters[0].periodMs = this->statsLogs.logEn ? this->statsLogs.logPeriodMs.load() : -1; +#endif + int64_t sleepTime = 60000; // минута по-умолчанию + auto now = TIME_NOW(); + for (auto& u: updaters) { + if (u.checkNeedUpdate(now)) { + auto targetTime = u.lastUpdate + u.periodMs; + if (targetTime + SLEEP_THRESHOLD <= now && targetTime - SLEEP_THRESHOLD >= now) { + u.lastUpdate = targetTime; + } else { + u.lastUpdate = now; + } + + u.callback(); + now = TIME_NOW(); + } + if (u.periodMs >= 0) { + sleepTime = std::min(sleepTime, u.getNextUpdate(now)); + } + } + + if (sleepTime > 0) { + boost::this_thread::sleep_for(boost::chrono::duration(boost::chrono::milliseconds(sleepTime))); + } + } +} + +api_driver::TerminalApiDaemon::TerminalApiDaemon(): daemon([this]() { this->run(); }) {} + +void api_driver::TerminalApiDaemon::getState(obj::TerminalState &dest) { + std::shared_lock _lock(state); + dest = state; +} + +void api_driver::TerminalApiDaemon::getDeviceState(obj::TerminalDeviceState &dest) { + std::shared_lock _lock(state); + dest = stateDev; +} + +void api_driver::TerminalApiDaemon::getSettingsRxTx(obj::TerminalRxTxSettings &dest) { +} + +void api_driver::TerminalApiDaemon::getNetworkSettings(obj::TerminalNetworkSettings &dest) { +} + +void api_driver::TerminalApiDaemon::getQosSettings(bool &isEnabled, std::string &json) { +} + +void api_driver::TerminalApiDaemon::setSettingsRxTx(obj::TerminalRxTxSettings &s, bool readback) { +} + +void api_driver::TerminalApiDaemon::setSettingsDpdi(DPDI_parmeters &s, bool readback) { +} + +void api_driver::TerminalApiDaemon::setSettingsBucLnb(buc_lnb_settings &bucLnb, bool readback) { +} + +void api_driver::TerminalApiDaemon::setQosSettings(bool enabled, const std::string &str, bool readback) { +} + +void api_driver::TerminalApiDaemon::setNetworkSettings(obj::TerminalNetworkSettings &s, bool readback) { +} + +api_driver::obj::TerminalFirmwareVersion api_driver::TerminalApiDaemon::getFirmware() { +} + +void api_driver::TerminalApiDaemon::resetPacketStatistics() { +} + +void api_driver::TerminalApiDaemon::resetDefaultSettings() { +} + +api_driver::TerminalApiDaemon::~TerminalApiDaemon() { + try { + daemon.interrupt(); + daemon.try_join_for(boost::chrono::seconds(2)); + } catch (std::exception& e) { + BOOST_LOG_TRIVIAL(error) << "api_driver::~TerminalApiDaemon(): " << e.what(); + } +} + + + + +///////////////////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Этот демон нужен для того, чтобы получать статистику из API, а так же корректно сохранять настройки + */ +class api_driver::TerminalApiDaemon { + void updateState() { + obj::TerminalDeviceState s; + + std::lock_guard lock(this->cpApiMutex); + try { + s.updateCallback(cp); + } + + { + std::lock_guard lock2(this->stateMutex); + this->state = s; +#ifdef MODEM_IS_TDMA + this->state.fInitState = tmpDevState; +#endif + } + } + + void updateSettings() { + modulator_settings mod{}; + // uint32_t modulatorModcod; + // CP_GetModulatorParams(sid, "modcod", &modulatorModcod); + demodulator_settings demod{}; +#ifdef MODEM_IS_SCPC + ACM_parameters_serv_ acm{}; +#endif + DPDI_parmeters dpdi{}; + buc_lnb_settings bucLnb{}; + + std::lock_guard lock(this->cpApiMutex); + logCpApiError("api_driver::TerminalApiDaemon::updateSettings()->CP_GetModulatorSettings()", CP_GetModulatorSettings(sid, mod)); + logCpApiError("api_driver::TerminalApiDaemon::updateSettings()->CP_GetDemodulatorSettings()", CP_GetDemodulatorSettings(sid, demod)); +#ifdef MODEM_IS_SCPC + logCpApiError("api_driver::TerminalApiDaemon::updateSettings()->CP_GetAcmParams()", CP_GetAcmParams(sid, &acm)); +#endif + logCpApiError("api_driver::TerminalApiDaemon::updateSettings()->CP_GetDpdiParams()", CP_GetDpdiParams(sid, &dpdi)); + logCpApiError("api_driver::TerminalApiDaemon::updateSettings()->CP_GetBUC_LNB_settings()", CP_GetBUC_LNB_settings(sid, bucLnb)); + + { + std::lock_guard lock2(this->settingsMutex); + this->modSettings = mod; + this->demodSettings = demod; +#ifdef MODEM_IS_SCPC + this->acmSettings = acm; +#endif + this->dpdiSettings = dpdi; + this->bucLnbSettings = bucLnb; + } + } + + void updateNetworkSettings() { + obj::TerminalNetworkSettings s; + + std::lock_guard lock(this->cpApiMutex); + unsafeLoadNetworkSettings(s); + + { + std::lock_guard lock2(this->networkSettingsMutex); + this->networkSettings = s; + } + } + + void updateQos() { + bool tmp1; std::string tmp2; + std::scoped_lock lock{this->cpApiMutex}; + logCpApiError("api_driver::TerminalApiDaemon::updateQos()->CP_GetQoSSettings()", CP_GetQoSSettings(this->sid, tmp2, tmp1)); + { + std::lock_guard lock2(this->qosSettingsMutex); + this->qosEnabled = tmp1; + this->qosClassesJson = tmp2.empty() ? DEFAULT_QOS_CLASSES : tmp2; + } + } + +public: + + + + /** + * Получение статистики, копирует текущие значения в структуры, переданные по указателю. Если передан пустой указатель, копирования не произойдет. + */ + TerminalDeviceState getState() { + TerminalDeviceState s; + { + std::shared_lock lock(this->stateMutex); + s = this->state; + } + return s; + } + /** + * Получение настроек, копирует текущие значения в структуры, переданные по указателю. Если передан пустой указатель, копирования не произойдет. + */ + void getSettings( + modulator_settings* mod, demodulator_settings* demod, +#ifdef MODEM_IS_SCPC + ACM_parameters_serv_* acm, +#endif + DPDI_parmeters* dpdi, buc_lnb_settings* bucLnb) { + if (mod || demod || +#ifdef MODEM_IS_SCPC + acm || +#endif + dpdi || bucLnb) { + std::shared_lock lock(this->settingsMutex); + if (mod) { *mod = this->modSettings; } + if (demod) { *demod = this->demodSettings; } +#ifdef MODEM_IS_SCPC + if (acm) { *acm = this->acmSettings; } +#endif + if (dpdi) { *dpdi = this->dpdiSettings; } + if (bucLnb) { *bucLnb = this->bucLnbSettings; } + } + } + +#ifdef MODEM_IS_SCPC + bool getIsCinC() { + std::shared_lock lock(this->settingsMutex); + return modSettings.is_cinc; + } +#endif + + bool isTest() { + std::shared_lock lock(this->settingsMutex); + return modSettings.tx_is_on && (!modSettings.is_carrier +#ifdef MODEM_IS_SCPC + || this->modSettings.is_test_data +#endif + ); + } + + void getNetworkSettings(TerminalNetworkSettings& dest) { + std::shared_lock lock(this->networkSettingsMutex); + dest = this->networkSettings; + } + + void getQosSettings(bool& isEnabled, std::string& json) { + std::shared_lock lock(this->qosSettingsMutex); + isEnabled = this->qosEnabled; + json = this->qosClassesJson; + } + +#ifdef MODEM_IS_SCPC + void setSettingsRxTx(modulator_settings& mod, demodulator_settings& demod, ACM_parameters_serv_& acm, bool readback = true) { + std::lock_guard lock(this->cpApiMutex); + logCpApiError("api_driver::TerminalApiDaemon::setSettingsRxTx()->CP_SetDmaDebug(begin_save_config)", CP_SetDmaDebug(sid, "begin_save_config", "")); + logCpApiError("api_driver::TerminalApiDaemon::setSettingsRxTx()->CP_SetModulatorSettings()", CP_SetModulatorSettings(this->sid, mod)); + logCpApiError("api_driver::TerminalApiDaemon::setSettingsRxTx()->CP_SetDemodulatorSettings()", CP_SetDemodulatorSettings(this->sid, demod)); + logCpApiError("api_driver::TerminalApiDaemon::setSettingsRxTx()->CP_SetAcmParams()", CP_SetAcmParams(this->sid, acm)); + if (readback) { + logCpApiError("api_driver::TerminalApiDaemon::setSettingsRxTx()->CP_GetModulatorSettings()", CP_GetModulatorSettings(this->sid, mod)); + logCpApiError("api_driver::TerminalApiDaemon::setSettingsRxTx()->CP_GetDemodulatorSettings()", CP_GetDemodulatorSettings(this->sid, demod)); + logCpApiError("api_driver::TerminalApiDaemon::setSettingsRxTx()->CP_GetAcmParams()", CP_GetAcmParams(this->sid, &acm)); + { + std::lock_guard lock2{this->settingsMutex}; + this->modSettings = mod; + this->demodSettings = demod; + this->acmSettings = acm; + } + } + logCpApiError("api_driver::TerminalApiDaemon::setSettingsRxTx()->CP_SetDmaDebug(save_config)", CP_SetDmaDebug(sid, "save_config", "")); + } +#else + void setSettingsRxTx(modulator_settings& mod, demodulator_settings& demod, bool readback = true) { + std::lock_guard lock(this->cpApiMutex); + logCpApiError("api_driver::TerminalApiDaemon::setSettingsRxTx()->CP_SetDmaDebug(begin_save_config)", CP_SetDmaDebug(sid, "begin_save_config", "")); + logCpApiError("api_driver::TerminalApiDaemon::setSettingsRxTx()->CP_SetModulatorSettings()", CP_SetModulatorSettings(this->sid, mod)); + logCpApiError("api_driver::TerminalApiDaemon::setSettingsRxTx()->CP_SetDemodulatorSettings()", CP_SetDemodulatorSettings(this->sid, demod)); + if (readback) { + logCpApiError("api_driver::TerminalApiDaemon::setSettingsRxTx()->CP_GetModulatorSettings()", CP_GetModulatorSettings(this->sid, mod)); + logCpApiError("api_driver::TerminalApiDaemon::setSettingsRxTx()->CP_GetDemodulatorSettings()", CP_GetDemodulatorSettings(this->sid, demod)); + { + std::lock_guard lock2{this->settingsMutex}; + this->modSettings = mod; + this->demodSettings = demod; + } + } + logCpApiError("api_driver::TerminalApiDaemon::setSettingsRxTx()->CP_SetDmaDebug(save_config)", CP_SetDmaDebug(sid, "save_config", "")); + } +#endif + + void setSettingsDpdi(DPDI_parmeters& s, bool readback = true) { + std::lock_guard lock(this->cpApiMutex); + logCpApiError("api_driver::TerminalApiDaemon::setSettingsDpdi()->CP_SetDmaDebug(begin_save_config)", CP_SetDmaDebug(sid, "begin_save_config", "")); + logCpApiError("api_driver::TerminalApiDaemon::setSettingsDpdi()->CP_SetDpdiParams()", CP_SetDpdiParams(sid, s)); + if (readback) { + logCpApiError("api_driver::TerminalApiDaemon::setSettingsDpdi()->CP_GetDpdiParams()", CP_GetDpdiParams(this->sid, &s)); + { + std::lock_guard lock2{this->settingsMutex}; + this->dpdiSettings = s; + } + } + logCpApiError("api_driver::TerminalApiDaemon::setSettingsDpdi()->CP_SetDmaDebug(save_config)", CP_SetDmaDebug(sid, "save_config", "")); + } + + void setSettingsBucLnb(buc_lnb_settings& bucLnb, bool readback = true) { + std::lock_guard lock(this->cpApiMutex); + logCpApiError("api_driver::TerminalApiDaemon::setSettingsBucLnb()->CP_SetDmaDebug(begin_save_config)", CP_SetDmaDebug(sid, "begin_save_config", "")); + logCpApiError("api_driver::TerminalApiDaemon::setSettingsBucLnb()->CP_SetBUC_LNB_settings()", CP_SetBUC_LNB_settings(this->sid, bucLnb)); + if (readback) { + logCpApiError("api_driver::TerminalApiDaemon::setSettingsBucLnb()->CP_GetBUC_LNB_settings()", CP_GetBUC_LNB_settings(this->sid, bucLnb)); + { + std::lock_guard lock2{this->settingsMutex}; + this->bucLnbSettings = bucLnb; + } + } + logCpApiError("api_driver::TerminalApiDaemon::setSettingsBucLnb()->CP_SetDmaDebug(save_config)", CP_SetDmaDebug(sid, "save_config", "")); + } + + void setQosSettings(bool enabled, const std::string& str, bool readback = true) { + std::lock_guard lock(this->cpApiMutex); + logCpApiError("api_driver::TerminalApiDaemon::setQosSettings()->CP_SetDmaDebug(begin_save_config)", CP_SetDmaDebug(sid, "begin_save_config", "")); + logCpApiError("api_driver::TerminalApiDaemon::setQosSettings()->CP_SetQoSSettings()", CP_SetQoSSettings(this->sid, str, enabled)); + if (readback) { + bool tmp1; std::string tmp2; + logCpApiError("api_driver::TerminalApiDaemon::setQosSettings()->CP_GetQoSSettings()", CP_GetQoSSettings(this->sid, tmp2, tmp1)); + { + std::lock_guard lock2(this->qosSettingsMutex); + this->qosEnabled = tmp1; + this->qosClassesJson = tmp2.empty() ? DEFAULT_QOS_CLASSES : tmp2; + } + } + logCpApiError("api_driver::TerminalApiDaemon::setQosSettings()->CP_SetDmaDebug(save_config)", CP_SetDmaDebug(sid, "save_config", "")); + } + + void setNetworkSettings(TerminalNetworkSettings& s, bool readback = true) { + // const auto mang = splitIpAndMask(); + // std::pair data; + // if (!s.isL2) { + // data = splitIpAndMask(s.dataIp); + // } + + std::lock_guard lock(this->cpApiMutex); + logCpApiError("api_driver::TerminalApiDaemon::setNetworkSettings()->CP_SetDmaDebug(begin_save_config)", CP_SetDmaDebug(sid, "begin_save_config", "")); + unsafStoreNetworkSettings(s); + + if (readback) { + unsafeLoadNetworkSettings(s); + { + std::lock_guard lock2(this->networkSettingsMutex); + this->networkSettings = s; + } + } + logCpApiError("api_driver::TerminalApiDaemon::setNetworkSettings()->CP_SetDmaDebug(save_config)", CP_SetDmaDebug(sid, "save_config", "")); + } + + TerminalFirmwareVersion getFirmware() { + std::shared_lock lock(this->firmwareMutex); + return firmware; + } + + void resetPacketStatistics() { + std::string tmp; + std::lock_guard lock(this->cpApiMutex); + logCpApiError("api_driver::TerminalApiDaemon::resetPacketStatistics()->CP_GetDmaDebug(reset_cnt_rx)", CP_GetDmaDebug(sid, "reset_cnt_rx", &tmp)); + } + + void resetDefaultSettings() { + std::lock_guard lock(this->cpApiMutex); + logCpApiError("api_driver::TerminalApiDaemon::resetDefaultSettings()->CP_SetDmaDebug(begin_save_config)", CP_SetDmaDebug(sid, "begin_save_config", "")); + logCpApiError("api_driver::TerminalApiDaemon::resetDefaultSettings()->CP_SetDmaDebug(default_params)", CP_SetDmaDebug(sid, "default_params", "")); + logCpApiError("api_driver::TerminalApiDaemon::resetDefaultSettings()->CP_SetDmaDebug(save_config)", CP_SetDmaDebug(sid, "save_config", "")); + } + +}; diff --git a/src/api-driver/daemon.h b/src/api-driver/daemon.h new file mode 100644 index 0000000..2b7b90e --- /dev/null +++ b/src/api-driver/daemon.h @@ -0,0 +1,80 @@ +#ifndef DAEMON_H +#define DAEMON_H + +#include + +#include "proxy.h" +#include "api-driver/structs.h" + +namespace api_driver { + class TerminalApiDaemon { + std::mutex cpApiMutex; + boost::thread daemon; + proxy::CpProxy cp; + + void connectToApi(); + + void run(); + + std::shared_mutex stateMutex; + obj::TerminalState state; + obj::TerminalDeviceState stateDev; + + std::shared_mutex settingsMutex; + obj::TerminalRxTxSettings settingsRxTx; +#if API_OBJECT_NETWORK_SETTINGS_ENABLE + obj::TerminalNetworkSettings settingsNetwork; +#endif +#if API_OBJECT_QOS_SETTINGS_ENABLE + obj::TerminalQosSettings settingsQos; +#endif + + std::shared_mutex firmwareMutex; + obj::TerminalFirmwareVersion firmware; + + public: +#if API_OBJECT_STATISTICS_ENABLE + obj::StatisticsLogger statsLogs; +#endif + + explicit TerminalApiDaemon(); + + std::string getDeviceInitState(); + + /** + * Получение статистики, копирует текущие значения в структуры, переданные по указателю. Если передан пустой указатель, копирования не произойдет. + */ + void getState(obj::TerminalState& dest); + void getDeviceState(obj::TerminalDeviceState& dest); + + // /** + // * Получение настроек, копирует текущие значения в структуры, переданные по указателю. Если передан пустой указатель, копирования не произойдет. + // */ + void getSettingsRxTx(obj::TerminalRxTxSettings& dest); + + void getNetworkSettings(obj::TerminalNetworkSettings& dest); + + void getQosSettings(bool& isEnabled, std::string& json); + + void setSettingsRxTx(obj::TerminalRxTxSettings& s, bool readback = true); + + void setSettingsDpdi(DPDI_parmeters& s, bool readback = true); + + void setSettingsBucLnb(buc_lnb_settings& bucLnb, bool readback = true); + + void setQosSettings(bool enabled, const std::string& str, bool readback = true); + + void setNetworkSettings(obj::TerminalNetworkSettings& s, bool readback = true); + + obj::TerminalFirmwareVersion getFirmware(); + + void resetPacketStatistics(); + + void resetDefaultSettings(); + + ~TerminalApiDaemon(); + }; +} + + +#endif //DAEMON_H diff --git a/src/api-driver/proxy.cpp b/src/api-driver/proxy.cpp index 5ff2d13..16ee327 100644 --- a/src/api-driver/proxy.cpp +++ b/src/api-driver/proxy.cpp @@ -1 +1,10 @@ #include "proxy.h" + +//#define CPAPI_PROXY_CALL(proxy, func, ...) do { auto _res = func(proxy.sid, __VA_ARGS__); if (_res != OK) { BOOST_LOG_TRIVIAL(error) << "CP API error in " #func "(" #__VA_ARGS__ "): " << _res; } } while (0) +// void foo() { +// api_driver::proxy::CpProxy proxy; +// std::string tmp; +// CPAPI_PROXY_CALL(proxy, CP_GetDmaDebug, "fuck", &tmp); +// } + + diff --git a/src/api-driver/proxy.h b/src/api-driver/proxy.h index 97cbd0f..d9ff6be 100644 --- a/src/api-driver/proxy.h +++ b/src/api-driver/proxy.h @@ -1,52 +1,53 @@ #ifndef PROXY_H #define PROXY_H +#include "api-driver/stricts-enable.h" #include #include std::ostream& operator<<(std::ostream& out, CP_Result result); -namespace api_driver { - /** - * Функция-хелпер для логгирования ошибок всех вызовов API. - * @return то же значение ошибки, что и было передано в качестве параметра - */ - CP_Result logCpApiError(const char* desc, CP_Result err) { - if (err != OK) { - BOOST_LOG_TRIVIAL(error) << "CP API error in " << desc << ": " << err; - } - return err; - } -} - -#define CPAPI_PROXY_CALL(proxy, func, ...) do { auto _res = func(proxy.sid, __VA_ARGS__); if (_res != OK) { BOOST_LOG_TRIVIAL(error) << "CP API error in " #func "(" #__VA_ARGS__ "): " << _res; } } while (0) - -// void foo() { -// api_driver::proxy::CpProxy proxy; -// std::string tmp; -// CPAPI_PROXY_CALL(proxy, CP_GetDmaDebug, "fuck", &tmp); -// } namespace api_driver::proxy { class CpProxy { public: TSID sid; + CP_Result lastCpError = OK; CpProxy(); CpProxy(TSID s); - std::string getDmaDebug(TSID sid, const std::string& arg, const char* calledFrom = ""); + /** + * Вызывает процедуру подключения к CP_API. Бросает исключение, если не удалось подключиться. + */ + void connect(); - void getModState(TSID sid, modulator_state& dest, const char* calledFrom = ""); - void getModSettings(TSID sid, modulator_settings& dest, const char* calledFrom = ""); - void setModSettings(TSID sid, modulator_settings& dest, const char* calledFrom = ""); + /** + * Процедура отключения от API, после ее вызова запрещается использовать CP_API + */ + void disconnect(); - void getDemodState(TSID sid, demodulator_state& dest, const char* calledFrom = ""); - void getDemodSettings(TSID sid, demodulator_settings& dest, const char* calledFrom = ""); - void setDemodSettings(TSID sid, demodulator_settings& dest, const char* calledFrom = ""); + std::string getDmaDebug(const std::string& arg); + + std::string getNetwork(const std::string& param); + void setNetwork(const std::string& param, const std::string& value); + + void getModState(modulator_state& dest); + void getModSettings(modulator_settings& dest); + void setModSettings(modulator_settings& dest); + + void getDemodState(demodulator_state& dest); + void getDemodSettings(demodulator_settings& dest); + void setDemodSettings(demodulator_settings& dest); + + void getDeviceState(device_state& dest); #ifdef MODEM_IS_SCPC - void getCincState(TSID sid, demodulator_settings& dest, const char* calledFrom = ""); + void getCincState(CinC_state& dest); +#endif + +#if API_OBJECT_STATISTICS_ENABLE + void getDebugMetrics(debug_metrics& dest); #endif ~CpProxy(); diff --git a/src/api-driver/stricts-enable.h b/src/api-driver/stricts-enable.h new file mode 100644 index 0000000..9068101 --- /dev/null +++ b/src/api-driver/stricts-enable.h @@ -0,0 +1,8 @@ +#ifndef API_DRIVER_STRICTS_ENABLE_H +#define API_DRIVER_STRICTS_ENABLE_H + +#define API_OBJECT_STATISTICS_ENABLE defined(MODEM_IS_SCPC) +#define API_OBJECT_NETWORK_SETTINGS_ENABLE defined(MODEM_IS_SCPC) || defined(MODEM_IS_TDMA) +#define API_OBJECT_QOS_SETTINGS_ENABLE defined(MODEM_IS_SCPC) || defined(MODEM_IS_TDMA) + +#endif //API_DRIVER_STRICTS_ENABLE_H diff --git a/src/api-driver/structs.cpp b/src/api-driver/structs.cpp index 4ff2b88..5a1048c 100644 --- a/src/api-driver/structs.cpp +++ b/src/api-driver/structs.cpp @@ -1,8 +1,68 @@ #include "api-driver/structs.h" +#include "api-driver/proxy.h" #include +#include +#include -#include "api-driver/proxy.h" + +#define TIME_NOW() std::chrono::time_point_cast(std::chrono::system_clock::now()).time_since_epoch().count() + +typedef boost::property_tree::ptree::path_type json_path; + +static constexpr const char* DEFAULT_QOS_CLASSES = R"({"rt1":[],"rt2":[],"rt3":[],"cd":[]})"; +// пороговое значение сна + +// static int calculateSubnetMask(const std::string& subnet_mask) { +// int mask = 0; +// std::istringstream iss(subnet_mask); +// std::string octet; +// while (std::getline(iss, octet, '.')) { +// int octet_value = std::stoi(octet); +// for (int i = 7; i >= 0; i--) { +// if (octet_value & (1 << i)) { +// mask++; +// } +// } +// } +// return mask; +// } + +/** + * Преобразует строку вида `1.2.3.4/24` в пару строк вида `1.2.3.4` `255.255.255.0` + */ +// std::pair splitIpAndMask(const std::string& input) { +// auto pos = input.find('/'); +// if (pos == std::string::npos) { +// // Обработка ошибки: нет символа '/' +// throw std::runtime_error("address not contains mask"); +// } +// std::string ip = input.substr(0, pos); +// const unsigned int mask_int = std::stoul(input.substr(pos + 1)); +// +// if (mask_int > 32) { +// throw std::runtime_error("invalid mask"); +// } +// +// std::string mask_binary = std::string(mask_int, '1') + std::string(32 - mask_int, '0'); +// std::string mask_str; +// +// for (unsigned int i = 0; i < 4; ++i) { +// std::string octet = mask_binary.substr(i * 8u, 8); +// int octet_value = std::stoi(octet, nullptr, 2); +// mask_str += std::to_string(octet_value) + (i < 3 ? "." : ""); +// } +// +// return std::make_pair(ip, mask_str); +// } +static inline void rtrim(std::string &s) { + s.erase(std::find_if(s.rbegin(), s.rend(), [](unsigned char ch) { + return !std::isspace(ch); + }).base(), s.end()); +} +static inline const char* boolAsStr(bool value) { + return value ? "true" : "false"; +} std::ostream& operator<<(std::ostream& out, CP_Result result) { switch (result) { @@ -47,23 +107,227 @@ int64_t api_driver::obj::CpUpdatebleObject::getNextUpdate(int64_t now) const { } api_driver::obj::CpUpdatebleObject::~CpUpdatebleObject() = default; +#if API_OBJECT_STATISTICS_ENABLE +api_driver::obj::StatisticsLogger::StatisticsLogger(): timeStart(TIME_NOW()) {} -void api_driver::obj::TerminalState::updateCallback(TSID sid, CP_Result &lastCpError) { - constexpr const char* thisFunc = "api_driver::obj::TerminalState::load()"; +std::string api_driver::obj::StatisticsLogger::getSettings() { + std::lock_guard _lock(mutex); + std::stringstream res; + res << "{\"en\":" << boolAsStr(this->logEn); + res << ",\"logPeriodMs\":" << logPeriodMs; + res << ",\"maxAgeMs\":" << maxAgeMs; + res << '}'; + return res.str(); +} - modulator_state modulator{}; - demodulator_state demodulator{}; +void api_driver::obj::StatisticsLogger::setSettings(boost::property_tree::ptree &pt) { + const bool newEn = pt.get("en"); + const int newInterval = pt.get("logPeriodMs"); + const int newMaxAgeMs = pt.get("maxAgeMs"); + + std::lock_guard _lock(this->mutex); + this->logPeriodMs = newInterval; + this->maxAgeMs = newMaxAgeMs; + + if (newEn != this->logEn) { + if (newEn) { + this->logFile.open(LOG_FILENAME, std::ios::out); + if (this->logFile.is_open()) { + const auto* header = "timestamp\tcnt ok\tcnt bad\tfine freq dem\tcrs freq dem\tcrs freq compensator\tcrs time est\tfine time est\tmax level corr\tcurrent delay\tSNR\tcurrent modcod\tfine freq compensator\tind freq grb\tind freq tochn\tind filt adapt\tfilter corr cinc\tcorr cnt\tRSS\tcor erl\tcor lat\tgc gain\tpower pl rx\n"; + this->logFile.write(header, static_cast(strlen(header))); + this->logEn = true; + this->timeStart = TIME_NOW(); + } + } else { + if (this->logFile.is_open()) { + this->logFile.close(); + } + this->logEn = false; + } + } +} + +void api_driver::obj::StatisticsLogger::updateCallback(proxy::CpProxy &cp) { + +} + +void api_driver::obj::StatisticsLogger::putItem(const debug_metrics &item) { + std::lock_guard _lock(this->mutex); + if (!logEn) return; + if (this->logFile.is_open()) { + std::stringstream res; + res << makeTimepointFromMillis(TIME_NOW()) << '\t'; + res << item.cnt_ok << '\t'; + res << item.cnt_bad << '\t'; + res << item.fine_freq_dem << '\t'; + res << item.crs_freq_dem << '\t'; + res << item.crs_freq_compensator << '\t'; + res << item.crs_time_est << '\t'; + res << item.fine_time_est << '\t'; + res << item.max_level_corr << '\t'; + res << item.current_delay << '\t'; + res << item.SNR << '\t'; + res << item.current_modcod << '\t'; + res << item.fine_freq_compensator << '\t'; + res << item.ind_freq_grb << '\t'; + res << item.ind_freq_tochn << '\t'; + res << item.ind_filt_adapt << '\t'; + res << item.filter_corr_cinc << '\t'; + res << item.corr_cnt << '\t'; + res << item.RSS << '\t'; + res << item.cor_erl << '\t'; + res << item.cor_lat << '\t'; + res << item.gc_gain << '\t'; + res << item.power_pl_rx << '\n'; + + const auto out = res.str(); + this->logFile.write(out.c_str(), static_cast(out.length())); + this->logFile.flush(); + } +} + +api_driver::obj::StatisticsLogger::~StatisticsLogger() = default; +#endif + +#if API_OBJECT_NETWORK_SETTINGS_ENABLE +api_driver::obj::TerminalNetworkSettings::TerminalNetworkSettings() { loadDefaults(); } + +api_driver::obj::TerminalNetworkSettings::TerminalNetworkSettings(const TerminalNetworkSettings &src) = default; + +api_driver::obj::TerminalNetworkSettings & api_driver::obj::TerminalNetworkSettings::operator=(const TerminalNetworkSettings &src) { + managementIp = src.managementIp; + managementGateway = src.managementGateway; + dataIp = src.dataIp; + serverName = src.serverName; + isL2 = src.isL2; + dataMtu = src.dataMtu; + return *this; +} + +void api_driver::obj::TerminalNetworkSettings::loadDefaults() { + managementIp = "0.0.0.0"; + managementGateway = ""; + isL2 = true; + dataIp = "0.0.0.0"; + dataMtu = 1500; + serverName = DEFAULT_SERVER_NAME; +} + +void api_driver::obj::TerminalNetworkSettings::updateCallback(proxy::CpProxy &cp) { + loadDefaults(); + try { + managementIp = cp.getNetwork("addr"); + // s.managementIp += "/"; + // s.managementIp += std::to_string(calculateSubnetMask(cp.getNetwork("mask"))); + + managementGateway = cp.getNetwork("gateway"); + if (cp.getNetwork("mode") == "tun") { + isL2 = false; + dataIp = cp.getNetwork("addr_data"); + } else { + isL2 = true; + } + dataMtu = 1500; + serverName = cp.getNetwork("name_serv"); + if (serverName.empty()) { + serverName = DEFAULT_SERVER_NAME; + } + } catch (std::exception& e) { + throw std::runtime_error(std::string("api_driver::obj::TerminalNetworkSettings::updateCallback() error: ") + e.what()); + } +} + +void api_driver::obj::TerminalNetworkSettings::updateFromPt(boost::property_tree::ptree &pt) { +} + +void api_driver::obj::TerminalNetworkSettings::store(proxy::CpProxy& cp) { + try { + cp.setNetwork("mode", isL2 ? "tap" : "tun"); + cp.setNetwork("addr", managementIp); + + if (!isL2) { + cp.setNetwork("addr_data", dataIp); + } + cp.setNetwork("mask", "255.255.255.0"); + cp.setNetwork("gateway", managementGateway); + + // cp.setNetwork("data_mtu", std::to_string(dataMtu)); + + cp.setNetwork("name_serv", serverName); + } catch (std::exception& e) { + throw std::runtime_error(std::string("api_driver::obj::TerminalNetworkSettings::store() error: ") + e.what()); + } +} + +std::string api_driver::obj::TerminalNetworkSettings::asJson() { + std::stringstream out; + + return out.str(); +} + +api_driver::obj::TerminalNetworkSettings::~TerminalNetworkSettings() = default; +#endif + +#if API_OBJECT_QOS_SETTINGS_ENABLE +api_driver::obj::TerminalQosSettings::TerminalQosSettings() { +} + +api_driver::obj::TerminalQosSettings::TerminalQosSettings(const TerminalQosSettings &src) { +} + +api_driver::obj::TerminalQosSettings & api_driver::obj::TerminalQosSettings::operator=(const TerminalQosSettings &src) { +} + +void api_driver::obj::TerminalQosSettings::loadDefaults() { +} + +void api_driver::obj::TerminalQosSettings::updateCallback(proxy::CpProxy &cp) { +} + +void api_driver::obj::TerminalQosSettings::updateFromPt(boost::property_tree::ptree &pt) { +} + +void api_driver::obj::TerminalQosSettings::store(proxy::CpProxy &cp) { +} + +std::string api_driver::obj::TerminalQosSettings::asJson() { +} + +api_driver::obj::TerminalQosSettings::~TerminalQosSettings() { +} +#endif + + + + + + +void api_driver::obj::TerminalState::updateCallback(proxy::CpProxy& cp) { + modulator_state mod{}; + demodulator_state demod{}; #ifdef MODEM_IS_SCPC CinC_state cinc{}; #endif + try { + cp.getModState(mod); + cp.getDemodState(demod); +#ifdef MODEM_IS_SCPC + // CinC state прописывается в настройках + { - proxy::getModState(sid, modulator, thisFunc); - proxy::getDemodState(sid, demodulator, thisFunc); -#ifdef MODEM_IS_TDMA - const auto tmpDevState = proxy::getDmaDebug(sid, "status_init", thisFunc); + } + cp.getCincState(cinc); #endif +#ifdef MODEM_IS_TDMA + fInitState = cp.getDmaDebug("status_init"); +#endif + } catch (std::exception& e) { + throw std::runtime_error(std::string("api_driver::obj::TerminalState::updateCallback() error: ") + e.what()); + } + #ifdef MODEM_IS_SCPC + bool isCinC = getIsCinC(); if (isCinC) { logCpApiError("api_driver::TerminalApiDaemon::updateState()->CP_GetCinCState()", CP_GetCinCState(sid, cinc)); @@ -71,7 +335,6 @@ void api_driver::obj::TerminalState::updateCallback(TSID sid, CP_Result &lastCpE #endif { - std::lock_guard lock2(this->mutex); #ifdef MODEM_IS_TDMA this->fInitState = tmpDevState; #endif @@ -201,6 +464,96 @@ void api_driver::obj::TerminalState::updateCallback(TSID sid, CP_Result &lastCpE api_driver::obj::TerminalState::~TerminalState() = default; +api_driver::obj::TerminalDeviceState::TerminalDeviceState() = default; +api_driver::obj::TerminalDeviceState::TerminalDeviceState(const TerminalDeviceState &src) = default; +api_driver::obj::TerminalDeviceState & api_driver::obj::TerminalDeviceState::operator=(const TerminalDeviceState &src) { + fOsUptime = src.fOsUptime; + fOsLoad1 = src.fOsLoad1; + fOsLoad5 = src.fOsLoad5; + fOsLoad15 = src.fOsLoad15; + fOsTotalram = src.fOsTotalram; + fOsFreeram = src.fOsFreeram; + fOsProcs = src.fOsProcs; + fTempAdrv = src.fTempAdrv; + fTempZynq = src.fTempZynq; + fTempFpga = src.fTempFpga; +#ifdef MODEM_IS_TDMA + fUpgradeStatus = src.fUpgradeStatus; + fUpgradePercent = src.fUpgradePercent; + fUpgradeImage = src.fUpgradeImage; +#endif + return *this; +} + +void api_driver::obj::TerminalDeviceState::updateCallback(proxy::CpProxy &cp) { + { + device_state ds{}; + cp.getDeviceState(ds); + fTempAdrv = ds.adrv_temp; + fTempZynq = ds.pl_temp; + fTempFpga = ds.zynq_temp; + } +#ifdef MODEM_IS_TDMA + { + progress_msg ds{}; + logCpApiError("api_driver::TerminalApiDaemon::updateState()->CP_GetUpdateStatus()", CP_GetUpdateStatus(sid, ds)); + fOtaStatus = ds.status; + fOtaPercent = ds.dwl_percent; + fOtaImage = ds.cur_image; + } +#endif + + struct sysinfo info{}; + sysinfo(&info); + + const double f_load = 100.0 / ((1 << SI_LOAD_SHIFT) * get_nprocs()); + fOsUptime = info.uptime; + fOsLoad1 = f_load * static_cast(info.loads[0]); + fOsLoad5 = f_load * static_cast(info.loads[1]); + fOsLoad15 = f_load * static_cast(info.loads[2]); + fOsTotalram = (info.totalram * info.mem_unit) >> 20; // Mb + fOsFreeram = (info.totalram * info.mem_unit) >> 20; // Mb + fOsProcs = info.procs; +} + +std::string api_driver::obj::TerminalDeviceState::asJson() const { + std::stringstream result; + result << "{\"uptime\":" << fOsUptime + << ",\"load1min\":" << std::setprecision(2) << fOsLoad1 + << ",\"load5min\":" << std::setprecision(2) << fOsLoad5 + << ",\"load15min\":" << std::setprecision(2) << fOsLoad15 + << ",\"totalram\":" << fOsTotalram + << ",\"freeram\":" << fOsFreeram + << ",\"procs\":" << fOsProcs + << ",\"adrv\":" << std::setprecision(1) << fTempAdrv + << ",\"fpga\":" << std::setprecision(1) << fTempFpga + << ",\"zynq\":" << std::setprecision(1) << fTempZynq; +#ifdef MODEM_IS_TDMA + if (fUpgradeImage.empty()) { + result << R"(, +"upgradeStatus":"Нет обновлений","upgradePercent":0,"upgradeImage":"")"; + } else { + switch (fUpgradeStatus) { + case NORM_RX_OBJECT_NEW_API: result << ",\n" R"("upgradeStatus": "Начало загрузки")"; break; + case NORM_RX_OBJECT_INFO_API: result << ",\n" R"("upgradeStatus": "Получено имя образа")"; break; + case NORM_RX_OBJECT_UPDATED_API: result << ",\n" R"("upgradeStatus": "Загружается")"; break; + case NORM_RX_OBJECT_COMPLETED_API: result << ",\n" R"("upgradeStatus": "Загрузка завершена")"; break; + case NORM_RX_OBJECT_ABORTED_API: result << ",\n" R"("upgradeStatus": "Загрузка прервана")"; break; + default: result << ",\n" R"("upgradeStatus": "?")"; + + } + result << ",\"upgradePercent\":" << fUpgradePercent; + result << ",\"upgradeImage\":" << buildEscapedString(fUpgradeImage); + } + +#endif + result << "}"; + return result.str(); +} + +api_driver::obj::TerminalDeviceState::~TerminalDeviceState() = default; + + diff --git a/src/api-driver/structs.h b/src/api-driver/structs.h index 094146b..cdc7d1d 100644 --- a/src/api-driver/structs.h +++ b/src/api-driver/structs.h @@ -1,10 +1,15 @@ #ifndef STRUCTS_H #define STRUCTS_H + +#include "api-driver/stricts-enable.h" +#include "proxy.h" +#include +#include #include #include #include #include -#include + namespace api_driver::obj { @@ -17,7 +22,10 @@ namespace api_driver::obj { int64_t lastUpdate = 0; int64_t updatePeriodMs = -1; - virtual void updateCallback(TSID sid, CP_Result& lastCpError) = 0; + /** + * Функция для обновления (загрузки) объекта из CP API. + */ + virtual void updateCallback(proxy::CpProxy& cp) = 0; bool checkNeedUpdate(int64_t now) const; @@ -27,10 +35,12 @@ namespace api_driver::obj { }; -#ifdef MODEM_IS_SCPC - class api_driver::StatisticsLogger { +#if API_OBJECT_STATISTICS_ENABLE + class StatisticsLogger: public CpUpdatebleObject { public: - StatisticsLogger(): timeStart(TIME_NOW()) {} + StatisticsLogger(); + + static constexpr const char* LOG_FILENAME = "/tmp/weblog-statistics.csv"; int64_t timeStart; @@ -42,80 +52,15 @@ namespace api_driver::obj { * * @return {"en": bool, "logPeriodMs": int, "maxAgeMs": int} */ - std::string getSettings() { - std::lock_guard _lock(mutex); - std::stringstream res; - res << "{\"en\":" << boolAsStr(this->logEn); - res << ",\"logPeriodMs\":" << logPeriodMs; - res << ",\"maxAgeMs\":" << maxAgeMs; - res << '}'; - return res.str(); - } - void setSettings(boost::property_tree::ptree &pt) { - const bool newEn = pt.get("en"); - const int newInterval = pt.get("logPeriodMs"); - const int newMaxAgeMs = pt.get("maxAgeMs"); - - std::lock_guard _lock(this->mutex); - this->logPeriodMs = newInterval; - this->maxAgeMs = newMaxAgeMs; - - if (newEn != this->logEn) { - if (newEn) { - this->logFile.open("/tmp/weblog-statistics.csv", std::ios::out); - if (this->logFile.is_open()) { - const auto* header = "timestamp\tcnt ok\tcnt bad\tfine freq dem\tcrs freq dem\tcrs freq compensator\tcrs time est\tfine time est\tmax level corr\tcurrent delay\tSNR\tcurrent modcod\tfine freq compensator\tind freq grb\tind freq tochn\tind filt adapt\tfilter corr cinc\tcorr cnt\tRSS\tcor erl\tcor lat\tgc gain\tpower pl rx\n"; - this->logFile.write(header, static_cast(strlen(header))); - this->logEn = true; - this->timeStart = TIME_NOW(); - } - } else { - if (this->logFile.is_open()) { - this->logFile.close(); - } - this->logEn = false; - } - } - } + std::string getSettings(); + void setSettings(boost::property_tree::ptree &pt); + void updateCallback(proxy::CpProxy& cp) override; /** * Записать значение в "базу данных". Метку при этом вставлять не нужно, она будет вставлена автоматически. * @param item */ - void putItem(const debug_metrics& item) { - std::lock_guard _lock(this->mutex); - if (!logEn) return; - if (this->logFile.is_open()) { - std::stringstream res; - res << makeTimepointFromMillis(TIME_NOW()) << '\t'; - res << item.cnt_ok << '\t'; - res << item.cnt_bad << '\t'; - res << item.fine_freq_dem << '\t'; - res << item.crs_freq_dem << '\t'; - res << item.crs_freq_compensator << '\t'; - res << item.crs_time_est << '\t'; - res << item.fine_time_est << '\t'; - res << item.max_level_corr << '\t'; - res << item.current_delay << '\t'; - res << item.SNR << '\t'; - res << item.current_modcod << '\t'; - res << item.fine_freq_compensator << '\t'; - res << item.ind_freq_grb << '\t'; - res << item.ind_freq_tochn << '\t'; - res << item.ind_filt_adapt << '\t'; - res << item.filter_corr_cinc << '\t'; - res << item.corr_cnt << '\t'; - res << item.RSS << '\t'; - res << item.cor_erl << '\t'; - res << item.cor_lat << '\t'; - res << item.gc_gain << '\t'; - res << item.power_pl_rx << '\n'; - - const auto out = res.str(); - this->logFile.write(out.c_str(), static_cast(out.length())); - this->logFile.flush(); - } - } + void putItem(const debug_metrics& item); // void collectExpiredItems(); @@ -124,7 +69,7 @@ namespace api_driver::obj { // logs.clear(); // } - ~StatisticsLogger() = default; + ~StatisticsLogger() override; private: // std::pmr::deque logs; std::fstream logFile{}; @@ -132,14 +77,17 @@ namespace api_driver::obj { }; #endif -#ifdef MODEM_IS_SCPC - static constexpr const char* DEFAULT_SERVER_NAME = "RCSM-101"; -#endif -#ifdef MODEM_IS_TDMA - static constexpr const char* DEFAULT_SERVER_NAME = "RCSM-101 TDMA"; +#if defined(MODEM_IS_SCPC) + static constexpr const char* DEFAULT_SERVER_NAME = "RSCM-101"; +#elif defined(MODEM_IS_TDMA) + static constexpr const char* DEFAULT_SERVER_NAME = "TDMA Abonent"; +#elif defined(MODEM_IS_SHPC) + static constexpr const char* DEFAULT_SERVER_NAME = "SHPS Terminal"; +#else +#error "Selected modem type not supported!" #endif -#if defined(MODEM_IS_SCPC) +#if API_OBJECT_NETWORK_SETTINGS_ENABLE class TerminalNetworkSettings: public CpUpdatebleObject { public: std::string managementIp, managementGateway, dataIp, serverName; @@ -150,24 +98,39 @@ namespace api_driver::obj { TerminalNetworkSettings(const TerminalNetworkSettings& src); TerminalNetworkSettings& operator= (const TerminalNetworkSettings& src); - void loadDefaults() { - managementIp = "0.0.0.0"; - managementGateway = ""; - isL2 = true; - dataIp = "0.0.0.0"; - dataMtu = 1500; - serverName = DEFAULT_SERVER_NAME; - } + void loadDefaults(); - void updateCallback(TSID sid, CP_Result &lastCpError) override; + void updateCallback(proxy::CpProxy& cp) override; void updateFromPt(boost::property_tree::ptree &pt); - void store(TSID sid, CP_Result& lastCpError); + void store(proxy::CpProxy& cp); std::string asJson(); ~TerminalNetworkSettings() override; }; #endif +#if API_OBJECT_QOS_SETTINGS_ENABLE + class TerminalQosSettings: public CpUpdatebleObject { + public: + static constexpr const char* DEFAULT_QOS_CLASSES = R"({"rt1":[],"rt2":[],"rt3":[],"cd":[]})"; + std::string qosSettingsJson; + bool qosEnabled = false; + + TerminalQosSettings(); + TerminalQosSettings(const TerminalQosSettings& src); + TerminalQosSettings& operator= (const TerminalQosSettings& src); + + void loadDefaults(); + + void updateCallback(proxy::CpProxy& cp) override; + void updateFromPt(boost::property_tree::ptree &pt); + void store(proxy::CpProxy& cp); + std::string asJson(); + + ~TerminalQosSettings() override; + }; +#endif + class TerminalFirmwareVersion { public: std::string version, modemId, modemSn, macMang, macData; @@ -176,6 +139,13 @@ namespace api_driver::obj { TerminalFirmwareVersion(const TerminalFirmwareVersion& src); ~TerminalFirmwareVersion(); + // logCpApiError("api_driver::TerminalApiDaemon::connectToApi()->CP_GetNetwork(version)", CP_GetNetwork(sid, "version", &f.version)); + // logCpApiError("api_driver::TerminalApiDaemon::connectToApi()->CP_GetNetwork(chip_id)", CP_GetNetwork(sid, "chip_id", &f.modemId)); + // rtrim(f.modemId); + // logCpApiError("api_driver::TerminalApiDaemon::connectToApi()->CP_GetNetwork(serial)", CP_GetNetwork(sid, "serial", &f.modemSn)); + // logCpApiError("api_driver::TerminalApiDaemon::connectToApi()->CP_GetNetwork(mac_eth0)", CP_GetNetwork(sid, "mac_eth0", &f.macMang)); + // logCpApiError("api_driver::TerminalApiDaemon::connectToApi()->CP_GetNetwork(mac_eth1)", CP_GetNetwork(sid, "mac_eth1", &f.macData)); + void load(proxy::CpProxy& cp); std::string asJson(); TerminalFirmwareVersion& operator= (const TerminalFirmwareVersion& src); @@ -239,7 +209,7 @@ namespace api_driver::obj { /** * Обновление основной части статистики, то есть RX/TX и sysinfo */ - void updateCallback(TSID sid, CP_Result &lastCpError) override; + void updateCallback(proxy::CpProxy& cp) override; void updateFromPt(boost::property_tree::ptree &pt); void store(TSID sid, CP_Result& lastCpError); @@ -250,30 +220,45 @@ namespace api_driver::obj { class TerminalDeviceState: public CpUpdatebleObject { public: - time_t fStatOsUptime; - double fStatOsLoad1; - double fStatOsLoad5; - double fStatOsLoad15; - int fStatOsTotalram; - int fStatOsFreeram; - int fStatOsProcs; + time_t fOsUptime{}; + double fOsLoad1{}; + double fOsLoad5{}; + double fOsLoad15{}; + unsigned int fOsTotalram{}; + unsigned int fOsFreeram{}; + unsigned int fOsProcs{}; - double fStatDeviceAdrv; - double fStatDeviceZynq; - double fStatDeviceFpga; + double fTempAdrv{}; + double fTempZynq{}; + double fTempFpga{}; #ifdef MODEM_IS_TDMA - DOWNLOAD_STATUS fStatDeviceUpgradeStatus; - unsigned int fStatDeviceUpgradePercent; - std::string fStatDeviceUpgradeImage; + DOWNLOAD_STATUS fUpgradeStatus{}; + unsigned int fUpgradePercent{}; + std::string fUpgradeImage; #endif - void updateCallback(TSID sid, CP_Result &lastCpError) override; - void updateFromPt(boost::property_tree::ptree &pt); - void store(TSID sid, CP_Result& lastCpError); - std::string asJson(); + TerminalDeviceState(); + TerminalDeviceState(const TerminalDeviceState& src); + TerminalDeviceState& operator= (const TerminalDeviceState& src); + + void updateCallback(proxy::CpProxy& cp) override; + std::string asJson() const; ~TerminalDeviceState() override; }; + + class TerminalRxTxSettings: public CpUpdatebleObject { + public: + + // TODO описать все параметры для всех терминалов + + void updateCallback(proxy::CpProxy& cp) override; + void updateFromPt(boost::property_tree::ptree &pt); + void store(proxy::CpProxy& cp); + std::string asJson(); + + ~TerminalRxTxSettings() override; + }; } #endif //STRUCTS_H diff --git a/src/terminal_api_driver.cpp b/src/terminal_api_driver.cpp index 6a7052c..8466781 100644 --- a/src/terminal_api_driver.cpp +++ b/src/terminal_api_driver.cpp @@ -14,59 +14,15 @@ typedef boost::property_tree::ptree::path_type json_path; -static constexpr const char* DEFAULT_QOS_CLASSES = R"({"rt1":[],"rt2":[],"rt3":[],"cd":[]})"; // пороговое значение сна static constexpr int64_t SLEEP_THRESHOLD = 10; -// static int calculateSubnetMask(const std::string& subnet_mask) { -// int mask = 0; -// std::istringstream iss(subnet_mask); -// std::string octet; -// while (std::getline(iss, octet, '.')) { -// int octet_value = std::stoi(octet); -// for (int i = 7; i >= 0; i--) { -// if (octet_value & (1 << i)) { -// mask++; -// } -// } -// } -// return mask; -// } - -/** - * Преобразует строку вида `1.2.3.4/24` в пару строк вида `1.2.3.4` `255.255.255.0` - */ -// std::pair splitIpAndMask(const std::string& input) { -// auto pos = input.find('/'); -// if (pos == std::string::npos) { -// // Обработка ошибки: нет символа '/' -// throw std::runtime_error("address not contains mask"); -// } -// std::string ip = input.substr(0, pos); -// const unsigned int mask_int = std::stoul(input.substr(pos + 1)); -// -// if (mask_int > 32) { -// throw std::runtime_error("invalid mask"); -// } -// -// std::string mask_binary = std::string(mask_int, '1') + std::string(32 - mask_int, '0'); -// std::string mask_str; -// -// for (unsigned int i = 0; i < 4; ++i) { -// std::string octet = mask_binary.substr(i * 8u, 8); -// int octet_value = std::stoi(octet, nullptr, 2); -// mask_str += std::to_string(octet_value) + (i < 3 ? "." : ""); -// } -// -// return std::make_pair(ip, mask_str); -// } - static inline void rtrim(std::string &s) { s.erase(std::find_if(s.rbegin(), s.rend(), [](unsigned char ch) { return !std::isspace(ch); }).base(), s.end()); } -static const char* boolAsStr(bool value) { +static inline const char* boolAsStr(bool value) { return value ? "true" : "false"; } @@ -262,546 +218,6 @@ private: }; #endif -/** - * Этот демон нужен для того, чтобы получать статистику из API, а так же корректно сохранять настройки - */ -class api_driver::TerminalApiDaemon { -private: - CP_Result lastCpError = OK; - void logCpApiError(const char* desc, CP_Result err) { - if (err != OK) { - BOOST_LOG_TRIVIAL(error) << "CP API error in " << desc << ": " << err; - this->lastCpError = err; - } - } - - void updateState() { - TerminalDeviceState s; - - std::lock_guard lock(this->cpApiMutex); - logCpApiError("api_driver::TerminalApiDaemon::updateState()->CP_GetModulatorState()", CP_GetModulatorState(sid, s.mod)); - logCpApiError("api_driver::TerminalApiDaemon::updateState()->CP_GetDemodulatorState()", CP_GetDemodulatorState(sid, s.demod)); -#ifdef MODEM_IS_TDMA - std::string tmpDevState; - logCpApiError("api_driver::TerminalApiDaemon::updateState()->CP_GetDmaDebug(status_init)", CP_GetDmaDebug(sid, "status_init", &tmpDevState)); -#endif - { - device_state ds{}; - logCpApiError("api_driver::TerminalApiDaemon::updateState()->CP_GetDeviceState()", CP_GetDeviceState(sid, ds)); - s.adrv_temp = ds.adrv_temp; - s.pl_temp = ds.pl_temp; - s.zynq_temp = ds.zynq_temp; - } -#ifdef MODEM_IS_TDMA - { - progress_msg ds{}; - logCpApiError("api_driver::TerminalApiDaemon::updateState()->CP_GetUpdateStatus()", CP_GetUpdateStatus(sid, ds)); - s.otaStatus = ds.status; - s.otaPercent = ds.dwl_percent; - s.otaImage = ds.cur_image; - } -#endif - -#ifdef MODEM_IS_SCPC - bool isCinC = getIsCinC(); - if (isCinC) { - logCpApiError("api_driver::TerminalApiDaemon::updateState()->CP_GetCinCState()", CP_GetCinCState(sid, s.cinc)); - } -#endif - - { - std::lock_guard lock2(this->stateMutex); - this->state = s; -#ifdef MODEM_IS_TDMA - this->deviceInitState = tmpDevState; -#endif - } - } - - void updateSettings() { - modulator_settings mod{}; - // uint32_t modulatorModcod; - // CP_GetModulatorParams(sid, "modcod", &modulatorModcod); - demodulator_settings demod{}; -#ifdef MODEM_IS_SCPC - ACM_parameters_serv_ acm{}; -#endif - DPDI_parmeters dpdi{}; - buc_lnb_settings bucLnb{}; - - std::lock_guard lock(this->cpApiMutex); - logCpApiError("api_driver::TerminalApiDaemon::updateSettings()->CP_GetModulatorSettings()", CP_GetModulatorSettings(sid, mod)); - logCpApiError("api_driver::TerminalApiDaemon::updateSettings()->CP_GetDemodulatorSettings()", CP_GetDemodulatorSettings(sid, demod)); -#ifdef MODEM_IS_SCPC - logCpApiError("api_driver::TerminalApiDaemon::updateSettings()->CP_GetAcmParams()", CP_GetAcmParams(sid, &acm)); -#endif - logCpApiError("api_driver::TerminalApiDaemon::updateSettings()->CP_GetDpdiParams()", CP_GetDpdiParams(sid, &dpdi)); - logCpApiError("api_driver::TerminalApiDaemon::updateSettings()->CP_GetBUC_LNB_settings()", CP_GetBUC_LNB_settings(sid, bucLnb)); - - { - std::lock_guard lock2(this->settingsMutex); - this->modSettings = mod; - this->demodSettings = demod; -#ifdef MODEM_IS_SCPC - this->acmSettings = acm; -#endif - this->dpdiSettings = dpdi; - this->bucLnbSettings = bucLnb; - } - } - - void unsafeLoadNetworkSettings(TerminalNetworkSettings& s) { - s.loadDefaults(); - logCpApiError("api_driver::TerminalApiDaemon::unsafeLoadNetworkSettings()->CP_GetNetwork(addr)", CP_GetNetwork(sid, "addr", &s.managementIp)); - // logCpApiError("api_driver::TerminalApiDaemon::setNetworkSettings()->CP_GetNetwork(mask)", CP_GetNetwork(sid, "mask", &tmp)); - // s.managementIp += "/"; - // s.managementIp += std::to_string(calculateSubnetMask(tmp)); - logCpApiError("api_driver::TerminalApiDaemon::unsafeLoadNetworkSettings()->CP_GetNetwork(gateway)", CP_GetNetwork(sid, "gateway", &s.managementGateway)); - std::string nm; logCpApiError("api_driver::TerminalApiDaemon::unsafeLoadNetworkSettings()->CP_GetNetwork(mode)", CP_GetNetwork(sid, "mode", &nm)); - if (nm == "tun") { - s.isL2 = false; - logCpApiError("api_driver::TerminalApiDaemon::unsafeLoadNetworkSettings()->CP_GetNetwork(addr_data)", CP_GetNetwork(sid, "addr_data", &s.dataIp)); - } else { - s.isL2 = true; - } - s.dataMtu = 1500; - logCpApiError("api_driver::TerminalApiDaemon::unsafeLoadNetworkSettings()->CP_GetNetwork(name_serv)", CP_GetNetwork(sid, "name_serv", &s.serverName)); - if (s.serverName.empty()) { - s.serverName = TerminalNetworkSettings::DEFAULT_SERVER_NAME; - } - } - void unsafStoreNetworkSettings(TerminalNetworkSettings& s) { - logCpApiError("api_driver::TerminalApiDaemon::unsafStoreNetworkSettings()->CP_SetNetwork(mode)", CP_SetNetwork(sid, "mode", s.isL2 ? "tap" : "tun")); - logCpApiError("api_driver::TerminalApiDaemon::unsafStoreNetworkSettings()->CP_SetNetwork(addr)", CP_SetNetwork(sid, "addr", s.managementIp.c_str())); - if (!s.isL2) { - logCpApiError("api_driver::TerminalApiDaemon::unsafStoreNetworkSettings()->CP_SetNetwork(addr_data)", CP_SetNetwork(sid, "addr_data", s.dataIp.c_str())); - // TODO маска не устанавливается, потому что в API этого нет - } - logCpApiError("api_driver::TerminalApiDaemon::unsafStoreNetworkSettings()->CP_SetNetwork(mask)", CP_SetNetwork(sid, "mask", "255.255.255.0")); - logCpApiError("api_driver::TerminalApiDaemon::unsafStoreNetworkSettings()->CP_SetNetwork(gateway)", CP_SetNetwork(sid, "gateway", s.managementGateway.c_str())); - - // TODO MTU не устанавливается, потому что в API этого нет - - logCpApiError("api_driver::TerminalApiDaemon::unsafeLoadNetworkSettings()->CP_SetNetwork(name_serv)", CP_SetNetwork(sid, "name_serv", s.serverName.c_str())); - } - - void updateNetworkSettings() { - TerminalNetworkSettings s; - - std::lock_guard lock(this->cpApiMutex); - unsafeLoadNetworkSettings(s); - - { - std::lock_guard lock2(this->networkSettingsMutex); - this->networkSettings = s; - } - } - - void updateQos() { - bool tmp1; std::string tmp2; - std::scoped_lock lock{this->cpApiMutex}; - logCpApiError("api_driver::TerminalApiDaemon::updateQos()->CP_GetQoSSettings()", CP_GetQoSSettings(this->sid, tmp2, tmp1)); - { - std::lock_guard lock2(this->qosSettingsMutex); - this->qosEnabled = tmp1; - this->qosClassesJson = tmp2.empty() ? DEFAULT_QOS_CLASSES : tmp2; - } - } - - void connectToApi() { - { - std::lock_guard _lock(this->stateMutex); - this->deviceInitState = "Not connected to API"; - this->networkSettings.loadDefaults(); - } - - unsigned int access{}; - for (int connectAttempt = 0;; connectAttempt++) { - BOOST_LOG_TRIVIAL(info) << "api_driver::TerminalApiDaemon::connectToApi(): Try to connect api (attempt " << connectAttempt << ")..."; - auto res = CP_Login("admin", "pass", &sid, &access); - logCpApiError(R"(api_driver::TerminalApiDaemon::connectToApi()->CP_Login("admin", "pass"))", res); - if (res != OK) { - boost::this_thread::sleep_for(boost::chrono::duration(boost::chrono::milliseconds(1000))); - } else { - break; - } - } - - std::string tmp; - logCpApiError("api_driver::TerminalApiDaemon::run()->CP_GetDmaDebug(status_init)", CP_GetDmaDebug(sid, "status_init", &tmp)); - { - std::lock_guard _lock(this->stateMutex); - this->deviceInitState = tmp; - } - BOOST_LOG_TRIVIAL(info) << "api_driver::TerminalApiDaemon::connectToApi(): Success connect!"; - BOOST_LOG_TRIVIAL(info) << "api_driver::TerminalApiDaemon::connectToApi(): API status: " << tmp; - - TerminalFirmwareVersion f; - logCpApiError("api_driver::TerminalApiDaemon::connectToApi()->CP_GetNetwork(version)", CP_GetNetwork(sid, "version", &f.version)); - logCpApiError("api_driver::TerminalApiDaemon::connectToApi()->CP_GetNetwork(chip_id)", CP_GetNetwork(sid, "chip_id", &f.modemId)); - rtrim(f.modemId); - logCpApiError("api_driver::TerminalApiDaemon::connectToApi()->CP_GetNetwork(serial)", CP_GetNetwork(sid, "serial", &f.modemSn)); - logCpApiError("api_driver::TerminalApiDaemon::connectToApi()->CP_GetNetwork(mac_eth0)", CP_GetNetwork(sid, "mac_eth0", &f.macMang)); - logCpApiError("api_driver::TerminalApiDaemon::connectToApi()->CP_GetNetwork(mac_eth1)", CP_GetNetwork(sid, "mac_eth1", &f.macData)); - - { - std::lock_guard _lock(this->firmwareMutex); - this->firmware = f; - } - - this->lastCpError = OK; - } - - void run() { - // это демон, который в бесконечном цикле опрашивает API - this->connectToApi(); - - struct IntervalUpdate_t { - int64_t lastUpdate; - int64_t periodMs; - - std::function callback; - - bool checkNeedUpdate(int64_t now) const { - if (periodMs < 0) return false; - // тут нет смысла спать меньше чем на 20мс, поэтому можно разрешить чтение на некоторое время раньше - return now - lastUpdate >= (periodMs - SLEEP_THRESHOLD); - } - - int64_t getNextUpdate(int64_t now) const { - if (checkNeedUpdate(now)) { - return 0; - } - auto next = now - lastUpdate; - return next < 0 ? 0 : next; - } - }; - - IntervalUpdate_t updaters[] = { -#ifdef MODEM_IS_SCPC - // обновление логов - {.lastUpdate = 0, .periodMs = -1, .callback = [this]() { - try { - { - std::lock_guard _alock(this->cpApiMutex); - std::lock_guard _slock(this->stateMutex); - logCpApiError("api_driver::TerminalApiDaemon->statsLogs.putItem()->CP_GetDebugMetrics()", CP_GetDebugMetrics(sid, state.debug)); - } - this->statsLogs.putItem(state.debug); - BOOST_LOG_TRIVIAL(debug) << "api_driver::TerminalApiDaemon->statsLogs.putItem(): success write statistics state to log!"; - } catch (std::exception& e) { - BOOST_LOG_TRIVIAL(error) << "api_driver::TerminalApiDaemon->statsLogs.putItem() failed to log: " << e.what(); - } - }}, -#endif - // обновление статистики - {.lastUpdate = 0, .periodMs = CACHE_STATISTICS_UPDATE_MS, .callback = [this]() { - try { - this->updateState(); - BOOST_LOG_TRIVIAL(debug) << "api_driver::TerminalApiDaemon::updateState(): success update!"; - } catch (std::exception& e) { - BOOST_LOG_TRIVIAL(error) << "api_driver::TerminalApiDaemon::updateState(): " << e.what(); - } - }}, - // обновление кеша настроек - {.lastUpdate = 0, .periodMs = CACHE_SETTINGS_UPDATE_MS, .callback = [this]() { - try { - this->updateSettings(); - BOOST_LOG_TRIVIAL(debug) << "api_driver::TerminalApiDaemon::updateSettings(): success update!"; - } catch (std::exception& e) { - BOOST_LOG_TRIVIAL(error) << "api_driver::TerminalApiDaemon::updateSettings(): " << e.what(); - } - }}, - // обновление кеша настроек сети (делается отдельно) - {.lastUpdate = 0, .periodMs = CACHE_SETTINGS_UPDATE_MS, .callback = [this]() { - try { - this->updateNetworkSettings(); - BOOST_LOG_TRIVIAL(debug) << "api_driver::TerminalApiDaemon::updateNetworkSettings(): success update!"; - } catch (std::exception& e) { - BOOST_LOG_TRIVIAL(error) << "api_driver::TerminalApiDaemon::updateNetworkSettings(): " << e.what(); - } - }}, - // обновление кеша QoS - {.lastUpdate = 0, .periodMs = CACHE_QOS_UPDATE_MS, .callback = [this]() { - try { - this->updateQos(); - BOOST_LOG_TRIVIAL(debug) << "api_driver::TerminalApiDaemon::updateQos(): success update!"; - } catch (std::exception& e) { - BOOST_LOG_TRIVIAL(error) << "api_driver::TerminalApiDaemon::updateQos(): " << e.what(); - } - }} - }; - - while (true) { - if (this->lastCpError == ERROR || this->lastCpError == TIMEOUT) { - BOOST_LOG_TRIVIAL(error) << "api_driver::TerminalApiDaemon::run(): close current daemon session caused error " << this->lastCpError; - CP_Logout(this->sid); - this->connectToApi(); - } -#ifdef MODEM_IS_SCPC - updaters[0].periodMs = this->statsLogs.logEn ? this->statsLogs.logPeriodMs.load() : -1; -#endif - int64_t sleepTime = 60000; // минута по-умолчанию - auto now = TIME_NOW(); - for (auto& u: updaters) { - if (u.checkNeedUpdate(now)) { - auto targetTime = u.lastUpdate + u.periodMs; - if (targetTime + SLEEP_THRESHOLD <= now && targetTime - SLEEP_THRESHOLD >= now) { - u.lastUpdate = targetTime; - } else { - u.lastUpdate = now; - } - - u.callback(); - now = TIME_NOW(); - } - if (u.periodMs >= 0) { - sleepTime = std::min(sleepTime, u.getNextUpdate(now)); - } - } - - if (sleepTime > 0) { - boost::this_thread::sleep_for(boost::chrono::duration(boost::chrono::milliseconds(sleepTime))); - } - } - } - - std::shared_mutex stateMutex; - std::string deviceInitState; - TerminalDeviceState state; - - std::shared_mutex settingsMutex; - modulator_settings modSettings{}; - demodulator_settings demodSettings{}; -#ifdef MODEM_IS_SCPC - ACM_parameters_serv_ acmSettings{}; -#endif - DPDI_parmeters dpdiSettings{}; - buc_lnb_settings bucLnbSettings{}; - - std::shared_mutex networkSettingsMutex; - TerminalNetworkSettings networkSettings; - - std::shared_mutex qosSettingsMutex; - bool qosEnabled; - std::string qosClassesJson; - - std::shared_mutex firmwareMutex; - TerminalFirmwareVersion firmware; - -public: -#ifdef MODEM_IS_SCPC - StatisticsLogger statsLogs; -#endif - - std::mutex cpApiMutex; - TSID sid; - boost::thread daemon; - - explicit TerminalApiDaemon(): deviceInitState("Not connected to API"), qosEnabled(false), sid(0), daemon([this]() { this->run(); }) { - this->qosClassesJson = DEFAULT_QOS_CLASSES; - } - - std::string getDeviceInitState() { - std::shared_lock lock(this->stateMutex); - return this->deviceInitState; - } - - /** - * Получение статистики, копирует текущие значения в структуры, переданные по указателю. Если передан пустой указатель, копирования не произойдет. - */ - TerminalDeviceState getState() { - TerminalDeviceState s; - { - std::shared_lock lock(this->stateMutex); - s = this->state; - } - return s; - } - /** - * Получение настроек, копирует текущие значения в структуры, переданные по указателю. Если передан пустой указатель, копирования не произойдет. - */ - void getSettings( - modulator_settings* mod, demodulator_settings* demod, -#ifdef MODEM_IS_SCPC - ACM_parameters_serv_* acm, -#endif - DPDI_parmeters* dpdi, buc_lnb_settings* bucLnb) { - if (mod || demod || -#ifdef MODEM_IS_SCPC - acm || -#endif - dpdi || bucLnb) { - std::shared_lock lock(this->settingsMutex); - if (mod) { *mod = this->modSettings; } - if (demod) { *demod = this->demodSettings; } -#ifdef MODEM_IS_SCPC - if (acm) { *acm = this->acmSettings; } -#endif - if (dpdi) { *dpdi = this->dpdiSettings; } - if (bucLnb) { *bucLnb = this->bucLnbSettings; } - } - } - -#ifdef MODEM_IS_SCPC - bool getIsCinC() { - std::shared_lock lock(this->settingsMutex); - return modSettings.is_cinc; - } -#endif - - bool isTest() { - std::shared_lock lock(this->settingsMutex); - return modSettings.tx_is_on && (!modSettings.is_carrier -#ifdef MODEM_IS_SCPC - || this->modSettings.is_test_data -#endif - ); - } - - void getNetworkSettings(TerminalNetworkSettings& dest) { - std::shared_lock lock(this->networkSettingsMutex); - dest = this->networkSettings; - } - - void getQosSettings(bool& isEnabled, std::string& json) { - std::shared_lock lock(this->qosSettingsMutex); - isEnabled = this->qosEnabled; - json = this->qosClassesJson; - } - -#ifdef MODEM_IS_SCPC - void setSettingsRxTx(modulator_settings& mod, demodulator_settings& demod, ACM_parameters_serv_& acm, bool readback = true) { - std::lock_guard lock(this->cpApiMutex); - logCpApiError("api_driver::TerminalApiDaemon::setSettingsRxTx()->CP_SetDmaDebug(begin_save_config)", CP_SetDmaDebug(sid, "begin_save_config", "")); - logCpApiError("api_driver::TerminalApiDaemon::setSettingsRxTx()->CP_SetModulatorSettings()", CP_SetModulatorSettings(this->sid, mod)); - logCpApiError("api_driver::TerminalApiDaemon::setSettingsRxTx()->CP_SetDemodulatorSettings()", CP_SetDemodulatorSettings(this->sid, demod)); - logCpApiError("api_driver::TerminalApiDaemon::setSettingsRxTx()->CP_SetAcmParams()", CP_SetAcmParams(this->sid, acm)); - if (readback) { - logCpApiError("api_driver::TerminalApiDaemon::setSettingsRxTx()->CP_GetModulatorSettings()", CP_GetModulatorSettings(this->sid, mod)); - logCpApiError("api_driver::TerminalApiDaemon::setSettingsRxTx()->CP_GetDemodulatorSettings()", CP_GetDemodulatorSettings(this->sid, demod)); - logCpApiError("api_driver::TerminalApiDaemon::setSettingsRxTx()->CP_GetAcmParams()", CP_GetAcmParams(this->sid, &acm)); - { - std::lock_guard lock2{this->settingsMutex}; - this->modSettings = mod; - this->demodSettings = demod; - this->acmSettings = acm; - } - } - logCpApiError("api_driver::TerminalApiDaemon::setSettingsRxTx()->CP_SetDmaDebug(save_config)", CP_SetDmaDebug(sid, "save_config", "")); - } -#else - void setSettingsRxTx(modulator_settings& mod, demodulator_settings& demod, bool readback = true) { - std::lock_guard lock(this->cpApiMutex); - logCpApiError("api_driver::TerminalApiDaemon::setSettingsRxTx()->CP_SetDmaDebug(begin_save_config)", CP_SetDmaDebug(sid, "begin_save_config", "")); - logCpApiError("api_driver::TerminalApiDaemon::setSettingsRxTx()->CP_SetModulatorSettings()", CP_SetModulatorSettings(this->sid, mod)); - logCpApiError("api_driver::TerminalApiDaemon::setSettingsRxTx()->CP_SetDemodulatorSettings()", CP_SetDemodulatorSettings(this->sid, demod)); - if (readback) { - logCpApiError("api_driver::TerminalApiDaemon::setSettingsRxTx()->CP_GetModulatorSettings()", CP_GetModulatorSettings(this->sid, mod)); - logCpApiError("api_driver::TerminalApiDaemon::setSettingsRxTx()->CP_GetDemodulatorSettings()", CP_GetDemodulatorSettings(this->sid, demod)); - { - std::lock_guard lock2{this->settingsMutex}; - this->modSettings = mod; - this->demodSettings = demod; - } - } - logCpApiError("api_driver::TerminalApiDaemon::setSettingsRxTx()->CP_SetDmaDebug(save_config)", CP_SetDmaDebug(sid, "save_config", "")); - } -#endif - - void setSettingsDpdi(DPDI_parmeters& s, bool readback = true) { - std::lock_guard lock(this->cpApiMutex); - logCpApiError("api_driver::TerminalApiDaemon::setSettingsDpdi()->CP_SetDmaDebug(begin_save_config)", CP_SetDmaDebug(sid, "begin_save_config", "")); - logCpApiError("api_driver::TerminalApiDaemon::setSettingsDpdi()->CP_SetDpdiParams()", CP_SetDpdiParams(sid, s)); - if (readback) { - logCpApiError("api_driver::TerminalApiDaemon::setSettingsDpdi()->CP_GetDpdiParams()", CP_GetDpdiParams(this->sid, &s)); - { - std::lock_guard lock2{this->settingsMutex}; - this->dpdiSettings = s; - } - } - logCpApiError("api_driver::TerminalApiDaemon::setSettingsDpdi()->CP_SetDmaDebug(save_config)", CP_SetDmaDebug(sid, "save_config", "")); - } - - void setSettingsBucLnb(buc_lnb_settings& bucLnb, bool readback = true) { - std::lock_guard lock(this->cpApiMutex); - logCpApiError("api_driver::TerminalApiDaemon::setSettingsBucLnb()->CP_SetDmaDebug(begin_save_config)", CP_SetDmaDebug(sid, "begin_save_config", "")); - logCpApiError("api_driver::TerminalApiDaemon::setSettingsBucLnb()->CP_SetBUC_LNB_settings()", CP_SetBUC_LNB_settings(this->sid, bucLnb)); - if (readback) { - logCpApiError("api_driver::TerminalApiDaemon::setSettingsBucLnb()->CP_GetBUC_LNB_settings()", CP_GetBUC_LNB_settings(this->sid, bucLnb)); - { - std::lock_guard lock2{this->settingsMutex}; - this->bucLnbSettings = bucLnb; - } - } - logCpApiError("api_driver::TerminalApiDaemon::setSettingsBucLnb()->CP_SetDmaDebug(save_config)", CP_SetDmaDebug(sid, "save_config", "")); - } - - void setQosSettings(bool enabled, const std::string& str, bool readback = true) { - std::lock_guard lock(this->cpApiMutex); - logCpApiError("api_driver::TerminalApiDaemon::setQosSettings()->CP_SetDmaDebug(begin_save_config)", CP_SetDmaDebug(sid, "begin_save_config", "")); - logCpApiError("api_driver::TerminalApiDaemon::setQosSettings()->CP_SetQoSSettings()", CP_SetQoSSettings(this->sid, str, enabled)); - if (readback) { - bool tmp1; std::string tmp2; - logCpApiError("api_driver::TerminalApiDaemon::setQosSettings()->CP_GetQoSSettings()", CP_GetQoSSettings(this->sid, tmp2, tmp1)); - { - std::lock_guard lock2(this->qosSettingsMutex); - this->qosEnabled = tmp1; - this->qosClassesJson = tmp2.empty() ? DEFAULT_QOS_CLASSES : tmp2; - } - } - logCpApiError("api_driver::TerminalApiDaemon::setQosSettings()->CP_SetDmaDebug(save_config)", CP_SetDmaDebug(sid, "save_config", "")); - } - - void setNetworkSettings(TerminalNetworkSettings& s, bool readback = true) { - // const auto mang = splitIpAndMask(); - // std::pair data; - // if (!s.isL2) { - // data = splitIpAndMask(s.dataIp); - // } - - std::lock_guard lock(this->cpApiMutex); - logCpApiError("api_driver::TerminalApiDaemon::setNetworkSettings()->CP_SetDmaDebug(begin_save_config)", CP_SetDmaDebug(sid, "begin_save_config", "")); - unsafStoreNetworkSettings(s); - - if (readback) { - unsafeLoadNetworkSettings(s); - { - std::lock_guard lock2(this->networkSettingsMutex); - this->networkSettings = s; - } - } - logCpApiError("api_driver::TerminalApiDaemon::setNetworkSettings()->CP_SetDmaDebug(save_config)", CP_SetDmaDebug(sid, "save_config", "")); - } - - TerminalFirmwareVersion getFirmware() { - std::shared_lock lock(this->firmwareMutex); - return firmware; - } - - void resetPacketStatistics() { - std::string tmp; - std::lock_guard lock(this->cpApiMutex); - logCpApiError("api_driver::TerminalApiDaemon::resetPacketStatistics()->CP_GetDmaDebug(reset_cnt_rx)", CP_GetDmaDebug(sid, "reset_cnt_rx", &tmp)); - } - - void resetDefaultSettings() { - std::lock_guard lock(this->cpApiMutex); - logCpApiError("api_driver::TerminalApiDaemon::resetDefaultSettings()->CP_SetDmaDebug(begin_save_config)", CP_SetDmaDebug(sid, "begin_save_config", "")); - logCpApiError("api_driver::TerminalApiDaemon::resetDefaultSettings()->CP_SetDmaDebug(default_params)", CP_SetDmaDebug(sid, "default_params", "")); - logCpApiError("api_driver::TerminalApiDaemon::resetDefaultSettings()->CP_SetDmaDebug(save_config)", CP_SetDmaDebug(sid, "save_config", "")); - } - - ~TerminalApiDaemon() { - try { - daemon.interrupt(); - daemon.try_join_for(boost::chrono::seconds(2)); - } catch (std::exception& e) { - BOOST_LOG_TRIVIAL(error) << "api_driver::~TerminalApiDaemon(): " << e.what(); - } - } -}; - api_driver::ApiDriver::ApiDriver() = default; @@ -1378,41 +794,4 @@ void api_driver::ApiDriver::setLoggingStatisticsSettings(boost::property_tree::p } #endif -std::string api_driver::ApiDriver::loadSysInfo() { - std::stringstream result; - struct sysinfo info{}; - sysinfo(&info); - - // struct sysinfo { - // long uptime; /* Seconds since boot */ - // unsigned long loads[3]; /* 1, 5, and 15 minute load averages */ - // unsigned long totalram; /* Total usable main memory size */ - // unsigned long freeram; /* Available memory size */ - // unsigned long sharedram; /* Amount of shared memory */ - // unsigned long bufferram; /* Memory used by buffers */ - // unsigned long totalswap; /* Total swap space size */ - // unsigned long freeswap; /* Swap space still available */ - // unsigned short procs; /* Number of current processes */ - // unsigned long totalhigh; /* Total high memory size */ - // unsigned long freehigh; /* Available high memory size */ - // unsigned int mem_unit; /* Memory unit size in bytes */ - // }; - - const double f_load = 100.0 / ((1 << SI_LOAD_SHIFT) * get_nprocs()); - - result << "{\n\"uptime\":" << info.uptime; - result << ",\"load1min\":"; writeDouble(result, f_load * static_cast(info.loads[0]), 2); - result << ",\"load5min\":"; writeDouble(result, f_load * static_cast(info.loads[1]), 2); - result << ",\"load15min\":"; writeDouble(result, f_load * static_cast(info.loads[2]), 2); - result << ",\"totalram\":" << ((info.totalram * info.mem_unit) >> 20); // Mb - result << ",\"freeram\":" << ((info.freeram * info.mem_unit) >> 20); // Mb - // result << ",\"sharedram\":" << ((info.sharedram * info.mem_unit) >> 20); // Mb - // result << ",\"bufferram\":" << ((info.bufferram * info.mem_unit) >> 20); // Mb - // result << ",\"totalswap\":" << info.totalswap * info.mem_unit; - // result << ",\"freeswap\":" << info.freeswap * info.mem_unit; - result << ",\"procs\":" << static_cast(info.procs); - result << "\n}"; - return result.str(); -} - api_driver::ApiDriver::~ApiDriver() = default;