#include <ConnectionPool.h>

Public Member Functions
void	configure ()

	ConnectionPool ()

Session	createReadOnlySession (const std::string &connectionString, const std::string &transactionId)

Session	createSession (const std::string &connectionString, bool writeCapable=false, BackendType backType=DEFAULT_DB)

bool	isLoggingEnabled () const

void	setAuthenticationPath (const std::string &p)

void	setAuthenticationSystem (int authSysCode)

void	setLogging (bool flag)

void	setMessageVerbosity (coral::MsgLevel level)

void	setParameters (const edm::ParameterSet &connectionPset)

	~ConnectionPool ()

Private Member Functions
void	configure (coral::IConnectionServiceConfiguration &coralConfig)

Session	createSession (const std::string &connectionString, const std::string &transactionId, bool writeCapable=false, BackendType backType=DEFAULT_DB)

Private Attributes
std::string	m_authPath

int	m_authSys = 0

std::map< std::string, int >	m_dbTypes

bool	m_loggingEnabled = false

coral::MsgLevel	m_messageLevel = coral::Error

cond::CoralServiceManager *	m_pluginManager = 0

Detailed Description

Definition at line 30 of file ConnectionPool.h.

Constructor & Destructor Documentation

cond::persistency::ConnectionPool::ConnectionPool ( )

Definition at line 30 of file ConnectionPool.cc.

References configure(), and m_pluginManager.

                                   {
       m_pluginManager = new cond::CoralServiceManager;
       configure();
     }

cond::persistency::ConnectionPool::~ConnectionPool ( )

Definition at line 35 of file ConnectionPool.cc.

References m_pluginManager.

                                    {
       delete m_pluginManager;
     }

Member Function Documentation

void cond::persistency::ConnectionPool::configure ( )

Definition at line 132 of file ConnectionPool.cc.

Referenced by CondDBESSource::CondDBESSource(), ConnectionPool(), DTKeyedConfigHandler::getNewObjects(), and DTUserKeyedConfigHandler::getNewObjects().

                                    {
       coral::ConnectionService connServ;
       configure( connServ.configuration() );
     }

void cond::persistency::ConnectionPool::configure ( coral::IConnectionServiceConfiguration & coralConfig )

private

Definition at line 80 of file ConnectionPool.cc.

References builder_last_value_cfg::authPath, cond::Auth::COND_AUTH_PATH, cond::Auth::COND_AUTH_PATH_PROPERTY, cond::Auth::COND_AUTH_SYS, cond::persistency::CondDbKey, cond::persistency::CoralXMLFile, gather_cfg::cout, instance, m_authPath, m_authSys, m_messageLevel, m_pluginManager, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                     {
       
       coralConfig.disablePoolAutomaticCleanUp();
       coralConfig.disableConnectionSharing();
       // message streaming
       coral::MessageStream::setMsgVerbosity( m_messageLevel );
       std::string authServiceName("CORAL/Services/EnvironmentAuthenticationService");
       std::string authPath = m_authPath;
       // authentication
       if( authPath.empty() ){
         // first try to check the env...
         const char* authEnv = ::getenv( cond::Auth::COND_AUTH_PATH );
         if(authEnv){
           authPath += authEnv;
         } 
       }
       int authSys = m_authSys;
       // first attempt, look at the env...
       const char* authSysEnv = ::getenv( cond::Auth::COND_AUTH_SYS );
       if( authSysEnv ){
           authSys = ::atoi( authSysEnv );
       }
       if( authSys !=CondDbKey && authSys != CoralXMLFile ){
           // take the default
           authSys = CondDbKey;
       }  
       std::string servName("");
       if( authSys == CondDbKey ){
           if( authPath.empty() ){
               const char* authEnv = ::getenv("HOME");
               if(authEnv){
                   authPath += authEnv;
               } 
           }
           servName = "COND/Services/RelationalAuthenticationService";     
       } else if( authSys == CoralXMLFile ){
           if( authPath.empty() ){
               authPath = ".";
           }
           servName = "COND/Services/XMLAuthenticationService";  
       }
       if( !authPath.empty() ){
           authServiceName = servName;    
           coral::Context::instance().PropertyManager().property(cond::Auth::COND_AUTH_PATH_PROPERTY)->set(authPath);  
           coral::Context::instance().loadComponent( authServiceName, m_pluginManager );
       }
       
       std::cout << "==> using " << servName << " for auth, sys " << authSys << std::endl;
       
       coralConfig.setAuthenticationService( authServiceName );
     }

Session cond::persistency::ConnectionPool::createReadOnlySession	(	const std::string &	connectionString,
		const std::string &	transactionId
	)

Definition at line 176 of file ConnectionPool.cc.

References createSession().

Referenced by CondDBESSource::CondDBESSource(), and CondDBESSource::setIntervalFor().

                                                                                                                     {
       return createSession( connectionString, transactionId );
     }

Session cond::persistency::ConnectionPool::createSession	(	const std::string &	connectionString,
		bool	writeCapable = `false`,
		BackendType	backType = `DEFAULT_DB`
	)

Definition at line 172 of file ConnectionPool.cc.

Referenced by createReadOnlySession(), cond::persistency::exportTagToFile(), CondDBESSource::fillTagCollectionFromGT(), DTUserKeyedConfigHandler::getNewObjects(), and DTKeyedConfigHandler::getNewObjects().

                                                                                                                      {
       return createSession( connectionString, "", writeCapable, backType );
     }

