cond::persistency::SessionImpl Class Reference

#include <SessionImpl.h>

Public Types
enum	FailureOnOpeningPolicy { THROW, DO_NOT_THROW, CREATE }

Public Member Functions
void	close ()
void	commitTransaction ()
IGTSchema &	gtSchema ()
IIOVSchema &	iovSchema ()
bool	isActive () const
bool	isTransactionActive (bool deep=true) const
void	openDb ()
void	openGTDb (FailureOnOpeningPolicy policy=THROW)
void	openIovDb (FailureOnOpeningPolicy policy=THROW)
void	openRunInfoDb ()
void	rollbackTransaction ()
IRunInfoSchema &	runInfoSchema ()
	SessionImpl ()
	SessionImpl (std::shared_ptr< coral::ISessionProxy > &session, const std::string &connectionString, const std::string &principalName)
void	startTransaction (bool readOnly=true)
	~SessionImpl ()

Public Attributes
std::string	connectionString
std::shared_ptr< coral::ISessionProxy >	coralSession
std::unique_ptr< IGTSchema >	gtSchemaHandle
std::unique_ptr< IIOVSchema >	iovSchemaHandle
std::set< std::string >	lockedTags
std::string	principalName
std::unique_ptr< IRunInfoSchema >	runInfoSchemaHandle
std::string	sessionHash
std::unique_ptr< ITransaction >	transaction

Private Member Functions
void	releaseTagLocks ()

Private Attributes
std::unique_lock< std::recursive_mutex >	transactionLock
std::recursive_mutex	transactionMutex

Detailed Description

Definition at line 40 of file SessionImpl.h.

Member Enumeration Documentation

FailureOnOpeningPolicy

enum cond::persistency::SessionImpl::FailureOnOpeningPolicy

Enumerator
THROW
DO_NOT_THROW
CREATE

Definition at line 42 of file SessionImpl.h.

{ THROW, DO_NOT_THROW, CREATE } FailureOnOpeningPolicy;

Constructor & Destructor Documentation

SessionImpl() [1/2]

cond::persistency::SessionImpl::SessionImpl

(

)

Definition at line 33 of file SessionImpl.cc.

: coralSession() {}

SessionImpl() [2/2]

cond::persistency::SessionImpl::SessionImpl	(	std::shared_ptr< coral::ISessionProxy > &	session,
		const std::string &	connectionString,
		const std::string &	principalName
	)

Definition at line 35 of file SessionImpl.cc.

References cond::auth::COND_SESSION_HASH_SIZE, cond::auth::KeyGenerator::make(), and sessionHash.

        : coralSession(session), sessionHash(""), connectionString(connectionStr), principalName(principalNm) {
      cond::auth::KeyGenerator kg;
      sessionHash = kg.make(cond::auth::COND_SESSION_HASH_SIZE);
    }

~SessionImpl()

cond::persistency::SessionImpl::~SessionImpl

(

)

Definition at line 43 of file SessionImpl.cc.

References close().

{ close(); }

Member Function Documentation

close()

void cond::persistency::SessionImpl::close

(

void

)

Definition at line 45 of file SessionImpl.cc.

References commitTransaction(), coralSession, isActive(), lockedTags, releaseTagLocks(), rollbackTransaction(), startTransaction(), and transaction.

Referenced by esMonitoring.AsyncLineReaderMixin::handle_close(), esMonitoring.FDJsonServer::handle_close(), and ~SessionImpl().

                            {
      if (isActive()) {
        if (coralSession->transaction().isActive()) {
          rollbackTransaction();
        }
        if (!lockedTags.empty()) {
          startTransaction(false);
          releaseTagLocks();
          commitTransaction();
        }
        coralSession.reset();
      }
      transaction.reset();
    }

commitTransaction()

void cond::persistency::SessionImpl::commitTransaction

(

)

Definition at line 78 of file SessionImpl.cc.

References gtSchemaHandle, iovSchemaHandle, CommonMethods::lock(), runInfoSchemaHandle, transaction, and transactionLock.

Referenced by close(), and cond::persistency::Transaction::commit().

                                        {
      std::unique_lock<std::recursive_mutex> lock;
      lock.swap(transactionLock);
      if (transaction) {
        transaction->clients--;
        if (!transaction->clients) {
          transaction->commit();
          transaction.reset();
          iovSchemaHandle.reset();
          gtSchemaHandle.reset();
          runInfoSchemaHandle.reset();
        }
      }
    }

gtSchema()

IGTSchema & cond::persistency::SessionImpl::gtSchema

(

)

Definition at line 202 of file SessionImpl.cc.

References gtSchemaHandle.

{ return *gtSchemaHandle; }

iovSchema()

IIOVSchema & cond::persistency::SessionImpl::iovSchema

(

)

Definition at line 200 of file SessionImpl.cc.

References iovSchemaHandle.

Referenced by releaseTagLocks().

{ return *iovSchemaHandle; }

isActive()

bool cond::persistency::SessionImpl::isActive

