SessionMgr.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
#include "TrigConfStorage/SessionMgr.h"
 
#include "RelationalAccess/AccessMode.h"
#include "RelationalAccess/IDatabaseServiceDescription.h"
#include "RelationalAccess/IDatabaseServiceSet.h"
#include "RelationalAccess/ILookupService.h"
#include "RelationalAccess/IAuthenticationService.h"
#include "RelationalAccess/IAuthenticationCredentials.h"
#include "RelationalAccess/ITypeConverter.h"
#include "RelationalAccess/IRelationalDomain.h"
#include "RelationalAccess/ConnectionService.h"
#include "RelationalAccess/IConnectionService.h"
#include "RelationalAccess/IConnectionServiceConfiguration.h"
 
#include "RelationalAccess/ISessionProxy.h"
 
 
#include "./ReplicaSorter.h"
 
#include "CoralKernel/Context.h"
#include "CoralBase/Exception.h"
 
#include <boost/algorithm/string/case_conv.hpp>
 
#include <iostream>
#include <stdlib.h>
#include <string.h>
 
 
using namespace std;
using namespace TrigConf;
 
SessionMgr::SessionMgr() :
   TrigConfMessaging("SessionMgr")
{}
 
SessionMgr::~SessionMgr() {
   // Dtors are noexcept by default, so if closeSession() throws,
   // std::terminate will be called.  However, cppcheck warns here
   // about the uncaught exception, so do the std::terminate call
   // explicitly.
   try {
     closeSession();
   } catch (...) {
     std::terminate();
   }
   // never delete the m_replicaSorter, we will have to live with that
   // one-time memory leak. The problem is the CORAL interface that
   // does keeps a reference to the replicaSorter and keeps using it
   // but doesn't clean it up. And if we delete it too early, then
   // later access leads to a crash
}
 
void
SessionMgr::closeSession() {
 
   if(m_sessionproxy) {
      try{
         delete m_sessionproxy;
         m_sessionproxy = nullptr;
         TRG_MSG_INFO("Closing session " << m_connectionString);
      }
      catch ( coral::Exception& e ) {
         TRG_MSG_WARNING("CORAL exception " << e.what());
         throw;
      }
   }
 
}
 
void
TrigConf::SessionMgr::buildConnectionString() {
 
   if(m_connectionString!="")
      return;
 
   if(m_dbserver=="") { 
      m_connectionString = m_dbname; 
   } else if(m_dbtype == "dblookup") { 
      m_connectionString = m_dbserver; 
   } else { 
      m_connectionString = m_dbtype + "://" + m_dbserver + "/" + m_dbname;     
   }
}
 
 
coral::ISessionProxy&
TrigConf::SessionMgr::createSession() {
 
   if( m_sessionproxy ) return *m_sessionproxy;
 
   coral::ConnectionService connSvc;
   coral::IConnectionServiceConfiguration& csc = connSvc.configuration();
   csc.setConnectionRetrialPeriod( m_retrialPeriod );
   csc.setConnectionRetrialTimeOut( m_retrialTimeout );
   csc.setConnectionTimeOut( m_connectionTimeout );
 
   
   if(csc.replicaSortingAlgorithm() == nullptr) { // likely to be standalone, create our own
      TRG_MSG_INFO("Create own ReplicaSortingAlgorithm");
      m_replicaSorter = new TrigConf::ReplicaSorter();
      csc.setReplicaSortingAlgorithm(*m_replicaSorter);
   }
 
   buildConnectionString();
   TRG_MSG_INFO("Connecting to " << m_connectionString);
   m_sessionproxy = connSvc.connect(m_connectionString, coral::AccessMode::ReadOnly);
   TRG_MSG_INFO("Opening session " << m_connectionString << " with " << m_retrialPeriod << "/" << m_retrialTimeout << "/" << m_connectionTimeout);
 
   return *m_sessionproxy;   
}
 
 
void
TrigConf::SessionMgr::setDbType(const std::string & s) {
   m_dbtype = boost::to_lower_copy(s);
   m_connectionString = "";
}
 
void
TrigConf::SessionMgr::setDbServer(const std::string & s) {
   m_dbserver = s;
   m_connectionString = "";
}
 
void
TrigConf::SessionMgr::setDbName(const std::string & s) { 
   m_dbname = s;
   m_connectionString = "";
}
 
void
TrigConf::SessionMgr::setDbUser(const std::string & s) {
   m_user = s;
   m_connectionString = "";
}
 
void
TrigConf::SessionMgr::setDbPassword(const std::string & s) {
   m_password = s;
   m_connectionString = "";
}