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

                 

---

/BdbApplMgmt/BdbApplication.cc

Go to the documentation of this file.

//--------------------------------------------------------------------------
// File and Version Information:
//      $Id: BdbApplication.cc,v 1.2 2002/06/21 18:32:18 ryd Exp $
//
// Description:
//      Class BdbApplication implementation file. This class represents an 
//      BaBar database application.     It is implemented as a singleton class,
//      having a single instance.
//
// Environment:
//      Software developed for the BaBar Detector at the SLAC B-Factory.
//
// Author List:
//      David R. Quarrie        Original Author
//
// History:
//
//------------------------------------------------------------------------
//-----------------------
// This Class's Header --
//-----------------------
#include "BdbApplMgmt/BdbApplication.hh"

//-------------
// C Headers --
//-------------
extern "C" {
#include <assert.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

}

//---------------
// C++ Headers --
//---------------
#include <iostream.h>

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

#include "BdbUtil/BdbDebug.hh"
#include "BdbDomainOODB/BdbMThreads.hh"
#include "BdbDomainOODB/BdbStatTimers.hh"
#include "BdbApplMgmt/BdbApplicationErrors.hh"
#include "BdbApplMgmt/BdbAbsInhibitMgr.hh"


#include <string>
using std::string;

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

static const char rcsid[] = "$Id: BdbApplication.cc,v 1.2 2002/06/21 18:32:18 ryd Exp $";

static ooErrorHandlerPtr defEHPtr;
d_Boolean      BdbApplication::_suppressErrorMsg = d_False;
BdbStatTimers* BdbApplication::_ats              = new BdbStatTimers;
int            BdbApplication::_pid              = getpid();

/**  BaBarObjyErrorHandler
 **
 **  This function replaces default Objectivity error handler.
 **  Error 3001 corresponds to a conflict with an existing lock on
 **  an object. Error 4577 correponds to a conflict with an existing
 **  lock on a container. Both of these are benign when they occur
 **  in BdbApplication::readAttempt, which is when this error handler
 **  is active.
 **
 **  Error 3028 corresponds to detection of a deadlock
 **/


ooStatus
BaBarObjyErrorHandler( ooErrorLevel errorLevel,
                       ooError& errorID,
                       ooHandle(ooObj)* contextObj,
                       char* errMsg )
{
    uint32 theError = errorID.errorN ;
    char charbuf[256];
    if ( 0 != contextObj ) {
        ooId theID = *contextObj;
        sprintf( charbuf, "[%d,%d]", theID.get_DB( ), theID.get_OC( ) ); 
    } else {
        sprintf( charbuf, "[null]" );
    }
    COUT1 << "BaBarObjyErrorHandler: ";
    
    if ( 3001 == theError || 4577 == theError ) {
        COUT1 << "Lock collision detected - context "
              << charbuf << " - backing off" << endl ;
        return BdbcError ;
    } else if ( 3028 == theError ) {
        COUT1 << "deadlock detected - context " << charbuf << endl;
        BdbSignal( BdbcWarning, BdbApplicationErrDeadlock,
                   0, "BaBarObjyErrorHandler", charbuf );
    } else if ( 4335 == theError || 3012 == theError || 11026 == theError ) {
        char command[128];
        sprintf(command, "oolockmon -detail 2>&1 > /tmp/oolockmon%i_%i.objy &", 
                         BdbApplication::_pid, (int) theError);
        COUT1 << "Issuing command: " << command << endl;
        system(command);
    } else {
        if ( BdbApplication::_suppressErrorMsg ) {
            return BdbcError;
        }
        COUT1 << "Error " << theError << " detected - context " 
              << charbuf << endl;
    }

    return defEHPtr( errorLevel, errorID, contextObj, errMsg );
}



/**  BaBarMessageHandler
 **
 ** This function replaces default Objectivity message handler.
 ** It redirects all Objy error messages to BaBar ErrLogger
 ** and reformats the data.
 **/

