pool::UserDatabase Class Reference

UserDatabase is an implementation of the IDatabase interface. More...

#include <UserDatabase.h>

Inheritance diagram for pool::UserDatabase:

Collaboration diagram for pool::UserDatabase:

Public Member Functions
	UserDatabase (UserSession &session, const std::string &name, const DatabaseSpecification::NameType nameType)
	Constructor.
virtual	~UserDatabase ()
	Destructor.
virtual void	connectForRead () override
	Connects explicitly to the database for read operations.
void *	readObject (const Token &token, void *object=0)
	Reads an object given a token.
virtual void	connectForWrite () override
	Connects explicitly to the database for write/update operations.
Token *	writeObject (const std::string &containerName, long minorTechnology, const void *object, const RootType &type)
	Writes an object and returns a token.
virtual void	disconnect () override
	Disconnects from the database.
virtual Io::IoFlag	openMode () const override
	Returns the opening mode. It can be used to check whether the database is connected.
virtual const std::string &	fid () override
	Returns the file identifier of this database.
virtual const std::string &	pfn () override
	Returns the physical file name of this database.
virtual bool	setTechnology (long technology) override
	Sets the technology identifier for this database.
virtual std::vector< std::string >	containers () override
	Returns the names of the containers in this database.
virtual IContainer *	containerHandle (const std::string &name) override
	Returns a pointer to a container object. The user acquires ownership of that object.
virtual FileDescriptor *	fileDescriptor () override final
	Expose FileDescriptor object for the technology specific DB implementation.
bool	msgLvl (const MSG::Level lvl) const
	Test the output level.
MsgStream &	msg () const
	The standard message stream.
MsgStream &	msg (const MSG::Level lvl) const
	The standard message stream.
void	setLevel (MSG::Level lvl)
	Change the current logging level.

Protected Member Functions
virtual bool	attributeOfType (const std::string &attributeName, void *data, const std::type_info &typeInfo, const std::string &option) override
	The method returning the attribute data given a name.
virtual bool	setAttributeOfType (const std::string &attributeName, const void *data, const std::type_info &typeInfo, const std::string &option) override
	The method setting the attribute data given a name.

Private Member Functions
bool	checkInRegistry ()
	Checks in the registry if the database handler already exists.
void	initMessaging () const
	Initialize our message level and MessageSvc.

Private Attributes
UserSession &	m_session
	Reference to the session.
IFileCatalog &	m_catalog
	Reference to the file catalog.
Io::IoFlag	m_transactionType
	Transaction type (read/update).
DatabaseRegistry &	m_registry
	Reference to the database registry.
std::string	m_name
	The database name.
DatabaseSpecification::NameType	m_nameType
	The database name spacification.
long	m_technology
	The technology identifier of the database.
bool	m_technologySet
	Checks if the technology identifier has been set.
DatabaseHandler *	m_databaseHandler
	The underlying database handler.
Io::IoFlag	m_openMode
	Current open mode.
bool	m_alreadyConnected
	Flag indicating whether a connection has been already made once.
std::string	m_the_fid
	Other names used.
std::string	m_the_pfn
std::string	m_nm
	Message source name.
boost::thread_specific_ptr< MsgStream >	m_msg_tls
	MsgStream instance (a std::cout like with print-out levels).
std::atomic< IMessageSvc * >	m_imsg { nullptr }
	MessageSvc pointer.
std::atomic< MSG::Level >	m_lvl { MSG::NIL }
	Current logging level.
std::atomic_flag m_initialized	ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
	Messaging initialized (initMessaging).

Detailed Description

UserDatabase is an implementation of the IDatabase interface.

Definition at line 27 of file UserDatabase.h.

Constructor & Destructor Documentation

UserDatabase()

pool::UserDatabase::UserDatabase	(	pool::UserSession &	session,
		const std::string &	name,
		const DatabaseSpecification::NameType	nameType )

Constructor.

