cond::XMLAuthenticationService::XMLAuthenticationService Class Reference

#include <XMLAuthenticationService.h>

Inheritance diagram for cond::XMLAuthenticationService::XMLAuthenticationService:

Public Member Functions
const coral::IAuthenticationCredentials &	credentials (const std::string &connectionString) const override
const coral::IAuthenticationCredentials &	credentials (const std::string &connectionString, const std::string &role) const override
void	setAuthenticationPath (const std::string &inputPath)
	Sets the input file name. More...
	XMLAuthenticationService (const std::string &name)
	Standard Constructor. More...
	~XMLAuthenticationService () override
	Standard Destructor. More...

Private Member Functions
bool	initialize ()
	Service framework related initialization. More...
bool	processFile (const std::string &inputFileName)
	Parses an xml file. More...
void	reset ()
	Reset parsed data. More...
std::set< std::string >	verifyFileName ()
	Verifies the existence of the authentication files. More...

Private Attributes
coral::Property::CallbackID	m_callbackID
std::map< std::string, DataSourceEntry * >	m_data
	The structure with the authentication data. More...
std::string	m_inputFileName
	The input file with the data. More...
bool	m_isInitialized
	Flag indicating whether the service has been initialized. More...
boost::mutex	m_mutexLock
	the mutex lock More...

Detailed Description

Definition at line 80 of file XMLAuthenticationService.h.

Constructor & Destructor Documentation

XMLAuthenticationService()

cond::XMLAuthenticationService::XMLAuthenticationService::XMLAuthenticationService ( const std::string &  name )

explicit

Standard Constructor.

Definition at line 77 of file XMLAuthenticationService.cc.

    : coral::Service(key), m_isInitialized(false), m_inputFileName(""), m_data(), m_mutexLock(), m_callbackID(0) {
  boost::function1<void, std::string> cb(std::bind(
      &cond::XMLAuthenticationService::XMLAuthenticationService::setAuthenticationPath, this, std::placeholders::_1));
 
  coral::Property* pm = dynamic_cast<coral::Property*>(
      coral::Context::instance().PropertyManager().property(auth::COND_AUTH_PATH_PROPERTY));
  if (pm) {
    setAuthenticationPath(pm->get());
    m_callbackID = pm->registerCallback(cb);
  }
}

References cond::auth::COND_AUTH_PATH_PROPERTY, instance, m_callbackID, and setAuthenticationPath().

~XMLAuthenticationService()

cond::XMLAuthenticationService::XMLAuthenticationService::~XMLAuthenticationService ( )

override

Standard Destructor.

Definition at line 90 of file XMLAuthenticationService.cc.

                                                                                {
  for (std::map<std::string, cond::XMLAuthenticationService::DataSourceEntry*>::iterator iConnection = m_data.begin();
       iConnection != m_data.end();
       ++iConnection)
    delete iConnection->second;
}

Member Function Documentation

credentials() [1/2]

const coral::IAuthenticationCredentials & cond::XMLAuthenticationService::XMLAuthenticationService::credentials ( const std::string &  connectionString ) const

override

Returns a reference to the credentials object for a given connection string. If the connection string is not known to the service an UnknownConnectionException is thrown.

Definition at line 346 of file XMLAuthenticationService.cc.

                                             {
  boost::mutex::scoped_lock lock(m_mutexLock);
  if (!m_isInitialized) {
    const_cast<cond::XMLAuthenticationService::XMLAuthenticationService*>(this)->initialize();
  }
  std::map<std::string, cond::XMLAuthenticationService::DataSourceEntry*>::const_iterator iConnection =
      m_data.find(connectionString);
  if (iConnection == m_data.end())
    throw coral::UnknownConnectionException(this->name(), connectionString);
  return iConnection->second->credentials();
}

References l1RCTOmdsFedVectorProducer_cfi::connectionString, CommonMethods::lock(), and Skims_PA_cff::name.

credentials() [2/2]

const coral::IAuthenticationCredentials & cond::XMLAuthenticationService::XMLAuthenticationService::credentials ( const std::string &  connectionString, const std::string &  role  ) const

override

Returns a reference to the credentials object for a given connection string. If the connection string is not known to the service an UnknownConnectionException is thrown. If the role is not known to the service an UnknownRoleException is thrown.