void
BaBarObjyMessageHandler(char* message)
{
    char *outBuf = new char [strlen(message) + 16] ;
    
    // - add "Objectivity/DB "
    strcpy(outBuf, "Objectivity/DB") ;

    // - remove leading "**"
    char * theMessage = message+2 ;

    // - remove "\n           " (if any)
    char *junk ;
    while ( (junk=strchr(theMessage, '\n')) != 0 ) {
        int length = junk - theMessage ;
        strncat(outBuf, theMessage, length) ;
        strcat(outBuf, " ") ;

        junk++ ;
        while ( *junk == ' ' ) {
            junk ++ ;
        }
        theMessage = junk ;
    }

    strcat(outBuf, theMessage) ;

    if ( oovLastErrorLevel == oocNoError ) {
        ErrMsg(routine) << outBuf << endmsg ;
    } else if ( oovLastErrorLevel == oocWarning ) {
        ErrMsg(warning) << outBuf << endmsg ;
    } else if ( oovLastErrorLevel == oocUserError ) {
        ErrMsg(error) << outBuf << endmsg ;
    } else if ( oovLastErrorLevel == oocSystemError ) {
        ErrMsg(error) << outBuf << endmsg ;
    } else if ( oovLastErrorLevel == oocFatalError ) {
        // ErrMsg(fatal) will end the job too soon.
        // Let Objy do this
        ErrMsg(error) << outBuf << endmsg ;
    }

    delete [] outBuf ;
}

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

BdbApplication*
BdbApplication::_instance = NULL;

BdbDebug*
BdbApplication::debug = NULL;

const char* 
BdbApplication::managementName = "management";


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

//---------
// Public -
//---------

BdbApplication* 
BdbApplication::activeInstance( )
{
    if ( NULL == _instance ) {
        new BdbApplication( );
    }
    return _instance;
}

const char*
BdbApplication::bootName( )
{
    char* result;

    result = getenv( "OO_FD_BOOT" );
    return result;
}



    
//----------
// Private -
//----------


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

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

BdbApplication::~BdbApplication( ) 
{
    if ( NULL != _name ) {
        delete [] _name;
        _name = NULL;
    }
    if ( NULL != _dirName ) {
        delete [] _dirName;
        _dirName = NULL;
    }
    if ( NULL != _hostName ) {
        delete [] _hostName;
        _hostName = NULL;
    }
    _ats->print();
}

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

d_Boolean
BdbApplication::verbose( ) const
{
    return _verbose;
}

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


void
BdbApplication::setName( const char* const theName )
{
    if ( NULL != _name ) {
        delete [] _name;
    }
    if ( NULL != theName ) {
        _name = new char[strlen( theName )+1];
        strcpy( _name, theName );
    }
}
    
void
BdbApplication::setVerbose( d_Boolean flag )
{
    _verbose = flag;
}

BdbStatTimers&
BdbApplication::statTimers()
{
   return( *_ats) ;
}

void
BdbApplication::ignoreErrors()
{
   _suppressErrorMsg = d_True ;
}

void
BdbApplication::noticeErrors()
{
   _suppressErrorMsg = d_False ;
}

//--------------------
// Helper functions --
//--------------------

d_Boolean
BdbApplication::dbExist( const char* dbName )
{
    d_Boolean result = d_False;
    BdbHandle(BdbDBObj) db ;
    initialize( );
    if ( db.exist(fd(), dbName, BdbcNoOpen) ) {
        result = d_False;
    }
    return result;
}

const char*
BdbApplication::dirName( ) const
{
    const char* bootFile;
    char component[256];
    char value[256];

    BdbApplication* self = (BdbApplication*)this;
    if ( 0 == _dirName ) {

        // The base directory name hasn't been setup explicitly, setup the
        // default location from the OO_FD_BOOT environment variable. This
        // should reference the boot file, which is parsed for a line of the
        // form "ooFDDBFileName=<file-name>". If found, the directory corresponding
        // to <file-name> is determined.

        if ( isBootFileValid( ) ) {
            bootFile = bootName( );
            if ( 0 == strstr( bootFile, "::" ) )
              {
                ifstream ifs;
                ifs.open( bootFile );
                while ( ifs && ( 0 == _dirName ) ) {
                  ifs.getline( component, 256, '=' );
                  ifs.getline( value, 256 );
                  if ( 0 == strcmp( component, "ooFDDBFileName" ) ) {
                    if ( 0 != strchr( value, '/' ) ) {
                      int i = strlen( value );
                      while ( i > 0 && value[i] != '/' ) {
                    i--;
                      }
                      value[i] = '\0';
                    } else {
                      getcwd( value, 256 );
                    }
                    self->setDirName( value );
                  }
                }
                ifs.close( );
              }
            else
              {
                string theBoot( bootFile );
                string dir( theBoot );
                size_t firstCol = dir.find_first_of( ':' );
                dir.erase( 0, firstCol+2 );
                size_t lastSlash = dir.find_last_of( '/' );
                dir.erase( lastSlash );
                self->setDirName( dir.c_str() );
              }
        }
    }
    return _dirName;
}
 




   
const char*
BdbApplication::hostName( ) const
{
    const char* bootFile;
    char component[256];
    static char value[256];

    BdbApplication* self = (BdbApplication*)this;
    if ( 0 == _hostName ) {

        // Parse the boot file for the catalog server host name.
        if ( isBootFileValid( ) ) {
            bootFile = bootName( );
            if ( 0 == strstr( bootFile, "::" ) )
              {
                ifstream ifs;
                ifs.open( bootFile );
                while ( ifs && ( 0 == _hostName ) ) {
                  ifs.getline( component, 256, '=' );
                  ifs.getline( value, 256 );
                  if ( 0 == strcmp( component, "ooFDDBHost" ) ) {
                    self->setHostName( value );
                  }
                }
                ifs.close( );
              }
            else
              {
                string theBoot( bootFile );
                string host( theBoot );
                size_t firstCol = host.find_first_of( ':' );
                host.erase( firstCol );
                self->setHostName( host.c_str() );
              }
        }
    }
    return _hostName;
}
    