Definition at line 20 of file UserDatabase.cxx.

                                                                                    :
  APRMessaging("PersistencySvc::UserDB"),                                                  
  m_session( session ),
  m_catalog( session.fileCatalog() ),
  m_transactionType( session.type() ),
  m_registry( session.registry() ),
  m_name( name ),
  m_nameType( nameType ),
  m_technology( 0 ),
  m_technologySet( false ),
  m_databaseHandler( 0 ),
  m_openMode( Io::INVALID ),
  m_alreadyConnected( false ),
  m_the_fid( "" ),
  m_the_pfn( "" )
{
  this->checkInRegistry();
}

~UserDatabase()

pool::UserDatabase::~UserDatabase ( )

virtual

Destructor.

Definition at line 42 of file UserDatabase.cxx.

{}

Member Function Documentation

attributeOfType()

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

overrideprotectedvirtual

The method returning the attribute data given a name.

Implements pool::IDatabase.

Definition at line 363 of file UserDatabase.cxx.

{
  if ( ! m_databaseHandler ) return false;
  else return m_databaseHandler->attribute( attributeName, data, typeInfo, option );
}

checkInRegistry()

bool pool::UserDatabase::checkInRegistry ( )

private

Checks in the registry if the database handler already exists.

Definition at line 327 of file UserDatabase.cxx.

{
  // Check first if the database is already connected.
  switch( m_nameType ) {
  case pool::DatabaseSpecification::PFN:
    m_databaseHandler = m_registry.lookupByPFN( m_name );
    break;
  case pool::DatabaseSpecification::FID:
    m_databaseHandler = m_registry.lookupByFID( m_name );
    break;
  case pool::DatabaseSpecification::LFN:
    m_databaseHandler = m_registry.lookupByLFN( m_name );
    break;
  default:
    throw std::runtime_error( "Only PFN, LFN and FID database types are currently supported (APR: \" UserDatabase::checkInRegistry \" from \" PersistencySvc \")" );
  };
  if ( m_databaseHandler ) {
    m_alreadyConnected = true;
    m_technology = m_databaseHandler->technology();
    m_openMode   = m_databaseHandler->accessMode();
    m_the_fid = m_name = m_databaseHandler->fid();
    m_the_pfn = m_databaseHandler->pfn();
    m_nameType = pool::DatabaseSpecification::FID;
    return true;
  }
  else return false;
}

connectForRead()

void pool::UserDatabase::connectForRead ( )

overridevirtual

Connects explicitly to the database for read operations.

Implements pool::IDatabase.

Definition at line 47 of file UserDatabase.cxx.

{
  if( !m_databaseHandler && m_transactionType != Io::INVALID ) {
    // Check if the database is already connected
    if( !checkInRegistry() ) {
      // It is not. Connect !
      switch( m_nameType ) {
      case pool::DatabaseSpecification::PFN:
        if ( this->fid().empty() ) {
          throw std::runtime_error( "PFN \"" + m_name + "\" is not existing (APR: \" UserDatabase::connectForRead \" from \" PersistencySvc \")" );
        }
        break;
 
      case pool::DatabaseSpecification::FID:
        if ( this->pfn().empty() ) {
          throw std::runtime_error( "FID \"" + m_name + "\" is not existing in the catalog (APR: \" UserDatabase::connectForRead \" from \" PersistencySvc \")" );
        }
        break;
      case pool::DatabaseSpecification::LFN:
        {
          std::string lfn = m_name;
          if ( this->fid().empty() ) {
            throw std::runtime_error( "LFN \"" + m_name + "\" is not existing in the catalog (APR: \" UserDatabase::connectForRead \" from \" PersistencySvc \")" );
          }
          this->connectForRead();
          m_registry.registerDatabaseHandler( m_databaseHandler, lfn );
        }
      return;
      break;
      default:
        throw std::runtime_error( "Unknown database name type (APR: \" UserDatabase::connectForRead \" from \" PersistencySvc \")" );
      };
 
      // Now we have all the usefull information to open the file.
      // Check the registry now that we have the FID (in case of ambiguous PFNs)
      m_databaseHandler = m_registry.lookupByFID( m_the_fid );
      if( !m_databaseHandler ) {
         // still no luck - make a new connection
         m_databaseHandler = m_session.microSessionManager( m_technology ).connect( m_transactionType, m_the_fid, m_the_pfn );
      }
      if( m_databaseHandler ) {
        m_openMode = Io::READ;
      }
      else {
        throw std::runtime_error( "Could not connect to the file (APR: \" UserDatabase::connectForRead \" from \" PersistencySvc \")" );
      }
    }
  }
}

