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

                 

---

/BdbEventStore/BdbCollectionTFactory.cc

Go to the documentation of this file.

#if !defined(BDBCOLLECTIONTFACTORY_CC)
#define BDBCOLLECTIONTFACTORY_CC
//------------------------------------------------------------------------------
// File and Version Information:
//      $Id: BdbCollectionTFactory.cc,v 1.1 2002/05/31 07:06:03 becla Exp $
//
// Description:
//      Class BdbCollectionTFactory interface (.cc) file. This file declares the 
//      abstract factory of collections.
//
// Environment:
//      Software developed for the BaBar Detector at the SLAC B-Factory
//
// Author List:
//      Simon Patton            Original Author (source in BdbCollectionFactory)
//      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/BdbCollectionTFactory.hh"

//-------------
// C Headers --
//-------------
extern "C" {
#include <unistd.h> // getpid
}

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

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

//-------------------------------
// Collaborating Class Headers --
//-------------------------------
#include "BdbEventStore/BdbEventStore.hh"
#include "BdbTrees/BdbTreeNode.hh"
#include "BdbApplication/BdbDomainAuth.hh"
#include "BdbUtil/BdbPathName.hh"

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

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

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

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

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

template < class T >
BdbCollectionTFactory< T >::BdbCollectionTFactory()
   : _collectionHint( 0 ),
     _nodeHint( 0 ),
     _fullCollName( 0 ),
     _collName( 0 )
{
}

template < class T >
BdbCollectionTFactory< T >::BdbCollectionTFactory( BdbAbstractClusteringHint& theCollectionHint,
                                                 BdbAbstractClusteringHint& theTreeNodeHint )
   : _collectionHint( &theCollectionHint ),
     _nodeHint( &theTreeNodeHint ),
     _fullCollName( 0 ),
     _collName( 0 )
{
}

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

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

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

template < class T >
BdbCollectionTFactory< T >::~BdbCollectionTFactory()
{
   delete [] _collName;
   delete [] _fullCollName;
}

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

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

template < class T >
BdbAbstractClusteringHint*
BdbCollectionTFactory< T >::collectionHint() const
{
   return( _collectionHint ) ;
}

template < class T >
BdbAbstractClusteringHint*
BdbCollectionTFactory< T >::nodeHint() const
{
   return( _nodeHint ) ;
}

template < class T >
const char*
BdbCollectionTFactory< T >::fullCollName() const
{
   return( _fullCollName ) ;
}

template < class T >
const char*
BdbCollectionTFactory< T >::collName() const
{
   return( _collName ) ;
}

template < class T >
d_ULong
BdbCollectionTFactory< T >::initialSize() const
{
   return( _initialSize ) ;
}

template < class T >
BdbAbstractClusteringHint*
BdbCollectionTFactory< T >::factoryCollectionHint( BdbCollectionTFactory< T >& factory )
{
   return( factory.collectionHint() ) ;
}

template < class T >
BdbAbstractClusteringHint*
BdbCollectionTFactory< T >::factoryNodeHint( BdbCollectionTFactory< T >& factory )
{
   return( factory.nodeHint() ) ;
}

template < class T >
const char*
BdbCollectionTFactory< T >::factoryFullCollName( BdbCollectionTFactory< T >& factory )
{
   return( factory.fullCollName() ) ;
}

template < class T >
const char*
BdbCollectionTFactory< T >::factoryCollName( BdbCollectionTFactory< T >& factory )
{
   return( factory.collName() ) ;
}

template < class T >
BdbCollectionTFactory< T >::Failure
BdbCollectionTFactory< T >::getResult() const
{
   return( _failure );
}

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

template < class T >
void
BdbCollectionTFactory< T >::setHints( BdbCollectionTFactory< T >& factory,
                                     BdbAbstractClusteringHint& collectionHint,
                                     BdbAbstractClusteringHint& nodeHint )
{
   factory.setInstanceHints( &collectionHint,
                             &nodeHint );
}

template < class T >
BdbAbsCollectionT< T >*
BdbCollectionTFactory< T >::getCollection( const char* const theCollPath,
                                          d_ULong initialSize )
{
   _failure = kNoFailure;

   _nodeP = 0;
   _updatedCollHint = 0;
   _initialSize = initialSize;

   delete [] _fullCollName;
   _fullCollName = new char[ strlen( theCollPath ) + 1 ];
   strcpy( _fullCollName,
           theCollPath );

   delete [] _collName;
   _collName = BdbPathName::leaf( _fullCollName );
   if( 0 == collName() ) {
      _failure = kNameFailure;
      nameError();
      return( 0 );
   }

   BdbEventStore& evs( *BdbEventStore::instance() );
   BdbAbsCollectionT< T >* theColl( evs.collection( _fullCollName,
                                                   (*(T*)0),
                                                   false ) );
   if( 0 != theColl ) {
      // As collection exists this is a creation error!
      // (If this is not considered and error then the
      // creation factory should be decorated by the
      // BdbFetchCollTFactory subclass)
      _failure = kExistsFailure;
      existsError( _fullCollName );
      return( 0 );
   }

   // Fetch the node, creating it if necessary
   char* theNodePath( BdbPathName::stem( _fullCollName,
                                         true ) );
   BdbEventStore::AuthLevels  theAuthLevel( evs.parseAuthLevel( theNodePath ) );
   const char* theAuthName( evs.parseAuthName( theNodePath ) );

   if (evs.setAuthLevel( theAuthLevel,
                         theAuthName ) ) {
      theColl = attemptGet();
      if( kExistsFailure == getResult() ) {
         existsError( _fullCollName );
      }
   }
   else {
      _failure = kAuthFailure;
      authError( _fullCollName );
   }
   delete [] theNodePath;
   return theColl;
}