void
BdbApplication::initialize( )
{
    // if oosession has not been initialised do it now
    if ( ! _isInitialized ) {

       ErrMsg( routine ) << "Initializing Objectivity using BdbApplication"
                         << " class"
                         << endmsg ;

        // Check for a valid OO_FD_BOOT location & file
        if ( isBootFileValid( ) ) {

            // Initialize Objectivity
            BdbSession::init();

            // Wait until the federation is marked as being available
            if ( 0 != _inhibitMgr ) {
                _inhibitMgr->waitUntilAvailable( );
            }

            // Set the default check vtable pointer mode
            checkVTablePointer( d_False );

            // Establish the error and message handlers
            ooRegMsgHandler(BaBarObjyMessageHandler) ;
            defEHPtr = ooRegErrorHandler(BaBarObjyErrorHandler) ;

            _isInitialized = d_True;
        }
    }
}

d_Boolean
BdbApplication::hasInhibitMgr( ) const
{
    return ( 0 != _inhibitMgr );
}

d_Boolean
BdbApplication::hasInhibitPolicy( ) const
{
   if( 0 == _inhibitMgr ) {
      return( false ) ;
   }
   return( _inhibitMgr->hasPolicy() ) ;
}

BdbAbsInhibitMgr*
BdbApplication::setInhibitMgr( BdbAbsInhibitMgr* iMgr )
{
    BdbAbsInhibitMgr* oldMgr = _inhibitMgr ;
    _inhibitMgr = iMgr;
    return( oldMgr ) ;
}

void
BdbApplication::setInhibitPolicy( const BdbInhibitPolicy* policy )
{
   if( 0 != _inhibitMgr ) {
      _inhibitMgr->setPolicy( policy ) ;
   }
}

d_Boolean
BdbApplication::isLocked(d_Boolean ignoreDelay) const
{
    if ( 0 != _inhibitMgr ) {
        return _inhibitMgr->isLocked(ignoreDelay);
    }
    return d_False;
}


d_Boolean
BdbApplication::isLocked4Read(d_Boolean ignoreDelay) const
{
    if ( 0 != _inhibitMgr ) {
        return _inhibitMgr->isLocked4Read(ignoreDelay);
    }
    return d_False;
}


d_Boolean
BdbApplication::oodbIsInitialized( ) const
{
    return _isInitialized;
}

BdbStatus
BdbApplication::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( BdbcNoWait );
    result = theObj.update( );
    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 );
        while ( ( BdbcSuccess != result ) && ( count < timeout ) ) {

            // Attempt to lock the object for updating, waiting for up to 60 secs
            setLockWait( 60 );
            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 << "BdbApplication::updateAndWait: Update attempt on "
                      << charbuf
                      << " failed - retrying..." << endl;
                BdbSignal( BdbcWarning, BdbApplicationErrUpdateWaiting, 0, 
                          "BdbApplication::updateAndWait", charbuf ); 
            }
            count++;
        }
    }
    if ( BdbcSuccess != result ) {
        BdbSignal( BdbcUserError, BdbApplicationErrUpdateWaitTimeout, 0, 
                  "BdbApplication::updateAndWait" ); 
    }
    setLockWait( oldWait );
    return result; 
}