connectForWrite()

void pool::UserDatabase::connectForWrite ( )

overridevirtual

Connects explicitly to the database for write/update operations.

Implements pool::IDatabase.

Definition at line 109 of file UserDatabase.cxx.

{
  if( !m_databaseHandler && m_transactionType != Io::INVALID ) {
    if ( m_transactionType != Io::WRITE && m_transactionType != Io::APPEND ) {
      throw std::runtime_error( "Could not open a database for write outside an update transaction. (APR: \" UserDatabase::connectForWrite \" from \" PersistencySvc \")" );
    }
 
    if ( this->checkInRegistry() ) {
      if ( m_openMode == Io::READ ) {
        throw std::runtime_error( "Could not open a database for write that is already connected for read. (APR: \" UserDatabase::connectForWrite \" from \" PersistencySvc \")" );
      }
    }
    else { // The database is not yet connected.
      bool dbRegistered = false;
      switch( m_nameType ) {
      case pool::DatabaseSpecification::PFN:
        m_the_pfn = m_name;
        if ( this->fid().empty() ) {
      // Check if the technology is already set
      if( ! m_technologySet ) {
         throw std::runtime_error( "The back end technology has not been specified (APR: \" UserDatabase::connectForWrite \" from \" PersistencySvc \")" );
      }
      // register in the catalog 
      pool::DbType dbType( m_technology );
      pool::DbType dbTypeMajor( dbType.majorType() );
      m_catalog.registerPFN( m_the_pfn.substr(0, m_the_pfn.find('?')), dbTypeMajor.storageName(), m_the_fid );
          ATH_MSG_DEBUG("registered PFN: " << m_the_pfn << " with FID:" << m_the_fid);
      dbRegistered = true;
        }
        break;
      case pool::DatabaseSpecification::FID:
        m_the_fid = m_name;
        if ( this->pfn().empty() ) {
          throw std::runtime_error( "Could not find the FID \"" + m_name + "\" in the file catalog (APR: \" UserDatabase::connectForWrite \" from \" PersistencySvc \")" );
        }
        break;
      case pool::DatabaseSpecification::LFN:
        {
          std::string lfn = m_name;
          if ( this->fid().empty() ) {
            throw std::runtime_error( "Could not find the LFN \"" + m_name  + "\" in the file catalog (APR: \" UserDatabase::connectForWrite \" from \" PersistencySvc \")" );
          }
          this->connectForWrite();
          m_registry.registerDatabaseHandler( m_databaseHandler, lfn );
        }
        return;
        break;
      default:
        throw std::runtime_error( "Unknown database name type (APR: \" UserDatabase::connectForWrite \" from \" PersistencySvc \")" );
      };
 
      m_databaseHandler = m_session.microSessionManager( m_technology ).connect( m_transactionType, m_the_fid, m_the_pfn );
      if( !m_databaseHandler ) {
        if( dbRegistered ) {
          // creation failed, remove entry from the in-memory catalog
          m_catalog.deleteFID( m_the_fid );
        }
        throw std::runtime_error( "Could not connect to the file (APR: \" UserDatabase::connectForWrite \" from \" PersistencySvc \")" );
      }
      m_openMode = m_transactionType == Io::WRITE ? Io::WRITE : Io::APPEND;
    } // Connection established
 
  } // Database handler retrieved
}

containerHandle()

pool::IContainer * pool::UserDatabase::containerHandle ( const std::string & name )

overridevirtual

Returns a pointer to a container object. The user acquires ownership of that object.

