XMLAuthenticationService.cc

Go to the documentation of this file.

//#include "CondCore/DBCommon/interface/DecodingKey.h"
#include "CondCore/DBCommon/interface/FileUtils.h"
#include "CondCore/DBCommon/interface/Exception.h"
#include "CondCore/DBCommon/interface/Auth.h"
#include "RelationalAccess/AuthenticationCredentials.h"
#include "CoralCommon/Cipher.h"
#include "RelationalAccess/AuthenticationServiceException.h"
#include "CoralKernel/IPropertyManager.h"
#include "CoralKernel/Property.h"
#include "CoralKernel/Context.h"
#include "CondCore/DBCommon/interface/CoralServiceMacros.h"
#include "FWCore/Concurrency/interface/Xerces.h"
#include "xercesc/parsers/XercesDOMParser.hpp"
#include "xercesc/framework/MemBufInputSource.hpp"
#include "xercesc/dom/DOM.hpp"
#include "xercesc/sax/HandlerBase.hpp"
#include "xercesc/util/XMLString.hpp"
#include "xercesc/util/PlatformUtils.hpp"
#include "XMLAuthenticationService.h"

#include <memory>
#include <cstdlib>
#include <fstream>
#include <sys/stat.h>
#include <fcntl.h>
#include <boost/filesystem.hpp>
#include <boost/version.hpp>
#include <boost/bind.hpp>
//#include <iostream>
#include "CoralBase/MessageStream.h"

constexpr char XML_AUTHENTICATION_FILE[] = "authentication.xml";

cond::XMLAuthenticationService::DataSourceEntry::DataSourceEntry( const std::string& serviceName,
                                                                  const std::string& connectionName ):
  m_serviceName( serviceName ),
  m_connectionName( connectionName ),
  m_default( new coral::AuthenticationCredentials( serviceName ) ),
  m_data()
{}

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

void
cond::XMLAuthenticationService::DataSourceEntry::appendCredentialItem( const std::string& item,
                                                                       const std::string& value )
{
  m_default->registerItem( item, value );
}

void
cond::XMLAuthenticationService::DataSourceEntry::appendCredentialItemForRole( const std::string& item,
                                                                              const std::string& value,
                                                                              const std::string& role )
{
  std::map< std::string, coral::AuthenticationCredentials* >::iterator iRole = m_data.find( role );
  if ( iRole == m_data.end() ) {
    iRole = m_data.insert( std::make_pair( role, new coral::AuthenticationCredentials( m_serviceName ) ) ).first;
  }
  iRole->second->registerItem( item, value );
}

const coral::IAuthenticationCredentials&
cond::XMLAuthenticationService::DataSourceEntry::credentials() const
{
  return *m_default;
}

const coral::IAuthenticationCredentials&
cond::XMLAuthenticationService::DataSourceEntry::credentials( const std::string& role ) const
{
  return *m_default;
}

cond::XMLAuthenticationService::XMLAuthenticationService::XMLAuthenticationService( const std::string& key )
  : coral::Service( key ),
    m_isInitialized( false ),
    m_inputFileName( "" ),
    m_data(),
    m_mutexLock(),
    m_callbackID(0)
{
  boost::function1<void, std::string> cb(boost::bind(&cond::XMLAuthenticationService::XMLAuthenticationService::setAuthenticationPath, this, _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);
  } 
}

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

void
cond::XMLAuthenticationService::XMLAuthenticationService::setAuthenticationPath(  const std::string& inputPath )
{
  boost::filesystem::path boostAuthPath( inputPath );
  if(boost::filesystem::is_directory(boostAuthPath)){
    boostAuthPath /= boost::filesystem::path(XML_AUTHENTICATION_FILE);      
  }

  m_inputFileName = boostAuthPath.string();
  reset();
}

bool
cond::XMLAuthenticationService::XMLAuthenticationService::processFile( const std::string& inputFileName )
{
  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;
  }
  
  // check the 
  boost::filesystem::path filePath( inputFileName );
#if (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 47
  std::string name = filePath.filename().string();
#else
  std::string name = filePath.leaf();
#endif

  xercesc::MemBufInputSource* memBufInputSource = 0;
  
  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 = 0;
          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;
}


bool
cond::XMLAuthenticationService::XMLAuthenticationService::initialize()
{  
  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;
}

void cond::XMLAuthenticationService::XMLAuthenticationService::reset(){
  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;  
}



const coral::IAuthenticationCredentials&
cond::XMLAuthenticationService::XMLAuthenticationService::credentials( const std::string& connectionString ) const
{
  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();
}


const coral::IAuthenticationCredentials&
cond::XMLAuthenticationService::XMLAuthenticationService::credentials( const std::string& connectionString,
                                                                       const std::string& role ) const
{
  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 );
}


std::set< std::string >
cond::XMLAuthenticationService::XMLAuthenticationService::verifyFileName()
{
  coral::MessageStream log("cond::XMLAuthenticationService::verifyFileName");
  std::set< std::string > fileNames;

  // Try the file name as is...
  boost::filesystem::path filePath( m_inputFileName );
  if ( boost::filesystem::exists( m_inputFileName ) ) {
    if(boost::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;
    }
    boost::filesystem::path& fullPath = filePath.normalize();
    fileNames.insert( fullPath.string() );
    if(filePath.is_complete()) return fileNames;
  }
  
  // Try to find other files in the path variable
  const char* thePathVariable = ::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(boost::filesystem::exists(searchPath)){
    if(!boost::filesystem::is_directory( searchPath )){
      log<<coral::Debug<<"Search path \"" << searchPath << "\" is not a directory."<<coral::MessageStream::endmsg;
      return fileNames;
    }
    boost::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;
}

DEFINE_CORALSERVICE(cond::XMLAuthenticationService::XMLAuthenticationService,"COND/Services/XMLAuthenticationService");