Definition at line 359 of file XMLAuthenticationService.cc.

                                                                    {
  boost::mutex::scoped_lock lock(m_mutexLock);
  if (!m_isInitialized) {
    const_cast<cond::XMLAuthenticationService::XMLAuthenticationService*>(this)->initialize();
  }
  std::map<std::string, cond::XMLAuthenticationService::DataSourceEntry*>::const_iterator iConnection =
      m_data.find(connectionString);
  if (iConnection == m_data.end())
    throw coral::UnknownConnectionException(this->name(), connectionString);
  return iConnection->second->credentials(role);
}

References l1RCTOmdsFedVectorProducer_cfi::connectionString, CommonMethods::lock(), and Skims_PA_cff::name.

initialize()

bool cond::XMLAuthenticationService::XMLAuthenticationService::initialize ( )

private

Service framework related initialization.

Definition at line 299 of file XMLAuthenticationService.cc.

                                                                      {
  coral::MessageStream log("cond::XMLAuthenticationService::initialize");
  std::set<std::string> inputFileNames = this->verifyFileName();
  if (inputFileNames.empty()) {
    //seal::MessageStream log( this, this->name(),seal::Msg::Verbose );
    //std::cout<< "Could not open \"" << m_inputFileName << "\" for reading" << std::endl;
    log << coral::Debug << "Could not open \"" << m_inputFileName << "\" for reading" << coral::MessageStream::endmsg;
    return false;
  }
 
  try {
    cms::concurrency::xercesInitialize();
  } catch (const xercesc::XMLException& toCatch) {
    char* message = xercesc::XMLString::transcode(toCatch.getMessage());
    //seal::MessageStream log( this, this->name(),seal::Msg::Verbose );
    //log << seal::Msg::Error << message << seal::flush;
    log << coral::Error << std::string(message) << coral::MessageStream::endmsg;
    xercesc::XMLString::release(&message);
    return false;
  }
 
  bool result = false;
  for (std::set<std::string>::const_reverse_iterator iFileName = inputFileNames.rbegin();
       iFileName != inputFileNames.rend();
       ++iFileName) {
    if (this->processFile(*iFileName)) {
      result = true;
    }
  }
 
  cms::concurrency::xercesTerminate();
 
  m_isInitialized = result;
  if (!m_isInitialized)
    reset();
  return result;
}

References Debug, mitigatedMETSequence_cff::inputFileNames, dqm-mbProfile::log, fetchall_from_DQM_v2::release, reset(), mps_fire::result, AlCaHLTBitMon_QueryRunRegistry::string, cms::concurrency::xercesInitialize(), and cms::concurrency::xercesTerminate().

processFile()

bool cond::XMLAuthenticationService::XMLAuthenticationService::processFile ( const std::string &  inputFileName )

private

Parses an xml file.