Implements pool::IDatabase.

Definition at line 316 of file UserDatabase.cxx.

{
  pool::IContainer* container = 0;
  if ( m_databaseHandler ) {
    container = m_databaseHandler->container( name );
  }
  return container;
}

containers()

std::vector< std::string > pool::UserDatabase::containers ( )

overridevirtual

Returns the names of the containers in this database.

Implements pool::IDatabase.

Definition at line 305 of file UserDatabase.cxx.

{
  std::vector< std::string > containers;
  if ( m_databaseHandler ) {
    containers = m_databaseHandler->containers();
  }
  return containers;
}

disconnect()

void pool::UserDatabase::disconnect ( )

overridevirtual

Disconnects from the database.

Implements pool::IDatabase.

Definition at line 189 of file UserDatabase.cxx.

{
  if ( m_databaseHandler ) {
    m_session.microSessionManager( m_technology ).disconnect( m_databaseHandler );
    m_openMode = Io::INVALID;
  }
}

fid()

const std::string & pool::UserDatabase::fid ( )

overridevirtual

Returns the file identifier of this database.

Implements pool::IDatabase.

Definition at line 206 of file UserDatabase.cxx.

{
  if ( m_databaseHandler ) return m_databaseHandler->fid();
  else {
    if ( m_nameType == pool::DatabaseSpecification::FID ) return m_name;
    else if ( !m_the_fid.empty() ) return m_the_fid;
    else {
      if ( m_nameType == pool::DatabaseSpecification::PFN ) {
         std::string technology;
         m_catalog.lookupFileByPFN( m_name.substr(0, m_name.find('?')), m_the_fid, technology );
         ATH_MSG_DEBUG("lookupPFN: " << m_name << " returned FID: '" << m_the_fid << "' tech=" << technology);
         if ( ! m_the_fid.empty() ) {
            if( technology.empty() ) {
               m_nameType = DatabaseSpecification::LFN;
               ATH_MSG_DEBUG("Retrying 'connect' using assumed PFN " << m_name << " as LFN (no tech found in PFC)" );
               return m_the_fid;
            }
            m_the_pfn = m_name;
            m_technology = pool::DbType::getType( technology ).majorType();
            m_alreadyConnected = true;
         }
         else {
           if( m_transactionType != Io::WRITE ) { // Fetch the FID from the db itself !
              if( !m_technologySet ) {
                 ATH_MSG_DEBUG("Opening database '" << m_name << "' with no technology set");
                 m_technology = pool::ROOT_StorageType.type();
                 m_technologySet = true;
              }
              m_the_fid = m_session.microSessionManager( m_technology ).fidForPfn( m_name );
              if( ! m_the_fid.empty() ) {
                 // sanity check - verify that the FID is not registered in PFC under a different name
                 std::string  pfn, tech;
                 m_catalog.getFirstPFN( m_the_fid, pfn, tech );
                 if( !pfn.empty() ) {
                    ATH_MSG_WARNING("Opening file '" << m_name << "' which is already registered in the Catalog as '" << pfn 
                                    <<"' (GUID " << m_the_fid << ") - this is not supported and may even lead to a crash!" );
                 }
                 m_the_pfn = m_name;
                 m_alreadyConnected = true;
              }
           }
        }
      } /* not PFN */
      else if ( m_nameType == pool::DatabaseSpecification::LFN ) {
         m_the_fid = m_catalog.lookupLFN( m_name );
      }
      if ( ! m_the_fid.empty() ) {
        m_name = m_the_fid;
        m_nameType = pool::DatabaseSpecification::FID;
      }
      return m_the_fid;
    }
    return emptyString;
  }
}

fileDescriptor()

pool::FileDescriptor * pool::UserDatabase::fileDescriptor ( )

finaloverridevirtual

Expose FileDescriptor object for the technology specific DB implementation.

Implements pool::IDatabase.

Definition at line 356 of file UserDatabase.cxx.

{
  return m_databaseHandler? &m_databaseHandler->fileDescriptor() : nullptr;
}