(

)

const

Definition at line 60 of file SessionImpl.cc.

References coralSession.

Referenced by close().

{ return coralSession.get(); }

isTransactionActive()

bool cond::persistency::SessionImpl::isTransactionActive

(

bool

deep = true

)

const

Definition at line 105 of file SessionImpl.cc.

References transaction.

Referenced by cond::persistency::Transaction::isActive().

                                                         {
      if (!transaction)
        return false;
      if (!deep)
        return true;
      return transaction->isActive();
    }

openDb()

void cond::persistency::SessionImpl::openDb

(

)

Definition at line 179 of file SessionImpl.cc.

References gtSchemaHandle, iovSchemaHandle, cond::persistency::throwException(), and transaction.

                             {
      if (!transaction.get())
        throwException("The transaction is not active.", "SessionImpl::openIovDb");
      if (!transaction->iovDbOpen) {
        transaction->iovDbExists = iovSchemaHandle->exists();
        transaction->iovDbOpen = true;
      }
      if (!transaction->gtDbOpen) {
        transaction->gtDbExists = gtSchemaHandle->exists();
        transaction->gtDbOpen = true;
      }
      if (!transaction->iovDbExists) {
        iovSchemaHandle->create();
        transaction->iovDbExists = true;
        if (!transaction->gtDbExists) {
          gtSchemaHandle->create();
          transaction->gtDbExists = true;
        }
      }
    }

openGTDb()

void cond::persistency::SessionImpl::openGTDb

(

SessionImpl::FailureOnOpeningPolicy

policy = THROW

)

Definition at line 149 of file SessionImpl.cc.

References CREATE, gtSchemaHandle, THROW, cond::persistency::throwException(), and transaction.

                                                                       {
      if (!transaction.get())
        throwException("The transaction is not active.", "SessionImpl::openGTDb");
      if (!transaction->gtDbOpen) {
        transaction->gtDbExists = gtSchemaHandle->exists();
        transaction->gtDbOpen = true;
      }
      if (!transaction->gtDbExists) {
        if (policy == CREATE) {
          gtSchemaHandle->create();
          transaction->gtDbExists = true;
        } else {
          if (policy == THROW)
            throwException("GT Database does not exist.", "SessionImpl::openGTDb");
        }
      }
    }

openIovDb()

void cond::persistency::SessionImpl::openIovDb

(

SessionImpl::FailureOnOpeningPolicy

policy = THROW

)

Definition at line 131 of file SessionImpl.cc.

References CREATE, iovSchemaHandle, THROW, cond::persistency::throwException(), and transaction.

                                                                        {
      if (!transaction.get())
        throwException("The transaction is not active.", "SessionImpl::openIovDb");
      if (!transaction->iovDbOpen) {
        transaction->iovDbExists = iovSchemaHandle->exists();
        transaction->iovDbOpen = true;
      }
      if (!transaction->iovDbExists) {
        if (policy == CREATE) {
          iovSchemaHandle->create();
          transaction->iovDbExists = true;
        } else {
          if (policy == THROW)
            throwException("IOV Database does not exist.", "SessionImpl::openIovDb");
        }
      }
    }

openRunInfoDb()

void cond::persistency::SessionImpl::openRunInfoDb

(

)

Definition at line 167 of file SessionImpl.cc.

References runInfoSchemaHandle, cond::persistency::throwException(), and transaction.

                                    {
      if (!transaction.get())
        throwException("The transaction is not active.", "SessionImpl::openRunInfoDb");
      if (!transaction->runInfoDbOpen) {
        transaction->runInfoDbExists = runInfoSchemaHandle->exists();
        transaction->runInfoDbOpen = true;
      }
      if (!transaction->runInfoDbExists) {
        throwException("RunInfo Database does not exist.", "SessionImpl::openRunInfoDb");
      }
    }

releaseTagLocks()

void cond::persistency::SessionImpl::releaseTagLocks ( )

private

Definition at line 113 of file SessionImpl.cc.

References writedatasetfile::action, cond::auth::COND_DBTAG_LOCK_ACCESS_CODE, cond::auth::COND_SESSION_HASH_CODE, cond::persistency::ITagLogTable::insert(), iovSchema(), lockedTags, cond::persistency::ITagAccessPermissionTable::removeEntriesForCredential(), sessionHash, AlCaHLTBitMon_QueryRunRegistry::string, makeGlobalPositionRcd_cfg::tag, cond::persistency::IIOVSchema::tagAccessPermissionTable(), cond::persistency::IIOVSchema::tagLogTable(), cond::persistency::IIOVSchema::tagTable(), and cond::persistency::ITagTable::unsetProtectionCode().

