QTestConfigurationParser.cc

Go to the documentation of this file.

#include "DQMServices/ClientConfig/interface/QTestConfigurationParser.h"
#include "DQMServices/ClientConfig/interface/QTestParameterNames.h"
#include "DQMServices/ClientConfig/interface/ParserFunctions.h"
#include <cstring>
#include <stdexcept>
using namespace xercesc;

int QTestConfigurationParser::s_numberOfInstances = 0;

QTestConfigurationParser::QTestConfigurationParser() {
  qtestParamNames = new QTestParameterNames();

  try {
    if (s_numberOfInstances == 0)
      cms::concurrency::xercesInitialize();
  } catch (const XMLException &e) {
    throw(std::runtime_error("Standard pool exception : Fatal Error on pool::TrivialFileCatalog"));
  }

  ++s_numberOfInstances;
}

QTestConfigurationParser::~QTestConfigurationParser() {
  delete qtestParamNames;
  qtestParamNames = nullptr;
}

bool QTestConfigurationParser::parseQTestsConfiguration() {
  testsToDisable.clear();
  testsRequested.clear();
  mapMonitorElementTests.clear();
  bool qtErrors = this->qtestsConfig();
  bool meErrors = this->monitorElementTestsMap();
  return (qtErrors || meErrors);
}

bool QTestConfigurationParser::qtestsConfig() {
  std::string testActivationOFF = "false";

  unsigned int qtestTagsNum = doc()->getElementsByTagName(qtxml::_toDOMS("QTEST"))->getLength();

  for (unsigned int i = 0; i < qtestTagsNum; ++i) {
    DOMNode *qtestNode = doc()->getElementsByTagName(qtxml::_toDOMS("QTEST"))->item(i);

    if (!qtestNode) {
      return true;
    }
    DOMElement *qtestElement = static_cast<DOMElement *>(qtestNode);
    if (!qtestElement) {
      return true;
    }
    std::string qtestName = qtxml::_toString(qtestElement->getAttribute(qtxml::_toDOMS("name")));
    std::string activate = qtxml::_toString(qtestElement->getAttribute(qtxml::_toDOMS("activate")));
    if (!std::strcmp(activate.c_str(), testActivationOFF.c_str())) {
      testsToDisable.push_back(qtestName);
    } else {
      DOMNodeList *typeNodePrefix = qtestElement->getElementsByTagName(qtxml::_toDOMS("TYPE"));

      if (typeNodePrefix->getLength() != 1)
        return true;

      DOMElement *prefixNode = dynamic_cast<DOMElement *>(typeNodePrefix->item(0));
      if (!prefixNode)
        return true;

      DOMText *prefixText = dynamic_cast<DOMText *>(prefixNode->getFirstChild());
      if (!prefixText)
        return true;

      std::string qtestType = qtxml::_toString(prefixText->getData());

      testsRequested[qtestName] = this->getParams(qtestElement, qtestType);

      if (this->checkParameters(qtestName, qtestType))
        return true;
    }

  }  //loop on qtestTagsNum

  return false;
}

std::map<std::string, std::string> QTestConfigurationParser::getParams(DOMElement *qtestElement,
                                                                       std::string qtestType) {
  std::map<std::string, std::string> paramNamesValues;
  paramNamesValues["type"] = qtestType;

  DOMNodeList *arguments = qtestElement->getElementsByTagName(qtxml::_toDOMS("PARAM"));

  for (unsigned int i = 0; i < arguments->getLength(); ++i) {
    DOMElement *argNode = dynamic_cast<DOMElement *>(arguments->item(i));
    std::string regExp = qtxml::_toString(argNode->getAttribute(qtxml::_toDOMS("name")));
    DOMText *argText = dynamic_cast<DOMText *>(argNode->getFirstChild());
    if (!argText) {
      break;
    }

    std::string regExpValue = qtxml::_toString(argText->getData());
    paramNamesValues[regExp] = regExpValue;
  }

  return paramNamesValues;
}

bool QTestConfigurationParser::checkParameters(std::string qtestName, std::string qtestType) {
  std::vector<std::string> paramNames = qtestParamNames->getTestParamNames(qtestType);
  // commenting out as does not seem to be logical SDutta 22/3/2013
  /*if(paramNames.size() == 0) {

        return true;
        }*/

  paramNames.push_back("error");
  paramNames.push_back("warning");

  std::map<std::string, std::string> namesMap = testsRequested[qtestName];

  for (std::vector<std::string>::iterator namesItr = paramNames.begin(); namesItr != paramNames.end(); ++namesItr) {
    if (namesMap.find(*namesItr) == namesMap.end()) {
      return true;
    }
  }

  return false;
}

bool QTestConfigurationParser::monitorElementTestsMap() {
  std::string testON = "true";
  std::string testOFF = "false";

  unsigned int linkTagsNum = doc()->getElementsByTagName(qtxml::_toDOMS("LINK"))->getLength();

  for (unsigned int i = 0; i < linkTagsNum; ++i) {
    DOMNode *linkNode = doc()->getElementsByTagName(qtxml::_toDOMS("LINK"))->item(i);
    if (!linkNode) {
      return true;
    }
    DOMElement *linkElement = static_cast<DOMElement *>(linkNode);
    if (!linkElement) {
      return true;
    }
    std::string linkName = qtxml::_toString(linkElement->getAttribute(qtxml::_toDOMS("name")));

    DOMNodeList *testList = linkElement->getElementsByTagName(qtxml::_toDOMS("TestName"));
    unsigned int numberOfTests = testList->getLength();

    std::vector<std::string> qualityTestList;
    for (unsigned int tt = 0; tt < numberOfTests; ++tt) {
      DOMElement *testElement = dynamic_cast<DOMElement *>(testList->item(tt));
      if (!testElement) {
        return true;
      }

      std::string activate = qtxml::_toString(testElement->getAttribute(qtxml::_toDOMS("activate")));

      DOMText *argText = dynamic_cast<DOMText *>(testElement->getFirstChild());

      if (!std::strcmp(activate.c_str(), testON.c_str())) {
        if (!argText) {
          return true;
        } else {
          std::string regExpValue = qtxml::_toString(argText->getData());
          qualityTestList.push_back(regExpValue);
        }
      }
      if (!std::strcmp(activate.c_str(), testOFF.c_str())) {
        if (argText) {
          std::string regExpValue = qtxml::_toString(argText->getData());
          // Create List of QTests to unattach from current ME
        }
      }
    }

    if (!qualityTestList.empty())
      mapMonitorElementTests[linkName] = qualityTestList;
  }  

  return false;
}