initMessaging()

void AthMessaging::initMessaging ( ) const

privateinherited

Initialize our message level and MessageSvc.

This method should only be called once.

Definition at line 39 of file AthMessaging.cxx.

{
  m_imsg = Athena::getMessageSvc();
  // If user did not set an explicit level, set a default
  if (m_lvl == MSG::NIL) {
    m_lvl = m_imsg ?
      static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
      MSG::INFO;
  }
}

msg() [1/2]

MsgStream & AthMessaging::msg ( ) const

inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 167 of file AthMessaging.h.

{
  MsgStream* ms = m_msg_tls.get();
  if (!ms) {
    if (!m_initialized.test_and_set()) initMessaging();
    ms = new MsgStream(m_imsg,m_nm);
    m_msg_tls.reset( ms );
  }
 
  ms->setLevel (m_lvl);
  return *ms;
}

msg() [2/2]

MsgStream & AthMessaging::msg ( const MSG::Level lvl ) const

inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 182 of file AthMessaging.h.

{ return msg() << lvl; }

msgLvl()

bool AthMessaging::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Test the output level.

Parameters

lvl	The message level to test against

Returns

boolean Indicating if messages at given level will be printed

Return values

true	Messages at level "lvl" will be printed

Definition at line 151 of file AthMessaging.h.

{
  // If user did not set explicit message level we have to initialize
  // the messaging and retrieve the default via the MessageSvc.
  if (m_lvl==MSG::NIL && !m_initialized.test_and_set()) initMessaging();
 
  if (m_lvl <= lvl) {
    msg() << lvl;
    return true;
  } else {
    return false;
  }
}

openMode()

Io::IoFlag pool::UserDatabase::openMode ( ) const

overridevirtual

Returns the opening mode. It can be used to check whether the database is connected.

Implements pool::IDatabase.

Definition at line 199 of file UserDatabase.cxx.

{
  return m_openMode;
}

pfn()

const std::string & pool::UserDatabase::pfn ( )

overridevirtual

Returns the physical file name of this database.

Implements pool::IDatabase.

Definition at line 264 of file UserDatabase.cxx.

{
  if( m_databaseHandler )  return m_databaseHandler->pfn();
  if( m_nameType == pool::DatabaseSpecification::PFN )  return m_name;
  if( ! m_the_pfn.empty() )  return m_the_pfn;
  
  if( m_nameType == pool::DatabaseSpecification::LFN ) {
     m_the_fid = m_catalog.lookupLFN( m_name );
     if ( ! m_the_fid.empty() ) {
        m_name = m_the_fid;
        m_nameType = pool::DatabaseSpecification::FID;
        // go from FID=>PFN in the next step
     }
  }
  if( m_nameType == pool::DatabaseSpecification::FID ) {
     std::string technology;
     m_catalog.getFirstPFN( m_name, m_the_pfn, technology );
     if( !m_the_pfn.empty() ) {
        m_the_fid = m_name;
        m_technology = pool::DbType::getType( technology ).majorType();
        m_alreadyConnected = true;
     }
     return m_the_pfn; 
  }
  return emptyString;
}

readObject()

void * pool::UserDatabase::readObject	(	const Token &	token,
		void *	object = 0 )

Reads an object given a token.

Definition at line 99 of file UserDatabase.cxx.

{
   if( !m_databaseHandler) {
      throw std::runtime_error( "Could not open a database for read object. (APR: \" UserDatabase::connectForWrite \" from \" PersistencySvc \")" );
   }
   return m_databaseHandler->readObject( token, object );
}

setAttributeOfType()

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

overrideprotectedvirtual

The method setting the attribute data given a name.

Implements pool::IDatabase.

Definition at line 374 of file UserDatabase.cxx.

{
  if ( ! m_databaseHandler ) return false;
  else return m_databaseHandler->setAttribute( attributeName, data, typeInfo, option );
}

setLevel()

void AthMessaging::setLevel ( MSG::Level lvl )

inherited

Change the current logging level.

