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

                 

---

/BdbEventStore/BdbFetchCollTFactory.cc

Go to the documentation of this file.

#if !defined(BDBFETCHCOLLTFACTORY_CC)
#define BDBFETCHCOLLTFACTORY_CC
//------------------------------------------------------------------------------
// File and Version Information:
//      $Id: BdbFetchCollTFactory.cc,v 1.1 2002/05/31 07:06:03 becla Exp $
//
// Description:
//      Class BdbFetchCollTFactory interface (.cc) file.
//
// Environment:
//      Software developed for the BaBar Detector at the SLAC B-Factory
//
// Author List:
//      Simon Patton            Original Author (source in BdbFetchCollFactory)
//      Jacek Becla             Modified to break dependency between Event Store
//                              and BdbEvent
//
// Copyright Information:
//      Copyright (C) 2002      Stanford Linear Accelerator Center
//
//------------------------------------------------------------------------------

//-----------------------
// This Class's Header --
//-----------------------
#include "BdbEventStore/BdbFetchCollTFactory.hh"

//-------------
// C Headers --
//-------------
extern "C" {
}

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

//----------------
// BaBar Header --
//----------------
#include "BaBar/BaBar.hh"
#include "BdbUtil/Bdb.hh"

//-------------------------------
// Collaborating Class Headers --
//-------------------------------
#include "BdbEventStore/BdbAbsCollectionT.hh"
#include "BdbClustering/BdbRefHandleClusteringHint.hh"

#include "ErrLogger/ErrLog.hh"

//------------------------------------
// Collaborating Class Declarations --
//------------------------------------

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

//              -----------------------------------------------
//              -- Static Data & Function Member Definitions --
//              -----------------------------------------------

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

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

template < class T >
BdbFetchCollTFactory< T >::BdbFetchCollTFactory( BdbCollectionTFactory< T >& factory,
                                               unsigned int retries )
   : BdbCollTFactoryDecorator< T >( factory ),
   _retries( retries )
{
}

template < class T >
BdbFetchCollTFactory< T >::BdbFetchCollTFactory( BdbCollectionTFactory< T >* factory,
                                               unsigned int retries )
   : BdbCollTFactoryDecorator< T >( factory ),
   _retries( retries )
{
}

// template < class T >
// BdbFetchCollTFactory< T >::BdbFetchCollTFactory()
// {
// }

// template < class T >
// BdbFetchCollTFactory< T >::BdbFetchCollTFactory( const BdbFetchCollTFactory< T >& aRhs )
// {
// }

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

template < class T >
BdbFetchCollTFactory< T >::~BdbFetchCollTFactory()
{
}

//-------------
// Operators --
//-------------
    
// template < class T >
// const BdbFetchCollTFactory< T >& BdbFetchCollTFactory< T >::operator=( const BdbFetchCollTFactory< T >& aRhs )
// {
// }

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

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

template < class T >
BdbAbsCollectionT< T >*
BdbFetchCollTFactory< T >::getCollection( const char* const theCollPath,
                                         d_ULong initialSize )
{
   return( attemptGet( true,
                       theCollPath,
                       initialSize ) );
}

template < class T >
BdbAbsCollectionT< T >*
BdbFetchCollTFactory< T >::attemptGet( bool isGetting,
                                      const char* const theCollPath,
                                      d_ULong initialSize )
{
   setResult( kNoFailure );
   bool doGet( isGetting );

   // The final result
   BdbAbsCollectionT< T >* theColl( 0 );

   char* theNodePath( BdbPathName::stem( theCollPath,
                                         true ) );
   BdbEventStore& evs( *BdbEventStore::instance() );
   BdbEventStore::AuthLevels  theAuthLevel( evs.parseAuthLevel( theNodePath ) );
   const char* theAuthName( evs.parseAuthName( theNodePath ) );

   if( evs.setAuthLevel( theAuthLevel,
                         theAuthName ) ) {
      if( 0 == theColl ) {

         // Collection doesn't exist - use factory to get one
         if( doGet ) {
            
            // If this is the first attempt, cut wait time to zero
            // in case transaction needs to be committed
            d_Long oldWait = evs.lockWait();
            evs.setLockWait( BdbcNoWait );
            theColl = getFactory().getCollection( theCollPath,
                                             initialSize ) ;
            doGet = false;
            evs.setLockWait( oldWait );
         }
         else {
            theColl = getFactory().regetCollection() ;
         }
         if( kExistsFailure == getResult() ) {
            theColl = evs.collection( theCollPath,
                                      (*(T*)0),
                                      false );
         }

         if( ( 0 == theColl ) &&
             ( kLockFailure == getResult() ) ) {
            theColl = attemptRegets();
         }
      }
      else {
         evs.setLastPath( theNodePath );
         theNodePath = 0;
      }
   }
   else {
      setResult( kAuthFailure );
      authError( theCollPath );
   }
   delete [] theNodePath;

   return theColl;
}

template < class T >
BdbAbsCollectionT< T >*
BdbFetchCollTFactory< T >::attemptRegets()
{
   BdbAbsCollectionT< T >* theColl( 0 );
   BdbEventStore& evs( *BdbEventStore::instance() );
   BdbCollectionTFactory< T >& factory( getFactory() );
   size_t regetsLeft( _retries );
   
   // make sure that there is some wait set
   const int kMinimumWait( 60 );
   d_Long oldWait = evs.lockWait();
   if( kMinimumWait > oldWait ) {
      evs.setLockWait( kMinimumWait );
   }

   while( ( 0 == theColl ) &&
          ( kLockFailure == getResult() ) &&
          ( 0 != regetsLeft ) ) {

      ErrMsg( warning ) << "BdbFetchCollTFactory:"
                        << " Unable to gain update lock, retrying."
                        << "("
                        << regetsLeft
                        << " attempts remaining)"
                        << endmsg ;

      // restart the transaction
      evs.change( evs.mode(),
                  d_True );
      theColl = factory.regetCollection() ;
      regetsLeft-- ;

      if( kExistsFailure == getResult() ) {
         // If other transaction has created collection, it will be
         // returned. However 'getResult' will reflect the fact that
         // this instance of the factory was not responsible for the
         // creation.
         theColl = evs.collection( factoryFullCollName( factory ),
                                   (*(T*)0),
                                   false );
      }
   }
   evs.setLockWait( oldWait );

   if( ( 0 == theColl ) &&
       ( kLockFailure == getResult() ) &&
       ( 0 == regetsLeft ) ) {
      ErrMsg( error ) << "BdbFetchCollTFactory:"
                      << " Unable to gain update lock"
                      << " after maximum number of retries ("
                      << _retries
                      << ")."
                      << endmsg ;
   }

   return( theColl );
}

template < class T >
BdbAbsCollectionT< T >*
BdbFetchCollTFactory< T >::regetCollection()
{
   return( attemptGet( false,
                       factoryFullCollName( getFactory() ) ) );
}

#endif // BDBFETCHCOLLTFACTORY_CC

 

---

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

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