--- /dev/null
+/*
+ * @copyright Copyright (c) 2016-2020 TOYOTA MOTOR CORPORATION.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+///////////////////////////////////////////////////////////////////////////////
+/// \ingroup tag_SystemManager
+/// \brief This file provides support for System Manager configuration.
+///
+///////////////////////////////////////////////////////////////////////////////
+
+#include <boost/algorithm/string.hpp>
+
+
+#include <other_service/PosixBasedOS001ClockCycleApi.h>
+#include <other_service/ultoa.h>
+#include <native_service/frameworkunified_framework_if.h>
+#include <system_service/ss_string_maps.h>
+#include <system_service/ss_templates.h>
+#include <native_service/ns_config_parser_if.h>
+#include <errno.h>
+#include <sys/time.h>
+#include <sys/resource.h>
+#include <cctype>
+#include <string>
+#include <iomanip>
+#include <fstream>
+#include <iostream>
+#include <sstream>
+#include <algorithm>
+#include <functional>
+#include <list>
+#include <vector>
+#include <utility>
+
+#include "ss_sm_config.h"
+#include "ss_sm_systemmanagerlog.h"
+#include "ss_sm_launch_configuration.h"
+#include "system_launcher_cfg_format.h"
+#include "ss_sm_default_paths.h"
+
+using namespace std; // NOLINT
+
+// Constants for Heart Beat configuration data
+const UI_32 HBApplicationHeartBeatIntervalInitial = 40u; // Units of seconds. 0 = HB Disabled.
+const UI_32 HBApplicationHeartBeatIntervalRepeat = 5u; // Units of seconds. 0 = HB Disabled.
+const UI_32 HBMaxHeartBeatRetryCount = 3u;
+
+// Constants for Crash Detector configuration data
+const BOOL CDEnabled = TRUE;
+
+// Constants for system low memory configuration data
+
+const UI_32 SLMTimerValue = 5000; // msec
+const UI_32 SLMThresholdValue = (1024 * 512); // bytes
+const UI_32 SLMRetryCount = 6;
+const UI_32 SLMSystemmanagerLogIntervalMs = 30000;
+
+// Constants for Module connect time and Stat Resp Time
+
+const UI_32 ModuleConnectionNumTimesToCheck = 5;
+const UI_32 ModuleConnectionTimeOutSec = 5; // sec
+const UI_32 ModuleStartRespTimeOutSec = 120; // sec
+
+// Constants for Critical Apps Max wait timeout
+
+const UI_32 CriticalAppsMaxShutdownTimeFastSleepSec = 2; // sec
+const UI_32 CriticalAppsMaxShutdownTimeNormalResetSec = 15; // sec
+
+// Constants for User Mode data structure type
+const BOOL isBoolean = TRUE;
+
+const CHAR SMConfigDataHeader[] = "SystemManager";
+const CHAR HBConfigDataHeader[] = "HeartBeat";
+const CHAR CDConfigDataHeader[] = "CrashDetector";
+const CHAR SLMConfigDataHeader[] = "SysLowMemory";
+const CHAR UserModeConfigDataHeader[] = "UserMode";
+
+struct CfgLaunchParams {
+ CfgLaunchParams() :
+ group_id(0),
+ group_launch_wait(0),
+ group_wait_for_trigger(0),
+ priority(0),
+ critical(0),
+ retry_cnt(0),
+ is_start_required(0),
+ shutdown_critical(0),
+ shutdown_wait_time(0),
+ fast_shutdown_wait_time(0),
+ cpu_assign(0x0),
+ is_agl_unit(TRUE),
+ disable_agl_resethistory(FALSE),
+ disable_nonagl_resethistory(FALSE) {
+ std::memset(&group_name[0], 0, sizeof(group_name));
+ std::memset(&name[0], 0, sizeof(name));
+ std::memset(&binary_name[0], 0, sizeof(binary_name));
+ std::memset(&arguments[0], 0, sizeof(arguments));
+ std::memset(&logging_msk_str[0], 0, sizeof(logging_msk_str));
+ std::memset(&restart[0], 0, sizeof(restart));
+ std::memset(&unix_user_name[0], 0, sizeof(unix_user_name));
+ std::memset(&env_value_condition[0], 0, sizeof(env_value_condition));
+ }
+
+ CHAR group_name[100];
+ UI_32 group_id;
+ UI_32 group_launch_wait;
+ BOOL group_wait_for_trigger;
+ CHAR name[100];
+ CHAR binary_name[MAX_PATH_LENGTH];
+ UI_32 priority;
+ BOOL critical;
+ UI_32 retry_cnt;
+ CHAR arguments[512];
+ CHAR logging_msk_str[50];
+ CHAR restart[32];
+ BOOL is_start_required;
+ BOOL shutdown_critical;
+ UI_32 shutdown_wait_time;
+ UI_32 fast_shutdown_wait_time;
+ TUserNameBuffer unix_user_name; // TODO(username): Stuff.: Does Posix define a useful
+ // constant representing max length of user id?
+ CHAR env_value_condition[256];
+ int cpu_assign;
+
+ public:
+ BOOL IsAGLUnit(void) const { return is_agl_unit; }
+ BOOL IsAGLResetHistoryDisable(void) const { return disable_agl_resethistory; }
+ BOOL IsNonAGLResetHistoryDisable(void) const { return disable_nonagl_resethistory; }
+ void SetAGLUnit(BOOL f_is_agl_unit) { is_agl_unit = f_is_agl_unit; }
+ void SetAGLResetHistoryDisable(BOOL f_disable_agl_resethistory) {
+ disable_agl_resethistory = f_disable_agl_resethistory;
+ }
+ void SetNonAGLResetHisoryDisable(BOOL f_disable_nonagl_resethistory) {
+ disable_nonagl_resethistory = f_disable_nonagl_resethistory;
+ }
+
+ private:
+ BOOL is_agl_unit;
+ BOOL disable_agl_resethistory;
+ BOOL disable_nonagl_resethistory;
+};
+
+namespace ss_sm_cfg {
+class cfg_args {
+ public:
+ enum { // typedef enum _tokens
+ group_name,
+ group_id,
+ group_launch_wait,
+ group_wait_for_trigger,
+ name,
+ binary_name,
+ priority,
+ critical,
+ retry_cnt,
+ arguments,
+ logging_msk,
+ restart,
+ is_start_required,
+ shutdown_critical,
+ shutdown_wait_time,
+ fast_shutdown_wait_time,
+ unix_user_name,
+ is_agl_unit,
+ disable_agl_resethistory,
+ disable_nonagl_resethistory,
+ env_value_condition,
+ cpu_assign,
+ END
+ };
+};
+}; // namespace ss_sm_cfg
+
+static void set_grp_member_info(const LaunchInfo& launch_info, ModuleLaunchList& module_lst); // NOLINT
+static void load_parameters_order_cfg(
+ GroupLaunchMap& groups_map, LaunchOrderedVector& f_OrderList, SS_String& f_launchOrderName, SS_String& f_launchCfgFn); // NOLINT
+
+/*******************************************************************************
+ * CTimeSpan class *
+ * *
+ * Set Initial time, reset Final and Delta to zero, return time *
+ * */
+UI_64 CTimeSpan::Begin() {
+ initial = GetTimeMilliseconds();
+ final = 0;
+ delta = 0;
+ return initial;
+} // End of UI_64 CTimeSpan::Begin()
+
+/*
+ * Set Final time, calculate Delta time, return time
+ */
+UI_64 CTimeSpan::End() {
+ final = GetTimeMilliseconds();
+ delta = (final > initial) ? (final - initial) : 0; // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+ return final;
+} // End of UI_64 CTimeSpan::End()
+
+UI_64 CTimeSpan::GetInitial(void) {
+ return initial;
+}
+
+UI_64 CTimeSpan::GetFinal() {
+ return final;
+}
+
+UI_64 CTimeSpan::GetDelta() {
+ return delta;
+}
+
+UI_64 CTimeSpan::GetTimeMilliseconds() {
+ UI_64 l_totalmsec = 0;
+ struct timespec timeSpec;
+
+ if (0 != clock_gettime(CLOCK_MONOTONIC, &timeSpec)) {
+ SS_ASERT_ERRNO(0); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length)
+ } else {
+ l_totalmsec = (timeSpec.tv_sec * 1000ULL)
+ + (timeSpec.tv_nsec / 1000000);
+ }
+
+ return l_totalmsec;
+}
+
+/* *
+ * End of CTimeSpan class *
+ ******************************************************************************/
+
+ModuleLaunchParams::ModuleLaunchParams():
+ name("")
+ , path("")
+ , arguments("")
+ , restart("")
+ , configuration_priority(0)
+ , cpu_assign(0x0)
+ , previous_priority(0)
+ , current_priority(0)
+ , critical(FALSE)
+ , retry_cnt(0)
+ , logging_msk_str("")
+ , is_start_required(FALSE)
+ , shutdown_critical(FALSE)
+ , shutdown_wait_time(0)
+ , fast_shutdown_wait_time(0)
+ , pid(0)
+ , hsession(NULL)
+ , relaunch_count(0)
+ , relaunch_status(NotRelaunched)
+ , group_id(0xFFFF)
+ , m_serviceAvailability(FALSE)
+ , m_startReason()
+ , m_stopReason()
+ , m_ModuleDebugDumpState(MODULE_DEBUG_DUMP_STATE_NOT_REQUESTED)
+ , is_agl_unit(TRUE)
+ , disable_agl_resethistory(FALSE)
+ , disable_nonagl_resethistory(FALSE) { // LCOV_EXCL_BR_START 11:Gcov constraints (because exception-handling routes are automatically generated)
+ SetModuleState(MODULE_STATE_INVALID, FALSE);
+ //
+ // Module State strings
+ m_ModuleStateStrMap[MODULE_STATE_INVALID] = "INVALID";
+ m_ModuleStateStrMap[MODULE_STATE_SKIPPED] = "SKIPPED";
+ m_ModuleStateStrMap[MODULE_STATE_LAUNCHING] = "LAUNCHING";
+ m_ModuleStateStrMap[MODULE_STATE_LAUNCHED] = "LAUNCHED";
+ m_ModuleStateStrMap[MODULE_STATE_LAUNCH_FAILED] = "LAUNCH_FAIL";
+ m_ModuleStateStrMap[MODULE_STATE_CONNECTED] = "CONNECTED";
+ m_ModuleStateStrMap[MODULE_STATE_START_SENT] = "START_SENT";
+ m_ModuleStateStrMap[MODULE_STATE_START_FAILED] = "START_FAIL";
+ m_ModuleStateStrMap[MODULE_STATE_STARTED] = "STARTED";
+ m_ModuleStateStrMap[MODULE_STATE_STOP_FAILED] = "STOP_FAIL";
+ m_ModuleStateStrMap[MODULE_STATE_STOP_SENT] = "STOP_SENT";
+ m_ModuleStateStrMap[MODULE_STATE_STOPPED] = "STOPPED";
+ m_ModuleStateStrMap[MODULE_STATE_START_PRE_SENT] = "PRE_START_SENT";
+ m_ModuleStateStrMap[MODULE_STATE_START_PRE_FAILED] = "PRE_START_FAIL";
+ m_ModuleStateStrMap[MODULE_STATE_STARTED_PRE] = "PRE_STARTED";
+ m_ModuleStateStrMap[MODULE_STATE_STOP_PRE_SENT] = "PRE_STOP_SENT";
+ m_ModuleStateStrMap[MODULE_STATE_STOP_PRE_FAILED] = "PRE_STOP_FAIL";
+ m_ModuleStateStrMap[MODULE_STATE_STOPPED_PRE] = "PRE_STOPPED";
+ m_ModuleStateStrMap[MODULE_STATE_START_BACKGROUND_SENT] = "BACKGROUND_START_SENT";
+ m_ModuleStateStrMap[MODULE_STATE_START_BACKGROUND_FAILED] = "BACKGROUND_START_FAIL";
+ m_ModuleStateStrMap[MODULE_STATE_STARTED_BACKGROUND] = "BACKGROUND_STARTED";
+ m_ModuleStateStrMap[MODULE_STATE_STOP_BACKGROUND_SENT] = "BACKGROUND_STOP_SENT";
+ m_ModuleStateStrMap[MODULE_STATE_STOP_BACKGROUND_FAILED] = "BACKGROUND_STOP_FAIL";
+ m_ModuleStateStrMap[MODULE_STATE_STOPPED_BACKGROUND] = "BACKGROUND_STOPPED";
+ // LCOV_EXCL_BR_STOP
+
+ m_startReason.SetReason(NotStarted);
+ m_stopReason.SetReason(NotStopped);
+
+ MAP_ENTRY(m_ModuleDebugDumpStateStrMap, MODULE_DEBUG_DUMP_STATE_NOT_REQUESTED); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length)
+ MAP_ENTRY(m_ModuleDebugDumpStateStrMap, MODULE_DEBUG_DUMP_STATE_REQUEST_SENT); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length)
+ MAP_ENTRY(m_ModuleDebugDumpStateStrMap, MODULE_DEBUG_DUMP_STATE_RESPONSE_RECEIVED); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length)
+
+ std::memset(&unix_user_name[0], 0, sizeof(unix_user_name));
+} // End of ModuleLaunchParams::ModuleLaunchParams() :
+
+ModuleLaunchParams::~ModuleLaunchParams() {
+} // End of ModuleLaunchParams::~ModuleLaunchParams() :
+
+SMModuleState ModuleLaunchParams::GetModuleState(void) {
+ return m_moduleState;
+} // End of SMModuleState ModuleLaunchParams::GetModuleState(void)
+
+BOOL ModuleLaunchParams::IsModuleState(SMModuleState f_moduleState) {
+ return m_moduleState == f_moduleState;
+} // End of BOOL ModuleLaunchParams::IsModuleState(SMModuleState f_moduleState )
+
+// IsModuleConnected
+// Determine if a module is in a state capable of receiving messages from System Manager.
+BOOL ModuleLaunchParams::IsModuleConnected() const {
+ BOOL l_isModuleConnected = FALSE;
+
+ switch (m_moduleState) {
+ case MODULE_STATE_CONNECTED:
+ case MODULE_STATE_START_SENT:
+ case MODULE_STATE_START_FAILED:
+ case MODULE_STATE_STARTED:
+ case MODULE_STATE_STOP_SENT:
+ case MODULE_STATE_STOP_FAILED:
+ case MODULE_STATE_STOPPED:
+ case MODULE_STATE_START_PRE_SENT:
+ case MODULE_STATE_START_PRE_FAILED:
+ case MODULE_STATE_STARTED_PRE:
+ case MODULE_STATE_STOP_PRE_SENT:
+ case MODULE_STATE_STOP_PRE_FAILED:
+ case MODULE_STATE_STOPPED_PRE:
+ case MODULE_STATE_START_BACKGROUND_SENT:
+ case MODULE_STATE_START_BACKGROUND_FAILED:
+ case MODULE_STATE_STARTED_BACKGROUND:
+ case MODULE_STATE_STOP_BACKGROUND_SENT:
+ case MODULE_STATE_STOP_BACKGROUND_FAILED:
+ case MODULE_STATE_STOPPED_BACKGROUND:
+ l_isModuleConnected = TRUE;
+ break;
+
+ default:
+ l_isModuleConnected = FALSE;
+ break;
+ }
+
+ return (l_isModuleConnected);
+} // End of BOOL ModuleLaunchParams::IsModuleConnected(void)
+
+VOID ModuleLaunchParams::SetModuleState(SMModuleState f_moduleState, BOOL f_bLog) {
+ m_moduleState = f_moduleState;
+
+ switch (m_moduleState) { // Because the module status cannot be changed from the external API
+ case MODULE_STATE_INVALID:
+ case MODULE_STATE_SKIPPED:
+ case MODULE_STATE_LAUNCH_FAILED:
+ case MODULE_STATE_LAUNCHING:
+ case MODULE_STATE_LAUNCHED:
+ case MODULE_STATE_CONNECTED:
+ break;
+ case MODULE_STATE_START_SENT:
+ m_startReason.Begin();
+ break;
+ case MODULE_STATE_START_FAILED:
+ m_startReason.End();
+ m_startReason.SetReason(StartedByModuleStartFail);
+ break;
+ case MODULE_STATE_STARTED:
+ m_startReason.End();
+ m_startReason.SetReason(StartedByModuleStartComplete);
+ break;
+
+ case MODULE_STATE_STOP_SENT:
+ m_stopReason.Begin();
+ break;
+
+ case MODULE_STATE_STOP_FAILED:
+ m_stopReason.End();
+ m_stopReason.SetReason(StoppedByModuleStopFail);
+ break;
+ case MODULE_STATE_STOPPED:
+ m_stopReason.End();
+ m_stopReason.SetReason(StoppedByModuleStopComplete);
+ break;
+
+ case MODULE_STATE_START_PRE_SENT:
+ m_startReason.Begin();
+ break;
+ case MODULE_STATE_START_PRE_FAILED:
+ m_startReason.End();
+ m_startReason.SetReason(StartedByModulePreStartFail);
+ break;
+ case MODULE_STATE_STARTED_PRE:
+ m_startReason.End();
+ m_startReason.SetReason(StartedByModulePreStartComplete);
+ break;
+ case MODULE_STATE_STOP_PRE_SENT:
+ m_stopReason.Begin();
+ break;
+ case MODULE_STATE_STOP_PRE_FAILED:
+ m_stopReason.End();
+ m_stopReason.SetReason(StoppedByModulePreStopFail);
+ break;
+ case MODULE_STATE_STOPPED_PRE:
+ m_stopReason.End();
+ m_stopReason.SetReason(StoppedByModulePreStopComplete);
+ break;
+
+ case MODULE_STATE_START_BACKGROUND_SENT:
+ m_startReason.Begin();
+ break;
+ case MODULE_STATE_START_BACKGROUND_FAILED:
+ m_startReason.End();
+ m_startReason.SetReason(StartedByModuleBackgroundStartFail);
+ break;
+ case MODULE_STATE_STARTED_BACKGROUND:
+ m_startReason.End();
+ m_startReason.SetReason(StartedByModuleBackgroundStartComplete);
+ break;
+ case MODULE_STATE_STOP_BACKGROUND_SENT:
+ m_stopReason.Begin();
+ break;
+ case MODULE_STATE_STOP_BACKGROUND_FAILED:
+ m_stopReason.End();
+ m_stopReason.SetReason(StoppedByModuleBackgroundStopFail);
+ break;
+ case MODULE_STATE_STOPPED_BACKGROUND:
+ m_stopReason.End();
+ m_stopReason.SetReason(StoppedByModuleBackgroundStopComplete);
+ break;
+
+ // default: Don't code a 'default' here - let the compiler
+ // issue a warning ( set via -Wall or -Wswitch ) when the set of
+ // enumerations changes - then the maintainer will
+ // automagically know to update this switch statement.
+ }
+
+ if (f_bLog) {
+ char buf[255];
+ char *p = buf;
+ strcpy(p, m_ModuleStateStrMap[m_moduleState].c_str()); // NOLINT
+ p += m_ModuleStateStrMap[m_moduleState].size();
+ strcpy(p, ":"); // NOLINT
+ p += sizeof(":") - 1;
+ strcpy(p, name.c_str()); // NOLINT
+ FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, buf);
+ }
+} // End of VOID ModuleLaunchParams::SetModuleState(SMModuleState f_moduleState )
+
+std::string ModuleLaunchParams::ModuleStateStr(void) {
+ return m_ModuleStateStrMap[m_moduleState];
+} // End of std::string ModuleLaunchParams::ModuleStateStr(SMModuleState f_moduleState )
+
+SMModuleDebugDumpState ModuleLaunchParams::GetModuleDebugDumpState(void) { // LCOV_EXCL_START 6: Because the condition cannot be set // NOLINT(whitespace/line_length)
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ return m_ModuleDebugDumpState;
+} // End of SMModuleDebugDumpState ModuleLaunchParams::GetModuleDebugDumpState(void)
+// LCOV_EXCL_STOP
+
+std::string ModuleLaunchParams::GetModuleDebugDumpStateStr(void) {
+ return m_ModuleDebugDumpStateStrMap[m_ModuleDebugDumpState];
+} // End of std::string ModuleLaunchParams::GetModuleDebugDumpStateStr()
+
+VOID ModuleLaunchParams::SetModuleDebugDumpState(
+ SMModuleDebugDumpState f_moduleDebugDumpState, BOOL f_bLog) {
+ m_ModuleDebugDumpState = f_moduleDebugDumpState;
+
+ if (f_bLog) { // LCOV_EXCL_BR_LINE 200:f_bLog must be TRUE
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " %s set for %s",
+ GetModuleDebugDumpStateStr().c_str(), name.c_str());
+ }
+} // End of VOID ModuleLaunchParams::SetModuleDebugDumpState(SMModuleDebugDumpState f_moduleDebugDumpState )
+
+EFrameworkunifiedStatus ModuleLaunchParams::SendMsgAndUpdateState(
+ const UI_32 f_iCmd, const T_SS_SM_START_DataStructType* const f_startData) {
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ char l_cBuf[500] = " Error: char l_cBuf[] not built";
+ T_SS_SM_START_DataStructType l_startData;
+ SMModuleState l_SendSuccess = MODULE_STATE_START_SENT;
+ SMModuleState l_SendFailed = MODULE_STATE_START_FAILED;
+
+ memcpy(&l_startData, f_startData, sizeof(T_SS_SM_START_DataStructType));
+
+ switch (relaunch_status) { // LCOV_EXCL_BR_LINE 6: Because all conditions cannot be satisfied from the external API
+ case NotRelaunched:
+ // Setting startup information at the first startup
+ break;
+ case RelaunchSafe: // LCOV_EXCL_START 6: Because all conditions cannot be satisfied from the external API
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ l_startData.resetStatus = e_SS_SM_RESET_STATUS_NONE;
+ break;
+ case RelaunchErr:
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ l_startData.resetStatus = e_SS_SM_RESET_STATUS_NG;
+ break;
+ default:
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ SS_ASERT(0);
+ break;
+ // LCOV_EXCL_STOP
+ }
+
+ switch (f_iCmd) {
+ case SS_SM_PRE_START:
+ l_SendSuccess = MODULE_STATE_START_PRE_SENT;
+ l_SendFailed = MODULE_STATE_START_PRE_FAILED;
+ break;
+ case SS_SM_PRE_STOP:
+ l_SendSuccess = MODULE_STATE_STOP_PRE_SENT;
+ l_SendFailed = MODULE_STATE_STOP_PRE_FAILED;
+ break;
+ case SS_SM_BACKGROUND_START:
+ l_SendSuccess = MODULE_STATE_START_BACKGROUND_SENT;
+ l_SendFailed = MODULE_STATE_START_BACKGROUND_FAILED;
+ break;
+ case SS_SM_BACKGROUND_STOP:
+ l_SendSuccess = MODULE_STATE_STOP_BACKGROUND_SENT;
+ l_SendFailed = MODULE_STATE_STOP_BACKGROUND_FAILED;
+ break;
+ case SS_SM_START:
+ default:
+ l_SendSuccess = MODULE_STATE_START_SENT;
+ l_SendFailed = MODULE_STATE_START_FAILED;
+ break;
+ }
+
+ const EFrameworkunifiedStatus l_eStatus = FrameworkunifiedSendMsg(hsession, f_iCmd,
+ sizeof(T_SS_SM_START_DataStructType),
+ static_cast<PCVOID>(&l_startData));
+
+ // LCOV_EXCL_START 6: As no TRUE is returned
+ if (IS_ZONE_SET(ZONE_ERR) || IS_ZONE_SET(ZONE_INFO)) {
+
+ snprintf(l_cBuf, sizeof(l_cBuf), "FrameworkunifiedSendMsg(%s, system_manager protocol message, %d/%s)",
+ name.c_str(), l_startData.startupReason,
+ GetStr(l_startData.startupReason).c_str());
+ }
+ // LCOV_EXCL_STOP 6:As no TRUE is returned
+ if (eFrameworkunifiedStatusOK != l_eStatus) { // LCOV_EXCL_BR_LINE 4:NSFW's error
+ // LCOV_EXCL_START 4:NSFW's error
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ LOG_ERROR(l_cBuf); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length)
+ SetModuleState(l_SendFailed);
+ // LCOV_EXCL_STOP
+ } else {
+ LOG_SUCCESS(l_cBuf); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length)
+ SetModuleState(l_SendSuccess);
+ }
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return l_eStatus;
+}
+// End of EFrameworkunifiedStatus ModuleLaunchParams::SendMsgAndUpdateState(T_SS_SM_START_DataStructType const * f_startData)
+
+EFrameworkunifiedStatus ModuleLaunchParams::SendMsgAndUpdateState(
+ T_SS_SM_STOP_DataStructType const* f_stopData) {
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ char l_cBuf[500] = " Error: char l_cBuf[] not built";
+ EFrameworkunifiedStatus l_eStatus = FrameworkunifiedSendMsg(hsession, SS_SM_STOP,
+ sizeof(T_SS_SM_STOP_DataStructType),
+ static_cast<PCVOID>(f_stopData));
+
+ if (IS_ZONE_SET(ZONE_ERR) || IS_ZONE_SET(ZONE_INFO)) { // LCOV_EXCL_BR_LINE 200:alwasy true
+ snprintf(l_cBuf, sizeof(l_cBuf), "FrameworkunifiedSendMsg(%s, SS_SM_STOP, %d/%s, "
+ "Last User Mode: %s)", name.c_str(),
+ f_stopData->shutdownTrigger,
+ GetStr(f_stopData->shutdownTrigger).c_str(),
+ GetStr(f_stopData->lastUserMode).c_str());
+ }
+ if (eFrameworkunifiedStatusOK != l_eStatus) { // LCOV_EXCL_BR_LINE 4:NSFW's error
+ // LCOV_EXCL_START 4:NSFW's error
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ LOG_ERROR(l_cBuf); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length)
+ SetModuleState(MODULE_STATE_STOP_FAILED);
+ // LCOV_EXCL_STOP
+ } else {
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " %s successful", l_cBuf);
+ SetModuleState(MODULE_STATE_STOP_SENT);
+ }
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return l_eStatus;
+}
+// End of EFrameworkunifiedStatus ModuleLaunchParams::SendMsgAndUpdateState(T_SS_SM_STOP_DataStructType const * f_stopData)
+
+EFrameworkunifiedStatus ModuleLaunchParams::GetPriority(UI_32& f_Priority) {
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ EFrameworkunifiedStatus l_eStatus;
+
+ struct sched_param cur_sch_params;
+ errno = 0;
+ f_Priority = 0xDEAD;
+
+ if (0 == pid) { // LCOV_EXCL_BR_LINE 200: pid can not be 0
+ // LCOV_EXCL_START 200: pid can not be 0
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ l_eStatus = eFrameworkunifiedStatusInvldParam;
+ LOG_ERROR("0 == pid"); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length)
+ // LCOV_EXCL_STOP
+ } else if (-1 >= sched_getparam(pid, &cur_sch_params)) { // LCOV_EXCL_BR_LINE 5: system function failed
+ // LCOV_EXCL_START 5: system function failed
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ l_eStatus = eFrameworkunifiedStatusFault;
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ " Error: 'sched_getparam( pid %d, &cur_sch_params )' returned -1, "
+ "strerr() is '%s'", pid, strerror(errno));
+ // LCOV_EXCL_STOP
+ } else {
+ l_eStatus = eFrameworkunifiedStatusOK;
+ f_Priority = cur_sch_params.sched_priority;
+ }
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return l_eStatus;
+} // End of EFrameworkunifiedStatus ModuleLaunchParams::GetPriority (UI_32 & f_Priority )
+
+EFrameworkunifiedStatus ModuleLaunchParams::SetPriority(UI_32 f_Priority) {
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ EFrameworkunifiedStatus l_eStatus;
+
+ errno = 0;
+
+ if (99 < f_Priority) { // LCOV_EXCL_BR_LINE 200: priority can not greater than 99
+ // LCOV_EXCL_START 200: priority can not greater than 99
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ l_eStatus = eFrameworkunifiedStatusInvldParam;
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: Invalid 'f_Priority' %d/0x%X",
+ f_Priority, f_Priority);
+ // LCOV_EXCL_STOP
+ } else if (0 == pid) { // LCOV_EXCL_BR_LINE 200: pid can not be 0
+ // LCOV_EXCL_START 200: pid can not be 0
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ l_eStatus = eFrameworkunifiedStatusInvldParam;
+ LOG_ERROR("0 == pid"); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length)
+ // LCOV_EXCL_STOP
+ } else {
+ int rc;
+ struct sched_param l_schedParam = { };
+ l_schedParam.sched_priority = f_Priority;
+
+ if (f_Priority == 0) { // LCOV_EXCL_BR_LINE 200: f_Priority can not be 0
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ rc = sched_setscheduler(pid, SCHED_OTHER, &l_schedParam); // LCOV_EXCL_LINE 200: f_Priority can not be 0
+ } else {
+ rc = sched_setscheduler(pid, SCHED_FIFO, &l_schedParam);
+ }
+ SS_ASERT_ERRNO(0 == rc); // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h // NOLINT(whitespace/line_length)
+ if (rc == 0) {
+ previous_priority = current_priority;
+ current_priority = f_Priority;
+ l_eStatus = eFrameworkunifiedStatusOK;
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__,
+ " setprio( %s, pid %d, 'previous_priority' %d -> %d ) successful",
+ name.c_str(), pid, previous_priority, f_Priority);
+ } else if (rc == -1) { // LCOV_EXCL_BR_LINE 5: system function failed
+ // LCOV_EXCL_START 5: system function failed
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ l_eStatus = eFrameworkunifiedStatusFault;
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ " setprio( %s, pid %d, 'current_priority' %d -> %d ) returned '-1', strerr() is '%s'",
+ name.c_str(), pid, current_priority, f_Priority,
+ strerror(errno));
+ // LCOV_EXCL_STOP
+ } else { // LCOV_EXCL_BR_LINE 5: can not be other value
+ // LCOV_EXCL_START 5: can not be other value
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ l_eStatus = eFrameworkunifiedStatusFault;
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ " setprio( %s, pid %d, 'current_priority' %d -> %d ) returned '%d'; "
+ "'rc' is neither original priority nor '-1': 'errno' is '%d', strerr() is '%s'",
+ name.c_str(), pid, current_priority, f_Priority, rc,
+ errno, strerror(errno));
+ // LCOV_EXCL_STOP
+ }
+ }
+
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return l_eStatus;
+} // End of EFrameworkunifiedStatus ModuleLaunchParams::SetPriority( UI_32 f_Priority )
+
+SysMgrConfiguration::SysMgrConfiguration():
+l_pReaderCfg(NULL) {
+}
+
+SysMgrConfiguration::~SysMgrConfiguration() {
+}
+
+static BOOL is_satisfy_env_launch_cond(CHAR *env_cond) { // LCOV_EXCL_START 6: Because the condition cannot be set
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ BOOL l_isSatisfy = FALSE;
+ BOOL l_isReverse = FALSE;
+ CHAR *l_pString = NULL;
+
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "env_cond [%s]", env_cond);
+
+ if (NULL != (l_pString = strstr(env_cond, "!="))) {
+ l_isReverse = TRUE;
+ } else if (NULL == (l_pString = strstr(env_cond, "=="))) {
+ SS_ASERT(0);
+ }
+
+ if (NULL != l_pString) {
+ CHAR *l_pEnv = env_cond;
+ CHAR *l_pValue = l_pString + 2;
+ *l_pString = '\0';
+
+ CHAR *l_pEnvVariable = NULL;
+
+ if (NULL != (l_pEnvVariable = std::getenv(l_pEnv))) {
+ l_isSatisfy = (0 == strcmp(l_pValue, l_pEnvVariable)) ? TRUE : FALSE;
+ if (l_isReverse) {
+ l_isSatisfy = !l_isSatisfy;
+ }
+ }
+ }
+
+ return l_isSatisfy;
+}
+
+static void set_grp_member_info(const LaunchInfo& launch_info, ModuleLaunchList& module_lst) { // NOLINT
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ // Note: the
+ ModuleLaunchParams grp_member_info;
+ grp_member_info.name = launch_info.name;
+ grp_member_info.path = launch_info.binary_name;
+ grp_member_info.arguments = launch_info.arguments;
+ grp_member_info.restart = launch_info.restart;
+ grp_member_info.configuration_priority = launch_info.priority;
+ grp_member_info.retry_cnt = launch_info.retry_cnt;
+ grp_member_info.logging_msk_str = launch_info.logging_msk_str;
+ grp_member_info.critical = launch_info.critical;
+ grp_member_info.shutdown_critical = launch_info.shutdown_critical;
+ grp_member_info.shutdown_wait_time = launch_info.shutdown_wait_time;
+ grp_member_info.group_id = launch_info.group_id;
+ grp_member_info.is_start_required = launch_info.is_start_required;
+ grp_member_info.fast_shutdown_wait_time = launch_info.fast_shutdown_wait_time;
+ grp_member_info.SetAGLUnit(launch_info.IsAGLUnit());
+ grp_member_info.SetAGLResetHistoryDisable(launch_info.IsAGLResetHistoryDisable());
+ grp_member_info.SetNonAGLResetHisoryDisable(launch_info.IsNonAGLResetHistoryDisable());
+
+ module_lst.push_back(grp_member_info);
+}
+// LCOV_EXCL_STOP
+
+static ModuleLaunchListIter set_cfg_grp_member_info(
+ const CfgLaunchParams& launch_info, ModuleLaunchList& module_lst) { // NOLINT
+ ModuleLaunchParams grp_member_info;
+ ModuleLaunchListIter moduleLaunchListIter;
+
+ grp_member_info.name = launch_info.name;
+ grp_member_info.path = launch_info.binary_name;
+ grp_member_info.arguments = ( // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+ std::strcmp(launch_info.arguments, "NULL") == 0 ? "" : launch_info.arguments);
+ grp_member_info.restart = ( // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+ std::strcmp(launch_info.restart, "NULL") == 0 ? "" : launch_info.restart);
+ grp_member_info.configuration_priority = launch_info.priority;
+ grp_member_info.cpu_assign = launch_info.cpu_assign;
+ grp_member_info.retry_cnt = launch_info.retry_cnt;
+ grp_member_info.logging_msk_str = ( // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+ std::strcmp(launch_info.logging_msk_str, "NULL") == 0 ? "" : launch_info.logging_msk_str);
+
+ grp_member_info.critical = launch_info.critical;
+ grp_member_info.shutdown_critical = launch_info.shutdown_critical;
+ grp_member_info.shutdown_wait_time = launch_info.shutdown_wait_time;
+ grp_member_info.group_id = launch_info.group_id;
+ grp_member_info.is_start_required = launch_info.is_start_required;
+ grp_member_info.fast_shutdown_wait_time = launch_info.fast_shutdown_wait_time;
+ grp_member_info.SetAGLUnit(launch_info.IsAGLUnit());
+ grp_member_info.SetAGLResetHistoryDisable(launch_info.IsAGLResetHistoryDisable());
+ grp_member_info.SetNonAGLResetHisoryDisable(launch_info.IsNonAGLResetHistoryDisable());
+
+ strncpy(&grp_member_info.unix_user_name[0], &launch_info.unix_user_name[0],
+ sizeof(TUserNameBuffer));
+
+ moduleLaunchListIter = module_lst.insert(module_lst.end(), grp_member_info);
+ return (moduleLaunchListIter);
+}
+
+static void load_parameters_order_cfg(GroupLaunchMap& groups_map, // NOLINT
+ LaunchOrderedVector& f_OrderList, SS_String& f_launchOrderName, // NOLINT
+ SS_String& f_launchCfgFn) { // NOLINT
+ SS_String l_OrderCfgFn = f_launchCfgFn;
+ string::size_type pos = l_OrderCfgFn.find(".cfg");
+
+ if (pos == string::npos) { // LCOV_EXCL_BR_LINE 5:C error
+ // LCOV_EXCL_START 5:C error
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "invalid file name:%s",
+ f_launchCfgFn.c_str());
+ return;
+ // LCOV_EXCL_STOP
+ }
+
+ l_OrderCfgFn.replace(pos, strlen(".order.cfg"), ".order.cfg");
+ CNSConfigReader *l_pReaderOrderCfg = new CNSConfigReader(l_OrderCfgFn);
+
+ if (l_pReaderOrderCfg != NULL) { // LCOV_EXCL_BR_LINE 5:new error
+ CHAR key[128];
+ std::sprintf(key, "%s.order", f_launchOrderName.c_str()); // NOLINT
+ SS_String value = l_pReaderOrderCfg->GetString(key);
+ std::vector<std::string> strList;
+ if (value.empty()) { // LCOV_EXCL_BR_LINE 200:cannot be empty
+ goto ERROR;
+ }
+// LCOV_EXCL_START 6: Because an initialization condition is set at SystemManager startup and the branching condition cannot be satisfied
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ boost::split(strList, value, boost::is_any_of("|"));
+ for (UI_32 i = 0; i < strList.size(); i++) {
+ char* endptr = NULL;
+ f_OrderList.push_back(
+ static_cast<UI_32>(strtoul(strList[i].c_str(), &endptr, 10)));
+ if (*endptr != '\0') {
+ // Discard boot order if invalid string is detected
+ f_OrderList.clear();
+ goto ERROR;
+ }
+ }
+ std::sprintf(key, "%s.owlist", f_launchOrderName.c_str()); // NOLINT
+ SS_String ow_list_value = l_pReaderOrderCfg->GetString(key);
+ std::vector<std::string> owList;
+
+ if (!ow_list_value.empty()) {
+ boost::split(owList, ow_list_value, boost::is_any_of("|"));
+ for (UI_32 i = 0; i < owList.size(); i++) {
+ std::sprintf(key, "%s.%s", f_launchOrderName.c_str(), // NOLINT
+ owList[i].c_str());
+ SS_String grop_ow_time = l_pReaderOrderCfg->GetString(key);
+ if (owList[i].compare(0, 4, "oww_") == 0) {
+ char* endptr = NULL;
+ SS_String group_name = owList[i].substr(strlen("oww_"));
+ UI_32 group_launch_wait = static_cast<UI_32>(strtoul(
+ grop_ow_time.c_str(), &endptr, 10));
+ if (*endptr != '\0') {
+ continue;
+ }
+ GroupLaunchMapIter grp_iter = groups_map.begin();
+ while (grp_iter != groups_map.end()) {
+ if (group_name == grp_iter->second.name) {
+ grp_iter->second.grp_launch_wait = group_launch_wait;
+ FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__,
+ "grp_launch_wait %s=%d", group_name.c_str(),
+ group_launch_wait);
+ break;
+ }
+ grp_iter++;
+ }
+ }
+ }
+ }
+ } else {
+ FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "ConfigReader(%s) is NULL",
+ l_OrderCfgFn.c_str());
+ }
+// LCOV_EXCL_STOP
+ ERROR: if (l_pReaderOrderCfg != NULL) { // LCOV_EXCL_BR_LINE 200:cannot be null
+ delete l_pReaderOrderCfg; // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+ }
+ return;
+}
+
+// Given a string, splits it up on the seperator character
+// SubStringIterator( "a|b|| c |", '|' )
+// -> On each subsequent invocation of next() would return "a", "b", "", " c ", ""
+class SubStringIterator {
+ typedef std::string::const_iterator SCIter;
+
+ public:
+ SubStringIterator(const std::string& s, char c) :
+ m_position(s.begin()), m_end(s.end()), m_seperator(c), m_done(false) {
+ }
+
+ std::string next() {
+ SCIter begin = m_position;
+ while (m_position != m_end &&
+ *m_position != m_seperator) {
+ ++m_position;
+ }
+
+ const std::string ret(begin, m_position);
+ if (m_position == m_end) {
+ m_done = true;
+ } else {
+ ++m_position;
+ }
+
+ return ret;
+ }
+ bool done() const {
+ return m_done;
+ }
+
+ private:
+ SCIter m_position;
+ const SCIter m_end;
+ const char m_seperator;
+ bool m_done;
+};
+
+template<class Iter>
+static
+Iter skipPrecedingWS(Iter begin, Iter end) { // LCOV_EXCL_START 6: Because the condition cannot be set
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ return std::find_if(begin, end,
+ std::not1(std::ptr_fun((int (*)(int))std::isspace)));
+}
+
+// remove only preceding and trailing whitespace, but leave intermediate whitespace characters alone
+std::string strip(const std::string& str) {
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ std::string::const_iterator skipTo = skipPrecedingWS(str.begin(), str.end());
+ if (skipTo == str.end()) { // if string consists of ONLY whitespace
+ return std::string("");
+ } else {
+ return std::string(skipTo, skipPrecedingWS(str.rbegin(), str.rend()).base());
+ }
+}
+// LCOV_EXCL_STOP
+
+BOOL SysMgrConfiguration::LoadParametersCfg(GroupLaunchMap& groups_map,
+ ProcessNameMap& f_processNameMap, LaunchOrderedVector& f_OrderList,
+ SS_String& f_launchOrderName, SS_String& f_launchCfgFn) {
+ BOOL rtn_code = TRUE;
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+
+ l_pReaderCfg = new (std::nothrow) CNSConfigReader(f_launchCfgFn); // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+
+ if (NULL != l_pReaderCfg) { // LCOV_EXCL_BR_LINE 5:new error
+ UI_32 launch_idx = 1;
+ CHAR key[128];
+ std::sprintf(key, "ModulesLaunchConfig.Launch%d", launch_idx); // NOLINT
+ SS_String value = l_pReaderCfg->GetString(key);
+
+ if (value.empty()) { // LCOV_EXCL_BR_LINE 200:cannot be empty
+// LCOV_EXCL_START 6: For setting the initialization conditions at SystemManager startup
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ " Error: l_pReaderCfg->GetString(%s) returned empty-string; "
+ "is launch configuration file mis-configured ?",
+ key);
+ rtn_code = FALSE;
+// LCOV_EXCL_STOP
+ } else {
+ const char* nfsenv = getenv("AGL_NFS");
+ bool isNfs = (nfsenv && strcmp(nfsenv, "y") == 0) ? true : false; // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+
+ std::list<std::string> capFiles;
+ if (isNfs) {
+// LCOV_EXCL_START 6: Because an initialization condition is set at SystemManager startup and the branching condition cannot be satisfied
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ const std::string capPath("/usr/debug/share/target/cap.lst");
+ std::ifstream fin(capPath.c_str());
+ std::string line;
+ while (fin && std::getline(fin, line)) {
+ std::list<std::string> strList;
+ boost::split(strList, line, boost::is_any_of("|"));
+ if (!strList.empty()) {
+ if (strList.front()[0] == '/') { // Only character strings beginning with '/' are considered PATH
+ capFiles.push_back(strList.front().c_str());
+ }
+ }
+ }
+ }
+// LCOV_EXCL_STOP
+ while (!value.empty()) {
+ CHAR critical[10] = { };
+ CHAR is_start_required[10] = { };
+ CHAR shutdown_critical[10] = { };
+ CHAR group_wait_for_trigger[10] = { };
+ CHAR is_agl_unit[10] = { };
+ CHAR disable_agl_resethistory[10] = { };
+ CHAR disable_nonagl_resethistory[10] = { };
+ CfgLaunchParams cfg_data;
+
+ int at = static_cast<int>(ss_sm_cfg::cfg_args::group_name);
+
+ SubStringIterator iter(value, '|');
+ while (!iter.done() && ss_sm_cfg::cfg_args::END != at) {
+ const std::string data_ = iter.next();
+ if (!data_.empty()) {
+ const char* data = data_.c_str();
+ switch (at) {
+ case ss_sm_cfg::cfg_args::group_name:
+ snprintf(cfg_data.group_name,
+ sizeof(cfg_data.group_name), "%s", data);
+ break;
+ case ss_sm_cfg::cfg_args::group_id:
+ cfg_data.group_id = static_cast<UI_32>(strtoul(data, NULL, 10));
+ break;
+ case ss_sm_cfg::cfg_args::group_launch_wait:
+ cfg_data.group_launch_wait =
+ static_cast<UI_32>(strtoul(data, NULL, 10));
+ break;
+ case ss_sm_cfg::cfg_args::group_wait_for_trigger:
+ snprintf(group_wait_for_trigger,
+ sizeof(group_wait_for_trigger), "%s", data);
+ break;
+ case ss_sm_cfg::cfg_args::name:
+ snprintf(cfg_data.name, sizeof(cfg_data.name), "%s", data);
+ break;
+ case ss_sm_cfg::cfg_args::binary_name:
+ snprintf(cfg_data.binary_name,
+ sizeof(cfg_data.binary_name), "%s", data);
+ break;
+ case ss_sm_cfg::cfg_args::priority:
+ cfg_data.priority = static_cast<UI_32>(strtoul(data, NULL, 10));
+ break;
+ case ss_sm_cfg::cfg_args::critical:
+ snprintf(critical, sizeof(critical), "%s", data);
+ break;
+ case ss_sm_cfg::cfg_args::retry_cnt:
+ cfg_data.retry_cnt = static_cast<UI_32>(strtoul(data, NULL, 10));
+ break;
+ case ss_sm_cfg::cfg_args::arguments:
+ strncpy(cfg_data.arguments, data,
+ sizeof(cfg_data.arguments) - 1);
+ break;
+ case ss_sm_cfg::cfg_args::logging_msk:
+ snprintf(cfg_data.logging_msk_str,
+ sizeof(cfg_data.logging_msk_str), "%s", data);
+ break;
+ case ss_sm_cfg::cfg_args::restart:
+ snprintf(cfg_data.restart, sizeof(cfg_data.restart), "%s", data);
+ break;
+ case ss_sm_cfg::cfg_args::is_start_required:
+ snprintf(is_start_required,
+ sizeof(is_start_required), "%s", data);
+ break;
+ case ss_sm_cfg::cfg_args::shutdown_critical:
+ snprintf(shutdown_critical,
+ sizeof(shutdown_critical), "%s", data);
+ break;
+ case ss_sm_cfg::cfg_args::shutdown_wait_time:
+ cfg_data.shutdown_wait_time =
+ static_cast<UI_32>(strtoul(data, NULL, 10));
+ break;
+ case ss_sm_cfg::cfg_args::fast_shutdown_wait_time:
+ cfg_data.fast_shutdown_wait_time =
+ static_cast<UI_32>(strtoul(data, NULL, 10));
+ break;
+ case ss_sm_cfg::cfg_args::unix_user_name:
+ strncpy(&cfg_data.unix_user_name[0],
+ strip(data_).c_str(),
+ sizeof(cfg_data.unix_user_name) - 1);
+ break;
+ case ss_sm_cfg::cfg_args::is_agl_unit:
+ strncpy(is_agl_unit, data, sizeof(is_agl_unit));
+ break;
+ case ss_sm_cfg::cfg_args::disable_agl_resethistory:
+ strncpy(disable_agl_resethistory, data, sizeof(disable_agl_resethistory));
+ break;
+ case ss_sm_cfg::cfg_args::disable_nonagl_resethistory:
+ strncpy(disable_nonagl_resethistory, data, sizeof(disable_nonagl_resethistory));
+ break;
+ case ss_sm_cfg::cfg_args::env_value_condition: // LCOV_EXCL_START 6: Because an initialization condition is set at SystemManager startup and the branching condition cannot be satisfied // NOLINT(whitespace/line_length)
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ snprintf(cfg_data.env_value_condition,
+ sizeof(cfg_data.env_value_condition), "%s", data);
+ break;
+ case ss_sm_cfg::cfg_args::cpu_assign:
+ cfg_data.cpu_assign =
+ static_cast<int>(strtoul(data, NULL, 16));
+ break;
+ default:
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ " Error: unknown ss_sm_cfg::cfg_args::xxx/'at' "
+ "enum value '%d'", at);
+ break;
+ // LCOV_EXCL_STOP
+ }
+ }
+ ++at;
+ }
+ ////////////////////////////////////////////////////////////////////////////////
+// LCOV_EXCL_BR_START 6: Because an initialization condition is set at SystemManager startup and the branching condition cannot be satisfied
+ if (0 != std::strlen(cfg_data.env_value_condition)
+ && FALSE
+ == is_satisfy_env_launch_cond(
+// LCOV_EXCL_BR_STOP
+ cfg_data.env_value_condition)) { // LCOV_EXCL_LINE 6: For setting the initialization conditions at SystemManager startup
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__,
+ "exclude %s from wakeup service", cfg_data.name);
+ } else {
+ if (isNfs) { // LCOV_EXCL_BR_LINE 6: Because an initialization condition is set at SystemManager startup and the branching condition cannot be satisfied
+ // Since the NFS environment is used by copying the executable file containing the CAP to /tmp, it is read out.
+// LCOV_EXCL_START 6: Because an initialization condition is set at SystemManager startup and the branching condition cannot be satisfied
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ std::string binPath(cfg_data.binary_name);
+ for (std::list<std::string>::iterator ite =
+ capFiles.begin(); ite != capFiles.end(); ite++) {
+ if (binPath == *ite) {
+ std::list<std::string> nodes;
+ boost::split(nodes, binPath, boost::is_any_of("/"));
+ std::string newPath("/tmp/");
+ newPath += nodes.back();
+ FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "EXCHG %s", newPath.c_str());
+ snprintf(cfg_data.binary_name,
+ sizeof(cfg_data.binary_name), "%s", newPath.c_str());
+ break;
+ }
+ }
+ }
+// LCOV_EXCL_STOP
+ // FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "is_start_required: %s", is_start_required);
+ cfg_data.is_start_required = (std::strcmp("True",
+ is_start_required) == 0);
+
+ if (std::strcmp("True", group_wait_for_trigger) == 0) {
+ cfg_data.group_wait_for_trigger = TRUE;
+ } else {
+ cfg_data.group_wait_for_trigger = FALSE;
+ }
+
+ // FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "critical: %s", critical);
+ cfg_data.critical = (std::strcmp("True", critical) == 0);
+
+ // FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "shutdown_critical: %s", shutdown_critical);
+ cfg_data.shutdown_critical = (std::strcmp("True",
+ shutdown_critical) == 0);
+
+ cfg_data.SetAGLUnit(ParseBoolParameter(is_agl_unit, TRUE));
+ cfg_data.SetAGLResetHistoryDisable(ParseBoolParameter(disable_agl_resethistory));
+ cfg_data.SetNonAGLResetHisoryDisable(ParseBoolParameter(disable_nonagl_resethistory));
+
+ GroupLaunchInfo grp_info;
+ grp_info.start_complete = FALSE;
+ grp_info.stop_complete = FALSE;
+ grp_info.launch_complete = FALSE;
+ grp_info.name = cfg_data.group_name;
+ grp_info.id = cfg_data.group_id;
+ grp_info.grp_launch_wait = cfg_data.group_launch_wait;
+ grp_info.grp_wait_for_trigger =
+ cfg_data.group_wait_for_trigger;
+ ModuleLaunchListIter l_moduleLaunchListIter;
+
+ GroupLaunchMapIter grp_iter = groups_map.find(grp_info.id);
+ if (grp_iter != groups_map.end()) {
+ l_moduleLaunchListIter = set_cfg_grp_member_info(
+ cfg_data, grp_iter->second.modules);
+ } else {
+ l_moduleLaunchListIter = set_cfg_grp_member_info(
+ cfg_data, grp_info.modules);
+
+ // add this grp info object to the list of grps
+ groups_map.insert(make_pair(grp_info.id, grp_info));
+ }
+
+ std::string l_binaryNameStr = cfg_data.binary_name;
+ size_t l_binaryNamePos = l_binaryNameStr.find_last_of("/");
+ if (std::string::npos != l_binaryNamePos) {
+ l_binaryNameStr = l_binaryNameStr.substr(l_binaryNamePos + 1);
+ f_processNameMap.insert(
+ make_pair(l_binaryNameStr, l_moduleLaunchListIter));
+ }
+ }
+
+ std::sprintf(key, "ModulesLaunchConfig.Launch%d", ++launch_idx); // NOLINT
+ value = l_pReaderCfg->GetString(key);
+ } // end while
+ }
+ } else { // LCOV_EXCL_START 6: Because new doesn't pass the failure case
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ // defaults use from the header file ... this is much faster then reading from an xml file.
+ FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__,
+ " Warning: \"new CNSConfigReader(%s)\" returned NULL; using "
+ "constants.", f_launchCfgFn.c_str());
+ UI_32 num_of_items = static_cast<UI_32>(_countof(g_arrLaunchTableCfg));
+ for (UI_32 arr_idx = 0; arr_idx < num_of_items; arr_idx++) {
+ GroupLaunchInfo grp_info;
+ grp_info.launch_complete = FALSE;
+ grp_info.name = g_arrLaunchTableCfg[arr_idx].group_name;
+ grp_info.id = g_arrLaunchTableCfg[arr_idx].group_id;
+ grp_info.grp_launch_wait =
+ g_arrLaunchTableCfg[arr_idx].group_launch_wait;
+
+ GroupLaunchMapIter grp_iter = groups_map.find(grp_info.id);
+
+ if (grp_iter != groups_map.end()) {
+ set_grp_member_info(g_arrLaunchTableCfg[arr_idx],
+ grp_iter->second.modules);
+ } else {
+ set_grp_member_info(g_arrLaunchTableCfg[arr_idx],
+ grp_info.modules);
+ // add this grp info object to the list of grps
+ groups_map.insert(make_pair(grp_info.id, grp_info));
+ }
+ }
+ }
+ // LCOV_EXCL_STOP
+ if (rtn_code == TRUE) {
+ load_parameters_order_cfg(groups_map, f_OrderList, f_launchOrderName, f_launchCfgFn);
+ }
+
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return rtn_code;
+}
+
+VOID SysMgrConfiguration::PrintGroupInfo(GroupLaunchInfo& refGrpInfo) {
+ std::stringstream l_logMsg;
+
+ l_logMsg << endl << "Group: " << refGrpInfo.name.data() << endl
+ << " id: " << refGrpInfo.id << endl << " wait-time: "
+ << refGrpInfo.grp_launch_wait << endl << " launch complete: "
+ << (refGrpInfo.launch_complete == TRUE ? "YES" : "NO"); // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT(whitespace/line_length)
+
+ std::string l_logStr = l_logMsg.str();
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "%s", l_logStr.c_str());
+}
+
+VOID SysMgrConfiguration::PrintModuleInfo(ModuleLaunchParams& refMbrInfo) {
+ std::stringstream l_logMsg;
+
+ // LCOV_EXCL_BR_START 11:unexpected branch // NOLINT(whitespace/line_length)
+ l_logMsg << endl << "Module: " << refMbrInfo.name.data() << endl
+ << " path: " << refMbrInfo.path.data() << endl << " args: "
+ << refMbrInfo.arguments.data() << endl << " restart: "
+ << refMbrInfo.restart.data() << endl
+ << " configuration_priority: "
+ << refMbrInfo.configuration_priority << endl
+ << " cpu_assign: "
+ << refMbrInfo.cpu_assign << endl
+ << " current_priority: " << refMbrInfo.current_priority << endl
+ << " previous_priority: " << refMbrInfo.previous_priority << endl
+ << " critical: " << (refMbrInfo.critical == TRUE ? "YES" : "NO")
+ << endl
+ << " retry count: " << refMbrInfo.retry_cnt << endl
+ << " logging mask: " << refMbrInfo.logging_msk_str << endl
+ << " is_start_required: "
+ << (refMbrInfo.is_start_required == TRUE ? "YES" : "NO")
+ << endl
+ << " shutdown_critical: "
+ << (refMbrInfo.shutdown_critical == TRUE ? "YES" : "NO") << endl
+ << " shutdown_wait_time: " << refMbrInfo.shutdown_wait_time
+ << endl << " fast_shutdown_wait_time: "
+ << refMbrInfo.fast_shutdown_wait_time << endl << " is_agl_unit: "
+ << refMbrInfo.IsAGLUnit() << endl << " disable_agl_resethistory: "
+ << refMbrInfo.IsAGLResetHistoryDisable() << endl << " disable_nonagl_resethistory: "
+ << refMbrInfo.IsNonAGLResetHistoryDisable() << endl << " state: "
+ << refMbrInfo.ModuleStateStr() << endl << " group ID: "
+ << refMbrInfo.group_id << endl << " debug dump state: "
+ << refMbrInfo.GetModuleDebugDumpStateStr();
+ // LCOV_EXCL_BR_STOP
+ std::string l_logStr = l_logMsg.str();
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "%s", l_logStr.c_str());
+}
+
+VOID SysMgrConfiguration::PrintAllInfo(GroupLaunchMap& refGrpMap) {
+ // get first client from the map...
+ GroupLaunchMapIter grp_iter = refGrpMap.begin();
+
+ for (; grp_iter != refGrpMap.end(); grp_iter++) {
+ PrintGroupInfo(grp_iter->second);
+ ModuleLaunchListIter mbr_iter = grp_iter->second.modules.begin();
+ for (; mbr_iter != grp_iter->second.modules.end(); mbr_iter++) {
+ PrintModuleInfo(*mbr_iter);
+ }
+ }
+}
+
+BOOL SysMgrConfiguration::ParseBoolParameter(PCSTR f_value, BOOL f_default) const {
+ if (FALSE == f_default) {
+ const char TRUE_VALUE[] = "True";
+ if (0 == strcmp(TRUE_VALUE, f_value)) {
+ return TRUE;
+ }
+ } else {
+ const char FALSE_VALUE[] = "False";
+ if (0 == strcmp(FALSE_VALUE, f_value)) {
+ return FALSE;
+ }
+ }
+ return f_default;
+}
+
+/*
+ * SM Configuration data constructor
+ */
+SMConfigParams::SMConfigParams() {
+}
+
+/*
+ * SM Configuration data destructor
+ */
+SMConfigParams::~SMConfigParams() {
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////
+/// PrintConfigInfo
+/// \brief Print the configuration data stored in config structure
+///
+/// \param [in] configata
+/// ConfigurationData & - Ref to structure that get populated.
+///
+/// \return VOID
+////////////////////////////////////////////////////////////////////////////////////////////
+VOID SMConfigParams::PrintConfigInfo(ConfigurationData const & f_ConfigParams) {
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "AppHeartBeatInterval_Initial Info: %d",
+ f_ConfigParams.HBConfig.ApplicationHeartBeatIntervalInitial);
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "AppHeartBeatInterval_Repeat Info: %d",
+ f_ConfigParams.HBConfig.ApplicationHeartBeatIntervalRepeat);
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "HBMaxHeartBeatRetryCount Info: %d",
+ f_ConfigParams.HBConfig.MaxHeartBeatRetryCount);
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "CDEnabled: %d",
+ f_ConfigParams.CDConfig.CrashDetectorEnabled);
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "SLMTimerValue: %d",
+ f_ConfigParams.SLMConfig.SLMTimerValue);
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "SLMMaxRetryCount: %d",
+ f_ConfigParams.SLMConfig.SLMMaxRetryCount);
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "SLMThresholdValue: %d",
+ f_ConfigParams.SLMConfig.SLMThresholdValue);
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "SLMSystemmanagerLogIntervalMs: %d",
+ f_ConfigParams.SLMConfig.SLMSystemmanagerLogIntervalMs);
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "UserModeStructIsBoolean: %s",
+ GetStr(f_ConfigParams.UMConfig.IsUserModeNotificationABOOL).c_str());
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "ModuleConnectionNumTimesToCheck: %d",
+ f_ConfigParams.MCConfig.ModuleConnectionNumTimesToCheck);
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "ModuleConnectionTimeOutSec: %d",
+ f_ConfigParams.MCConfig.ModuleConnectionTimeOutSec);
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "ModuleStartRespTimeOutSec: %d",
+ f_ConfigParams.MCConfig.ModuleStartRespTimeOutSec);
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "CriticalAppsMaxShutdownTimeFastSleep: %d",
+ f_ConfigParams.CAMSTConfig.CriticalAppsMaxShutdownTimeFastSleep);
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__,
+ "CriticalAppsMaxShutdownTimeNormalReset: %d",
+ f_ConfigParams.CAMSTConfig.CriticalAppsMaxShutdownTimeNormalReset);
+ return;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////
+/// GetSMConfigInformation
+/// \brief Read config data from cfg file and populate the configuration data structure
+///
+/// \param [in] f_ConfigParams & - Ref to ConfigurationData that get populated.
+/// \param [in] f_FileName - Configuration file name.
+///
+/// \return BOOL
+/// BOOL - TRUE or FALSE
+////////////////////////////////////////////////////////////////////////////////////////////
+BOOL SMConfigParams::GetSMConfigInformation(ConfigurationData& f_ConfigParams, SS_String f_FileName) {
+ EFrameworkunifiedStatus l_eStatus;
+ BOOL l_rtnCode = FALSE; // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h // NOLINT(whitespace/line_length)
+
+ CNSConfigReader *l_pReaderCfg = new (std::nothrow) CNSConfigReader(); // LCOV_EXCL_BR_LINE 10: As new does not fail
+// LCOV_EXCL_BR_START 6: Because the applicable variable cannot be changed from the external API (only evaluated by the initial value)
+ if (NULL == l_pReaderCfg) {
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ " Error. new CNSConfigReader() returned NULL pointer.");
+ } else {
+ if (eFrameworkunifiedStatusOK != (l_eStatus = l_pReaderCfg->Parse(f_FileName))) {
+ // LCOV_EXCL_START 6: Because the applicable variable cannot be changed from the external API (only evaluated by the initial value)
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ " Error. l_pReaderCfg->Open(%s) returned NULL pointer.",
+ f_FileName.c_str());
+ // LCOV_EXCL_STOP
+ } else if (eFrameworkunifiedStatusOK
+ != (l_eStatus = l_pReaderCfg->GetInt(
+ "Heartbeat.MaxHeartBeatRetryCount",
+ f_ConfigParams.HBConfig.MaxHeartBeatRetryCount))) {
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ LOG_STATUS_IF_ERRORED(l_eStatus, // LCOV_EXCL_START 6: Because the applicable variable cannot be changed from the external API (only evaluated by the initial value)
+ "l_pReaderCfg->GetInt('Heartbeat.MaxHeartBeatRetryCount')");
+ } else if (eFrameworkunifiedStatusOK
+ != (l_eStatus = l_pReaderCfg->GetInt(
+ "Heartbeat.AppHeartBeatIntervalInitial",
+ f_ConfigParams.HBConfig.ApplicationHeartBeatIntervalInitial))) {
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ LOG_STATUS_IF_ERRORED(l_eStatus, // LCOV_EXCL_LINE 6: Because the applicable variable cannot be changed from the external API (only evaluated by the initial value)
+ "l_pReaderCfg->GetInt('Heartbeat.AppHeartBeatIntervalInitial')");
+ } else if (eFrameworkunifiedStatusOK
+ != (l_eStatus = l_pReaderCfg->GetInt(
+ "Heartbeat.AppHeartBeatIntervalRepeat",
+ f_ConfigParams.HBConfig.ApplicationHeartBeatIntervalRepeat))) {
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ LOG_STATUS_IF_ERRORED(l_eStatus, // LCOV_EXCL_LINE 6: Because the applicable variable cannot be changed from the external API (only evaluated by the initial value)
+ "l_pReaderCfg->GetInt('Heartbeat.AppHeartBeatIntervalRepeat')");
+ } else if (eFrameworkunifiedStatusOK
+ != (l_eStatus = l_pReaderCfg->GetBool("CrashDetector.Enabled",
+ f_ConfigParams.CDConfig.CrashDetectorEnabled))) {
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ LOG_STATUS_IF_ERRORED(l_eStatus, // LCOV_EXCL_LINE 6: Because the applicable variable cannot be changed from the external API (only evaluated by the initial value)
+ "l_pReaderCfg->GetBool('CrashDetector.Enabled')");
+ } else if (eFrameworkunifiedStatusOK
+ != (l_eStatus = l_pReaderCfg->GetInt("SysLowMemory.TimerValue",
+ f_ConfigParams.SLMConfig.SLMTimerValue))) {
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ LOG_STATUS_IF_ERRORED(l_eStatus, // LCOV_EXCL_LINE 6: Because the applicable variable cannot be changed from the external API (only evaluated by the initial value)
+ "l_pReaderCfg->GetInt('SysLowMemory.TimerValue')");
+ } else if (eFrameworkunifiedStatusOK
+ != (l_eStatus = l_pReaderCfg->GetInt(
+ "SysLowMemory.MaxRetryCount",
+ f_ConfigParams.SLMConfig.SLMMaxRetryCount))) {
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ LOG_STATUS_IF_ERRORED(l_eStatus, // LCOV_EXCL_LINE 6: Because the applicable variable cannot be changed from the external API (only evaluated by the initial value)
+ "l_pReaderCfg->GetInt('SysLowMemory.MaxRetryCount')");
+ } else if (eFrameworkunifiedStatusOK
+ != (l_eStatus = l_pReaderCfg->GetInt(
+ "SysLowMemory.ThresholdValue",
+ f_ConfigParams.SLMConfig.SLMThresholdValue))) {
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ LOG_STATUS_IF_ERRORED(l_eStatus, // LCOV_EXCL_LINE 6: Because the applicable variable cannot be changed from the external API (only evaluated by the initial value)
+ "l_pReaderCfg->GetInt('SysLowMemory.ThresholdValue')");
+ } else if (eFrameworkunifiedStatusOK
+ != (l_eStatus = l_pReaderCfg->GetInt(
+ "SysLowMemory.InterfaceunifiedLogIntervalMs",
+ f_ConfigParams.SLMConfig.SLMSystemmanagerLogIntervalMs))) {
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ LOG_STATUS_IF_ERRORED(l_eStatus, // LCOV_EXCL_LINE 6: Because the applicable variable cannot be changed from the external API (only evaluated by the initial value)
+ "l_pReaderCfg->GetInt('SysLowMemory.InterfaceunifiedLogIntervalMs')");
+ } else if (eFrameworkunifiedStatusOK
+ != (l_eStatus = l_pReaderCfg->GetBool(
+ "UserModeNotification.IsBoolean",
+ f_ConfigParams.UMConfig.IsUserModeNotificationABOOL))) {
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ LOG_STATUS_IF_ERRORED(l_eStatus, // LCOV_EXCL_LINE 6: Because the applicable variable cannot be changed from the external API (only evaluated by the initial value)
+ "l_pReaderCfg->GetBool('UserModeNotification.IsBoolean')");
+ f_ConfigParams.UMConfig.IsUserModeNotificationABOOL = TRUE;
+ } else if (eFrameworkunifiedStatusOK
+ != (l_eStatus = l_pReaderCfg->GetInt(
+ "Module.ModuleConnectionNumTimesToCheck",
+ f_ConfigParams.MCConfig.ModuleConnectionNumTimesToCheck))) {
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ LOG_STATUS_IF_ERRORED(l_eStatus, // LCOV_EXCL_LINE 6: Because the applicable variable cannot be changed from the external API (only evaluated by the initial value)
+ "l_pReaderCfg->GetInt('Module.ModuleConnectionNumTimesToCheck')");
+ } else if (eFrameworkunifiedStatusOK
+ != (l_eStatus = l_pReaderCfg->GetInt(
+ "Module.ModuleConnectionTimeOutSec",
+ f_ConfigParams.MCConfig.ModuleConnectionTimeOutSec))) {
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ LOG_STATUS_IF_ERRORED(l_eStatus, // LCOV_EXCL_LINE 6: Because the applicable variable cannot be changed from the external API (only evaluated by the initial value)
+ "l_pReaderCfg->GetInt('Module.ModuleConnectionTimeOutSec')");
+ } else if (eFrameworkunifiedStatusOK
+ != (l_eStatus = l_pReaderCfg->GetInt(
+ "Module.ModuleStartRespTimeOutSec",
+ f_ConfigParams.MCConfig.ModuleStartRespTimeOutSec))) {
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ LOG_STATUS_IF_ERRORED(l_eStatus, // LCOV_EXCL_LINE 6: Because the applicable variable cannot be changed from the external API (only evaluated by the initial value)
+ "l_pReaderCfg->GetInt('Module.ModuleStartRespTimeOutSec')");
+ } else if (eFrameworkunifiedStatusOK
+ != (l_eStatus = l_pReaderCfg->GetInt(
+ "CriticalApps.CriticalAppsMaxShutdownTimeFastSleep",
+ f_ConfigParams.CAMSTConfig.CriticalAppsMaxShutdownTimeFastSleep))) {
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ LOG_STATUS_IF_ERRORED(l_eStatus, // LCOV_EXCL_LINE 6: Because the applicable variable cannot be changed from the external API (only evaluated by the initial value)
+ "l_pReaderCfg->GetInt('CriticalApps.CriticalAppsMaxShutdownTimeFastSleep')");
+ } else if (eFrameworkunifiedStatusOK
+ != (l_eStatus = l_pReaderCfg->GetInt(
+ "CriticalApps.CriticalAppsMaxShutdownTimeNormalReset",
+ f_ConfigParams.CAMSTConfig.CriticalAppsMaxShutdownTimeNormalReset))) {
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ LOG_STATUS_IF_ERRORED(l_eStatus, // LCOV_EXCL_LINE 6: Because the applicable variable cannot be changed from the external API (only evaluated by the initial value)
+ "l_pReaderCfg->GetInt('CriticalApps.CriticalAppsMaxShutdownTimeNormalReset')");
+ } else {
+ l_rtnCode = TRUE;
+ }
+
+ delete l_pReaderCfg; // LCOV_EXCL_BR_LINE 10: As the delete does not fail
+ }
+// LCOV_EXCL_BR_STOP
+
+ return (l_rtnCode);
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////
+/// LoadSMConfigParameters
+/// \brief Read System Manager configuration parameters from cfg file or
+/// use defaults values in case cfg file is not available
+///
+/// \param [in] f_ConfigParams & - Ref to ConfigurationData that get populated.
+/// \param [in] f_FileName - Configuration file name.
+///
+/// \return BOOL
+/// BOOL - TRUE or FALSE
+////////////////////////////////////////////////////////////////////////////////////////////
+BOOL SMConfigParams::LoadSMConfigParameters(ConfigurationData& f_ConfigParams, SS_String f_FileName) {
+ BOOL rtn_code = TRUE;
+
+ rtn_code = GetSMConfigInformation(f_ConfigParams, f_FileName);
+
+ // cfg config file not found, use constants
+ if (FALSE == rtn_code) {
+ // LCOV_EXCL_START 6: Because the applicable variable cannot be changed from the external API (only evaluated by the initial value)
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__,
+ " Warning: cfg config file not open, using constants");
+
+ // Heart Beat constants
+ f_ConfigParams.HBConfig.ApplicationHeartBeatIntervalInitial =
+ HBApplicationHeartBeatIntervalInitial;
+ f_ConfigParams.HBConfig.ApplicationHeartBeatIntervalRepeat =
+ HBApplicationHeartBeatIntervalRepeat;
+ f_ConfigParams.HBConfig.MaxHeartBeatRetryCount = HBMaxHeartBeatRetryCount;
+
+ // Crash Detector constants
+ f_ConfigParams.CDConfig.CrashDetectorEnabled = CDEnabled;
+
+ // System Low Memory
+ f_ConfigParams.SLMConfig.SLMTimerValue = SLMTimerValue;
+ f_ConfigParams.SLMConfig.SLMMaxRetryCount = SLMRetryCount;
+ f_ConfigParams.SLMConfig.SLMThresholdValue = SLMThresholdValue;
+ f_ConfigParams.SLMConfig.SLMSystemmanagerLogIntervalMs = SLMSystemmanagerLogIntervalMs;
+
+ // Module connect and start resp
+ f_ConfigParams.MCConfig.ModuleConnectionNumTimesToCheck =
+ ModuleConnectionNumTimesToCheck;
+ f_ConfigParams.MCConfig.ModuleConnectionTimeOutSec =
+ ModuleConnectionTimeOutSec;
+ f_ConfigParams.MCConfig.ModuleStartRespTimeOutSec = ModuleStartRespTimeOutSec;
+
+ // Critical Apps shutdown time
+ f_ConfigParams.CAMSTConfig.CriticalAppsMaxShutdownTimeFastSleep =
+ CriticalAppsMaxShutdownTimeFastSleepSec;
+ f_ConfigParams.CAMSTConfig.CriticalAppsMaxShutdownTimeNormalReset =
+ CriticalAppsMaxShutdownTimeNormalResetSec;
+
+ // USer Mode Data Structure Type
+ f_ConfigParams.UMConfig.IsUserModeNotificationABOOL = TRUE;
+ // LCOV_EXCL_STOP
+ }
+ PrintConfigInfo(f_ConfigParams);
+
+ return rtn_code;
+} // LCOV_EXCL_BR_LINE 10: Final line
+
Code Review / staging / basesystem.git / blobdiff