---

CdbBdbProxyBase.cc

Go to the documentation of this file.

// File and Version Information:
//      $Id: CdbBdbProxyBase.cc,v 1.15 2005/03/09 22:57:00 gapon Exp $

/// The implementation of the CdbBdbProxyBase and CdbBdbProxyBaseUsingRevision classes.
/**
  * @see CdbBdbProxyBase
  * @see CdbBdbProxyBaseUsingRevision
  */
#include "BaBar/BaBar.hh"

#include "CdbBdb/CdbBdbProxyBase.hh"

#include "CdbBase/CdbStateId.hh"
#include "CdbBase/CdbTransaction.hh"

#include "BdbCond/BdbCondDefEventKey.hh"

#include "AbsEnv/AbsEnv.hh"
#include "GenEnv/GenEnv.hh"

#include "ProxyDict/AbsArgCast.hh"

#include "EidData/EidCondKeyTriplet.hh"
#include "ErrLogger/ErrLog.hh"

#include <assert.h>

////////////////////////////
// Class: CdbBdbProxyBase //
////////////////////////////

template< class T >
CdbBdbProxyBase<T>::CdbBdbProxyBase( BdbCondDefStrategy* theStrategy ) :
    CdbBdbProxyCache( ),
    _strategy (theStrategy),
    _transient(0)
{
  // Instantiate the default strategy to use the primary event key
  // if nothing else was specified

    if( 0 == strategy( )) setStrategy(  new BdbCondDefEventKey( ));
}

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

template< class T >
T*
CdbBdbProxyBase<T>::faultHandler( IfdProxyDict* theDict,
                                  const IfdKey& theKey,
                                  AbsArg&       theArg )
{
  // Figure out what time to use...

    BdbTime validityTime( 0 );
    if( 0 != strategy( )) {
        validityTime = strategy( )->defaultKey( ).key( );
    } else {
        BdbTime* t = AbsArgCast< BdbTime >::value( theArg );
        if( 0 == t ) ErrMsg(fatal) << "unable to determine the validity time." << endmsg;
        validityTime = *t;
    }

  // Check if the persistent cach is still valid. If not then update it and
  // recalculate the transient.

    if( 0 == transientCache( ) || !isCacheValid( validityTime )) {


      // Update the persistent cache otherwise
      //
      // NOTE: We're using the artificially constructed value of the State Identifier
      //       as a temporary solution just because the GenEnv does not provide us with
      //       this information.

      // The subsequent code is being executed within a transaction provided
      // via an object of the CdbTransaction class, implementing
      // the "resource-acquisition-is-initialization" paradigm.

        {
            CdbTransaction transaction;

          // do it in the loop until complete success or failure

            std::vector<CdbBdbProxyElement> elements;
            bool gotit = false ;
            do {

              // the persisten cache needs to be updated

                CdbStateId stateId( CdbId( 0, 0 ), BdbTime( 0 ));

                if( CdbStatus::Success != updateCache( validityTime,
                                                       stateId,
                                                       elements )) {

                  // failure to access conditions db

                    ErrMsg(error) << "failure to access conditions information: no transient returned" << endmsg;

                    invalidateTransientCache( );

                    gotit = true;   // while it's not really true, this will stop the loop

                } else {

                  // Let the actuall proxy to recalculate the transient, then update
                  // the local transient cache.

                    T* newtransient = this->redefinedFaultHandler( elements );

                    if ( 0 != newtransient ) {

                      // can stop at this point

                        gotit = true;

                    } else {

                      // can't make transient guy, try to fund different persistent guy.

                        BdbTime anotherTime;
                        if ( tryAnotherTime( validityTime,
                                             elements,
                                             anotherTime )) {

                          // rerun everything with the different time

                            validityTime = anotherTime;

                        } else {

                          // no, can't do it

                            gotit = true;
                        }
                    }

                  // Update the transient cache if got a new pointer

                    if( transientCache( ) != newtransient ) setTransientCache( newtransient );
                }

            } while ( !gotit );
        }
    }
    setCacheIsValid();  // flag the cach as being "valid"

  // Return whatever we have in teh cache (even if it's a null pointer).

    return transientCache( );
}

