You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
909 lines
42 KiB
909 lines
42 KiB
/*
|
|
* 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);
|
|
~CParameterMgr() override;
|
|
|
|
/** 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
|
|
std::string getKind() const override;
|
|
|
|
private:
|
|
CParameterMgr(const CParameterMgr &);
|
|
CParameterMgr &operator=(const CParameterMgr &);
|
|
|
|
// Init
|
|
bool init(std::string &strError) override;
|
|
|
|
// 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};
|
|
};
|