Referenced by close().

                                      {
      iovSchema().tagAccessPermissionTable().removeEntriesForCredential(sessionHash,
                                                                        cond::auth::COND_SESSION_HASH_CODE);
      std::string lt("-");
      std::string action("Lock removed by session ");
      action += sessionHash;
      for (const auto& tag : lockedTags) {
        iovSchema().tagTable().unsetProtectionCode(tag, cond::auth::COND_DBTAG_LOCK_ACCESS_CODE);
        iovSchema().tagLogTable().insert(tag,
                                         boost::posix_time::microsec_clock::universal_time(),
                                         cond::getUserName(),
                                         cond::getHostName(),
                                         cond::getCommand(),
                                         action,
                                         lt);
      }
    }

rollbackTransaction()

void cond::persistency::SessionImpl::rollbackTransaction

(

)

Definition at line 93 of file SessionImpl.cc.

References gtSchemaHandle, iovSchemaHandle, CommonMethods::lock(), runInfoSchemaHandle, transaction, and transactionLock.

Referenced by close(), and cond::persistency::Transaction::rollback().

                                          {
      std::unique_lock<std::recursive_mutex> lock;
      lock.swap(transactionLock);
      if (transaction) {
        transaction->rollback();
        transaction.reset();
        iovSchemaHandle.reset();
        gtSchemaHandle.reset();
        runInfoSchemaHandle.reset();
      }
    }

runInfoSchema()

IRunInfoSchema & cond::persistency::SessionImpl::runInfoSchema

(

)

Definition at line 204 of file SessionImpl.cc.

References runInfoSchemaHandle.

{ return *runInfoSchemaHandle; }

startTransaction()

void cond::persistency::SessionImpl::startTransaction

(

bool

readOnly = true

)

Definition at line 62 of file SessionImpl.cc.

References coralSession, gtSchemaHandle, iovSchemaHandle, CommonMethods::lock(), runInfoSchemaHandle, cond::persistency::throwException(), transaction, transactionLock, and transactionMutex.

Referenced by close(), and cond::persistency::Transaction::start().

                                                    {
      std::unique_lock<std::recursive_mutex> lock(transactionMutex);
      if (!transaction.get()) {
        coralSession->transaction().start(readOnly);
        iovSchemaHandle = std::make_unique<IOVSchema>(coralSession->nominalSchema());
        gtSchemaHandle = std::make_unique<GTSchema>(coralSession->nominalSchema());
        runInfoSchemaHandle = std::make_unique<RunInfoSchema>(coralSession->nominalSchema());
        transaction = std::make_unique<CondDBTransaction>(coralSession);
      } else {
        if (!readOnly)
          throwException("An update transaction is already active.", "SessionImpl::startTransaction");
      }
      transaction->clients++;
      transactionLock.swap(lock);
    }

Member Data Documentation

connectionString

std::string cond::persistency::SessionImpl::connectionString

Definition at line 71 of file SessionImpl.h.

coralSession

std::shared_ptr<coral::ISessionProxy> cond::persistency::SessionImpl::coralSession

Definition at line 69 of file SessionImpl.h.

Referenced by close(), isActive(), and startTransaction().

gtSchemaHandle

std::unique_ptr<IGTSchema> cond::persistency::SessionImpl::gtSchemaHandle

Definition at line 76 of file SessionImpl.h.

Referenced by commitTransaction(), gtSchema(), openDb(), openGTDb(), rollbackTransaction(), and startTransaction().

iovSchemaHandle

std::unique_ptr<IIOVSchema> cond::persistency::SessionImpl::iovSchemaHandle

Definition at line 75 of file SessionImpl.h.

Referenced by commitTransaction(), iovSchema(), openDb(), openIovDb(), rollbackTransaction(), and startTransaction().

lockedTags

std::set<std::string> cond::persistency::SessionImpl::lockedTags

Definition at line 73 of file SessionImpl.h.

Referenced by close(), and releaseTagLocks().

principalName

std::string cond::persistency::SessionImpl::principalName

Definition at line 72 of file SessionImpl.h.

runInfoSchemaHandle

std::unique_ptr<IRunInfoSchema> cond::persistency::SessionImpl::runInfoSchemaHandle

Definition at line 77 of file SessionImpl.h.

Referenced by commitTransaction(), openRunInfoDb(), rollbackTransaction(), runInfoSchema(), and startTransaction().

sessionHash

std::string cond::persistency::SessionImpl::sessionHash

Definition at line 70 of file SessionImpl.h.

Referenced by releaseTagLocks(), and SessionImpl().

transaction

std::unique_ptr<ITransaction> cond::persistency::SessionImpl::transaction

Definition at line 74 of file SessionImpl.h.

Referenced by close(), commitTransaction(), isTransactionActive(), openDb(), openGTDb(), openIovDb(), openRunInfoDb(), rollbackTransaction(), and startTransaction().

transactionLock

std::unique_lock<std::recursive_mutex> cond::persistency::SessionImpl::transactionLock

private

Definition at line 82 of file SessionImpl.h.

Referenced by commitTransaction(), rollbackTransaction(), and startTransaction().

transactionMutex

std::recursive_mutex cond::persistency::SessionImpl::transactionMutex

private

Definition at line 81 of file SessionImpl.h.

Referenced by startTransaction().