/*
* Copyright (c) 2011-2016, Intel Corporation
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation and/or
* other materials provided with the distribution.
*
* 3. Neither the name of the copyright holder nor the names of its contributors
* may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
* ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#pragma once
#include <mutex>
#include <map>
#include <vector>
#include "RemoteCommandHandlerTemplate.h"
#include "PathNavigator.h"
#include "SelectionCriterionType.h"
#include "SelectionCriterion.h"
#include "Element.h"
#include "XmlDocSink.h"
#include "XmlDocSource.h"
#include "XmlDomainExportContext.h"
#include "Results.h"
#include "ElementHandle.h"
#include <log/LogWrapper.h>
#include <log/Context.h>
#include <istream>
#include <memory>
#include <ostream>
#include <string>
class CElementLibrarySet;
class CSubsystemLibrary;
class CSystemClass;
class CSelectionCriteria;
class CParameterFrameworkConfiguration;
class CParameterBlackboard;
class CConfigurableDomains;
class IRemoteProcessorServerInterface;
class CParameterHandle;
class CSubsystemPlugins;
class CParameterAccessContext;
class CConfigurableElement;
class CParameterMgr : private CElement
{
enum ChildElement
{
EFrameworkConfiguration,
ESelectionCriteria,
ESystemClass,
EConfigurableDomains
};
enum ElementLibrary
{
EFrameworkConfigurationLibrary,
EParameterCreationLibrary,
EParameterConfigurationLibrary
};
// Parameter handle friendship
friend class ElementHandle;
public:
// Construction
CParameterMgr(const std::string &strConfigurationFilePath, core::log::ILogger &logger);
virtual ~CParameterMgr();
/** Load plugins, structures and settings from the config file given.
*
* @param[out] strError is a std::string describing the error if an error occurred
* undefined otherwise.
*
* @return true if no error occurred, false otherwise.
*/
bool load(std::string &strError);
// Remote command parsers
using CommandHandler = std::unique_ptr<TRemoteCommandHandlerTemplate<CParameterMgr>>;
/** Create and return a command handler for this ParameterMgr instance
*
* @returns a Command Handler
*/
CommandHandler createCommandHandler();
// Selection Criteria
CSelectionCriterionType *createSelectionCriterionType(bool bIsInclusive);
CSelectionCriterion *createSelectionCriterion(
const std::string &strName, const CSelectionCriterionType *pSelectionCriterionType);
// Selection criterion retrieval
CSelectionCriterion *getSelectionCriterion(const std::string &strName);
// Configuration application
void applyConfigurations();
/** const version of getConfigurableElement */
const CConfigurableElement *getConfigurableElement(const std::string &strPath,
std::string &strError) const;
/** Returns the CConfigurableElement corresponding to the path given in argument.
*
* @param[in] strPath A std::string representing a path to an element.
* @param[out] strError Error message
*
* @return A const pointer to the corresponding CConfigurableElement.
* On error, NULL is returned and the error is explained in strError.
*/
CConfigurableElement *getConfigurableElement(const std::string &strPath, std::string &strError);
// Dynamic parameter handling
CParameterHandle *createParameterHandle(const std::string &strPath, std::string &strError);
/** Creates a handle to a configurable element.
*
* The returned object is owned by the client who is responsible to delete it.
*
* @param[in] path A string representing a path to a configurable element.
* @param[out] error On error: an human readable error message
* On success: undefined
*
* @return An element handle on success
* nullptr on error
*/
ElementHandle *createElementHandle(const std::string &path, std::string &error);
/** Is the remote interface forcefully disabled ?
*/
bool getForceNoRemoteInterface() const;
/**
* Forcefully disable the remote interface or cancel this policy
*
* @param[in] bForceNoRemoteInterface disable the remote interface if true.
*/
void setForceNoRemoteInterface(bool bForceNoRemoteInterface);
/** Should start fail in case of missing subsystems.
*
* @param[in] bFail: If set to true, parameterMgr start will fail on missing subsystems.
* If set to false, missing subsystems will fallback on virtual subsystem.
*/
void setFailureOnMissingSubsystem(bool bFail);
/** Would start fail in case of missing subsystems.
*
* @return true if the subsystem will fail on missing subsystem, false otherwise.
*/
bool getFailureOnMissingSubsystem() const;
/** Should start fail in failed settings load.
*
* @param[in] bFail: If set to true, parameterMgr start will fail on failed settings load.
* If set to false, failed settings load will be ignored.
*/
void setFailureOnFailedSettingsLoad(bool bFail);
/** Would start fail in case of failed settings load.
*
* @return failure on failed settings load policy state.
*/
bool getFailureOnFailedSettingsLoad() const;
/** Get the XML Schemas URI
*
* @returns the XML Schemas URI
*/
const std::string &getSchemaUri() const;
/** Override the XML Schemas URI
*
* @param[in] schemaUri XML Schemas URI
*/
void setSchemaUri(const std::string &schemaUri);
/** Should .xml files be validated on start ?
*
* @param[in] bValidate:
* If set to true, parameterMgr will report an error
* when being unable to validate .xml files
* If set to false, no .xml/xsd validation will happen
* (default behaviour)
*
* @return false if unable to set, true otherwise.
*/
void setValidateSchemasOnStart(bool bValidate);
/** Would .xml files be validated on start?
*
* @return areSchemasValidated
*/
bool getValidateSchemasOnStart() const;
//////////// Tuning /////////////
/**
* Activate / deactivate the tuning mode.
*
* @param[in] bOn true if tuning mode activation is requested, false for desactivation
* @param[out] strError human readable error
* @return true if request is successful, false if the Parameter Manager is already in the mode
* requested or in case of error.
* If false, strError is set with the associated human readable error.
*/
bool setTuningMode(bool bOn, std::string &strError);
bool tuningModeOn() const;
// Current value space for user set/get value interpretation
void setValueSpace(bool bIsRaw);
bool valueSpaceIsRaw();
// Current Output Raw Format for user get value interpretation
void setOutputRawFormat(bool bIsHex);
bool outputRawFormatIsHex();
// Automatic hardware synchronization control (during tuning session)
bool setAutoSync(bool bAutoSyncOn, std::string &strError);
bool autoSyncOn() const;
bool sync(std::string &strError);
// User set/get parameters
bool accessParameterValue(const std::string &strPath, std::string &strValue, bool bSet,
std::string &strError);
/**
* Returns the element mapping corresponding to the path given in parameter.
*
* @param[in] strPath Path of an element
* @param[out] strValue A sting containing the mapping
*
* @return true if a mapping was found for this element
*/
bool getParameterMapping(const std::string &strPath, std::string &strValue) const;
bool accessConfigurationValue(const std::string &strDomain, const std::string &stConfiguration,
const std::string &strPath, std::string &strValue, bool bSet,
std::string &strError);
////////// Configuration/Domains handling //////////////
// Creation/Deletion
bool createDomain(const std::string &strName, std::string &strError);
bool renameDomain(const std::string &strName, const std::string &strNewName,
std::string &strError);
bool deleteDomain(const std::string &strName, std::string &strError);
bool deleteAllDomains(std::string &strError);
bool setSequenceAwareness(const std::string &strName, bool bSequenceAware,
std::string &strResult);
bool getSequenceAwareness(const std::string &strName, bool &bSequenceAware,
std::string &strResult);
bool createConfiguration(const std::string &strDomain, const std::string &strConfiguration,
std::string &strError);
bool deleteConfiguration(const std::string &strDomain, const std::string &strConfiguration,
std::string &strError);
bool renameConfiguration(const std::string &strDomain, const std::string &strConfiguration,
const std::string &strNewConfiguration, std::string &strError);
/** Restore a configuration
*
* @param[in] strDomain the domain name
* @param[in] strConfiguration the configuration name
* @param[out] errors errors encountered during restoration
* @return true if success false otherwise
*/
bool restoreConfiguration(const std::string &strDomain, const std::string &strConfiguration,
core::Results &errors);
bool saveConfiguration(const std::string &strDomain, const std::string &strConfiguration,
std::string &strError);
// Configurable element - domain association
bool addConfigurableElementToDomain(const std::string &strDomain,
const std::string &strConfigurableElementPath,
std::string &strError);
bool removeConfigurableElementFromDomain(const std::string &strDomain,
const std::string &strConfigurableElementPath,
std::string &strError);
bool split(const std::string &strDomain, const std::string &strConfigurableElementPath,
std::string &strError);
bool setElementSequence(const std::string &strDomain, const std::string &strConfiguration,
const std::vector<std::string> &astrNewElementSequence,
std::string &strError);
bool getApplicationRule(const std::string &strDomain, const std::string &strConfiguration,
std::string &strResult);
bool setApplicationRule(const std::string &strDomain, const std::string &strConfiguration,
const std::string &strApplicationRule, std::string &strError);
bool clearApplicationRule(const std::string &strDomain, const std::string &strConfiguration,
std::string &strError);
/**
* Method that imports Configurable Domains from an Xml source.
*
* @param[in] xmlSource a std::string containing an xml description or a path to an xml file
* @param[in] withSettings a boolean that determines if the settings should be used in the
* xml description
* @param[in] fromFile a boolean that determines if the source is an xml description in
* xmlSource or contained in a file. In that case xmlSource is just the file path.
* @param[out] errorMsg is used as the error output
*
* @return false if any error occures
*/
bool importDomainsXml(const std::string &xmlSource, bool withSettings, bool fromFile,
std::string &errorMsg);
/**
* Method that imports a single Configurable Domain from an Xml source.
*
* @param[in] xmlSource a string containing an xml description or a path to an xml file
* @param[in] overwrite when importing an existing domain, allow
* overwriting or return an error
* @param[in] withSettings a boolean that determines if the settings should be used in the
* xml description
* @param[in] fromFile a boolean that determines if the source is an xml description in
* xmlSource or contained in a file. In that case xmlSource is just the file path.
* @param[out] errorMsg is used as the error output
*
* @return false if any error occurs
*/
bool importSingleDomainXml(const std::string &xmlSource, bool overwrite, bool withSettings,
bool fromFile, std::string &errorMsg);
/**
* Method that exports Configurable Domains to an Xml destination.
*
* @param[in,out] xmlDest a string containing an xml description or a path to an xml file
* @param[in] withSettings a boolean that determines if the settings should be used in the
* xml description
* @param[in] toFile a boolean that determines if the destination is an xml description in
* xmlDest or contained in a file. In that case xmlDest is just the file path.
* @param[out] errorMsg is used as the error output
*
* @return false if any error occurs, true otherwise.
*/
bool exportDomainsXml(std::string &xmlDest, bool withSettings, bool toFile,
std::string &errorMsg) const;
/**
* Method that exports a given Configurable Domain to an Xml destination.
*
* @param[in,out] xmlDest a string containing an xml description or a path to an xml file
* @param[in] domainName the name of the domain to be exported
* @param[in] withSettings a boolean that determines if the settings should be used in the
* xml description
* @param[in] toFile a boolean that determines if the destination is an xml description in
* xmlDest or contained in a file. In that case xmlDest is just the file path.
* @param[out] errorMsg is used as the error output
*
* @return false if any error occurs, true otherwise.
*/
bool exportSingleDomainXml(std::string &xmlDest, const std::string &domainName,
bool withSettings, bool toFile, std::string &errorMsg) const;
/**
* Method that exports an Xml description of the passed element into a string
*
* @param[in] pXmlSource The source element to export
* @param[in] strRootElementType The XML root element name of the exported instance document
* @param[in] xmlSerializingContext the context to use for serialization
* Is an rvalue as it must be destructed after this function
* call to set the error.
* Additionally, using it for an other serialization would
* override the error.
* @param[out] strResult contains the xml description or the error description in case false is
* returned
*
* @return true for success, false if any error occurs during the creation of the xml
* description (validation or encoding)
*/
bool exportElementToXMLString(const IXmlSource *pXmlSource,
const std::string &strRootElementType,
CXmlSerializingContext &&xmlSerializingContext,
std::string &strResult) const;
// CElement
virtual std::string getKind() const;
private:
CParameterMgr(const CParameterMgr &);
CParameterMgr &operator=(const CParameterMgr &);
// Init
virtual bool init(std::string &strError);
// Version
std::string getVersion() const;
// This using is here for internal reasons: CommandHandler is public and is
// a unique_ptr but we want the type that's inside. And for legacy reason
// because that's the original name before a rework; this directive avoids
// renaming a lot of stuff.
using CCommandHandler = CommandHandler::element_type;
using RemoteCommandParser = CCommandHandler::CommandStatus (CParameterMgr::*)(
const IRemoteCommand &remoteCommand, std::string &strResult);
// Parser descriptions
struct SRemoteCommandParserItem
{
const char *_pcCommandName;
CParameterMgr::RemoteCommandParser _pfnParser;
size_t _minArgumentCount;
const char *_pcHelp;
const char *_pcDescription;
};
////////////////:: Remote command parsers
/// Version
CCommandHandler::CommandStatus versionCommandProcess(const IRemoteCommand &remoteCommand,
std::string &strResult);
/// Status
CCommandHandler::CommandStatus statusCommandProcess(const IRemoteCommand &remoteCommand,
std::string &strResult);
/// Tuning Mode
CCommandHandler::CommandStatus setTuningModeCommandProcess(const IRemoteCommand &remoteCommand,
std::string &strResult);
CCommandHandler::CommandStatus getTuningModeCommandProcess(const IRemoteCommand &remoteCommand,
std::string &strResult);
/// Value Space
CCommandHandler::CommandStatus setValueSpaceCommandProcess(const IRemoteCommand &remoteCommand,
std::string &strResult);
CCommandHandler::CommandStatus getValueSpaceCommandProcess(const IRemoteCommand &remoteCommand,
std::string &strResult);
/// Output Raw Format
CCommandHandler::CommandStatus setOutputRawFormatCommandProcess(
const IRemoteCommand &remoteCommand, std::string &strResult);
CCommandHandler::CommandStatus getOutputRawFormatCommandProcess(
const IRemoteCommand &remoteCommand, std::string &strResult);
/// Sync
CCommandHandler::CommandStatus setAutoSyncCommandProcess(const IRemoteCommand &remoteCommand,
std::string &strResult);
CCommandHandler::CommandStatus getAutoSyncCommandProcess(const IRemoteCommand &remoteCommand,
std::string &strResult);
CCommandHandler::CommandStatus syncCommandProcess(const IRemoteCommand &remoteCommand,
std::string &strResult);
/// Criteria
CCommandHandler::CommandStatus listCriteriaCommandProcess(const IRemoteCommand &remoteCommand,
std::string &strResult);
/// Domains
CCommandHandler::CommandStatus listDomainsCommandProcess(const IRemoteCommand &remoteCommand,
std::string &strResult);
CCommandHandler::CommandStatus createDomainCommandProcess(const IRemoteCommand &remoteCommand,
std::string &strResult);
CCommandHandler::CommandStatus deleteDomainCommandProcess(const IRemoteCommand &remoteCommand,
std::string &strResult);
CCommandHandler::CommandStatus deleteAllDomainsCommandProcess(
const IRemoteCommand &remoteCommand, std::string &strResult);
CCommandHandler::CommandStatus renameDomainCommandProcess(const IRemoteCommand &remoteCommand,
std::string &strResult);
CCommandHandler::CommandStatus setSequenceAwarenessCommandProcess(
const IRemoteCommand &remoteCommand, std::string &strResult);
CCommandHandler::CommandStatus getSequenceAwarenessCommandProcess(
const IRemoteCommand &remoteCommand, std::string &strResult);
CCommandHandler::CommandStatus listDomainElementsCommandProcess(
const IRemoteCommand &remoteCommand, std::string &strResult);
CCommandHandler::CommandStatus addElementCommandProcess(const IRemoteCommand &remoteCommand,
std::string &strResult);
CCommandHandler::CommandStatus removeElementCommandProcess(const IRemoteCommand &remoteCommand,
std::string &strResult);
CCommandHandler::CommandStatus splitDomainCommandProcess(const IRemoteCommand &remoteCommand,
std::string &strResult);
/// Configurations
CCommandHandler::CommandStatus listConfigurationsCommandProcess(
const IRemoteCommand &remoteCommand, std::string &strResult);
CCommandHandler::CommandStatus dumpDomainsCommandProcess(const IRemoteCommand &remoteCommand,
std::string &strResult);
CCommandHandler::CommandStatus createConfigurationCommandProcess(
const IRemoteCommand &remoteCommand, std::string &strResult);
CCommandHandler::CommandStatus deleteConfigurationCommandProcess(
const IRemoteCommand &remoteCommand, std::string &strResult);
CCommandHandler::CommandStatus renameConfigurationCommandProcess(
const IRemoteCommand &remoteCommand, std::string &strResult);
CCommandHandler::CommandStatus saveConfigurationCommandProcess(
const IRemoteCommand &remoteCommand, std::string &strResult);
CCommandHandler::CommandStatus restoreConfigurationCommandProcess(
const IRemoteCommand &remoteCommand, std::string &strResult);
CCommandHandler::CommandStatus setElementSequenceCommandProcess(
const IRemoteCommand &remoteCommand, std::string &strResult);
CCommandHandler::CommandStatus getElementSequenceCommandProcess(
const IRemoteCommand &remoteCommand, std::string &strResult);
CCommandHandler::CommandStatus setRuleCommandProcess(const IRemoteCommand &remoteCommand,
std::string &strResult);
CCommandHandler::CommandStatus clearRuleCommandProcess(const IRemoteCommand &remoteCommand,
std::string &strResult);
CCommandHandler::CommandStatus getRuleCommandProcess(const IRemoteCommand &remoteCommand,
std::string &strResult);
/// Elements/Parameters
CCommandHandler::CommandStatus listElementsCommandProcess(const IRemoteCommand &remoteCommand,
std::string &strResult);
CCommandHandler::CommandStatus listParametersCommandProcess(const IRemoteCommand &remoteCommand,
std::string &strResult);
CCommandHandler::CommandStatus getElementStructureXMLCommandProcess(
const IRemoteCommand &remoteCommand, std::string &strResult);
CCommandHandler::CommandStatus getElementBytesCommandProcess(
const IRemoteCommand &remoteCommand, std::string &strResult);
CCommandHandler::CommandStatus setElementBytesCommandProcess(
const IRemoteCommand &remoteCommand, std::string &strResult);
CCommandHandler::CommandStatus getElementXMLCommandProcess(const IRemoteCommand &remoteCommand,
std::string &strResult);
CCommandHandler::CommandStatus setElementXMLCommandProcess(const IRemoteCommand &remoteCommand,
std::string &strResult);
CCommandHandler::CommandStatus dumpElementCommandProcess(const IRemoteCommand &remoteCommand,
std::string &strResult);
CCommandHandler::CommandStatus getElementSizeCommandProcess(const IRemoteCommand &remoteCommand,
std::string &strResult);
CCommandHandler::CommandStatus showPropertiesCommandProcess(const IRemoteCommand &remoteCommand,
std::string &strResult);
CCommandHandler::CommandStatus getParameterCommandProcess(const IRemoteCommand &remoteCommand,
std::string &strResult);
CCommandHandler::CommandStatus setParameterCommandProcess(const IRemoteCommand &remoteCommand,
std::string &strResult);
CCommandHandler::CommandStatus getConfigurationParameterCommandProcess(
const IRemoteCommand &remoteCommand, std::string &strResult);
CCommandHandler::CommandStatus setConfigurationParameterCommandProcess(
const IRemoteCommand &remoteCommand, std::string &strResult);
CCommandHandler::CommandStatus listBelongingDomainsCommandProcess(
const IRemoteCommand &remoteCommand, std::string &strResult);
CCommandHandler::CommandStatus listAssociatedDomainsCommandProcess(
const IRemoteCommand &remoteCommand, std::string &strResult);
CCommandHandler::CommandStatus showMappingCommandProcess(const IRemoteCommand &remoteCommand,
std::string &strResult);
/// Browse
CCommandHandler::CommandStatus listAssociatedElementsCommandProcess(
const IRemoteCommand &remoteCommand, std::string &strResult);
CCommandHandler::CommandStatus listConflictingElementsCommandProcess(
const IRemoteCommand &remoteCommand, std::string &strResult);
CCommandHandler::CommandStatus listRogueElementsCommandProcess(
const IRemoteCommand &remoteCommand, std::string &strResult);
/// Settings Import/Export
CCommandHandler::CommandStatus exportDomainsXMLCommandProcess(
const IRemoteCommand &remoteCommand, std::string &strResult);
CCommandHandler::CommandStatus importDomainsXMLCommandProcess(
const IRemoteCommand &remoteCommand, std::string &strResult);
CCommandHandler::CommandStatus exportDomainsWithSettingsXMLCommandProcess(
const IRemoteCommand &remoteCommand, std::string &strResult);
CCommandHandler::CommandStatus importDomainsWithSettingsXMLCommandProcess(
const IRemoteCommand &remoteCommand, std::string &strResult);
/**
* Command handler method for exportDomainWithSettingsXML command.
*
* @param[in] remoteCommand contains the arguments of the received command.
* @param[out] result a std::string containing the result of the command
*
* @return CCommandHandler::ESucceeded if command succeeded or CCommandHandler::EFailed
* in the other case
*/
CCommandHandler::CommandStatus exportDomainWithSettingsXMLCommandProcess(
const IRemoteCommand &remoteCommand, std::string &result);
CCommandHandler::CommandStatus importDomainWithSettingsXMLCommandProcess(
const IRemoteCommand &remoteCommand, std::string &strResult);
/**
* Command handler method for getDomainsWithSettings command.
*
* @param[in] remoteCommand contains the arguments of the received command.
* @param[out] strResult a std::string containing the result of the command
*
* @return CCommandHandler::ESucceeded if command succeeded or CCommandHandler::EFailed
* in the other case
*/
CCommandHandler::CommandStatus getDomainsWithSettingsXMLCommandProcess(
const IRemoteCommand &remoteCommand, std::string &strResult);
/**
* Command handler method for getDomainWithSettings command.
*
* @param[in] remoteCommand contains the arguments of the received command.
* @param[out] strResult a string containing the result of the command
*
* @return CCommandHandler::ESucceeded if command succeeded or CCommandHandler::EFailed
* in the other case
*/
CCommandHandler::CommandStatus getDomainWithSettingsXMLCommandProcess(
const IRemoteCommand &remoteCommand, std::string &strResult);
/**
* Command handler method for setDomainsWithSettings command.
*
* @param[in] remoteCommand contains the arguments of the received command.
* @param[out] strResult a std::string containing the result of the command
*
* @return CCommandHandler::ESucceeded if command succeeded or CCommandHandler::EFailed
* in the other case
*/
CCommandHandler::CommandStatus setDomainsWithSettingsXMLCommandProcess(
const IRemoteCommand &remoteCommand, std::string &strResult);
/**
* Command handler method for setDomainWithSettings command.
*
* @param[in] remoteCommand contains the arguments of the received command.
* @param[out] result a std::string containing the result of the command
*
* @return CCommandHandler::ESucceeded if command succeeded or CCommandHandler::EFailed
* in the other case
*/
CCommandHandler::CommandStatus setDomainWithSettingsXMLCommandProcess(
const IRemoteCommand &remoteCommand, std::string &result);
/**
* Command handler method for getSystemClass command.
*
* @param[in] remoteCommand contains the arguments of the received command.
* @param[out] strResult a std::string containing the result of the command
*
* @return CCommandHandler::ESucceeded if command succeeded or CCommandHandler::EFailed
* in the other case
*/
CCommandHandler::CommandStatus getSystemClassXMLCommandProcess(
const IRemoteCommand &remoteCommand, std::string &strResult);
// Max command usage length, use for formatting
void setMaxCommandUsageLength();
// For tuning, check we're in tuning mode
bool checkTuningModeOn(std::string &strError) const;
// Blackboard (dynamic parameter handling)
std::mutex &getBlackboardMutex();
// Blackboard reference (dynamic parameter handling)
CParameterBlackboard *getParameterBlackboard();
// Parameter access
bool accessValue(CParameterAccessContext ¶meterAccessContext, const std::string &strPath,
std::string &strValue, bool bSet, std::string &strError);
bool doSetValue(const std::string &strPath, const std::string &strValue, bool bRawValueSpace,
bool bDynamicAccess, std::string &strError) const;
bool doGetValue(const std::string &strPath, std::string &strValue, bool bRawValueSpace,
bool bHexOutputRawFormat, bool bDynamicAccess, std::string &strError) const;
// Framework global configuration loading
bool loadFrameworkConfiguration(std::string &strError);
/** Load required subsystems
*
* @param[out] error error description if there is one
* @return true if succeed false otherwise
*/
bool loadSubsystems(std::string &error);
// System class Structure loading
bool loadStructure(std::string &strError);
// System class Structure loading
bool loadSettings(std::string &strError);
bool loadSettingsFromConfigFile(std::string &strError);
/** Get settings from a configurable element in binary format.
*
* @param[in] element configurable element.
* @param[out] settings current element settings (in mainblackboard) in binary format
*
* @return true on success, false on error
*/
void getSettingsAsBytes(const CConfigurableElement &element,
std::vector<uint8_t> &settings) const;
/** Assign settings to a configurable element in binary format.
*
* @param[in] element configurable element.
* @param[in] settings the settings as byte array (binary).
* @param[out] error error message filled in case of error
*
* @return true in case of success, false oherwise, in which case error is filled with error
* message.
*/
bool setSettingsAsBytes(const CConfigurableElement &element,
const std::vector<uint8_t> &settings, std::string &error);
/** Assign settings to a configurable element in XML format.
*
* @param[in] configurableElement The element to set.
* @param[in] settings The settings to set.
* @param[out] error human readable error message filled in case of error,
* undefined in case of success.
* @return true in case of success, false otherwise
*/
bool setSettingsAsXML(CConfigurableElement *configurableElement, const std::string &settings,
std::string &error);
/** Get settings from a configurable element in XML format.
*
* @param[in] configurableElement The element to get settings from.
* @param[out] result on success: the exported setttings in XML
* on error: human readable error message
*
* @return true in case of success, false otherwise.
*/
bool getSettingsAsXML(const CConfigurableElement *configurableElement,
std::string &result) const;
/** Parse an XML stream into an element
*
* @param[in] elementSerializingContext serializing context
* @param[out] pRootElement the receiving element
* @param[in] input the input XML stream
* @param[in] baseUri the XML input file URI or ""
* @param[in] eElementLibrary which element library to be used
* @param[in] replace Should the element be overridden or modified in place
* @param[in] strNameAttributeName the name of the element's XML "name" attribute
*
* @returns true if parsing succeeded, false otherwise
*/
bool xmlParse(CXmlElementSerializingContext &elementSerializingContext, CElement *pRootElement,
_xmlDoc *doc, const std::string &baseUri, ElementLibrary eElementLibrary,
bool replace = true, const std::string &strNameAttributeName = "Name");
/** Wrapper for converting public APIs semantics to internal API
*
* Public APIs have a string argument that can either contain:
* - a path to an XML file or;
* - an actual XML document.
* They also have a boolean argument specifying which of the two cases it
* is.
*
* Instead, the internal APIs only take an std::istream argument. This
* method opens the file as a stream if applicable or simply wrap the
* string in a stream. It then passes the stream to the internal methods.
*
* @param[in] xmlSource the XML source (either a path or an actual xml
* document)
* @param[in] fromFile specifies whether xmlSource is a path or an
* actual XML document
* @param[in] withSettings if false, only import the configurations
* applicability rules; if true, also import their settings
* @param[out] element the receiving element
* @param[in] nameAttributeName the name of the element's XML "name"
* attribute
* @param[out] errorMsg string used as output for any error message
*
* @returns true if the import succeeded, false otherwise
*/
bool wrapLegacyXmlImport(const std::string &xmlSource, bool fromFile, bool withSettings,
CElement &element, const std::string &nameAttributeName,
std::string &errorMsg);
/**
* Export an element object to an Xml destination.
*
*
* @param[out] output the stream to output the XML to
* @param[in] xmlSerializingContext the serializing context
* @param[in] element object to be serialized.
*
* @return false if any error occurs, true otherwise.
*/
bool serializeElement(std::ostream &output, CXmlSerializingContext &xmlSerializingContext,
const CElement &element) const;
/** Wrapper for converting public APIs semantics to internal API
*
* Public APIs have a string argument that can either:
* - contain a path to an XML file or;
* - receive an actual XML document.
* They also have a boolean argument specifying which of the two cases it
* is.
*
* Instead, the internal APIs only take an std::ostream argument. This
* method opens the file as a stream if applicable or simply wrap the
* string in a stream. It then passes the stream to the internal methods.
*
* @param[in] xmlDest the XML sink (either a path or any string that
* will be filled)
* @param[in] toFile specifies whether xmlSource is a path or a
* string that will receive an actual XML document
* @param[in] withSettings if false, only export the configurations
* applicability rules; if true, also export their settings
* @param[out] element the element to be exported
* @param[out] errorMsg string used as output for any error message
*
* @returns true if the export succeeded, false otherwise
*/
bool wrapLegacyXmlExport(std::string &xmlDest, bool toFile, bool withSettings,
const CElement &element, std::string &errorMsg) const;
/** Wrapper for converting public APIs semantics to internal API
*
* @see wrapLegacyXmlExport
*/
bool wrapLegacyXmlExportToFile(std::string &xmlDest, const CElement &element,
CXmlDomainExportContext &context) const;
/** Wrapper for converting public APIs semantics to internal API
*
* @see wrapLegacyXmlExport
*/
bool wrapLegacyXmlExportToString(std::string &xmlDest, const CElement &element,
CXmlDomainExportContext &context) const;
// Framework Configuration
CParameterFrameworkConfiguration *getFrameworkConfiguration();
const CParameterFrameworkConfiguration *getConstFrameworkConfiguration();
// Selection Criteria
CSelectionCriteria *getSelectionCriteria();
const CSelectionCriteria *getConstSelectionCriteria();
// System Class
CSystemClass *getSystemClass();
const CSystemClass *getConstSystemClass() const;
// Configurable Domains
CConfigurableDomains *getConfigurableDomains();
const CConfigurableDomains *getConstConfigurableDomains();
const CConfigurableDomains *getConstConfigurableDomains() const;
// Apply configurations
void doApplyConfigurations(bool bForce);
// Dynamic object creation libraries feeding
void feedElementLibraries();
// Remote Processor Server connection handling
bool isRemoteInterfaceRequired();
bool handleRemoteProcessingInterface(std::string &strError);
/** Log the result of a function
*
* @param[in] isSuccess indicates if the previous function has succeed
* @param[in] result function provided result string
* @return isSuccess parameter
*/
bool logResult(bool isSuccess, const std::string &result);
/** Info logger call helper */
inline core::log::details::Info info();
/** Warning logger call helper */
inline core::log::details::Warning warning();
// Tuning
bool _bTuningModeIsOn{false};
// Value Space
bool _bValueSpaceIsRaw{false};
// Output Raw Format
bool _bOutputRawFormatIsHex{false};
// Automatic synchronization to HW during Tuning session
bool _bAutoSyncOn{true};
// Current Parameter Settings
CParameterBlackboard *_pMainParameterBlackboard;
// Dynamic object creation
CElementLibrarySet *_pElementLibrarySet;
// XML parsing, object creation handling
std::string _xmlConfigurationUri;
std::string _schemaUri; // Place where schemas stand
// Subsystem plugin location
const CSubsystemPlugins *_pSubsystemPlugins{nullptr};
// Remote Processor Server
IRemoteProcessorServerInterface *_pRemoteProcessorServer{nullptr};
// Parser description array
static const SRemoteCommandParserItem gastRemoteCommandParserItems[];
// Maximum command usage length
size_t _maxCommandUsageLength{0};
// Blackboard access mutex
std::mutex _blackboardMutex;
/** Application main logger based on the one provided by the client */
mutable core::log::Logger _logger;
/** If set to false, the remote interface won't be started no matter what.
* If set to true - the default - it has no impact on the policy for
* starting the remote interface.
*/
bool _bForceNoRemoteInterface{false};
/** If set to true, missing subsystem will abort parameterMgr start.
* If set to false, missing subsystem will fallback on virtual subsystem.
*/
bool _bFailOnMissingSubsystem{true};
/** If set to true, unparsable or discording domains will abort parameterMgr start.
* If set to false, unparsable or discording domains
* will continue the parameterMgr start with no domains.
*/
bool _bFailOnFailedSettingsLoad{true};
/**
* If set to true, parameterMgr will report an error
* when being unable to validate .xml files
* If set to false, no .xml/xsd validation will happen (default behaviour)
*/
bool _bValidateSchemasOnStart{false};
};