Bdb packages | Design docs | Source docs | Guidelines | Recent releases
	Search | Site Map .

                 

---

/BdbDomainOODB/BdbDomainOODB.cc

Go to the documentation of this file.

//--------------------------------------------------------------------------
// File and Version Information:
//  $Id: BdbDomainOODB.cc,v 1.9 2002/08/12 18:41:20 becla Exp $
//
// Description:
//  Class BdbDomainOODB implementation file. This class represents an 
//  BaBar database application domain.
//
// Environment:
//  Software developed for the BaBar Detector at the SLAC B-Factory.
//
// Author List:
//  David R. Quarrie                Original Author
//  Igor A. Gaponenko               Modified to support *DBFS* interface
//
// History:
//
//------------------------------------------------------------------------
//-----------------------
// This Class's Header --
//-----------------------
#include "BdbDomainOODB/BdbDomainOODB.hh"

//-------------
// C Headers --
//-------------
extern "C" {
#include <stdlib.h> // abort
#include <strings.h>
}

//---------------
// C++ Headers --
//---------------

//-------------------------------
// Collaborating Class Headers --
//-------------------------------
#include "ErrLogger/ErrLog.hh"

#include "BdbDomainOODB/BdbImplDomainOODB.hh"
#include "BdbUtil/BdbDebug.hh"

//-----------------------------------------------------------------------
// Local Macros, Typedefs, Structures, Unions and Forward Declarations --
//-----------------------------------------------------------------------

static const char rcsid[] = "$Id: BdbDomainOODB.cc,v 1.9 2002/08/12 18:41:20 becla Exp $";

//----------------------------------
// default implementation classes --
//----------------------------------

#include "BdbDomainOODB/BdbNoOpenTransFunc.hh"
#include "BdbDomainOODB/BdbCheckPointFunc.hh"

class BdbNoOpNoOpenTransFunc
   : public BdbNoOpenTransFunc
{
   protected:
      // Modifiers
      virtual bool execute() { return( !false ) ; }
} ;

class BdbNoOpCheckPointFunc
   : public BdbCheckPointFunc
{
   public:
      // Selectors (const)
      virtual bool transNotOpen() { return( false ) ; } ;

   protected:
      // Modifiers
      virtual bool execute() { return( !false ) ; }
} ;

//      ------------------------------------
//      -- Static Data Member Definitions --
//      ------------------------------------

BdbDomainOODB* BdbDomainOODB::_ringEntrance( 0 ) ;
d_ULong BdbDomainOODB::_activationCount( 0 ) ;

//      ----------------------------------------
//      -- Static Function Member Definitions --
//      ----------------------------------------

BdbDomainOODB*
BdbDomainOODB::activeDomainOODB()
{
   if( 0 == _ringEntrance ) {
      return 0 ;
   }

   return( _ringEntrance->_impl->activeClient() ) ;
}

BdbNoOpenTransFunc&
BdbDomainOODB::noOpNoOpen()
{
   static BdbNoOpNoOpenTransFunc noOp ;
   return( noOp ) ;
}

BdbCheckPointFunc&
BdbDomainOODB::noOpCheckPoint()
{
   static BdbNoOpCheckPointFunc noOp ;
   return( noOp ) ;
}

//      ----------------------------------------
//      -- Public Function Member Definitions --
//      ----------------------------------------

//---------------
// Constructor --
//---------------

BdbDomainOODB::BdbDomainOODB( BdbImplDomainOODB* implementation )
   : _impl( implementation ) ,
     _isActive( false ) ,
     _next( 0 ) ,
     _previous( 0 )
{
   if( 0 == _ringEntrance ) {
      addToRing( _ringEntrance ) ;
      _ringEntrance = this ;
   }
   else {
      if( 0 != _ringEntrance->matchLabel( implementation->label(),
                                          _ringEntrance ) ) {
         ErrMsg( fatal ) << "Can not run two BdbDomainOODBs with the same"
                         << " label!"
                         << endmsg ;
         ::abort() ;
      }
      addToRing( _ringEntrance ) ;
   }


   _impl->setClient( *this ) ;

   return ;
}

//--------------
// Destructor --
//--------------

