pool::MicroSessionManager Class Reference

MicroSessionManager is a class taking care of starting sessions for a given major technology and managing the individual database connections. More...

#include <MicroSessionManager.h>

Collaboration diagram for pool::MicroSessionManager:

Public Member Functions
	MicroSessionManager (DatabaseRegistry &registry, long technology)
	Constructor.
virtual	~MicroSessionManager ()
	Destructor.
bool	connect (Io::IoFlag transType, int ageLimit)
	Connects to the storage service.
DatabaseHandler *	connect (Io::IoFlag transType, const std::string &fid, const std::string &pfn)
	Connects to a database.
void	disconnect (DatabaseHandler *database)
	Disconnects from a database.
bool	disconnectAll ()
	Disconnects from all the databases.
std::string	fidForPfn (const std::string &pfn)
	Fetches the FID by trying to temporatily connect to a database.
IStorageSvc &	getStorageSvc ()
	Return StorageSvc.
virtual bool	attributeOfType (const std::string &attributeName, void *data, const std::type_info &typeInfo, const std::string &option)
virtual bool	setAttributeOfType (const std::string &attributeName, const void *data, const std::type_info &typeInfo, const std::string &option)

Private Attributes
DatabaseRegistry &	m_registry
IStorageSvc *	m_storageSvc
bool	m_inSession
long	m_technology
std::set< DatabaseHandler * >	m_databaseHandlers

Detailed Description

MicroSessionManager is a class taking care of starting sessions for a given major technology and managing the individual database connections.

Definition at line 30 of file MicroSessionManager.h.

Constructor & Destructor Documentation

MicroSessionManager()

pool::MicroSessionManager::MicroSessionManager	(	pool::DatabaseRegistry &	registry,
		long	technology )

Constructor.

Definition at line 18 of file MicroSessionManager.cxx.

                                                                                            :
  m_registry( registry ),
  m_storageSvc( 0 ),
  m_inSession( false ),
  m_technology( technology ),
  m_databaseHandlers()
{
  m_storageSvc = createStorageSvc("StorageSvc");
  if ( ! m_storageSvc ) {
    throw std::runtime_error( "Could not create a StorageSvc object (APR: \" MicroSessionManager::MicroSessionManager \" from \" PersistencySvc \"" );
  }
}

~MicroSessionManager()

pool::MicroSessionManager::~MicroSessionManager ( )

virtual

Destructor.

Definition at line 32 of file MicroSessionManager.cxx.

{
  this->disconnectAll();
  m_storageSvc->release();
}

Member Function Documentation

attributeOfType()

bool pool::MicroSessionManager::attributeOfType ( const std::string & attributeName, void * data, const std::type_info & typeInfo, const std::string & option )

virtual

Definition at line 150 of file MicroSessionManager.cxx.

{
  if( !m_inSession ) {
      return false;
  }
  pool::DbOption domainOption( attributeName, option );
  if( !m_storageSvc->getDomainOption(domainOption).isSuccess() ) return false;
  return domainOption.i_getValue(typeInfo, data).isSuccess();
}

connect() [1/2]

pool::DatabaseHandler * pool::MicroSessionManager::connect	(	Io::IoFlag	transType,
		const std::string &	fid,
		const std::string &	pfn )

Connects to a database.

Definition at line 50 of file MicroSessionManager.cxx.

{
  if( mode == Io::INVALID ) return 0;
  if( m_databaseHandlers.empty() ) {
    if( !m_inSession ) {
      if( !m_storageSvc->startSession(mode, m_technology).isSuccess() ) {
        return nullptr;
      }
      m_inSession = true;
    }
  }
 
  pool::DatabaseHandler* db = 0;
  try {
    db = new pool::DatabaseHandler( *m_storageSvc, m_technology, fid, pfn, mode );
    m_registry.registerDatabaseHandler( db );
    m_databaseHandlers.insert( db );
  } catch( const std::runtime_error& /* error */) {
    delete db;
    m_storageSvc->endSession().ignore();
    m_inSession = false;
    return nullptr;
  }
 
  if( m_databaseHandlers.empty() && m_inSession ) {
    m_storageSvc->endSession().ignore();
    m_inSession = false;
  }
  return db;
}

connect() [2/2]

bool pool::MicroSessionManager::connect	(	Io::IoFlag	transType,
		int	ageLimit )

Connects to the storage service.

Definition at line 40 of file MicroSessionManager.cxx.

