1/* 2 * Copyright (c) 2011-2016, Intel Corporation 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without modification, 6 * are permitted provided that the following conditions are met: 7 * 8 * 1. Redistributions of source code must retain the above copyright notice, this 9 * list of conditions and the following disclaimer. 10 * 11 * 2. Redistributions in binary form must reproduce the above copyright notice, 12 * this list of conditions and the following disclaimer in the documentation and/or 13 * other materials provided with the distribution. 14 * 15 * 3. Neither the name of the copyright holder nor the names of its contributors 16 * may be used to endorse or promote products derived from this software without 17 * specific prior written permission. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 21 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 22 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR 23 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 24 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 25 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON 26 * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 28 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29 */ 30#pragma once 31 32#include <mutex> 33#include <map> 34#include <vector> 35#include "RemoteCommandHandlerTemplate.h" 36#include "PathNavigator.h" 37#include "SelectionCriterionType.h" 38#include "SelectionCriterion.h" 39#include "Element.h" 40#include "XmlDocSink.h" 41#include "XmlDocSource.h" 42#include "XmlDomainExportContext.h" 43#include "Results.h" 44#include "ElementHandle.h" 45#include <log/LogWrapper.h> 46#include <log/Context.h> 47 48#include <istream> 49#include <memory> 50#include <ostream> 51#include <string> 52 53class CElementLibrarySet; 54class CSubsystemLibrary; 55class CSystemClass; 56class CSelectionCriteria; 57class CParameterFrameworkConfiguration; 58class CParameterBlackboard; 59class CConfigurableDomains; 60class IRemoteProcessorServerInterface; 61class CParameterHandle; 62class CSubsystemPlugins; 63class CParameterAccessContext; 64class CConfigurableElement; 65 66class CParameterMgr : private CElement 67{ 68 enum ChildElement 69 { 70 EFrameworkConfiguration, 71 ESelectionCriteria, 72 ESystemClass, 73 EConfigurableDomains 74 }; 75 enum ElementLibrary 76 { 77 EFrameworkConfigurationLibrary, 78 EParameterCreationLibrary, 79 EParameterConfigurationLibrary 80 }; 81 82 // Parameter handle friendship 83 friend class ElementHandle; 84 85public: 86 // Construction 87 CParameterMgr(const std::string &strConfigurationFilePath, core::log::ILogger &logger); 88 virtual ~CParameterMgr(); 89 90 /** Load plugins, structures and settings from the config file given. 91 * 92 * @param[out] strError is a std::string describing the error if an error occurred 93 * undefined otherwise. 94 * 95 * @return true if no error occurred, false otherwise. 96 */ 97 bool load(std::string &strError); 98 99 // Remote command parsers 100 using CommandHandler = std::unique_ptr<TRemoteCommandHandlerTemplate<CParameterMgr>>; 101 102 /** Create and return a command handler for this ParameterMgr instance 103 * 104 * @returns a Command Handler 105 */ 106 CommandHandler createCommandHandler(); 107 108 // Selection Criteria 109 CSelectionCriterionType *createSelectionCriterionType(bool bIsInclusive); 110 CSelectionCriterion *createSelectionCriterion( 111 const std::string &strName, const CSelectionCriterionType *pSelectionCriterionType); 112 // Selection criterion retrieval 113 CSelectionCriterion *getSelectionCriterion(const std::string &strName); 114 115 // Configuration application 116 void applyConfigurations(); 117 118 /** const version of getConfigurableElement */ 119 const CConfigurableElement *getConfigurableElement(const std::string &strPath, 120 std::string &strError) const; 121 122 /** Returns the CConfigurableElement corresponding to the path given in argument. 123 * 124 * @param[in] strPath A std::string representing a path to an element. 125 * @param[out] strError Error message 126 * 127 * @return A const pointer to the corresponding CConfigurableElement. 128 * On error, NULL is returned and the error is explained in strError. 129 */ 130 CConfigurableElement *getConfigurableElement(const std::string &strPath, std::string &strError); 131 // Dynamic parameter handling 132 CParameterHandle *createParameterHandle(const std::string &strPath, std::string &strError); 133 134 /** Creates a handle to a configurable element. 135 * 136 * The returned object is owned by the client who is responsible to delete it. 137 * 138 * @param[in] path A string representing a path to a configurable element. 139 * @param[out] error On error: an human readable error message 140 * On success: undefined 141 * 142 * @return An element handle on success 143 * nullptr on error 144 */ 145 ElementHandle *createElementHandle(const std::string &path, std::string &error); 146 147 /** Is the remote interface forcefully disabled ? 148 */ 149 bool getForceNoRemoteInterface() const; 150 151 /** 152 * Forcefully disable the remote interface or cancel this policy 153 * 154 * @param[in] bForceNoRemoteInterface disable the remote interface if true. 155 */ 156 void setForceNoRemoteInterface(bool bForceNoRemoteInterface); 157 158 /** Should start fail in case of missing subsystems. 159 * 160 * @param[in] bFail: If set to true, parameterMgr start will fail on missing subsystems. 161 * If set to false, missing subsystems will fallback on virtual subsystem. 162 */ 163 void setFailureOnMissingSubsystem(bool bFail); 164 165 /** Would start fail in case of missing subsystems. 166 * 167 * @return true if the subsystem will fail on missing subsystem, false otherwise. 168 */ 169 bool getFailureOnMissingSubsystem() const; 170 171 /** Should start fail in failed settings load. 172 * 173 * @param[in] bFail: If set to true, parameterMgr start will fail on failed settings load. 174 * If set to false, failed settings load will be ignored. 175 */ 176 void setFailureOnFailedSettingsLoad(bool bFail); 177 /** Would start fail in case of failed settings load. 178 * 179 * @return failure on failed settings load policy state. 180 */ 181 bool getFailureOnFailedSettingsLoad() const; 182 183 /** Get the XML Schemas URI 184 * 185 * @returns the XML Schemas URI 186 */ 187 const std::string &getSchemaUri() const; 188 189 /** Override the XML Schemas URI 190 * 191 * @param[in] schemaUri XML Schemas URI 192 */ 193 void setSchemaUri(const std::string &schemaUri); 194 195 /** Should .xml files be validated on start ? 196 * 197 * @param[in] bValidate: 198 * If set to true, parameterMgr will report an error 199 * when being unable to validate .xml files 200 * If set to false, no .xml/xsd validation will happen 201 * (default behaviour) 202 * 203 * @return false if unable to set, true otherwise. 204 */ 205 void setValidateSchemasOnStart(bool bValidate); 206 207 /** Would .xml files be validated on start? 208 * 209 * @return areSchemasValidated 210 */ 211 bool getValidateSchemasOnStart() const; 212 213 //////////// Tuning ///////////// 214 /** 215 * Activate / deactivate the tuning mode. 216 * 217 * @param[in] bOn true if tuning mode activation is requested, false for desactivation 218 * @param[out] strError human readable error 219 * @return true if request is successful, false if the Parameter Manager is already in the mode 220 * requested or in case of error. 221 * If false, strError is set with the associated human readable error. 222 */ 223 bool setTuningMode(bool bOn, std::string &strError); 224 bool tuningModeOn() const; 225 226 // Current value space for user set/get value interpretation 227 void setValueSpace(bool bIsRaw); 228 bool valueSpaceIsRaw(); 229 230 // Current Output Raw Format for user get value interpretation 231 void setOutputRawFormat(bool bIsHex); 232 bool outputRawFormatIsHex(); 233 234 // Automatic hardware synchronization control (during tuning session) 235 bool setAutoSync(bool bAutoSyncOn, std::string &strError); 236 bool autoSyncOn() const; 237 bool sync(std::string &strError); 238 239 // User set/get parameters 240 bool accessParameterValue(const std::string &strPath, std::string &strValue, bool bSet, 241 std::string &strError); 242 /** 243 * Returns the element mapping corresponding to the path given in parameter. 244 * 245 * @param[in] strPath Path of an element 246 * @param[out] strValue A sting containing the mapping 247 * 248 * @return true if a mapping was found for this element 249 */ 250 bool getParameterMapping(const std::string &strPath, std::string &strValue) const; 251 bool accessConfigurationValue(const std::string &strDomain, const std::string &stConfiguration, 252 const std::string &strPath, std::string &strValue, bool bSet, 253 std::string &strError); 254 255 ////////// Configuration/Domains handling ////////////// 256 // Creation/Deletion 257 bool createDomain(const std::string &strName, std::string &strError); 258 bool renameDomain(const std::string &strName, const std::string &strNewName, 259 std::string &strError); 260 bool deleteDomain(const std::string &strName, std::string &strError); 261 bool deleteAllDomains(std::string &strError); 262 bool setSequenceAwareness(const std::string &strName, bool bSequenceAware, 263 std::string &strResult); 264 bool getSequenceAwareness(const std::string &strName, bool &bSequenceAware, 265 std::string &strResult); 266 bool createConfiguration(const std::string &strDomain, const std::string &strConfiguration, 267 std::string &strError); 268 bool deleteConfiguration(const std::string &strDomain, const std::string &strConfiguration, 269 std::string &strError); 270 bool renameConfiguration(const std::string &strDomain, const std::string &strConfiguration, 271 const std::string &strNewConfiguration, std::string &strError); 272 273 /** Restore a configuration 274 * 275 * @param[in] strDomain the domain name 276 * @param[in] strConfiguration the configuration name 277 * @param[out] errors errors encountered during restoration 278 * @return true if success false otherwise 279 */ 280 bool restoreConfiguration(const std::string &strDomain, const std::string &strConfiguration, 281 core::Results &errors); 282 283 bool saveConfiguration(const std::string &strDomain, const std::string &strConfiguration, 284 std::string &strError); 285 286 // Configurable element - domain association 287 bool addConfigurableElementToDomain(const std::string &strDomain, 288 const std::string &strConfigurableElementPath, 289 std::string &strError); 290 bool removeConfigurableElementFromDomain(const std::string &strDomain, 291 const std::string &strConfigurableElementPath, 292 std::string &strError); 293 bool split(const std::string &strDomain, const std::string &strConfigurableElementPath, 294 std::string &strError); 295 bool setElementSequence(const std::string &strDomain, const std::string &strConfiguration, 296 const std::vector<std::string> &astrNewElementSequence, 297 std::string &strError); 298 299 bool getApplicationRule(const std::string &strDomain, const std::string &strConfiguration, 300 std::string &strResult); 301 bool setApplicationRule(const std::string &strDomain, const std::string &strConfiguration, 302 const std::string &strApplicationRule, std::string &strError); 303 bool clearApplicationRule(const std::string &strDomain, const std::string &strConfiguration, 304 std::string &strError); 305 306 /** 307 * Method that imports Configurable Domains from an Xml source. 308 * 309 * @param[in] xmlSource a std::string containing an xml description or a path to an xml file 310 * @param[in] withSettings a boolean that determines if the settings should be used in the 311 * xml description 312 * @param[in] fromFile a boolean that determines if the source is an xml description in 313 * xmlSource or contained in a file. In that case xmlSource is just the file path. 314 * @param[out] errorMsg is used as the error output 315 * 316 * @return false if any error occures 317 */ 318 bool importDomainsXml(const std::string &xmlSource, bool withSettings, bool fromFile, 319 std::string &errorMsg); 320 321 /** 322 * Method that imports a single Configurable Domain from an Xml source. 323 * 324 * @param[in] xmlSource a string containing an xml description or a path to an xml file 325 * @param[in] overwrite when importing an existing domain, allow 326 * overwriting or return an error 327 * @param[in] withSettings a boolean that determines if the settings should be used in the 328 * xml description 329 * @param[in] fromFile a boolean that determines if the source is an xml description in 330 * xmlSource or contained in a file. In that case xmlSource is just the file path. 331 * @param[out] errorMsg is used as the error output 332 * 333 * @return false if any error occurs 334 */ 335 bool importSingleDomainXml(const std::string &xmlSource, bool overwrite, bool withSettings, 336 bool fromFile, std::string &errorMsg); 337 338 /** 339 * Method that exports Configurable Domains to an Xml destination. 340 * 341 * @param[in,out] xmlDest a string containing an xml description or a path to an xml file 342 * @param[in] withSettings a boolean that determines if the settings should be used in the 343 * xml description 344 * @param[in] toFile a boolean that determines if the destination is an xml description in 345 * xmlDest or contained in a file. In that case xmlDest is just the file path. 346 * @param[out] errorMsg is used as the error output 347 * 348 * @return false if any error occurs, true otherwise. 349 */ 350 bool exportDomainsXml(std::string &xmlDest, bool withSettings, bool toFile, 351 std::string &errorMsg) const; 352 353 /** 354 * Method that exports a given Configurable Domain to an Xml destination. 355 * 356 * @param[in,out] xmlDest a string containing an xml description or a path to an xml file 357 * @param[in] domainName the name of the domain to be exported 358 * @param[in] withSettings a boolean that determines if the settings should be used in the 359 * xml description 360 * @param[in] toFile a boolean that determines if the destination is an xml description in 361 * xmlDest or contained in a file. In that case xmlDest is just the file path. 362 * @param[out] errorMsg is used as the error output 363 * 364 * @return false if any error occurs, true otherwise. 365 */ 366 bool exportSingleDomainXml(std::string &xmlDest, const std::string &domainName, 367 bool withSettings, bool toFile, std::string &errorMsg) const; 368 369 /** 370 * Method that exports an Xml description of the passed element into a string 371 * 372 * @param[in] pXmlSource The source element to export 373 * @param[in] strRootElementType The XML root element name of the exported instance document 374 * @param[in] xmlSerializingContext the context to use for serialization 375 * Is an rvalue as it must be destructed after this function 376 * call to set the error. 377 * Additionally, using it for an other serialization would 378 * override the error. 379 * @param[out] strResult contains the xml description or the error description in case false is 380 * returned 381 * 382 * @return true for success, false if any error occurs during the creation of the xml 383 * description (validation or encoding) 384 */ 385 bool exportElementToXMLString(const IXmlSource *pXmlSource, 386 const std::string &strRootElementType, 387 CXmlSerializingContext &&xmlSerializingContext, 388 std::string &strResult) const; 389 390 // CElement 391 virtual std::string getKind() const; 392 393private: 394 CParameterMgr(const CParameterMgr &); 395 CParameterMgr &operator=(const CParameterMgr &); 396 397 // Init 398 virtual bool init(std::string &strError); 399 400 // Version 401 std::string getVersion() const; 402 403 // This using is here for internal reasons: CommandHandler is public and is 404 // a unique_ptr but we want the type that's inside. And for legacy reason 405 // because that's the original name before a rework; this directive avoids 406 // renaming a lot of stuff. 407 using CCommandHandler = CommandHandler::element_type; 408 using RemoteCommandParser = CCommandHandler::CommandStatus (CParameterMgr::*)( 409 const IRemoteCommand &remoteCommand, std::string &strResult); 410 411 // Parser descriptions 412 struct SRemoteCommandParserItem 413 { 414 const char *_pcCommandName; 415 CParameterMgr::RemoteCommandParser _pfnParser; 416 size_t _minArgumentCount; 417 const char *_pcHelp; 418 const char *_pcDescription; 419 }; 420 421 ////////////////:: Remote command parsers 422 /// Version 423 CCommandHandler::CommandStatus versionCommandProcess(const IRemoteCommand &remoteCommand, 424 std::string &strResult); 425 /// Status 426 CCommandHandler::CommandStatus statusCommandProcess(const IRemoteCommand &remoteCommand, 427 std::string &strResult); 428 /// Tuning Mode 429 CCommandHandler::CommandStatus setTuningModeCommandProcess(const IRemoteCommand &remoteCommand, 430 std::string &strResult); 431 CCommandHandler::CommandStatus getTuningModeCommandProcess(const IRemoteCommand &remoteCommand, 432 std::string &strResult); 433 /// Value Space 434 CCommandHandler::CommandStatus setValueSpaceCommandProcess(const IRemoteCommand &remoteCommand, 435 std::string &strResult); 436 CCommandHandler::CommandStatus getValueSpaceCommandProcess(const IRemoteCommand &remoteCommand, 437 std::string &strResult); 438 /// Output Raw Format 439 CCommandHandler::CommandStatus setOutputRawFormatCommandProcess( 440 const IRemoteCommand &remoteCommand, std::string &strResult); 441 CCommandHandler::CommandStatus getOutputRawFormatCommandProcess( 442 const IRemoteCommand &remoteCommand, std::string &strResult); 443 /// Sync 444 CCommandHandler::CommandStatus setAutoSyncCommandProcess(const IRemoteCommand &remoteCommand, 445 std::string &strResult); 446 CCommandHandler::CommandStatus getAutoSyncCommandProcess(const IRemoteCommand &remoteCommand, 447 std::string &strResult); 448 CCommandHandler::CommandStatus syncCommandProcess(const IRemoteCommand &remoteCommand, 449 std::string &strResult); 450 /// Criteria 451 CCommandHandler::CommandStatus listCriteriaCommandProcess(const IRemoteCommand &remoteCommand, 452 std::string &strResult); 453 /// Domains 454 CCommandHandler::CommandStatus listDomainsCommandProcess(const IRemoteCommand &remoteCommand, 455 std::string &strResult); 456 CCommandHandler::CommandStatus createDomainCommandProcess(const IRemoteCommand &remoteCommand, 457 std::string &strResult); 458 CCommandHandler::CommandStatus deleteDomainCommandProcess(const IRemoteCommand &remoteCommand, 459 std::string &strResult); 460 CCommandHandler::CommandStatus deleteAllDomainsCommandProcess( 461 const IRemoteCommand &remoteCommand, std::string &strResult); 462 CCommandHandler::CommandStatus renameDomainCommandProcess(const IRemoteCommand &remoteCommand, 463 std::string &strResult); 464 CCommandHandler::CommandStatus setSequenceAwarenessCommandProcess( 465 const IRemoteCommand &remoteCommand, std::string &strResult); 466 CCommandHandler::CommandStatus getSequenceAwarenessCommandProcess( 467 const IRemoteCommand &remoteCommand, std::string &strResult); 468 CCommandHandler::CommandStatus listDomainElementsCommandProcess( 469 const IRemoteCommand &remoteCommand, std::string &strResult); 470 CCommandHandler::CommandStatus addElementCommandProcess(const IRemoteCommand &remoteCommand, 471 std::string &strResult); 472 CCommandHandler::CommandStatus removeElementCommandProcess(const IRemoteCommand &remoteCommand, 473 std::string &strResult); 474 CCommandHandler::CommandStatus splitDomainCommandProcess(const IRemoteCommand &remoteCommand, 475 std::string &strResult); 476 /// Configurations 477 CCommandHandler::CommandStatus listConfigurationsCommandProcess( 478 const IRemoteCommand &remoteCommand, std::string &strResult); 479 CCommandHandler::CommandStatus dumpDomainsCommandProcess(const IRemoteCommand &remoteCommand, 480 std::string &strResult); 481 CCommandHandler::CommandStatus createConfigurationCommandProcess( 482 const IRemoteCommand &remoteCommand, std::string &strResult); 483 CCommandHandler::CommandStatus deleteConfigurationCommandProcess( 484 const IRemoteCommand &remoteCommand, std::string &strResult); 485 CCommandHandler::CommandStatus renameConfigurationCommandProcess( 486 const IRemoteCommand &remoteCommand, std::string &strResult); 487 CCommandHandler::CommandStatus saveConfigurationCommandProcess( 488 const IRemoteCommand &remoteCommand, std::string &strResult); 489 CCommandHandler::CommandStatus restoreConfigurationCommandProcess( 490 const IRemoteCommand &remoteCommand, std::string &strResult); 491 CCommandHandler::CommandStatus setElementSequenceCommandProcess( 492 const IRemoteCommand &remoteCommand, std::string &strResult); 493 CCommandHandler::CommandStatus getElementSequenceCommandProcess( 494 const IRemoteCommand &remoteCommand, std::string &strResult); 495 CCommandHandler::CommandStatus setRuleCommandProcess(const IRemoteCommand &remoteCommand, 496 std::string &strResult); 497 CCommandHandler::CommandStatus clearRuleCommandProcess(const IRemoteCommand &remoteCommand, 498 std::string &strResult); 499 CCommandHandler::CommandStatus getRuleCommandProcess(const IRemoteCommand &remoteCommand, 500 std::string &strResult); 501 /// Elements/Parameters 502 CCommandHandler::CommandStatus listElementsCommandProcess(const IRemoteCommand &remoteCommand, 503 std::string &strResult); 504 CCommandHandler::CommandStatus listParametersCommandProcess(const IRemoteCommand &remoteCommand, 505 std::string &strResult); 506 CCommandHandler::CommandStatus getElementStructureXMLCommandProcess( 507 const IRemoteCommand &remoteCommand, std::string &strResult); 508 CCommandHandler::CommandStatus getElementBytesCommandProcess( 509 const IRemoteCommand &remoteCommand, std::string &strResult); 510 CCommandHandler::CommandStatus setElementBytesCommandProcess( 511 const IRemoteCommand &remoteCommand, std::string &strResult); 512 CCommandHandler::CommandStatus getElementXMLCommandProcess(const IRemoteCommand &remoteCommand, 513 std::string &strResult); 514 CCommandHandler::CommandStatus setElementXMLCommandProcess(const IRemoteCommand &remoteCommand, 515 std::string &strResult); 516 CCommandHandler::CommandStatus dumpElementCommandProcess(const IRemoteCommand &remoteCommand, 517 std::string &strResult); 518 CCommandHandler::CommandStatus getElementSizeCommandProcess(const IRemoteCommand &remoteCommand, 519 std::string &strResult); 520 CCommandHandler::CommandStatus showPropertiesCommandProcess(const IRemoteCommand &remoteCommand, 521 std::string &strResult); 522 CCommandHandler::CommandStatus getParameterCommandProcess(const IRemoteCommand &remoteCommand, 523 std::string &strResult); 524 CCommandHandler::CommandStatus setParameterCommandProcess(const IRemoteCommand &remoteCommand, 525 std::string &strResult); 526 CCommandHandler::CommandStatus getConfigurationParameterCommandProcess( 527 const IRemoteCommand &remoteCommand, std::string &strResult); 528 CCommandHandler::CommandStatus setConfigurationParameterCommandProcess( 529 const IRemoteCommand &remoteCommand, std::string &strResult); 530 CCommandHandler::CommandStatus listBelongingDomainsCommandProcess( 531 const IRemoteCommand &remoteCommand, std::string &strResult); 532 CCommandHandler::CommandStatus listAssociatedDomainsCommandProcess( 533 const IRemoteCommand &remoteCommand, std::string &strResult); 534 CCommandHandler::CommandStatus showMappingCommandProcess(const IRemoteCommand &remoteCommand, 535 std::string &strResult); 536 /// Browse 537 CCommandHandler::CommandStatus listAssociatedElementsCommandProcess( 538 const IRemoteCommand &remoteCommand, std::string &strResult); 539 CCommandHandler::CommandStatus listConflictingElementsCommandProcess( 540 const IRemoteCommand &remoteCommand, std::string &strResult); 541 CCommandHandler::CommandStatus listRogueElementsCommandProcess( 542 const IRemoteCommand &remoteCommand, std::string &strResult); 543 /// Settings Import/Export 544 CCommandHandler::CommandStatus exportDomainsXMLCommandProcess( 545 const IRemoteCommand &remoteCommand, std::string &strResult); 546 CCommandHandler::CommandStatus importDomainsXMLCommandProcess( 547 const IRemoteCommand &remoteCommand, std::string &strResult); 548 CCommandHandler::CommandStatus exportDomainsWithSettingsXMLCommandProcess( 549 const IRemoteCommand &remoteCommand, std::string &strResult); 550 CCommandHandler::CommandStatus importDomainsWithSettingsXMLCommandProcess( 551 const IRemoteCommand &remoteCommand, std::string &strResult); 552 /** 553 * Command handler method for exportDomainWithSettingsXML command. 554 * 555 * @param[in] remoteCommand contains the arguments of the received command. 556 * @param[out] result a std::string containing the result of the command 557 * 558 * @return CCommandHandler::ESucceeded if command succeeded or CCommandHandler::EFailed 559 * in the other case 560 */ 561 CCommandHandler::CommandStatus exportDomainWithSettingsXMLCommandProcess( 562 const IRemoteCommand &remoteCommand, std::string &result); 563 CCommandHandler::CommandStatus importDomainWithSettingsXMLCommandProcess( 564 const IRemoteCommand &remoteCommand, std::string &strResult); 565 566 /** 567 * Command handler method for getDomainsWithSettings command. 568 * 569 * @param[in] remoteCommand contains the arguments of the received command. 570 * @param[out] strResult a std::string containing the result of the command 571 * 572 * @return CCommandHandler::ESucceeded if command succeeded or CCommandHandler::EFailed 573 * in the other case 574 */ 575 CCommandHandler::CommandStatus getDomainsWithSettingsXMLCommandProcess( 576 const IRemoteCommand &remoteCommand, std::string &strResult); 577 578 /** 579 * Command handler method for getDomainWithSettings command. 580 * 581 * @param[in] remoteCommand contains the arguments of the received command. 582 * @param[out] strResult a string containing the result of the command 583 * 584 * @return CCommandHandler::ESucceeded if command succeeded or CCommandHandler::EFailed 585 * in the other case 586 */ 587 CCommandHandler::CommandStatus getDomainWithSettingsXMLCommandProcess( 588 const IRemoteCommand &remoteCommand, std::string &strResult); 589 590 /** 591 * Command handler method for setDomainsWithSettings command. 592 * 593 * @param[in] remoteCommand contains the arguments of the received command. 594 * @param[out] strResult a std::string containing the result of the command 595 * 596 * @return CCommandHandler::ESucceeded if command succeeded or CCommandHandler::EFailed 597 * in the other case 598 */ 599 CCommandHandler::CommandStatus setDomainsWithSettingsXMLCommandProcess( 600 const IRemoteCommand &remoteCommand, std::string &strResult); 601 602 /** 603 * Command handler method for setDomainWithSettings command. 604 * 605 * @param[in] remoteCommand contains the arguments of the received command. 606 * @param[out] result a std::string containing the result of the command 607 * 608 * @return CCommandHandler::ESucceeded if command succeeded or CCommandHandler::EFailed 609 * in the other case 610 */ 611 CCommandHandler::CommandStatus setDomainWithSettingsXMLCommandProcess( 612 const IRemoteCommand &remoteCommand, std::string &result); 613 614 /** 615 * Command handler method for getSystemClass command. 616 * 617 * @param[in] remoteCommand contains the arguments of the received command. 618 * @param[out] strResult a std::string containing the result of the command 619 * 620 * @return CCommandHandler::ESucceeded if command succeeded or CCommandHandler::EFailed 621 * in the other case 622 */ 623 CCommandHandler::CommandStatus getSystemClassXMLCommandProcess( 624 const IRemoteCommand &remoteCommand, std::string &strResult); 625 626 // Max command usage length, use for formatting 627 void setMaxCommandUsageLength(); 628 629 // For tuning, check we're in tuning mode 630 bool checkTuningModeOn(std::string &strError) const; 631 632 // Blackboard (dynamic parameter handling) 633 std::mutex &getBlackboardMutex(); 634 635 // Blackboard reference (dynamic parameter handling) 636 CParameterBlackboard *getParameterBlackboard(); 637 638 // Parameter access 639 bool accessValue(CParameterAccessContext ¶meterAccessContext, const std::string &strPath, 640 std::string &strValue, bool bSet, std::string &strError); 641 bool doSetValue(const std::string &strPath, const std::string &strValue, bool bRawValueSpace, 642 bool bDynamicAccess, std::string &strError) const; 643 bool doGetValue(const std::string &strPath, std::string &strValue, bool bRawValueSpace, 644 bool bHexOutputRawFormat, bool bDynamicAccess, std::string &strError) const; 645 646 // Framework global configuration loading 647 bool loadFrameworkConfiguration(std::string &strError); 648 649 /** Load required subsystems 650 * 651 * @param[out] error error description if there is one 652 * @return true if succeed false otherwise 653 */ 654 bool loadSubsystems(std::string &error); 655 656 // System class Structure loading 657 bool loadStructure(std::string &strError); 658 659 // System class Structure loading 660 bool loadSettings(std::string &strError); 661 bool loadSettingsFromConfigFile(std::string &strError); 662 663 /** Get settings from a configurable element in binary format. 664 * 665 * @param[in] element configurable element. 666 * @param[out] settings current element settings (in mainblackboard) in binary format 667 * 668 * @return true on success, false on error 669 */ 670 void getSettingsAsBytes(const CConfigurableElement &element, 671 std::vector<uint8_t> &settings) const; 672 673 /** Assign settings to a configurable element in binary format. 674 * 675 * @param[in] element configurable element. 676 * @param[in] settings the settings as byte array (binary). 677 * @param[out] error error message filled in case of error 678 * 679 * @return true in case of success, false oherwise, in which case error is filled with error 680 * message. 681 */ 682 bool setSettingsAsBytes(const CConfigurableElement &element, 683 const std::vector<uint8_t> &settings, std::string &error); 684 685 /** Assign settings to a configurable element in XML format. 686 * 687 * @param[in] configurableElement The element to set. 688 * @param[in] settings The settings to set. 689 * @param[out] error human readable error message filled in case of error, 690 * undefined in case of success. 691 * @return true in case of success, false otherwise 692 */ 693 bool setSettingsAsXML(CConfigurableElement *configurableElement, const std::string &settings, 694 std::string &error); 695 696 /** Get settings from a configurable element in XML format. 697 * 698 * @param[in] configurableElement The element to get settings from. 699 * @param[out] result on success: the exported setttings in XML 700 * on error: human readable error message 701 * 702 * @return true in case of success, false otherwise. 703 */ 704 bool getSettingsAsXML(const CConfigurableElement *configurableElement, 705 std::string &result) const; 706 707 /** Parse an XML stream into an element 708 * 709 * @param[in] elementSerializingContext serializing context 710 * @param[out] pRootElement the receiving element 711 * @param[in] input the input XML stream 712 * @param[in] baseUri the XML input file URI or "" 713 * @param[in] eElementLibrary which element library to be used 714 * @param[in] replace Should the element be overridden or modified in place 715 * @param[in] strNameAttributeName the name of the element's XML "name" attribute 716 * 717 * @returns true if parsing succeeded, false otherwise 718 */ 719 bool xmlParse(CXmlElementSerializingContext &elementSerializingContext, CElement *pRootElement, 720 _xmlDoc *doc, const std::string &baseUri, ElementLibrary eElementLibrary, 721 bool replace = true, const std::string &strNameAttributeName = "Name"); 722 723 /** Wrapper for converting public APIs semantics to internal API 724 * 725 * Public APIs have a string argument that can either contain: 726 * - a path to an XML file or; 727 * - an actual XML document. 728 * They also have a boolean argument specifying which of the two cases it 729 * is. 730 * 731 * Instead, the internal APIs only take an std::istream argument. This 732 * method opens the file as a stream if applicable or simply wrap the 733 * string in a stream. It then passes the stream to the internal methods. 734 * 735 * @param[in] xmlSource the XML source (either a path or an actual xml 736 * document) 737 * @param[in] fromFile specifies whether xmlSource is a path or an 738 * actual XML document 739 * @param[in] withSettings if false, only import the configurations 740 * applicability rules; if true, also import their settings 741 * @param[out] element the receiving element 742 * @param[in] nameAttributeName the name of the element's XML "name" 743 * attribute 744 * @param[out] errorMsg string used as output for any error message 745 * 746 * @returns true if the import succeeded, false otherwise 747 */ 748 bool wrapLegacyXmlImport(const std::string &xmlSource, bool fromFile, bool withSettings, 749 CElement &element, const std::string &nameAttributeName, 750 std::string &errorMsg); 751 752 /** 753 * Export an element object to an Xml destination. 754 * 755 * 756 * @param[out] output the stream to output the XML to 757 * @param[in] xmlSerializingContext the serializing context 758 * @param[in] element object to be serialized. 759 * 760 * @return false if any error occurs, true otherwise. 761 */ 762 bool serializeElement(std::ostream &output, CXmlSerializingContext &xmlSerializingContext, 763 const CElement &element) const; 764 765 /** Wrapper for converting public APIs semantics to internal API 766 * 767 * Public APIs have a string argument that can either: 768 * - contain a path to an XML file or; 769 * - receive an actual XML document. 770 * They also have a boolean argument specifying which of the two cases it 771 * is. 772 * 773 * Instead, the internal APIs only take an std::ostream argument. This 774 * method opens the file as a stream if applicable or simply wrap the 775 * string in a stream. It then passes the stream to the internal methods. 776 * 777 * @param[in] xmlDest the XML sink (either a path or any string that 778 * will be filled) 779 * @param[in] toFile specifies whether xmlSource is a path or a 780 * string that will receive an actual XML document 781 * @param[in] withSettings if false, only export the configurations 782 * applicability rules; if true, also export their settings 783 * @param[out] element the element to be exported 784 * @param[out] errorMsg string used as output for any error message 785 * 786 * @returns true if the export succeeded, false otherwise 787 */ 788 bool wrapLegacyXmlExport(std::string &xmlDest, bool toFile, bool withSettings, 789 const CElement &element, std::string &errorMsg) const; 790 791 /** Wrapper for converting public APIs semantics to internal API 792 * 793 * @see wrapLegacyXmlExport 794 */ 795 bool wrapLegacyXmlExportToFile(std::string &xmlDest, const CElement &element, 796 CXmlDomainExportContext &context) const; 797 798 /** Wrapper for converting public APIs semantics to internal API 799 * 800 * @see wrapLegacyXmlExport 801 */ 802 bool wrapLegacyXmlExportToString(std::string &xmlDest, const CElement &element, 803 CXmlDomainExportContext &context) const; 804 805 // Framework Configuration 806 CParameterFrameworkConfiguration *getFrameworkConfiguration(); 807 const CParameterFrameworkConfiguration *getConstFrameworkConfiguration(); 808 809 // Selection Criteria 810 CSelectionCriteria *getSelectionCriteria(); 811 const CSelectionCriteria *getConstSelectionCriteria(); 812 813 // System Class 814 CSystemClass *getSystemClass(); 815 const CSystemClass *getConstSystemClass() const; 816 817 // Configurable Domains 818 CConfigurableDomains *getConfigurableDomains(); 819 const CConfigurableDomains *getConstConfigurableDomains(); 820 const CConfigurableDomains *getConstConfigurableDomains() const; 821 822 // Apply configurations 823 void doApplyConfigurations(bool bForce); 824 825 // Dynamic object creation libraries feeding 826 void feedElementLibraries(); 827 828 // Remote Processor Server connection handling 829 bool isRemoteInterfaceRequired(); 830 bool handleRemoteProcessingInterface(std::string &strError); 831 832 /** Log the result of a function 833 * 834 * @param[in] isSuccess indicates if the previous function has succeed 835 * @param[in] result function provided result string 836 * @return isSuccess parameter 837 */ 838 bool logResult(bool isSuccess, const std::string &result); 839 840 /** Info logger call helper */ 841 inline core::log::details::Info info(); 842 843 /** Warning logger call helper */ 844 inline core::log::details::Warning warning(); 845 846 // Tuning 847 bool _bTuningModeIsOn{false}; 848 849 // Value Space 850 bool _bValueSpaceIsRaw{false}; 851 852 // Output Raw Format 853 bool _bOutputRawFormatIsHex{false}; 854 855 // Automatic synchronization to HW during Tuning session 856 bool _bAutoSyncOn{true}; 857 858 // Current Parameter Settings 859 CParameterBlackboard *_pMainParameterBlackboard; 860 861 // Dynamic object creation 862 CElementLibrarySet *_pElementLibrarySet; 863 864 // XML parsing, object creation handling 865 std::string _xmlConfigurationUri; 866 std::string _schemaUri; // Place where schemas stand 867 868 // Subsystem plugin location 869 const CSubsystemPlugins *_pSubsystemPlugins{nullptr}; 870 871 // Remote Processor Server 872 IRemoteProcessorServerInterface *_pRemoteProcessorServer{nullptr}; 873 874 // Parser description array 875 static const SRemoteCommandParserItem gastRemoteCommandParserItems[]; 876 877 // Maximum command usage length 878 size_t _maxCommandUsageLength{0}; 879 880 // Blackboard access mutex 881 std::mutex _blackboardMutex; 882 883 /** Application main logger based on the one provided by the client */ 884 mutable core::log::Logger _logger; 885 886 /** If set to false, the remote interface won't be started no matter what. 887 * If set to true - the default - it has no impact on the policy for 888 * starting the remote interface. 889 */ 890 bool _bForceNoRemoteInterface{false}; 891 892 /** If set to true, missing subsystem will abort parameterMgr start. 893 * If set to false, missing subsystem will fallback on virtual subsystem. 894 */ 895 bool _bFailOnMissingSubsystem{true}; 896 /** If set to true, unparsable or discording domains will abort parameterMgr start. 897 * If set to false, unparsable or discording domains 898 * will continue the parameterMgr start with no domains. 899 */ 900 bool _bFailOnFailedSettingsLoad{true}; 901 902 /** 903 * If set to true, parameterMgr will report an error 904 * when being unable to validate .xml files 905 * If set to false, no .xml/xsd validation will happen (default behaviour) 906 */ 907 bool _bValidateSchemasOnStart{false}; 908}; 909