---

CdbRooRoView.cc

Go to the documentation of this file.

// File and Version Information:
//      $Id: CdbRooRoView.cc,v 1.5 2005/08/24 23:06:58 gapon Exp $

/// The implementation of the CdbRooRoView class.
/**
  * @see CdbRooRoView
  */
#include "BaBar/BaBar.hh"

#include "CdbRooReadonly/CdbRooRoView.hh"

#include "CdbBase/Cdb.hh"
#include "CdbBase/CdbId.hh"
#include "CdbBase/CdbFolder.hh"
#include "CdbBase/CdbPathName.hh"
#include "CdbBase/CdbRevisionPolicy.hh"

#include "CdbRooReadonly/CdbRooRoFolder.hh"
#include "CdbRooReadonly/CdbRooRoViewR.hh"
#include "CdbRooReadonly/CdbRooRoConditionAtFolderR.hh"
#include "CdbRooReadonly/CdbRooRoConfigCollectionR.hh"
#include "CdbRooReadonly/CdbRooRoPartitionR.hh"
#include "CdbRooReadonly/CdbRooRoPartitionsLayoutR.hh"

#include <iostream>
using std::cout;
using std::endl;

namespace {

    //////////////////////////////
    // Class: CdbRooRoConfigItr //
    //////////////////////////////

    class CdbRooRoConfigItr : public CdbItr<CdbConfigElement>::InterfaceType {

    private:

        CdbRooRoConfigItr( );

        CdbRooRoConfigItr& operator=( const CdbRooRoConfigItr& theItr );

    protected:

        CdbRooRoConfigItr( const CdbRooRoConfigItr& theItr ) :
            _itr  (theItr._itr),
            _value(theItr._value)
        { }

    public:

        CdbRooRoConfigItr( const CdbRooRoConfigCollectionR::IteratorOfIntervals& theInputItr ) :
            _itr(theInputItr)
        { }

        virtual ~CdbRooRoConfigItr( )
        { }

        virtual CdbStatus reset( )
        {
            return _itr.reset( );
        }

        virtual bool next( )
        {
            bool result = _itr.next( );
            if( result ) {

                CdbRooRoConfigInterval in = _itr.value( );
                if( in.value( ).accessIsAllowed( )) {

                  // This interval is allowed for accessing the database.

                    CdbRevisionPolicy policy;
                    if( in.value( ).useRevision( )) {
                        policy = CdbRevisionPolicy( in.value( ).revision ( ),
                                                    in.value( ).partition( ));
                    }
                    _value = CdbConfigElement( policy,
                                               in.begin( ),
                                               in.end  ( ));
                } else {

                  // This interval is NOT allowed.

                    _value = CdbConfigElement( in.begin( ),
                                               in.end  ( ));
                }

            } else {

              // The default constructor will construct an element disallowing any
              // access to the database for the whole range of the validity time.

                _value = CdbConfigElement( );
            }
            return result;
        }

        virtual ValueType value( )
        {
            if( ! isValid( )) {
                assert( 0 );
            }
            return _value;
        }

        virtual bool isValid( )
        {
            return _itr.isValid( );
        }

        virtual InterfaceType* clone( ) const
        {
            return new CdbRooRoConfigItr( *this );
        }

    private:

        CdbRooRoConfigCollectionR::IteratorOfIntervals _itr;

        CdbConfigElement _value;
    };
};

////////////////////////
// Class: CdbRooRoView //
////////////////////////

CdbView*
CdbRooRoView::clone( ) const
{
  // Get rid of the "const" to access non-const methods

    CdbRooRoView* mySelf = const_cast<CdbRooRoView*>( this );
    return new CdbRooRoView( mySelf->parent( ),
                             mySelf->name( ),
                             mySelf->id( ),
                             _persistentViewPtr,
                             _masterRegistryPtr,
                             _localRegistryPtr );
}