template < class T >
BdbAbsCollectionT< T >*
BdbCollectionTFactory< T >::attemptGet()
{
   if( ( kNoFailure != getResult() ) &&
       ( kLockFailure != getResult() ) ) {
      return( 0 );
   }

   BdbEventStore& evs( *BdbEventStore::instance() );

   // test a sleep time of 60 +- 30 sec.
   const int MEAN_SLEEP(60);
   const int SIGMA_SLEEP(30);
   const int TWO_SIGMA_SLEEP(SIGMA_SLEEP * 2);
   const int SLEEP_ADJUSTMENT(MEAN_SLEEP - SIGMA_SLEEP);
   if( _updatedCollHint.isNull() ) {

      // First attempt should not wait, in case commit is required
      // Other atempts need to wait to allow other locks to clear.
      if ( kLockFailure == getResult() ) {
         sleep( ( getpid() % TWO_SIGMA_SLEEP ) + SLEEP_ADJUSTMENT );
      }
      d_Long oldWait = evs.lockWait();
      evs.setLockWait( BdbcNoWait );
      _updatedCollHint = _collectionHint->updatedHint();
      evs.setLockWait( oldWait );

      if( _updatedCollHint.isNull() ) {
         _failure = kLockFailure;
         return( 0 );
      }
      _failure = kNoFailure;
   }

   if( _nodeP.isNull() ) {
      BdbTreeNode collectionNode;
      BdbAbstractClusteringHint* origHint( BdbTreeNodeP::clustering.delegate() );
      BdbTreeNodeP::clustering.setDelegate( _nodeHint ); 
      char* theNodePath( BdbPathName::stem( _fullCollName,
                                            true ) );
      
      // First attempt should not wait, in case commit is required,
      // Other atempts need to wait to allow other locks to clear.
      if ( kLockFailure == getResult() ) {
         sleep( ( getpid() % TWO_SIGMA_SLEEP ) + SLEEP_ADJUSTMENT );
      }
      d_Long oldWait = evs.lockWait();
      evs.setLockWait( BdbcNoWait );
      BdbStatus result( evs.fetchTreeNode( collectionNode,
                                           theNodePath ) );
      evs.setLockWait( oldWait );

      delete [] theNodePath;
      BdbTreeNodeP::clustering.setDelegate( origHint );

      if( BdbcSuccess != result ) {
         _failure = kLockFailure;
         return( 0 );
      }
      _nodeP = collectionNode.persistent();
      _failure = kNoFailure;
   }

   BdbHandleAny collHandle( _updatedCollHint );
   if ( BdbcSuccess != collHandle.update() ) {
      _failure = kLockFailure;
      lockError( _updatedCollHint );
      return( 0 );
   }

   BdbHandle(BdbTreeNodeP ) nodeHandle( _nodeP );
   if ( BdbcSuccess != nodeHandle.update() ) {
      _failure = kLockFailure;
      lockError( _nodeP );
      return( 0 );
   }

   // Now we have sole access. Check that no-one
   // else has created an item with the same name
   // while we were waiting for the update locks
   BdbAbsCollectionT< T >* theColl( evs.collection( fullCollName(),
                                                   (*(T*)0),
                                                   false ) );
   if ( 0 == theColl ) {

      // Collection doesn't already exist - create it
      theColl = createCollectionAtNode( collHandle,
                                        nodeHandle,
                                        collName(),
                                        initialSize() );
      if( 0 != theColl ) {
         evs.setLastPath( BdbPathName::stem( fullCollName(),
                                             true ) );
         _failure = kNoFailure;
      }
   }
   else {
      // As collection exists this is a creation error!
      // (If this is not considered and error then the
      // creation factory should be decorated by the
      // BdbFetchCollTFactory subclass)
      _failure = kExistsFailure;
      delete theColl;
      theColl = 0;
   }
   return theColl;
}

template < class T >
BdbAbsCollectionT< T >*
BdbCollectionTFactory< T >::regetCollection()
{
   if( ( 0 == fullCollName() ) ||
       ( 0 == collName() ) ) {
      return( 0 );
   }
   BdbAbsCollectionT< T >* theColl( attemptGet() );
   if( kExistsFailure == getResult() ) {
      existsError( fullCollName() );
   }
   return( theColl );
}

template < class T >
void
BdbCollectionTFactory< T >::setInstanceHints( BdbAbstractClusteringHint* collectionHint,
                                             BdbAbstractClusteringHint* nodeHint )
{
   _collectionHint = collectionHint;
   _nodeHint = nodeHint;
}

template < class T >
void
BdbCollectionTFactory< T >::setResult( const Failure failure )
{
   _failure = failure;
}

template < class T >
BdbAbsCollectionT< T >*
BdbCollectionTFactory< T >::createCollectionAtNode( BdbHandleAny& theHint,
                                                   BdbHandle( BdbTreeNodeP )& theNode ,
                                                   const char* theName ,
                                                   d_ULong theInitialSize )
{
   return( 0 );
}

#endif // BDBCOLLECTIONTFACTORY_CC

 

---

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

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