BdbDomainOODB::~BdbDomainOODB( ) 
{
   if( _ringEntrance == this ) {
      if( _next == _previous ) {
         _ringEntrance = 0 ;
      }
      else {
         _ringEntrance = _next ;
      }
   }

   removeFromRing() ;

   delete _impl ;
}

//-------------
// Selectors --
//-------------

d_Boolean
BdbDomainOODB::oodbIsInitialized() const
{
    return _impl->oodbIsInitialized() ;
}

const char*
BdbDomainOODB::bootName() const
{
    return _impl->bootName();
}

const char*
BdbDomainOODB::dirName( ) const
{
    return _impl->dirName( );
}
    
const char*
BdbDomainOODB::hostName( ) const
{
    return _impl->hostName( );
}

d_ULong 
BdbDomainOODB::cacheInitPages( ) const
{
    return _impl->cacheInitPages( );
}

d_ULong 
BdbDomainOODB::cacheMaxPages(  ) const
{
    return _impl->cacheMaxPages( );
}

d_ULong 
BdbDomainOODB::fileDescriptors(  ) const
{
    return _impl->fileDescriptors( );
}

BdbAMSUsage
BdbDomainOODB::amsUsage(  ) const
{
    return _impl->amsUsage( );
}

//-------------
// Modifiers --
//-------------

void 
BdbDomainOODB::setCacheInitPages( d_ULong thePages )
{
    _impl->setCacheInitPages( thePages );
}

void 
BdbDomainOODB::setCacheMaxPages( d_ULong thePages )
{
    _impl->setCacheMaxPages( thePages );
}

void 
BdbDomainOODB::setFileDescriptors( d_ULong theFiles )
{
    _impl->setFileDescriptors( theFiles );
}

void
BdbDomainOODB::setAMSUsage( BdbAMSUsage amsUsage )
{
   _impl->setAMSUsage( amsUsage ) ;
}

void 
BdbDomainOODB::setStandalone()
{
    _impl->setStandalone() ;
}

void
BdbDomainOODB::ignoreErrors()
{
    _impl->setIgnoreErrors( d_True ) ;
}

void
BdbDomainOODB::noticeErrors()
{
    _impl->setIgnoreErrors( d_False ) ;
}

void
BdbDomainOODB::setBootName( const char* bootName )
{
    _impl->setBootName( bootName ) ;
}

void
BdbDomainOODB::setDefaultBootName( const char* bootName )
{
    _impl->setDefaultBootName( bootName ) ;
}

void
BdbDomainOODB::holdCurrentTrans()
{
    _impl->holdCurrentTrans() ;
}

void
BdbDomainOODB::dropCurrentTrans()
{
    _impl->dropCurrentTrans() ;
}

void
BdbDomainOODB::setCurrentTrans( const BdbTransToken& token )
{
    _impl->setCurrentTrans( token ) ;
}

BdbTransToken
BdbDomainOODB::newCurrentTrans()
{
    return( _impl->newCurrentTrans() ) ;
}

/* phase 3.3 extension to allow creation of output transaction 
         associated with a different federation
*/
BdbTransToken
BdbDomainOODB::newCurrentTrans(const char *newBootName)
{
    return( _impl->newCurrentTrans(newBootName) ) ;
}

//--------------
// Operations --
//--------------

void
BdbDomainOODB::setIndexMode( BdbIndexMode indexMode )
{
    _impl->setIndexMode( indexMode );
}

void
BdbDomainOODB::setMrowMode( BdbMode mrowMode )
{
    _impl->setMrowMode( mrowMode );
}

void
BdbDomainOODB::setInhibitPolicy( const BdbInhibitPolicy* policy )
{
    _impl->setInhibitPolicy( policy ) ;
}

d_Boolean
BdbDomainOODB::hasInhibitPolicy( ) const
{
    return _impl->hasInhibitPolicy( );
}

BdbTransToken
BdbDomainOODB::currentTransToken() const
{
    return _impl->currentTransToken() ;
}

d_Boolean
BdbDomainOODB::currentTransIsHeld() const
{
    return _impl->currentTransIsHeld() ;
}
d_Boolean
BdbDomainOODB::isStandalone() const
{
    return _impl->isStandalone();
}

d_Long
BdbDomainOODB::rpcTimeout( ) const
{
    return _impl->rpcTimeout( );
}

void
BdbDomainOODB::setRpcTimeout( d_Long secs )
{
    _impl->setRpcTimeout( secs );
}