CdbRooRoView::CdbRooRoView( const CdbDatabasePtr&              thePtr,
                            const char*                        theName,
                            const CdbId&                       theId,
                            const CdbCPtr< CdbRooRoViewR >&    thePersistentViewPtr,
                            const CdbCPtr< CdbRooRoRegistry >& theMasterRegistryPtr ,
                            const CdbCPtr< CdbRooRoRegistry >& theLocalRegistryPtr ) :
    CdbView( thePtr,
             theName,
             theId ),
    _persistentViewPtr         (thePersistentViewPtr),
    _masterRegistryPtr         (theMasterRegistryPtr),
    _localRegistryPtr          (theLocalRegistryPtr),
    _beginCachedStateIdValidity(BdbTime::plusInfinity),
    _endCachedStateIdValidity  (BdbTime::plusInfinity)
{ }

CdbRooRoView::~CdbRooRoView( )
{ }

bool
CdbRooRoView::isValid( )
{
    return true;
}

bool
CdbRooRoView::isOpen( )
{
    return true;
}

CdbStatus
CdbRooRoView::open( )
{
    return CdbStatus::Success;
}

CdbStatus
CdbRooRoView::close( )
{
    return CdbStatus::Success;
}

BdbTime
CdbRooRoView::minValidity( ) const
{
    return _persistentViewPtr->minValidity( );
}

BdbTime
CdbRooRoView::maxValidity( ) const
{
    return _persistentViewPtr->maxValidity( );
}

BdbTime
CdbRooRoView::created( ) const
{
    return _persistentViewPtr->created( );
}

std::string
CdbRooRoView::description( ) const
{
    return _persistentViewPtr->description( );
}

bool
CdbRooRoView::hasDefaultConfig( ) const
{
    return 0 != _persistentViewPtr->defaultConfig( );
}

bool
CdbRooRoView::isLocal( ) const
{
    return id( ).origin == _localRegistryPtr->originId( );
}

bool 
CdbRooRoView::isFrozen( ) const
{
    return _persistentViewPtr->isFrozen( );
}

CdbStatus
CdbRooRoView::findFolder( CdbFolderPtr& thePtr,
                          const char*   theName )
{
    CdbStatus result = CdbStatus::Error;

    do {

        if( 0 != strcmp( theName, CdbPathName::separator( ))) {

            cout << "CdbRooRoView::findFolder() -- ERROR" << endl
                 << "    No such folder in this implementation: \"" << theName                   << "\"" << endl
                 << "    The only name allowed is the rood one: \"" << CdbPathName::separator( ) << "\"" << endl;

            break;
        }

      // Find out persistent folder for specified name
      //
      // IMPLEMENTATION NOTE:
      //
      //    The persistent pointer below lives in a scope of (is ownd by) a persistent view
      //    the current CDB API object is associated with. Therefore we can safely use this
      //    pointer in child CDB API folders of the current CDB API view. There shouldn't be
      //    any memory management problems.

        CdbRooRoFolderR* persistentFolderPtr;
        if( CdbStatus::Success != _persistentViewPtr->findFolder( theName,
            persistentFolderPtr )) {
            result = CdbStatus::NotFound;
            break;
        }

      // DESIGN NOTE: We need to construct a smart pointer against a clone since
      //              we don't know a smart pointer pointing to the current
      //              instance, therefore we can't guarantee the lifetime
      //              of the current instance.

        CdbFolderPtr parentFolderPtr( 0 );

        thePtr = new CdbRooRoFolder( CdbViewPtr( this->clone( )),
                                     parentFolderPtr,
                                     theName,
                                     persistentFolderPtr,
                                     _masterRegistryPtr,
                                     _localRegistryPtr );

      // Done.

        result = CdbStatus::Success;

    } while( false );

    return result;
}

CdbStatus
CdbRooRoView::folderIterator( CdbFolderItr& theItr )
{
    return _persistentViewPtr->folderIterator( theItr );
}