if(name!=XML_AUTHENTICATION_FILE){ cond::DecodingKey key; try{ key.readUserKeyString(cont); log << coral::Debug << "Decoding content of file \""<< key.dataSource()<<"""<<coral::MessageStream::endmsg; cond::FileReader dataFile; dataFile.read(key.dataSource()); cont = dataFile.content(); cont = coral::Cipher::decode(cont,key.key());
} catch (const cond::Exception& exc){ log << coral::Error << std::string(exc.what())<<coral::MessageStream::endmsg; return false; }

} else { seal::MessageStream log( this, this->name(),seal::Msg::Verbose ); log<<coral::Debug<< "Authentication file is expected standard XML."<<coral::MessageStream::endmsg; }

Definition at line 107 of file XMLAuthenticationService.cc.

                                                                                                     {
  coral::MessageStream log("cond::XMLAuthenticationService::processFile");
  //std::cout<< "Processing file \""<< inputFileName<<"\"" <<std::endl;
  bool result = true;
 
  cond::FileReader inputFile;
  std::string cont("");
  try {
    inputFile.read(inputFileName);
    cont = inputFile.content();
  } catch (const cond::Exception& exc) {
    log << coral::Error << "File \"" << inputFileName << "\" not found." << std::string(exc.what())
        << coral::MessageStream::endmsg;
    return false;
  }
 
  std::filesystem::path filePath(inputFileName);
  std::string name = filePath.filename().string();
 
  xercesc::MemBufInputSource* memBufInputSource = nullptr;
 
  try {
    xercesc::XercesDOMParser parser;
    parser.setValidationScheme(xercesc::XercesDOMParser::Val_Always);
    parser.setDoNamespaces(true);
 
    xercesc::HandlerBase errorHandler;
    parser.setErrorHandler(&errorHandler);
 
    const char* bufferId = "InMemoryDocument";
    const char* buffer = cont.c_str();
 
    memBufInputSource = new xercesc::MemBufInputSource((const XMLByte*)buffer, strlen(buffer), bufferId, false);
 
    parser.parse(*memBufInputSource);
 
    xercesc::DOMDocument* document = parser.getDocument();
 
    XMLCh tempStr[20];
    xercesc::XMLString::transcode("connection", tempStr, 19);
 
    xercesc::DOMNodeList* connectionList = document->getElementsByTagName(tempStr);
 
    if (connectionList) {
      XMLSize_t numberOfConnections = connectionList->getLength();
 
      for (XMLSize_t iConnection = 0; iConnection < numberOfConnections; ++iConnection) {
        xercesc::DOMNode* connectionNode = connectionList->item(iConnection);
 
        if (connectionNode) {
          char* connectionName =
              xercesc::XMLString::transcode(connectionNode->getAttributes()->item(0)->getNodeValue());
          std::string sConnectionName = connectionName;
          xercesc::XMLString::release(&connectionName);
 
          // Locate the credential
          cond::XMLAuthenticationService::DataSourceEntry* credential = nullptr;
          std::map<std::string, cond::XMLAuthenticationService::DataSourceEntry*>::iterator iConnection =
              m_data.find(sConnectionName);
          if (iConnection != m_data.end()) {
            credential = iConnection->second;
            // Issue a warning here.
            //coral::MessageStream log( this, this->name(),seal::Msg::Verbose );
            log << coral::Debug << "Credential parameters for connection string \"" << sConnectionName
                << "\" have already been defined. Only new elements are appended, while existing will be ignored."
                << coral::MessageStream::endmsg;
          } else {
            credential = new cond::XMLAuthenticationService::DataSourceEntry(this->name(), sConnectionName);
            m_data.insert(std::make_pair(sConnectionName, credential));
          }
 
          xercesc::DOMNodeList* parameterList = connectionNode->getChildNodes();
 
          if (parameterList) {
            XMLSize_t numberOfParameters = parameterList->getLength();
 
            for (XMLSize_t iParameter = 0; iParameter < numberOfParameters; ++iParameter) {
              xercesc::DOMNode* parameterNode = parameterList->item(iParameter);
 
              if (parameterNode && parameterNode->getNodeType() == xercesc::DOMNode::ELEMENT_NODE) {
                char* nodeName = xercesc::XMLString::transcode(parameterNode->getNodeName());
                std::string sNodeName = nodeName;
                xercesc::XMLString::release(&nodeName);
 
                if (sNodeName == "parameter") {  // The default parameters
                  char* parameterName =
                      xercesc::XMLString::transcode(parameterNode->getAttributes()->item(0)->getNodeValue());
                  std::string sParameterName = parameterName;
                  xercesc::XMLString::release(&parameterName);
                  char* parameterValue =
                      xercesc::XMLString::transcode(parameterNode->getAttributes()->item(1)->getNodeValue());
                  std::string sParameterValue = parameterValue;
                  xercesc::XMLString::release(&parameterValue);
 
                  credential->appendCredentialItem(sParameterName, sParameterValue);
                } else if (sNodeName == "role") {  // A role
                  char* roleName =
                      xercesc::XMLString::transcode(parameterNode->getAttributes()->item(0)->getNodeValue());
                  std::string sRoleName = roleName;
                  xercesc::XMLString::release(&roleName);
 
                  // Retrieve the parameters for the role
                  xercesc::DOMNodeList* roleParameterList = parameterNode->getChildNodes();
 
                  if (roleParameterList) {
                    XMLSize_t numberOfRoleParameters = roleParameterList->getLength();
 
                    for (XMLSize_t iRoleParameter = 0; iRoleParameter < numberOfRoleParameters; ++iRoleParameter) {
                      xercesc::DOMNode* roleParameterNode = roleParameterList->item(iRoleParameter);
                      if (roleParameterNode && roleParameterNode->getNodeType() == xercesc::DOMNode::ELEMENT_NODE) {
                        char* roleNodeName = xercesc::XMLString::transcode(roleParameterNode->getNodeName());
                        std::string sRoleNodeName = roleNodeName;
                        xercesc::XMLString::release(&roleNodeName);
 
                        if (sRoleNodeName == "parameter") {
                          char* roleParameterName = xercesc::XMLString::transcode(
                              roleParameterNode->getAttributes()->item(0)->getNodeValue());
                          std::string sRoleParameterName = roleParameterName;
                          xercesc::XMLString::release(&roleParameterName);
                          char* roleParameterValue = xercesc::XMLString::transcode(
                              roleParameterNode->getAttributes()->item(1)->getNodeValue());
                          std::string sRoleParameterValue = roleParameterValue;
                          xercesc::XMLString::release(&roleParameterValue);
 
                          credential->appendCredentialItemForRole(sRoleParameterName, sRoleParameterValue, sRoleName);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
 
    parser.reset();
  } catch (const xercesc::XMLException& toCatch) {
    char* message = xercesc::XMLString::transcode(toCatch.getMessage());
    //coral::MessageStream log( this, this->name(),coral::Msg::Verbose );
    //log << coral::Msg::Error << message << coral::flush;
    log << coral::Error << std::string(message) << coral::MessageStream::endmsg;
    xercesc::XMLString::release(&message);
    result = false;
  } catch (const xercesc::DOMException& toCatch) {
    char* message = xercesc::XMLString::transcode(toCatch.msg);
    //seal::MessageStream log( this, this->name(),seal::Msg::Verbose );
    //log << seal::Msg::Error << message << seal::flush;
    log << coral::Error << std::string(message) << coral::MessageStream::endmsg;
    xercesc::XMLString::release(&message);
    result = false;
  } catch (const xercesc::SAXException& toCatch) {
    char* message = xercesc::XMLString::transcode(toCatch.getMessage());
    //seal::MessageStream log( this, this->name(),seal::Msg::Verbose );
    //log << seal::Msg::Error << message << seal::flush;
    log << coral::Error << std::string(message) << coral::MessageStream::endmsg;
    xercesc::XMLString::release(&message);
    result = false;
  } catch (...) {
    //seal::MessageStream log( this, this->name(),seal::Msg::Verbose );
    //log << seal::Msg::Error << "Unexpected Exception parsing file \"" << inputFileName << "\"" << seal::flush;
    log << coral::Error << "Unexpected Exception parsing file \"" << inputFileName << "\""
        << coral::MessageStream::endmsg;
    result = false;
  }
  if (memBufInputSource)
    delete memBufInputSource;
  return result;
}

References cond::XMLAuthenticationService::DataSourceEntry::appendCredentialItem(), cond::XMLAuthenticationService::DataSourceEntry::appendCredentialItemForRole(), edmScanValgrind::buffer, generateEDF::cont, Debug, dt4ml_dqm_sourceclient-live_cfg::filePath, dtResolutionTest_cfi::inputFile, InefficientDoubleROC::inputFileName, dqm-mbProfile::log, Skims_PA_cff::name, Herwig7_Dummy_ReadLHE_GEN_SIM::numberOfParameters, writedatasetfile::parser, castor_dqm_sourceclient_file_cfg::path, fetchall_from_DQM_v2::release, mps_fire::result, AlCaHLTBitMon_QueryRunRegistry::string, and cms::Exception::what().

reset()

void cond::XMLAuthenticationService::XMLAuthenticationService::reset ( void  )

private

Reset parsed data.

Definition at line 337 of file XMLAuthenticationService.cc.

                                                                 {
  for (std::map<std::string, cond::XMLAuthenticationService::DataSourceEntry*>::iterator iConnection = m_data.begin();
       iConnection != m_data.end();
       ++iConnection)
    delete iConnection->second;
  m_data.clear();
  m_isInitialized = false;
}

Referenced by MatrixReader.MatrixReader::__init__(), data_sources.json_list::next(), and MatrixReader.MatrixReader::showRaw().

setAuthenticationPath()

void cond::XMLAuthenticationService::XMLAuthenticationService::setAuthenticationPath

(

const std::string &

inputPath

)

Sets the input file name.

Definition at line 97 of file XMLAuthenticationService.cc.

                                                                                                           {
  std::filesystem::path AuthPath(inputPath);
  if (std::filesystem::is_directory(AuthPath)) {
    AuthPath /= std::filesystem::path(XML_AUTHENTICATION_FILE);
  }
 
  m_inputFileName = AuthPath.string();
  reset();
}

References SiStripCommissioningSource_FromEDM_cfg::inputPath, castor_dqm_sourceclient_file_cfg::path, reset(), and XML_AUTHENTICATION_FILE.

Referenced by XMLAuthenticationService().

verifyFileName()

std::set< std::string > cond::XMLAuthenticationService::XMLAuthenticationService::verifyFileName ( )

private

Verifies the existence of the authentication files.

Definition at line 372 of file XMLAuthenticationService.cc.

                                                                                       {
  coral::MessageStream log("cond::XMLAuthenticationService::verifyFileName");
  std::set<std::string> fileNames;
 
  // Try the file name as is...
  std::filesystem::path filePath(m_inputFileName);
  if (std::filesystem::exists(m_inputFileName)) {
    if (std::filesystem::is_directory(m_inputFileName)) {
      //seal::MessageStream log( this, this->name(),seal::Msg::Verbose );
      log << coral::Error << "Provided path \"" << m_inputFileName << "\" is a directory."
          << coral::MessageStream::endmsg;
      return fileNames;
    }
    std::filesystem::path fullPath = filePath.lexically_normal();
    fileNames.insert(fullPath.string());
    if (filePath.is_absolute())
      return fileNames;
  }
 
  // Try to find other files in the path variable
  const char* thePathVariable = std::getenv("CORAL_AUTH_PATH");
  if (!thePathVariable)
    return fileNames;
  log << coral::Debug << "File \"" << m_inputFileName
      << "\" not found in the current directory. Trying in the search path." << coral::MessageStream::endmsg;
 
  std::string searchPath(thePathVariable);
  //std::cout<<"searchPath "<<searchPath<<std::endl;
  if (std::filesystem::exists(searchPath)) {
    if (!std::filesystem::is_directory(searchPath)) {
      log << coral::Debug << "Search path \"" << searchPath << "\" is not a directory." << coral::MessageStream::endmsg;
      return fileNames;
    }
    std::filesystem::path fullPath(searchPath);
    fullPath /= filePath;
    fileNames.insert(fullPath.string());
  } else {
    log << coral::Debug << "Search path \"" << searchPath << "\" does not exist." << coral::MessageStream::endmsg;
    return fileNames;
  }
 
  return fileNames;
}

References Debug, LaserDQM_cfg::fileNames, dt4ml_dqm_sourceclient-live_cfg::filePath, contentValuesFiles::fullPath, dqm-mbProfile::log, castor_dqm_sourceclient_file_cfg::path, and AlCaHLTBitMon_QueryRunRegistry::string.

Member Data Documentation

m_callbackID

coral::Property::CallbackID cond::XMLAuthenticationService::XMLAuthenticationService::m_callbackID

private

Definition at line 132 of file XMLAuthenticationService.h.

Referenced by XMLAuthenticationService().

m_data

std::map<std::string, DataSourceEntry*> cond::XMLAuthenticationService::XMLAuthenticationService::m_data

private

The structure with the authentication data.

Definition at line 127 of file XMLAuthenticationService.h.

m_inputFileName

std::string cond::XMLAuthenticationService::XMLAuthenticationService::m_inputFileName

private

The input file with the data.

Definition at line 124 of file XMLAuthenticationService.h.

m_isInitialized

bool cond::XMLAuthenticationService::XMLAuthenticationService::m_isInitialized

private

Flag indicating whether the service has been initialized.

Definition at line 121 of file XMLAuthenticationService.h.

m_mutexLock

boost::mutex cond::XMLAuthenticationService::XMLAuthenticationService::m_mutexLock

mutableprivate

the mutex lock

Definition at line 130 of file XMLAuthenticationService.h.