Session cond::persistency::ConnectionPool::createSession	(	const std::string &	connectionString,
		const std::string &	transactionId,
		bool	writeCapable = `false`,
		BackendType	backType = `DEFAULT_DB`
	)

private

Definition at line 137 of file ConnectionPool.cc.

References cond::persistency::checkBackendType(), cond::Auth::COND_READER_ROLE, cond::Auth::COND_WRITER_ROLE, cond::persistency::getConnectionParams(), m_dbTypes, cond::persistency::ORA_IOV_TABLE_1(), cond::persistency::ORA_IOV_TABLE_2(), cond::persistency::ORA_IOV_TABLE_3(), cond::persistency::POOL_IOV_TABLE_DATA(), cond::persistency::TAG::tname, cond::persistency::PAYLOAD::tname, cond::persistency::IOV::tname, and cond::UNKNOWN_DB.

                                             {
       coral::ConnectionService connServ;
       std::pair<std::string,std::string> fullConnectionPars = getConnectionParams( connectionString, transactionId );
       if( !fullConnectionPars.second.empty() ) {
     // the olds formats
     connServ.webCacheControl().refreshTable( fullConnectionPars.second, POOL_IOV_TABLE_DATA );
     connServ.webCacheControl().refreshTable( fullConnectionPars.second, ORA_IOV_TABLE_1 );
     connServ.webCacheControl().refreshTable( fullConnectionPars.second, ORA_IOV_TABLE_2 );
     connServ.webCacheControl().refreshTable( fullConnectionPars.second, ORA_IOV_TABLE_3 );
     // the new schema...
     connServ.webCacheControl().setTableTimeToLive( fullConnectionPars.second, TAG::tname, 1 );
     connServ.webCacheControl().setTableTimeToLive( fullConnectionPars.second, IOV::tname, 1 );
     connServ.webCacheControl().setTableTimeToLive( fullConnectionPars.second, PAYLOAD::tname, 3 );
       }
 
       boost::shared_ptr<coral::ISessionProxy> coralSession( connServ.connect( fullConnectionPars.first, 
                                           writeCapable?Auth::COND_WRITER_ROLE:Auth::COND_READER_ROLE,
                                           writeCapable?coral::Update:coral::ReadOnly ) );
       BackendType bt;
       auto it = m_dbTypes.find( connectionString);
       if( it == m_dbTypes.end() ){
     bt = checkBackendType( coralSession, connectionString );
     if( bt == UNKNOWN_DB && writeCapable) bt = backType;
     m_dbTypes.insert( std::make_pair( connectionString, bt ) );
       } else {
     bt = (BackendType) it->second;
       }
    
       std::shared_ptr<SessionImpl> impl( new SessionImpl( coralSession, connectionString, bt ) );  
       return Session( impl );
     }

bool cond::persistency::ConnectionPool::isLoggingEnabled ( ) const

Definition at line 76 of file ConnectionPool.cc.

References m_loggingEnabled.

                                                 {
       return m_loggingEnabled;
     }

void cond::persistency::ConnectionPool::setAuthenticationPath ( const std::string & p )

Definition at line 39 of file ConnectionPool.cc.

References m_authPath, and AlCaHLTBitMon_ParallelJobs::p.

Referenced by DTKeyedConfigHandler::getNewObjects(), DTUserKeyedConfigHandler::getNewObjects(), and setParameters().

                                                                   {
       m_authPath = p;
     }

void cond::persistency::ConnectionPool::setAuthenticationSystem ( int authSysCode )

Definition at line 43 of file ConnectionPool.cc.

References m_authSys.

Referenced by setParameters().

                                                                  {
       m_authSys = authSysCode;
     }

void cond::persistency::ConnectionPool::setLogging ( bool flag )

Definition at line 47 of file ConnectionPool.cc.

References archive::flag, and m_loggingEnabled.

Referenced by setParameters().

                                               {
       m_loggingEnabled = flag;
     }

void cond::persistency::ConnectionPool::setMessageVerbosity ( coral::MsgLevel level )

Definition at line 179 of file ConnectionPool.cc.

References testEve_cfg::level, and m_messageLevel.

Referenced by setParameters().

                                                                  {
       m_messageLevel = level;
     }

void cond::persistency::ConnectionPool::setParameters ( const edm::ParameterSet & connectionPset )

Definition at line 51 of file ConnectionPool.cc.

References Debug, edm::ParameterSet::getUntrackedParameter(), testEve_cfg::level, setAuthenticationPath(), setAuthenticationSystem(), setLogging(), setMessageVerbosity(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by CondDBESSource::CondDBESSource().

                                                                              {
       setAuthenticationPath( connectionPset.getUntrackedParameter<std::string>("authenticationPath","") );
       setAuthenticationSystem( connectionPset.getUntrackedParameter<int>("authenticationSystem",0) );
       int messageLevel = connectionPset.getUntrackedParameter<int>("messageLevel",0);
       coral::MsgLevel level = coral::Error;
       switch (messageLevel) {
       case 0 :
     level = coral::Error;
     break;    
       case 1:
     level = coral::Warning;
     break;
       case 2:
     level = coral::Info;
     break;
       case 3:
     level = coral::Debug;
     break;
       default:
     level = coral::Error;
       }
       setMessageVerbosity(level);
       setLogging( connectionPset.getUntrackedParameter<bool>("logging",false) );
     }