Use this rather than msg().setLevel() for proper operation with MT.

Definition at line 28 of file AthMessaging.cxx.

{
  m_lvl = lvl;
}

setTechnology()

bool pool::UserDatabase::setTechnology ( long technology )

overridevirtual

Sets the technology identifier for this database.

This can only be called for newly created databases before the connect method is called. Otherwise false is returned.

Implements pool::IDatabase.

Definition at line 292 of file UserDatabase.cxx.

{
  if ( m_alreadyConnected ) return false;
  else {
    pool::DbType dbType( technology );
    m_technology = dbType.majorType();
    m_technologySet = true;
    return true;
  }
}

writeObject()

Token * pool::UserDatabase::writeObject	(	const std::string &	containerName,
		long	minorTechnology,
		const void *	object,
		const RootType &	type )

Writes an object and returns a token.

Definition at line 176 of file UserDatabase.cxx.

{
   if( !m_databaseHandler) {
      throw std::runtime_error( "Could not open a database for write object. (APR: \" UserDatabase::connectForWrite \" from \" PersistencySvc \")" );
   }
   return m_databaseHandler->writeObject( containerName, minorTechnology, object, type );
}

Member Data Documentation

ATLAS_THREAD_SAFE

std::atomic_flag m_initialized AthMessaging::ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT

mutableprivateinherited

Messaging initialized (initMessaging).

Definition at line 141 of file AthMessaging.h.

m_alreadyConnected

bool pool::UserDatabase::m_alreadyConnected

private

Flag indicating whether a connection has been already made once.

Definition at line 115 of file UserDatabase.h.

m_catalog

IFileCatalog& pool::UserDatabase::m_catalog

private

Reference to the file catalog.

Definition at line 97 of file UserDatabase.h.

m_databaseHandler

DatabaseHandler* pool::UserDatabase::m_databaseHandler

private

The underlying database handler.

Definition at line 111 of file UserDatabase.h.

m_imsg

std::atomic<IMessageSvc*> AthMessaging::m_imsg { nullptr }

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

{ nullptr };

m_lvl

std::atomic<MSG::Level> AthMessaging::m_lvl { MSG::NIL }

mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

{ MSG::NIL };

m_msg_tls

boost::thread_specific_ptr<MsgStream> AthMessaging::m_msg_tls

mutableprivateinherited

MsgStream instance (a std::cout like with print-out levels).

Definition at line 132 of file AthMessaging.h.

m_name

std::string pool::UserDatabase::m_name

private

The database name.

Definition at line 103 of file UserDatabase.h.

m_nameType

DatabaseSpecification::NameType pool::UserDatabase::m_nameType

private

The database name spacification.

Definition at line 105 of file UserDatabase.h.

m_nm

std::string AthMessaging::m_nm

privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

m_openMode

Io::IoFlag pool::UserDatabase::m_openMode

private

Current open mode.

Definition at line 113 of file UserDatabase.h.

m_registry

DatabaseRegistry& pool::UserDatabase::m_registry

private

Reference to the database registry.

Definition at line 101 of file UserDatabase.h.

m_session

UserSession& pool::UserDatabase::m_session

private

Reference to the session.

Definition at line 95 of file UserDatabase.h.

m_technology

long pool::UserDatabase::m_technology

private

The technology identifier of the database.

Definition at line 107 of file UserDatabase.h.

m_technologySet

bool pool::UserDatabase::m_technologySet

private

Checks if the technology identifier has been set.

Definition at line 109 of file UserDatabase.h.

m_the_fid

std::string pool::UserDatabase::m_the_fid

private

Other names used.

Definition at line 117 of file UserDatabase.h.

m_the_pfn

std::string pool::UserDatabase::m_the_pfn

private

Definition at line 118 of file UserDatabase.h.

m_transactionType

Io::IoFlag pool::UserDatabase::m_transactionType

private

Transaction type (read/update).

Definition at line 99 of file UserDatabase.h.

---

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

• UserDatabase.h
• UserDatabase.cxx