CdbStatus
CdbRooRoView::getDefault( const BdbTime&    theValidityTime,
                          CdbConfigElement& theConfigElement ) const
{
    const char* errorStr = "CdbRooRoView::getDefault() -- ERROR.";

    CdbStatus result = CdbStatus::Error;
    do {

      // Check if specified time fits into the validity interval covered by
      // the current view.

        if(( theValidityTime <  _persistentViewPtr->minValidity( )) ||
           ( theValidityTime >= _persistentViewPtr->maxValidity( ))) {

            cout << errorStr << endl
                 << "    The pased validity time is out of the validity interval covered" << endl
                 << "    by the current view." << endl
                 << "        Passed  validity time: " << theValidityTime << endl
                 << "        Minimum validity time: " << _persistentViewPtr->minValidity( ) << endl
                 << "        Maximum validity time: " << _persistentViewPtr->maxValidity( ) << endl;
            break;
        }

      // Use default configuration only (if any).

        const CdbRooRoConfigCollectionR* configCollPtr = _persistentViewPtr->defaultConfig( );
        if( 0 == configCollPtr) {
            result = CdbStatus::NotFound;
            break;
        }

      // Get the configuration interval.

        CdbRooRoConfigInterval configInterval;
        if( CdbStatus::Success != configCollPtr->find( theValidityTime,
                                                       configInterval )) {
            cout << errorStr << endl
                 << "    The default configuration of the current view is inproperly configured." << endl
                 << "    No configuration record found for specified validity time." << endl
                 << "    at the view level." << endl
                 << "        Current view name:     \"" << name( ) << "\"" << endl
                 << "        Passed validity time:  "   << theValidityTime << endl;
            break;
        }

      // Build the configuration element

        if( configInterval.value( ).accessIsAllowed( )) {

            CdbRevisionPolicy policy;
            if( configInterval.value( ).useRevision( )) {
                policy = CdbRevisionPolicy( configInterval.value( ).revision ( ),
                                            configInterval.value( ).partition( ));
            } else {
                policy = CdbRevisionPolicy( );
            }
            theConfigElement = CdbConfigElement( policy,
                                                 configInterval.begin( ),
                                                 configInterval.end  ( ));

        } else {

          // This element will prohibit accessing the database
          // for specified validity interval

            theConfigElement = CdbConfigElement( configInterval.begin( ),
                                                 configInterval.end  ( ));
        }

      // Done

        result = CdbStatus::Success;

    } while( false );

    return result;
}

CdbStatus
CdbRooRoView::defaultConfigIterator( CdbItr<CdbConfigElement>& theItr ) const
{
    CdbStatus result = CdbStatus::NotFound;
    do {

        const CdbRooRoConfigCollectionR* configCollPtr = _persistentViewPtr->defaultConfig( );
        if( 0 == configCollPtr ) break;

      // ATTENTION: This is not a memory leak - the created object
      //            will be destroyed by the iterator.

        theItr = CdbItr<CdbConfigElement>( new CdbRooRoConfigItr( configCollPtr->iterator( )));

      // Done

        result = CdbStatus::Success;

    } while( false );

    return result;
}