template< class T >
void
CdbBdbProxyBase<T>::storeHandler( IfdProxyDict* theDict,
                                  const IfdKey& theKey,
                                  AbsArg&       theArg,
                                  T*            theObject )
{
    ErrMsg(warning) << "this is just a dummy method. It does nothing except printing this message." << endmsg;
}

template< class T >
void
CdbBdbProxyBase<T>::testCache( )
{
    setCacheInvalid( );
}

template< class T >
BdbTime
CdbBdbProxyBase<T>::faultTime( ) const
{
    assert( 0 != strategy( ));  // It's either a bug in the class's implementation or a memory
                                // corruption problem. This pointer should never be the null one.

    return strategy( )->defaultKey( ).key( );    
}

template< class T >
bool 
CdbBdbProxyBase<T>::tryAnotherTime( const BdbTime&                         theOriginalTime, 
                                    const std::vector<CdbBdbProxyElement>& theListOfElements,
                                    BdbTime&                               TheOtherTime ) 
{
    return false;
}


/////////////////////////////////////////
// Class: CdbBdbProxyBaseUsingRevision //
/////////////////////////////////////////

template< class T >
CdbBdbProxyBaseUsingRevision<T>::CdbBdbProxyBaseUsingRevision( const std::string&  theRevisionName,
                                                               unsigned int        thePartitionId,
                                                               BdbCondDefStrategy* theStrategy ) :
    CdbBdbProxyBase<T>( theStrategy ),
    _revisionName(theRevisionName),
    _partitionId (thePartitionId)
{ }

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

template< class T >
T*
CdbBdbProxyBaseUsingRevision<T>::faultHandler( IfdProxyDict* theDict,
                                               const IfdKey& theKey,
                                               AbsArg&       theArg )
{
  // Figure out what time to use...

    BdbTime validityTime( 0 );
    if( 0 != strategy( )) {
        validityTime = strategy( )->defaultKey( ).key( );
    } else {
        BdbTime* t = AbsArgCast< BdbTime >::value( theArg );
        if( 0 == t ) ErrMsg(fatal) << "unable to determine the validity time." << endmsg;
        validityTime = *t;
    }

  // Check if the persistent cach is still valid. If not then update it and
  // recalculate the transient.

    if( 0 == transientCache( ) || !isCacheValid( validityTime )) {


      // Update the persistent cache otherwise
      //
      // NOTE: We're using the artificially constructed value of the State Identifier
      //       as a temporary solution just because the GenEnv does not provide us with
      //       this information.

      // The subsequent code is being executed within a transaction provided
      // via an object of the CdbTransaction class, implementing
      // the "resource-acquisition-is-initialization" paradigm.

        {
            CdbTransaction transaction;

          // do it in the loop until complete success or failure

            std::vector<CdbBdbProxyElement> elements;
            bool gotit = false ;
            do {

              // the persisten cache needs to be updated

                if( CdbStatus::Success != updateCache( validityTime,
                                                       _revisionName.c_str( ),
                                                       _partitionId,
                                                       elements )) {

                  // failure to access conditions db

                    ErrMsg(error) << "failure to access conditions information: no transient returned" << endmsg;

                    invalidateTransientCache( );

                    gotit = true;   // while it's not really true, this will stop the loop

                } else {

                  // Let the actuall proxy to recalculate the transient, then update
                  // the local transient cache.

                    T* newtransient = this->redefinedFaultHandler( elements );

                    if ( 0 != newtransient ) {

                      // can stop at this point

                        gotit = true;

                    } else {

                      // can't make transient guy, try to fund different persistent guy.

                        BdbTime anotherTime;
                        if ( tryAnotherTime( validityTime,
                                             elements,
                                             anotherTime )) {

                          // rerun everything with the different time

                            validityTime = anotherTime;

                        } else {

                          // no, can't do it

                            gotit = true;
                        }
                    }

                  // Update the transient cache if got a new pointer

                    if( transientCache( ) != newtransient ) setTransientCache( newtransient );
                }

            } while ( !gotit );
        }
    }
    setCacheIsValid();  // flag the cach as being "valid"

  // Return whatever we have in teh cache (even if it's a null pointer).

    return transientCache( );
}

/////////////////
// End Of File //
/////////////////

---