{
  if( !m_inSession ) {
    m_inSession = m_storageSvc->startSession(mode, m_technology, ageLimit).isSuccess();
  }
  return m_inSession;
}

disconnect()

void pool::MicroSessionManager::disconnect

(

pool::DatabaseHandler *

database

)

Disconnects from a database.

Definition at line 85 of file MicroSessionManager.cxx.

{
  std::set< pool::DatabaseHandler* >::iterator idb = m_databaseHandlers.find( database );
  if ( idb != m_databaseHandlers.end() ) {
    m_registry.deregisterDatabaseHandler( *idb );
    delete *idb;
    m_databaseHandlers.erase( idb );
  }
  if( m_databaseHandlers.empty() && m_inSession ) {
    m_storageSvc->endSession().ignore();
    m_inSession = false;
  }
}

disconnectAll()

bool pool::MicroSessionManager::disconnectAll

(

)

Disconnects from all the databases.

Definition at line 101 of file MicroSessionManager.cxx.

{
  bool ret = true;
  for ( std::set< pool::DatabaseHandler* >::iterator idb = m_databaseHandlers.begin();
        idb != m_databaseHandlers.end(); ++idb ) {
    m_registry.deregisterDatabaseHandler( *idb );
    ret = (*idb)->disconnectTransaction();
    delete *idb;
  }
  m_databaseHandlers.clear();
 
  if( m_inSession ) {
    ret = ret and m_storageSvc->endSession().isSuccess();
    m_inSession = false;
  }
  return ret;
}

fidForPfn()

std::string pool::MicroSessionManager::fidForPfn

(

const std::string &

pfn

)

Fetches the FID by trying to temporatily connect to a database.

Definition at line 120 of file MicroSessionManager.cxx.

{
  if ( m_databaseHandlers.empty() ) {
    Io::IoFlag mode = Io::READ;
    if( !m_storageSvc->startSession(mode, m_technology).isSuccess() ) {
      return "";
    }
  }
 
  std::string fid = "";
  pool::FileDescriptor fd( pfn, pfn );
  // this is only a temporary FID so use a special pattern to make that clear
  fd.setFID( fd.FID().substr(0,24) + "0FF0FF0FF0FF" );
  if( m_storageSvc->existsConnection(fd).isSuccess() ) {
    if ( m_storageSvc->connect(Io::READ, fd).isSuccess() ) {
      DbDatabase dbH( fd.dbc()->handle() );
      if ( ! dbH.param( "FID", fid ).isSuccess() ) fid = "";
      m_storageSvc->disconnect( fd ).ignore();
    }
  }
 
  if( m_databaseHandlers.empty() ) {
    m_storageSvc->endSession().ignore();
    m_inSession = false;
  }
 
  return fid;
}

getStorageSvc()

IStorageSvc & pool::MicroSessionManager::getStorageSvc ( )

inline

Return StorageSvc.

Definition at line 55 of file MicroSessionManager.h.

{ return *m_storageSvc; }

setAttributeOfType()

bool pool::MicroSessionManager::setAttributeOfType ( const std::string & attributeName, const void * data, const std::type_info & typeInfo, const std::string & option )

virtual

Definition at line 164 of file MicroSessionManager.cxx.

{
  if( !m_inSession ) {
      return false;
  }
  pool::DbOption domainOption( attributeName, option );
  if( !domainOption.i_setValue( typeInfo, const_cast<void*>( data ) ).isSuccess() ) return false;
  return m_storageSvc->setDomainOption(domainOption).isSuccess();
}

Member Data Documentation

m_databaseHandlers

std::set<DatabaseHandler*> pool::MicroSessionManager::m_databaseHandlers

private

Definition at line 74 of file MicroSessionManager.h.

m_inSession

bool pool::MicroSessionManager::m_inSession

private

Definition at line 72 of file MicroSessionManager.h.

m_registry

DatabaseRegistry& pool::MicroSessionManager::m_registry

private

Definition at line 70 of file MicroSessionManager.h.

m_storageSvc

IStorageSvc* pool::MicroSessionManager::m_storageSvc

private

Definition at line 71 of file MicroSessionManager.h.

m_technology

long pool::MicroSessionManager::m_technology

private

Definition at line 73 of file MicroSessionManager.h.

---

The documentation for this class was generated from the following files:

• MicroSessionManager.h
• MicroSessionManager.cxx