d_Boolean
BdbDomainOODB::isVTablePointerChecked( ) const
{
    return _impl->checkVTablePointer() ;
}

void 
BdbDomainOODB::setCheckVTablePointer( d_Boolean isChecked )
{
    _impl->setCheckVTablePointer( isChecked );
}

d_Long 
BdbDomainOODB::lockWait( ) const
{
    return _impl->lockWait( );
}

void 
BdbDomainOODB::setLockWait( d_Long waitMode )
{
    _impl->setLockWait( waitMode );
}

BdbIndexMode
BdbDomainOODB::indexMode() const
{
    return _impl->indexMode();
}

BdbMode
BdbDomainOODB::mrowMode() const
{
    return _impl->mrowMode();
}

BdbTransId
BdbDomainOODB::transId() const
{
    return _impl->transId();
}

BdbHandleCacheMgr*
BdbDomainOODB::currentHandleCache( )
{
    return _impl->currentHandleCache() ;
}

// Implementation taked from BdbApplication

BdbStatus
BdbDomainOODB::updateAndWait( BdbHandleAny& theObj, 
                              const char* const thePrefix, 
                              d_ULong timeout )
{
    BdbStatus result  = BdbcError;
    d_ULong count     = 0;
    BdbMode theMrowMode = mrowMode();

    // First make a single attempt to gain the lock
    d_Long oldWait = lockWait( );
    setLockWait( 300 );
    result = theObj.update( );
    setLockWait( oldWait );

    if ( BdbcSuccess != result ) {
        // The lock attempt didn't succeed. Change the strategy to wait for 
        // multiples of 1 minute up to the specified timeout limit. First 
        // release all resources by committing the transaction and starting
        // a new one.
        commit            ( thePrefix );
        setMrowMode( theMrowMode );
        startUpdate       ( thePrefix );

        setLockWait( 60 );
        while ( ( BdbcSuccess != result ) && ( count < timeout ) ) {
            // Attempt to lock the object for updating
            result = theObj.update( );
            if ( BdbcSuccess != result ) {
                // Attempt wasn't successful - issue some debug information & try again
                char charbuf[256];
                ooId theID = theObj;
                sprintf( charbuf, "[%d,%d]", theID.get_DB( ), theID.get_OC( ) ); 
                COUT1 << "BdbDomainOODB::updateAndWait: Update attempt on "
                      << charbuf << " failed - retrying..." << endl;
                ErrMsg( warning ) << "BdbDomainOODB::updateAndWait"
                                  << ": Update collision detected on "
                                  << charbuf << " - waiting..." << endmsg ;
            }
            count++;
        }
        setLockWait( oldWait );
    }
    if ( BdbcSuccess != result ) {
       ErrMsg( error ) << "BdbDomainOODB::updateAndWait"
                       << ": Update collision wait timeout exceeded"
                       << endmsg ;
    }
    return result; 
}