CdbStatus
CdbRooRoView::get( const char*       theName,
                   const BdbTime&    theValidityTime,
                   CdbConfigElement& theConfigElement ) const
{
    const char* errorStr = "CdbRooRoView::get() -- ERROR.";

    CdbStatus result = CdbStatus::Error;
    do {

      // Verify the condition path name.

        if( 0 == theName ) {
            cout << errorStr << endl
                 << "    Non 0 pointer onto a fully qualified condition path name was expected." << endl;
            break;
        }

        CdbPathName fullPath( theName );

        if( ! ( fullPath.isValid( ) &&
                fullPath.isAbsolute( ) &&
                fullPath.isComposite( ))) {

            cout << errorStr << endl
                 << "    Unsupported format of the condition name. Fully qualified" << endl
                 << "    condition name including its folder path was expected." << endl
                 << "        Passed condition name: \"" << theName << "\"" << endl;
            break;
        }

      // Check if specified time fits into the validity interval covered by
      // the current view.

        if(( theValidityTime <  _persistentViewPtr->minValidity( )) ||
           ( theValidityTime >= _persistentViewPtr->maxValidity( ))) {

            cout << errorStr << endl
                 << "    The pased validity time is out of the validity interval covered" << endl
                 << "    by the current view." << endl
                 << "        Passed  validity time: " << theValidityTime << endl
                 << "        Minimum validity time: " << _persistentViewPtr->minValidity( ) << endl
                 << "        Maximum validity time: " << _persistentViewPtr->maxValidity( ) << endl;
            break;
        }

      // First we're going to see if specified condition has  its own revision
      // configuration. This always superseeds the default configuration at
      // the level of the view.

        CdbRooRoConditionAtFolderR* conditionPtr;
        if( CdbStatus::Success != _persistentViewPtr->findCondition( theName,
                                                                     conditionPtr )) {
            result = CdbStatus::NotFound;
            break;
        }

        const CdbRooRoConfigCollectionR* configCollPtr = conditionPtr->config( );
        if( 0 == configCollPtr ) {

          // No configuration found at the conditin level. Get the default
          // configuration at the view level then.

            configCollPtr = _persistentViewPtr->defaultConfig( );
            if( 0 == configCollPtr ) {
                cout << errorStr << endl
                     << "    The current view is inproperly configured for specified condition." << endl
                     << "    No configuration found both at specified condition scope and" << endl
                     << "    at the view level." << endl
                     << "        Current view name:     \"" << name( ) << "\"" << endl
                     << "        Passed condition name: \"" << theName << "\"" << endl;
                break;
            }
        }

      // Get the configuration interval.

        CdbRooRoConfigInterval configInterval;
        if( CdbStatus::Success != configCollPtr->find( theValidityTime,
                                                       configInterval )) {
            cout << errorStr << endl
                 << "    The current view is inproperly configured for specified condition." << endl
                 << "    No configuration record found for specified validity time." << endl
                 << "    at the view level." << endl
                 << "        Current view name:     \"" << name( ) << "\"" << endl
                 << "        Passed condition name: \"" << theName << "\"" << endl
                 << "        Passed validity time:  "   << theValidityTime << endl;
            break;
        }

      // Build the configuration element

        if( configInterval.value( ).accessIsAllowed( )) {

            CdbRevisionPolicy policy;
            if( configInterval.value( ).useRevision( )) {
                policy = CdbRevisionPolicy( configInterval.value( ).revision ( ),
                                            configInterval.value( ).partition( ));
            } else {
                policy = CdbRevisionPolicy( );
            }
            theConfigElement = CdbConfigElement( policy,
                                                 configInterval.begin( ),
                                                 configInterval.end  ( ));

        } else {

          // This element will prohibit accessing the database
          // for specified validity interval

            theConfigElement = CdbConfigElement( configInterval.begin( ),
                                                 configInterval.end  ( ));
        }

      // Done

        result = CdbStatus::Success;

    } while( false );

    return result;
}

CdbStatus
CdbRooRoView::configIterator( const char*               theName,
                              CdbItr<CdbConfigElement>& theItr ) const
{
    const char* errorStr = "CdbRooRoView::configIterator() -- ERROR.";

    CdbStatus result = CdbStatus::Error;
    do {

      // Verify the condition path name.

        if( 0 == theName ) {
            cout << errorStr << endl
                 << "    Non 0 pointer onto a fully qualified condition path name was expected." << endl;
            break;
        }

        CdbPathName fullPath( theName );

        if( ! ( fullPath.isValid( ) &&
                fullPath.isAbsolute( ) &&
                fullPath.isComposite( ))) {

            cout << errorStr << endl
                 << "    Unsupported format of the condition name. Fully qualified" << endl
                 << "    condition name including its folder path was expected." << endl
                 << "        Passed condition name: \"" << theName << "\"" << endl;
            break;
        }

      // First we're going to see if specified condition has  its own revision
      // configuration. This always superseeds the default configuration at
      // the level of the view.

        CdbRooRoConditionAtFolderR* conditionPtr;
        if( CdbStatus::Success != _persistentViewPtr->findCondition( theName,
                                                                     conditionPtr )) {
            result = CdbStatus::NotFound;
            break;
        }

        const CdbRooRoConfigCollectionR* configCollPtr = conditionPtr->config( );
        if( 0 == configCollPtr ) {

          // No configuration found at the conditin level. Get the default
          // configuration at the view level then.

            configCollPtr = _persistentViewPtr->defaultConfig( );
            if( 0 == configCollPtr ) {
                cout << errorStr << endl
                     << "    The current view is inproperly configured for specified condition." << endl
                     << "    No configuration found both at specified condition scope and" << endl
                     << "    at the view level." << endl
                     << "        Current view name:     \"" << name( ) << "\"" << endl
                     << "        Passed condition name: \"" << theName << "\"" << endl;
                break;
            }
        }

      // ATTENTION: This is not a memory leak - the created object
      //            will be destroyed by the iterator.

        theItr = CdbItr<CdbConfigElement>( new CdbRooRoConfigItr( configCollPtr->iterator( )));

      // Done

        result = CdbStatus::Success;

    } while( false );

    return result;
}