BdbStatus
BdbApplication::updateAndWait( BdbHandleAny theHandles[], int nrElem, 
                               const char* const thePrefix, 
                               d_ULong timeout )
{
    int i;
    BdbStatus result  = BdbcError;
    BdbMode theMrowMode = mrowMode( );
    d_Boolean gotLock = d_False;
    int 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( BdbcNoWait );
    for ( i=0; i<nrElem; i++ ) {
        if ( ( result = theHandles[i].update( ) ) != BdbcSuccess ) {
            failedItem = i;
            break;
        }
    }
    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 << "BdbApplication::updateAndWait: Update attempt on "
                      << charbuf
                      << " (of multiple) failed - retrying..." << endl;
                BdbSignal( BdbcWarning, BdbApplicationErrUpdateWaiting, 0, 
                          "BdbApplication::updateAndWait(list)", charbuf ); 
                if ( gotLock ) {
                    commit     ( thePrefix );
                    setMrowMode( theMrowMode );
                    startUpdate( thePrefix );
                }
            }
            count++;
        }
    }
    if ( BdbcSuccess != result ) {
        BdbSignal( BdbcUserError, BdbApplicationErrUpdateWaitTimeout, 0, 
                  "BdbApplication::updateAndWait(list)" ); 
    }
    setLockWait( oldWait );
    return result; 
}

d_Boolean
BdbApplication::isVTablePointerChecked( ) const
{
    return _vtablePointerChecked;
}

void 
BdbApplication::checkVTablePointer( d_Boolean isChecked )
{
    ooCheckVTablePointer( isChecked );
    _vtablePointerChecked = isChecked;
}


void
BdbApplication::waitUntilAvailable4Read( ) const
{
    if ( 0 != _inhibitMgr ) {
        _inhibitMgr->waitUntilAvailable4Read( );
    }
}



void
BdbApplication::waitUntilAvailable( ) const
{
    if ( 0 != _inhibitMgr ) {
        _inhibitMgr->waitUntilAvailable( );
    }
}






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


void
BdbApplication::error( const char* const thePrefix, const char* theMessage ) const
{
    cerr << _name << "[" << thePrefix << "] error::" << theMessage << endl;
}


void 
BdbApplication::fatal( const char* const thePrefix, const char* theMessage, int exitCode ) const
{
    cerr << _name << "[" << thePrefix << "] fatal::" << theMessage << endl;
    exit( exitCode );
}    

void 
BdbApplication::message( const char* const thePrefix, const char* theMessage ) const
{
    cerr << _name << "[" << thePrefix << "]::" << theMessage << endl;
}
 
void 
BdbApplication::warning( const char* const thePrefix, const char* theMessage ) const
{
    cerr << _name << "[" << thePrefix << "] warning::" << theMessage << endl;
}
 
//      -------------------------------------------
//      -- Protected Function Member Definitions --
//      -------------------------------------------

//----------------
// Constructors --
//----------------

BdbApplication::BdbApplication( const char* const theName ) :
  _dirName               ( 0 ),
  _hostName              ( 0 ),
  _vtablePointerChecked  ( d_False ),
  _isInitialized         ( d_False ),
  _verbose               ( d_False ),
  _inhibitMgr            ( 0 )
{
    // If there is already an instance the DIE
    if ( 0 != _instance ) {
       ErrMsg( fatal ) << "Can not create a second instance of BdbApplication"
                       << endmsg ;
       ::abort() ;
    }

    if ( 0 != theName ) {
        _name = new char[strlen( theName )+1];
        strcpy( _name, theName );
    }

    _instance = this ;
}

void
BdbApplication::setDirName( const char* const theDirName )
{
    if ( NULL != _dirName ) {
        delete [] _dirName;
        _dirName = NULL;
    }
    if ( NULL != theDirName ) {
        _dirName = new char[strlen( theDirName )+1];
        strcpy( _dirName, theDirName );
    }
}


void
BdbApplication::setHostName( const char* const theHostName )
{
    if ( NULL != _hostName ) {
        delete [] _hostName;
        _hostName = NULL;
    }
    if ( NULL != theHostName ) {
        _hostName = new char[strlen( theHostName )+1];
        strcpy( _hostName, theHostName );
    }
}




BdbStatus
BdbApplication::startUpdate( const char* const thePrefix, const char* theTag )
{
    initialize();
    if ( 0 != _inhibitMgr ) {
        _inhibitMgr->waitUntilAvailable( );
    }
    return BdbSession::startUpdate(thePrefix, theTag);
}


BdbStatus
BdbApplication::startRead( const char* const thePrefix, const char* theTag )
{
    initialize();
    if ( 0 != _inhibitMgr ) {
        _inhibitMgr->waitUntilAvailable4Read( );
    }
    return BdbSession::startRead(thePrefix, theTag);
}

 

---

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

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