BdbStatus
BdbDomainOODB::updateAndWait( BdbHandleAny theHandles[], int nrElem, 
                              const char* const thePrefix, 
                              d_ULong timeout )
{
    BdbStatus result  = BdbcError;
    BdbMode theMrowMode = mrowMode( );
    d_Boolean gotLock = d_False;
    int i, failedItem    = 0;

    // First make a single attempt to gain the lock(s), failing immediately
    // with no lock waiting if there's a problem. However, remember the
    // first item that failed and use as the first one to try for the
    // next attempt.
    d_Long oldWait = lockWait( );
    setLockWait( 300 );
    for ( i=0; i<nrElem; i++ ) {
        if ( ( result = theHandles[i].update( ) ) != BdbcSuccess ) {
            failedItem = i;
            break;
        }
    }
    setLockWait( oldWait );

    if ( BdbcSuccess != result ) {

        // The lock attempt didn't succeed. Change the strategy to wait for 
        // multiples of 1 minute up to the specified timeout limit. First 
        // release all resources by committing the transaction and starting
        // a new one.
        commit     ( thePrefix );
        setMrowMode( theMrowMode );
        startUpdate( thePrefix );
        d_ULong count = 0;
        while ( ( BdbcSuccess != result ) && ( count < timeout ) ) {
            gotLock = d_False;

            // Attempt to lock one object for updating, waiting for up to 60 secs.
            // The object that's used for this is the first one that previous failed.
            setLockWait( 60 );
            result = theHandles[failedItem].update( );
            if ( BdbcSuccess == result ) {
                gotLock = d_True;

                // Lock gained on the first object. Attempt to lock the others.
                // Note that this attempt is done with zero lock waiting. 
                // Remember the first failure for the next attempt.
                setLockWait( BdbcNoWait );
                for ( i=0; i<nrElem; i++ ) {
                    if ( ( result = theHandles[i].update( ) ) != BdbcSuccess ) {
                        failedItem = i;
                        break;
                    }
                }
            }
            if ( BdbcSuccess != result ) {
                // Attempt wasn't successful - issue some debug information & try again.
                // If any objects were locked, release them by commiting the current
                // transaction and starting a new one.
                char charbuf[256];
                ooId theID = theHandles[failedItem];
                sprintf( charbuf, "[%d,%d]", theID.get_DB( ), theID.get_OC( ) ); 
                COUT1 << "BdbDomainOODB::updateAndWait: Update attempt on "
                      << charbuf  << " (of multiple) failed - retrying..." << endl;
                ErrMsg( warning ) << "BdbDomainOODB::updateAndWait"
                                  << ": Update collision detected on "
                                  << charbuf << " - waiting..." << endmsg ;
                if ( gotLock ) {
                    commit     ( thePrefix );
                    setMrowMode( theMrowMode );
                    startUpdate( thePrefix );
                }
            }
            count++;
            setLockWait( oldWait );
        }
    }
    if ( BdbcSuccess != result ) {
       ErrMsg( error ) << "BdbDomainOODB::updateAndWait"
                       << ": Update collision wait timeout exceeded"
                       << endmsg ;
    }
    return result; 
}
// end implementation

BdbHandle(BdbFDObj)&
BdbDomainOODB::fd( ) const
{
    return _impl->fd( );
}

d_Boolean
BdbDomainOODB::isActive() const
{
    return _impl->isActive() ;
}

d_Boolean
BdbDomainOODB::transIsOpen() const
{
   return BdbcNoOpen != _impl->mode() ;
}

BdbStatus
BdbDomainOODB::activate() const
{
   char* inset = new char[ _activationCount + 1 ] ;
   for( d_ULong depth( 0 ) ;
        _activationCount != depth ;
        depth++ ) {
      inset[ depth ] = ' ' ;
   }
   inset[ _activationCount ] = '\0' ;
   _activationCount++ ;
   COUT2 << "ACTIVE DOMAIN: "
         << inset
         << "Activating Domain \""
         << _impl->label()
         << "\""
         << endl ;
   delete [] inset ;
   return _impl->activate() ;
}

BdbStatus
BdbDomainOODB::deactivate() const
{
   if( 0 == _activationCount ) {
      ErrMsg( fatal ) << "No activate domain, so can not deactivate one!"
                      << endmsg ;
      ::abort() ;
   }
   _activationCount-- ;
   char* inset = new char[ _activationCount + 1 ] ;
   for( d_ULong depth( 0 ) ;
        _activationCount != depth ;
        depth++ ) {
      inset[ depth ] = ' ' ;
   }
   inset[ _activationCount ] = '\0' ;
   COUT2 << "ACTIVE DOMAIN: "
         << inset
         << "Deactivating Domain \""
         << _impl->label()
         << "\""
         << endl ;
   delete [] inset ;
   return _impl->deactivate() ;
}
  
BdbStatus 
BdbDomainOODB::startUpdate( const char* theTag )
{
    activate() ;
    return _impl->startUpdate( theTag ) ;
}

BdbStatus 
BdbDomainOODB::startRead( const char* theTag )
{
    activate() ;
    return _impl->startRead( theTag );
}

BdbStatus 
BdbDomainOODB::abort( const char* theTag )
{
    BdbStatus result( _impl->abort( theTag ) );
    deactivate() ;
    return result ;
}

BdbStatus 
BdbDomainOODB::commit( const char* theTag )
{
    BdbStatus result( _impl->commit( theTag ) );
    deactivate() ;
    return result ;
}

BdbStatus 
BdbDomainOODB::commitAndHold( const char* theTag )
{
    BdbStatus result( _impl->commitAndHold( theTag ) );
    deactivate() ;
    return result ;
}