CdbStateId
CdbRooRoView::currentStateId( const BdbTime& theValidityTime ) const
{
    const char* errorStr = "CdbRooRoView::currentStateId() -- ERROR.";

    CdbStateId result;  // REMEMBER: default value of the State ID is invalid
    do {

      // Verify the input parameter and return a non-valid State Id if it's
      // in a wrong state.

        if( theValidityTime == BdbTime::plusInfinity ) break;

      // The algorithm implemented in this method will first attempt to use
      // a cached value of the StateId if one is found, and if its validity interval
      // includes a timestamp passed as the parameter of the method.

        if( _cachedStateId.isValid( ) &&
            ( _beginCachedStateIdValidity <= theValidityTime ) && ( theValidityTime < _endCachedStateIdValidity )) {
            result = _cachedStateId;
            break;
        }

      // Reset the cached State Id and a validity interval of the partition in the cache to the default values.
      // We do it to prevent a missuse of the cached StateId in case if a proper partition won't be found by
      // the algorithm below.
 
        _cachedStateId = CdbStateId( );

        _beginCachedStateIdValidity = BdbTime::plusInfinity; 
        _endCachedStateIdValidity   = BdbTime::plusInfinity;

      // Find out a 'topmost' partition corresponding to specified validity time
      // and obtain its modification time.
      //
      // NOTE: The logic implemented by the current code is slightly different from
      //       the one found in previous implementations. Here are the differences:
      //
      //       (1) The previous implementations used _current_ wall-clock time if
      //           a 'closed' partition was found. The new logic will always use
      //           the modification time.
      //
      //           [ That older logic didn't seem right from the optimization point of view
      //             since the actual _meaning_ of StateId-s does not change with wall-clock
      //             time for closed partition. In this case an identifier of a views
      //             alone stored as a part of the StateId provides full description of
      //             the same state of CDB. ]
      //
      //       (2) Another tiny change in the logic is related to so called "non-instantiated"
      //           partition not owned by the current CDB. This transitional scenario is quite
      //           normal in a distributed CDB when a remote origin has not delivered its
      //           instance of a known to MASTER partition (unless this instance is supposed
      //           to belong to the current 'origin'. Having a non-instantiated partition
      //           belonging to  the current 'origin' is supposed to be a CDB initialization
      //           error.). When this transition scenario is detected the creation time of the
      //           partition (in fact - the 'bottom' of the partition in the modification
      //           time dimension) will be put into the StateID.
      //
      //       (3) The current wall-clock time will only be used if no partition will be
      //           found for the specified validity time. It's quite an unusual situation
      //           meaning that 'partitionable' conditions are not in use at all.
      //
      // If the found partition is still not 'closed' (is 'under construction')
      // and if the current database is not the MASTER one and (finally :-)) if found
      // partition belongs to the local database then we should switch to the local
      // partition object. Then we'll have the most 'up-to-date' information about
      // the modification time of that partition.
      //
      // This kind of logic will not only provide us with the 'up-to-date' modification
      // time of a partition in its owner database, but will also ensure the correctness
      // of its ('modification time') in other databases.
      //
      // NOTE: The modification time as a way to refine the current state of the database
      //      _ONLY_ makes sense for the 'partitionable' conditions. In case of 'regular'
      //       conditions one should rely on the regular revisions mechanizm (sufficiently 
      //       supported by views)  to acheive the reproducability of the database contents.

        BdbTime partitionModificationTime( BdbTime::now( ));    // _current_ time by default
        {
            CdbCPtr< CdbRooRoPartitionsLayoutR > partitionsLayoutPtr = _masterRegistryPtr->partitionsLayout( );

          // NOTE: The following operation will look for an 'topmost' partition at
          //       at the MASTER registry.

            CdbCPtr< CdbRooRoPartitionR > partitionPtr;
            if( CdbStatus::Success == partitionsLayoutPtr->topmost( theValidityTime,
                                                                    partitionPtr )) {

              // Refine which partition object to use

                if( !partitionPtr->isClosed( )) {

                  // Switch from the MASTER partition to the local one if needed, which
                  // is going to happen in acase when the found partition belongs to
                  // the local 'origin'.

                    if( _masterRegistryPtr->originId( ) != _localRegistryPtr->originId( )) {
                        if( _localRegistryPtr->originId( ) == partitionPtr->originId( )) {

                          // Since we're switching to the final partition then we have one extra requirement
                          // to this partition - it must exist.

                            partitionsLayoutPtr = _localRegistryPtr->partitionsLayout( );

                          // NOTE: Unlike the previou step when we're looking for the preliminary information
                          //       about the partition now we also need to find 'closed' partitions
                          //       This is why we're looking this partition by it's ID, not requering
                          //       its "openness".

                            CdbCPtr< CdbRooRoPartitionR > partitionFinalPtr;
                            if( CdbStatus::Success != partitionsLayoutPtr->find( partitionPtr->id( ),
                                                                                 partitionFinalPtr )) {
                                cout << errorStr << endl
                                     << "    Failed to locate a final partition with ID=" << partitionPtr->id( ) << endl
                                     << "    at the local database where it's supposed to belong to." << endl
                                     << "    The local database may not be properly initialized/loaded." << endl;
                                break;
                            }

                          // Okay, finished switching the partition to the final one.

                            partitionPtr = partitionFinalPtr;
                        }
                    }
                }

              // Check one more time if that partition is in the 'open' state because
              // the previous step was switch us to the final partition owned
              // by the current SLAVE database. Therefore the information we're looking
              // for must be 'up-to-date'.

                if( partitionPtr->isClosed( )) {

                  // Get the modification time of the 'closed' partition. It will correspond
                  // to the time when the partition was closed.

                    partitionModificationTime = partitionPtr->modified( );

                } else {

                  // The non-local partition is allowed to be not instantiated since
                  // its owner database may not have delivered the corresponding updated version of it.
                  //
                  // Otherwise we treat the non-instantiated partition as a database inconsistency problem...

                    if( partitionPtr->isInstantiated( )) {
                        partitionModificationTime = partitionPtr->modified( );
                    } else {
                        if( _localRegistryPtr->originId( ) == partitionPtr->originId( )) {
                            cout << errorStr << endl
                                 << "    The partition with ID=" << partitionPtr->id( ) << " corresponding to the following" << endl
                                 << "    validity time: " << theValidityTime << endl
                                 << "    belonging to the local database is not properly instantiated." << endl
                                 << "    The local database may not be properly initialized/loaded." << endl;
                            break;

                        } else {

                          // This is pretty normal 'transitional' situation - a remote database has
                          // not delivered its instantiated partition yet. Therefore we don't know yet
                          // when the partition was modified. So we just go along with 'creation' time
                          // of the partition. This 'creation' time represents the 'bottom' of the partition
                          // in the modification timeline. It will guarantee that we'll be relying on
                          // the values of 'partitionable' conditions stored _before_ the found partition.

                            partitionModificationTime = partitionPtr->created( );
                        }
                    }
                }

              // Update the validity interval of the partition in the cache. We're going to use this
              // information to optimize subsequent requests to the current method
 
                _beginCachedStateIdValidity = partitionPtr->cell( ).beginValidity( );
                _endCachedStateIdValidity   = partitionPtr->cell( ).endValidity( );
 
            } else {

              // No topmost partition found in the current database. That's exactly the case when
              // we're going to use the currnt value of the wall-clock time.

                ;
            }
        }

      // Build the valid state identifier
      //
      // NOTE: That a usable (for the subsequent calls to the current method) validity interval
      //       for the updated State Id object is produced only if an eligible partition is found above.
      //       If not then the cached State Id would be just useless.

        _cachedStateId = CdbStateId( id( ), partitionModificationTime );

        result = _cachedStateId;

    } while( false );

    return result;
}

CdbStatus
CdbRooRoView::historyEventIterator( CdbHistoryEventItr& theItr,
                                   const BdbTime&      theBeginTime,
                                   const BdbTime&      theEndTime,
                                   const char**        theEventsToSelect )
{
    return CdbStatus::NotImplemented;
}

CdbStatus
CdbRooRoView::historyEventTypeIterator( CdbHistoryEventTypeItr& theItr )
{
    return CdbStatus::NotImplemented;
}

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

---