mirror of
https://github.com/eclipse-openvehicle-api/openvehicle-api.git
synced 2026-04-18 10:38:16 +00:00
418 lines
19 KiB
C++
418 lines
19 KiB
C++
/********************************************************************************
|
|
* Copyright (c) 2025-2026 ZF Friedrichshafen AG
|
|
*
|
|
* This program and the accompanying materials are made available under the
|
|
* terms of the Apache License Version 2.0 which is available at
|
|
* https://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*
|
|
* Contributors:
|
|
* Erik Verhoeven - initial API and implementation
|
|
********************************************************************************/
|
|
|
|
#ifndef APP_SETTINGS_H
|
|
#define APP_SETTINGS_H
|
|
|
|
#include <interfaces/app.h>
|
|
#include <support/component_impl.h>
|
|
|
|
/**
|
|
* @brief Application settings class.
|
|
* @details The application settings class is responsible for interpretation of the initial application startup configuration and
|
|
* reading and writing the application main settings.
|
|
* The startup configuration is a string using the TOML format and is defined as follows:
|
|
* @code
|
|
* # Optional use of customized log handler
|
|
* [LogHandler]
|
|
* Class = "" # Component class name of a custom logger (optional)
|
|
* Path = "" # Component module path of a custom logger (optional)
|
|
* Tag = "" # Program tag to use instead of the name SDV_LOG_<pid>
|
|
* Filter = "" # Lowest severity filter to use when logging (Trace, Debug, Info, Warning, Error, Fatal). Default severity
|
|
* # level filter is Info (meaning Debug and Trace messages are not being stored).
|
|
* ViewFilter = "" # Lowest severity filter to use when logging (Trace, Debug, Info, Warning, Error, Fatal). Default severity
|
|
* # level filter is Error (meaning Debug, Trace, Info and Warning messages are not being shown).
|
|
*
|
|
* # Application behavior definition
|
|
* # Mode = "Standalone" (default) app->no RPC + core services + additional configurations allowed
|
|
* # Mode = "External" app->RPC client only + local services + target service(s) --> connection information through listener
|
|
* # Mode = "Isolated" app->RPC client only + local services + target service(s) --> connection information needed
|
|
* # Mode = "Main" app->RPC server + core services --> access key needed
|
|
* # Mode = "Essential" app->local services + additional configurations allowed
|
|
* # Mode = "Maintenance" app->RPC client only + local services + maintenance service --> connection information needed + access key
|
|
* # Instance = 1234
|
|
* [Application]
|
|
* Mode = "Main"
|
|
* Instance = 1234 # Optional instance ID to be used with main and isolated applications. Has no influence on other
|
|
* # applications. Default instance ID is 1000. The connection listener is using the instance ID to allow
|
|
* # connections from an external application to the main application. Furthermore, the instance ID is
|
|
* # used to locate the installation of SDV components. The location of the SDV components is relative to
|
|
* # the executable (unless a target directory is supplied) added with the instance and the installations:
|
|
* # <exe_path>/<instance>/<installation>
|
|
* InstallDir = "./test" # Optional custom installation directory to be used with main and isolated applications. Has no
|
|
* # influence on other applications. The default location for installations is the location of the
|
|
* # executable. Specifying a different directory will change the location of installations to
|
|
* # <install_directory>/<instance>/<installation>
|
|
* # NOTE The directory of the core library and the directory of the running executable are always added
|
|
* # to the system if they contain an installation manifest.
|
|
*
|
|
* # Optional configuration that should be loaded (only for local applications).
|
|
* Config = "abc.toml"
|
|
*
|
|
* #Console output
|
|
* [Console]
|
|
* Report = "Silent" # Either "Silent", "Normal" or "Verbose" for no, normal or extensive messages.
|
|
*
|
|
* # Search directories
|
|
* @endcode
|
|
*
|
|
* @todo Add config ignore list (e.g. platform.toml, vehicle_ifc.toml and vehicle_abstract.toml).
|
|
* @todo Add dedicated config (rather than standard config) as startup param.
|
|
*
|
|
* The settings file is a TOML file with the following structure:
|
|
* @code
|
|
* [Settings]
|
|
* Version = 100
|
|
*
|
|
* # The system configuration is divided into:
|
|
* # platform config - containing all the components needed to interact with the OS,
|
|
* # middleware, vehicle bus, Ethernet.
|
|
* # vehicle interface - containing the vehicle bus interpretation components like data link
|
|
* # based on DBC and devices for their abstraction.
|
|
* # vehicle abstraction - containing the vehicle abstraction services
|
|
* # The configuration files are loaded exactly in that order, allowing the vehicle interface to
|
|
* # depend on the platform and the vehicle abstraction to depend on the vehicle interface.
|
|
* # The configurations are loaded if the PlatformConfig, VehIfcConfig and VehAbstrConfig keywords
|
|
* # are present and describe a valid configuration file.
|
|
* # A relative path is relative to the installation directory (being "exe_location/instance_id").
|
|
* #
|
|
* # Example:
|
|
* # PlatformConfig = "platform.toml"
|
|
* # VehIfcConfig = "vehicle_ifc.toml"
|
|
* # VehAbstrConfig = "vehicle_abstract.toml"
|
|
* #
|
|
* PlatformConfig = ""
|
|
* VehIfcConfig = ""
|
|
* VehAbstrConfig = ""
|
|
*
|
|
* # The application config contains the configuration file that can be updated when services and
|
|
* # apps are being added to the system (or being removed from the system). Load the application
|
|
* # config by providing the "AppConfig" keyword as a string value. A relative path is relative to
|
|
* # the installation directory (being "exe_location/instance_id").
|
|
* #
|
|
* # Example
|
|
* # AppConfig = "app_config.toml"
|
|
* AppConfig = ""
|
|
* @endcode
|
|
*/
|
|
class CAppSettings : public sdv::IInterfaceAccess, public sdv::app::IAppContext, public sdv::IAttributes
|
|
{
|
|
public:
|
|
/**
|
|
* @brief Constructor
|
|
*/
|
|
CAppSettings();
|
|
|
|
/**
|
|
* @brief Destructor
|
|
*/
|
|
~CAppSettings();
|
|
|
|
// Interface map
|
|
BEGIN_SDV_INTERFACE_MAP()
|
|
SDV_INTERFACE_ENTRY(sdv::app::IAppContext)
|
|
END_SDV_INTERFACE_MAP()
|
|
|
|
/**
|
|
* @brief Process the application starrtup configuration.
|
|
* @param[in] rssConfig Reference to the configuration content (TOML format).
|
|
* @return Returns 'true' when processing was successful; false when not.
|
|
*/
|
|
bool ProcessAppStartupConfig(const sdv::u8string& rssConfig);
|
|
|
|
/**
|
|
* @brief Load the application settings file.
|
|
* @attention Only works if the application is running in main, isolation or maintenance mode.
|
|
* @remarks When there is no settings file, this is not an error. Default settings will be assumed.
|
|
* @return Returns whether the loading was successful.
|
|
*/
|
|
bool LoadSettingsFile();
|
|
|
|
/**
|
|
* @brief Save the application settings file (or create when not existing yet).
|
|
* @attention Only works if the application is running in main, isolation or maintenance mode.
|
|
* @return Returns whether the saving was successful.
|
|
*/
|
|
bool SaveSettingsFile();
|
|
|
|
/**
|
|
* @brief Return whether the current application is the main application.
|
|
* @return Returns 'true' when the current application is the main application; otherwise returns 'false'.
|
|
*/
|
|
bool IsMainApplication() const;
|
|
|
|
/**
|
|
* @brief Return whether the current application is an isolated application.
|
|
* @return Returns 'true' when the current application is an isolated application; otherwise returns 'false'.
|
|
*/
|
|
bool IsIsolatedApplication() const;
|
|
|
|
/**
|
|
* @brief Return whether the current application is a standalone application.
|
|
* @return Returns 'true' when the current application is a standalone application; otherwise returns 'false'.
|
|
*/
|
|
bool IsStandaloneApplication() const;
|
|
|
|
/**
|
|
* @brief Return whether the current application is an essential application.
|
|
* @return Returns 'true' when the current application is an essential application; otherwise returns 'false'.
|
|
*/
|
|
bool IsEssentialApplication() const;
|
|
|
|
/**
|
|
* @brief Return whether the current application is a maintenance application.
|
|
* @return Returns 'true' when the current application is a maintenance application; otherwise returns 'false'.
|
|
*/
|
|
bool IsMaintenanceApplication() const;
|
|
|
|
/**
|
|
* @brief Return whether the current application is an external application.
|
|
* @return Returns 'true' when the current application is an external application; otherwise returns 'false'.
|
|
*/
|
|
bool IsExternalApplication() const;
|
|
|
|
/**
|
|
* @brief Return the application context mode. Overload of sdv::app::IAppContext::GetContextType.
|
|
* @return The context mode.
|
|
*/
|
|
sdv::app::EAppContext GetContextType() const override;
|
|
|
|
/**
|
|
* @brief Return the core instance ID. Overload of sdv::app::IAppContext::GetContextType.
|
|
* @details Get the instance. If not otherwise specified, the current instance depends on whether the application is running
|
|
* as main or isolated application, in which case the instance is 1000. In all other cases the instance is 0. An instance
|
|
* ID can be supplied through the app startup configuration.
|
|
* @return The core instance ID.
|
|
*/
|
|
uint32_t GetInstanceID() const override;
|
|
|
|
/**
|
|
* @brief Return the number of retries to establish a connection. Overload of sdv::app::IAppContext::GetRetries.
|
|
* @return Number of retries.
|
|
*/
|
|
uint32_t GetRetries() const override;
|
|
|
|
/**
|
|
* @brief Get the class name of a logger service, if specified in the application startup configuration.
|
|
* @return The logger class name.
|
|
*/
|
|
std::string GetLoggerClass() const;
|
|
|
|
/**
|
|
* @brief Get the logger service module path, if specified in the application startup configuration.
|
|
* @return The logger module path.
|
|
*/
|
|
std::filesystem::path GetLoggerModulePath() const;
|
|
|
|
/**
|
|
* @brief Get the logger program tag, if specified in the application startup configuration.
|
|
* @return The logger program tag.
|
|
*/
|
|
std::string GetLoggerProgramTag() const;
|
|
|
|
/**
|
|
* @brief Get the logger severity filter, if specified in the application startup configuration.
|
|
* @return The logger severity filter.
|
|
*/
|
|
sdv::core::ELogSeverity GetLoggerSeverityFilter() const;
|
|
|
|
/**
|
|
* @brief Get the console reporting severity file, if specified in the application startup configuration.
|
|
* @return The console reporting severity filter value.
|
|
*/
|
|
sdv::core::ELogSeverity GetConsoleSeverityFilter() const;
|
|
|
|
/**
|
|
* @brief Should the console output be silent?
|
|
* @return Returns whether the console output is silent.
|
|
*/
|
|
bool IsConsoleSilent() const;
|
|
|
|
/**
|
|
* @brief Should the console output be verbose?
|
|
* @return Returns whether the verbose console output is activated.
|
|
*/
|
|
bool IsConsoleVerbose() const;
|
|
|
|
/**
|
|
* @brief Get the root directory for the application.
|
|
* @remarks Is only valid when used in main, isolated and maintenance applications.
|
|
* @return The location of root directory.
|
|
*/
|
|
std::filesystem::path GetRootDir() const;
|
|
|
|
/**
|
|
* @brief Get the installation directory of user components (root directory / instance ID).
|
|
* @remarks Is only valid when used in main, isolated and maintenance applications.
|
|
* @return The location of the installation director.
|
|
*/
|
|
std::filesystem::path GetInstallDir() const;
|
|
|
|
/**
|
|
* @brief Get a vector with the system configuration paths (relative to the installation directory) as specified in the
|
|
* settings file.
|
|
* @return The vector of system configuration paths.
|
|
*/
|
|
std::vector<std::filesystem::path> GetSystemConfigPaths() const;
|
|
|
|
/**
|
|
* @brief Configuration type
|
|
*/
|
|
enum class EConfigType
|
|
{
|
|
platform_config, ///< Contains the platform configuration
|
|
vehicle_interface_config, ///< Contains the vehicle interface configuration
|
|
vehicle_abstraction_config, ///< Contains the vehicle abstraction configuration
|
|
user_config ///< Contains the user configuration
|
|
};
|
|
|
|
/**
|
|
* @brief Get the stored or default configuration path name.
|
|
* @attention Setting a path is only valid when running as main application.
|
|
* @return The path name dependent on the configuration type. If no path name was configured, the default path name is returned.
|
|
*/
|
|
std::filesystem::path GetConfigPath(EConfigType eType) const;
|
|
|
|
/**
|
|
* @brief Enable a configuration file in the application settings.
|
|
* @attention The configuration file needs to be located at the root directory of the instance installation.
|
|
* @attention Setting a path is only valid when running as main application.
|
|
* @param[in] eType The configuration type to set the path for.
|
|
* @return Returns 'true' when adding the config file path was successful (or when the path already exists in the settings);
|
|
* otherwise returns 'false'.
|
|
*/
|
|
bool EnableConfig(EConfigType eType);
|
|
|
|
/**
|
|
* @brief Disable and remove a configuration file from the application settings.
|
|
* @attention The configuration file needs to be located at the root directory of the instance installation.
|
|
* @attention Removing a psth is only valid when running as main application.
|
|
* @param[in] eType The configuration type to remove the path from.
|
|
* @return Returns 'true' when the removal was successful.
|
|
*/
|
|
bool DisableConfig(EConfigType eType);
|
|
|
|
/**
|
|
* @brief Get the path to the user copnfiguration (relative to the installation directory) as specified in the settings file.
|
|
* @return Path to the user configuration.
|
|
*/
|
|
std::filesystem::path GetUserConfigPath() const;
|
|
|
|
/**
|
|
* @brief Set the user configuration file into the application settings. If a user configuration file is stored already in the
|
|
* settings file, the configuration file name is replaced by the new configuration file name.
|
|
* @remarks Setting the user config path is only valid for local applications. For server application, the path is managed by
|
|
* enabling the configuration.
|
|
* @param[in] rpathConfig Reference to the path containing the configuration file name.
|
|
* @return Returns 'true' when setting the config file path was successful; otherwise returns 'false'.
|
|
*/
|
|
bool SetUserConfigPath(const std::filesystem::path& rpathConfig);
|
|
|
|
/**
|
|
* @brief Remove the user configuration file from the application settings.
|
|
* @attention Removing the path is only valid when running as main application.
|
|
* @return Returns 'true' when the removal was successful.
|
|
*/
|
|
bool RemoveUserConfigPath();
|
|
|
|
/**
|
|
* @brief Get a sequence with the available attribute names. Overload of sdv::IAttributes::GetNames.
|
|
* @return The sequence of attribute names.
|
|
*/
|
|
virtual sdv::sequence<sdv::u8string> GetNames() const override;
|
|
|
|
/**
|
|
* @brief Get the attribute value. Overload of sdv::IAttributes::Get.
|
|
* @param[in] ssAttribute Name of the attribute.
|
|
* @return The attribute value or an empty any-value if the attribute wasn't found or didn't have a value.
|
|
*/
|
|
virtual sdv::any_t Get(/*in*/ const sdv::u8string& ssAttribute) const override;
|
|
|
|
/**
|
|
* @brief Set the attribute value. Overload of sdv::IAttributes::Set.
|
|
* @param[in] ssAttribute Name of the attribute.
|
|
* @param[in] anyAttribute Attribute value to set.
|
|
* @return Returns 'true' when setting the attribute was successful or 'false' when the attribute was not found or the
|
|
* attribute is read-only or another error occurred.
|
|
*/
|
|
virtual bool Set(/*in*/ const sdv::u8string& ssAttribute, /*in*/ sdv::any_t anyAttribute) override;
|
|
|
|
/**
|
|
* @brief Get the attribute flags belonging to a certain attribute. Overload of sdv::IAttributes::GetFlags.
|
|
* @param[in] ssAttribute Name of the attribute.
|
|
* @return Returns the attribute flags (zero or more EAttributeFlags flags) or 0 when the attribute could not be found.
|
|
*/
|
|
virtual uint32_t GetFlags(/*in*/ const sdv::u8string& ssAttribute) const override;
|
|
|
|
/**
|
|
* @brief Reset the settings after a shutdown.
|
|
*/
|
|
void Reset();
|
|
|
|
private:
|
|
sdv::app::EAppContext m_eContextMode = sdv::app::EAppContext::no_context; ///< The application is running as...
|
|
uint32_t m_uiInstanceID = 0u; ///< Instance number.
|
|
uint32_t m_uiRetries = 0u; ///< Number of retries to establish a connection.
|
|
std::string m_ssLoggerClass; ///< Class name of a logger service.
|
|
std::filesystem::path m_pathLoggerModule; ///< Module name of a custom logger.
|
|
std::string m_ssProgramTag; ///< Program tag to use when logging.
|
|
sdv::core::ELogSeverity m_eSeverityFilter = sdv::core::ELogSeverity::info; ///< Severity level filter while logging.
|
|
sdv::core::ELogSeverity m_eSeverityViewFilter = sdv::core::ELogSeverity::error; ///< Severity level filter while logging.
|
|
bool m_bSilent = false; ///< When set, no console reporting takes place.
|
|
bool m_bVerbose = false; ///< When set, extensive console reporting takes place.
|
|
std::filesystem::path m_pathRootDir; ///< Location of user component root directory.
|
|
std::filesystem::path m_pathInstallDir; ///< Location of user component installations (root with instance).
|
|
std::filesystem::path m_pathPlatformConfig; ///< The platform configuration from the settings file.
|
|
std::filesystem::path m_pathVehIfcConfig; ///< The vehicle interface configuration from the settings file.
|
|
std::filesystem::path m_pathVehAbstrConfig; ///< The vehicle abstraction configuration from the settings file.
|
|
std::filesystem::path m_pathUserConfig; ///< The user configuration from the settings file.
|
|
bool m_bPlatformConfig = false; ///< Platform config was explicitly enabled/disabled.
|
|
bool m_bVehIfcConfig = false; ///< Vehicle interface config was explicitly enabled/disabled.
|
|
bool m_bVehAbstrConfig = false; ///< Vehicle abstraction config was explicitly enabled/disabled.
|
|
bool m_bUserConfig = false; ///< User config was explicitly enabled/disabled.
|
|
};
|
|
|
|
/**
|
|
* @brief Return the application settings class.
|
|
* @return Reference to the application settings.
|
|
*/
|
|
CAppSettings& GetAppSettings();
|
|
|
|
/**
|
|
* @brief App settings service class.
|
|
*/
|
|
class CAppSettingsService : public sdv::CSdvObject
|
|
{
|
|
public:
|
|
CAppSettingsService() = default;
|
|
|
|
// Interface map
|
|
BEGIN_SDV_INTERFACE_MAP()
|
|
SDV_INTERFACE_ENTRY_MEMBER(sdv::IAttributes, GetAppSettings())
|
|
END_SDV_INTERFACE_MAP()
|
|
|
|
// Object declarations
|
|
DECLARE_OBJECT_CLASS_TYPE(sdv::EObjectType::system_object)
|
|
DECLARE_OBJECT_CLASS_NAME("AppSettingsService")
|
|
DECLARE_OBJECT_SINGLETON()
|
|
|
|
/**
|
|
* @brief Get access to the application settings.
|
|
* @return Returns the one global instance of the application config.
|
|
*/
|
|
static CAppSettings& GetAppSettings();
|
|
};
|
|
DEFINE_SDV_OBJECT(CAppSettingsService)
|
|
|
|
#endif // !defined APP_SETTINGS_H
|