BdbStatus 
BdbDomainOODB::checkPoint( const char* theTag )
{
    return checkPoint( noOpCheckPoint() ,
                       theTag ) ;
}

BdbStatus 
BdbDomainOODB::checkPoint( BdbCheckPointFunc& theFunction ,
                           const char* theTag )
{
    activate() ;
    BdbStatus result( _impl->checkPoint( theFunction ,
                                         theTag ) );
    deactivate() ;
    return result ;
}

BdbMode
BdbDomainOODB::change( BdbMode theMode, d_Boolean forceCommit , const char* theTag )
{
    activate() ;
    BdbMode result( _impl->change( theMode, forceCommit, theTag ) );
    deactivate() ;
    return result ;
}

BdbStatus 
BdbDomainOODB::closeAllAndReopen( const char* theTag )
{
    return closeAllAndReopen( noOpNoOpen() ,
                              theTag ) ;
}

BdbStatus 
BdbDomainOODB::closeAllAndReopen( BdbNoOpenTransFunc& theFunction ,
                                  const char* theTag )
{
    activate() ;
    BdbStatus result( _impl->closeAllAndReopen( theFunction ,
                                                theTag ) );
    deactivate() ;
    return result ;
}

BdbMode
BdbDomainOODB::mode( ) const
{
    return _impl->mode( );
}

const char*
BdbDomainOODB::modeName() const
{
    return _impl->modeName();
}

const char*
BdbDomainOODB::modeName( BdbMode mode )
{
    return _impl->modeName( mode ) ;
}

BdbNestingOptToken
BdbDomainOODB::issueOptToken()
{
    return _impl->issueOptToken() ;
}

void
BdbDomainOODB::releaseOptToken( BdbNestingOptToken optToken )
{
    _impl->releaseOptToken( optToken ) ;
}

BdbStatus
BdbDomainOODB::startNestedRead( BdbNestingOptToken optToken )
{
    activate() ;
    return _impl->startNestedRead( optToken ) ;
}

BdbStatus
BdbDomainOODB::startNestedUpdate( BdbNestingOptToken optToken )
{
    activate() ;
    return _impl->startNestedUpdate( optToken ) ;
}

BdbStatus
BdbDomainOODB::commitNested( BdbNestingOptToken optToken )
{
    BdbStatus result( _impl->commitNested( optToken ) );
    deactivate() ;
    return result ;
}

//      -----------------------------------------
//      -- Private Function Member Definitions --
//      -----------------------------------------

const BdbDomainOODB*
BdbDomainOODB::matchLabel( const char* label ,
                           const BdbDomainOODB* loopStart ) const
{
   if( 0 == strcmp( label ,
                    _impl->label() ) ) {
      return( this ) ;
   }

   if( loopStart == _next ) {
      return( 0 ) ;
   }
   return( _next->matchLabel( label ,
                              loopStart ) ) ;
}

void
BdbDomainOODB::addToRing( BdbDomainOODB* predecessor )
{
   if( ( 0 != _next ) ||
       ( 0 != _previous ) ) {
      ErrMsg( fatal ) << "Can not add BdbDomainOODB to a ring as it is"
                      << " already in one!"
                      << endmsg ;
      ::abort() ;
   }

   if( 0 == predecessor ) {
      _next = this ;
      _previous = this ;
      return ;
   }

   // Set local pointers for ring
   _next = predecessor->_next ;
   _previous = _next->_previous ;
   if( predecessor != _previous ) {
      ErrMsg( fatal ) << "BdbDomainOODB ring structure broken!"
                      << endmsg ;
      ::abort() ;
   }

   // place this BdbDomainOODB in ring
   _next->_previous = this ;
   _previous->_next = this ;
}

void
BdbDomainOODB::removeFromRing()
{
   if( ( 0== _next ) ||
       ( 0 == _previous ) ) {
      ErrMsg( fatal ) << "Can not remove BdbDomainOODB from a ring as it is"
                      << " not in one!"
                      << endmsg ;
      ::abort() ;
   }

   _next->_previous = _previous ;
   _previous->_next = _next ;

   _next = 0 ;
   _previous = 0 ;
}

 

---

BaBar Public Site | SLAC | News | Links | Who's Who | Contact Us

Page Owner: Jacek Becla
Last Update: October 04, 2002