---

CdbBdbSView.cc

Go to the documentation of this file.

// File and Version Information:
//      $Id: CdbBdbSView.cc,v 1.11 2005/02/02 15:04:24 gapon Exp $

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

#include "CdbBdbShared/CdbBdbSView.hh"

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

#include "CdbBdbShared/CdbBdbSFolder.hh"
#include "CdbBdbShared/CdbBdbSPartitionP.hh"
#include "CdbBdbShared/CdbBdbSViewP.hh"
#include "CdbBdbShared/CdbBdbSConditionAtFolderP.hh"
#include "CdbBdbShared/CdbBdbSConfigCollectionP.hh"

#include "BdbTime/BdbTime.hh"

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

namespace {

    /////////////////////////////
    // Class: CdbBdbSConfigItr //
    /////////////////////////////

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

    private:

        CdbBdbSConfigItr( );

        CdbBdbSConfigItr& operator=( const CdbBdbSConfigItr& theItr );

    protected:

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

    public:

        CdbBdbSConfigItr( const CdbBdbSConfigCollectionP::IteratorOfIntervals& theInputItr ) :
            _itr(theInputItr)
        { }

        virtual ~CdbBdbSConfigItr( )
        { }

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

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

                CdbBdbSConfigInterval 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 CdbBdbSConfigItr( *this );
        }

    private:

        CdbBdbSConfigCollectionP::IteratorOfIntervals _itr;

        CdbConfigElement _value;
    };
};

////////////////////////
// Class: CdbBdbSView //
////////////////////////

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

    CdbBdbSView* mySelf = const_cast<CdbBdbSView*>( this );
    return new CdbBdbSView( mySelf->parent( ),
                            mySelf->name( ),
                            mySelf->id( ),
                            _viewH,
                            _masterRegistryH,
                            _localRegistryH );
}

CdbBdbSView::CdbBdbSView( const CdbDatabasePtr&              thePtr,
                          const char*                        theName,
                          const CdbId&                       theId,
                          const BdbHandle(CdbBdbSViewP)&     theViewH,
                          const BdbHandle(CdbBdbSRegistryP)& theMasterRegistryH ,
                          const BdbHandle(CdbBdbSRegistryP)& theLocalRegistryH ) :
    CdbView( thePtr,
             theName,
             theId ),
    _viewH(theViewH),
    _masterRegistryH(theMasterRegistryH),
    _localRegistryH(theLocalRegistryH)
{ }

CdbBdbSView::~CdbBdbSView( )
{ }

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

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

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

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

BdbTime
CdbBdbSView::minValidity( ) const
{
    return _viewH->minValidity( );
}

BdbTime
CdbBdbSView::maxValidity( ) const
{
    return _viewH->maxValidity( );
}

BdbTime
CdbBdbSView::created( ) const
{
    return _viewH->created( );
}

std::string
CdbBdbSView::description( ) const
{
    return std::string( _viewH->description( ).head( ));
}

bool
CdbBdbSView::hasDefaultConfig( ) const
{
    return ! BdbIsNull( _viewH->defaultConfig( ));
}

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

bool 
CdbBdbSView::isFrozen( ) const
{
    return _viewH->isFrozen( );
}

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

    thePtr = 0;

    do {

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

            cout << "CdbBdbSView::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 sp[ecified name

        BdbRef(CdbBdbSFolderP) fRef;
        if( CdbStatus::Success != _viewH->findFolder( theName,
                                                      fRef )) {
            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.

        CdbViewPtr   myPtr( this->clone( ));
        CdbFolderPtr fPtr( 0 );

        thePtr = new CdbBdbSFolder( myPtr,
                                    fPtr,
                                    theName,
                                    fRef,
                                    _masterRegistryH,
                                    _localRegistryH );

      // Done.

        result = CdbStatus::Success;

    } while( false );

    return result;
}

CdbStatus
CdbBdbSView::folderIterator( CdbFolderItr& theItr )
{
    return _viewH->folderIterator( theItr );
}

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

    CdbStatus result = CdbStatus::Error;
    do {

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

        if(( theValidityTime <  _viewH->minValidity( )) ||
           ( theValidityTime >= _viewH->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: " << _viewH->minValidity( ) << endl
                 << "        Maximum validity time: " << _viewH->maxValidity( ) << endl;
            break;
        }

      // Use default configuration only (if any).

        BdbRef(CdbBdbSConfigCollectionP) configCollRef = _viewH->defaultConfig( );
        if( BdbIsNull(configCollRef)) {
            result = CdbStatus::NotFound;
            break;
        }

      // Get the configuration interval.

        CdbBdbSConfigInterval configInterval;
        if( CdbStatus::Success != configCollRef->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
CdbBdbSView::defaultConfigIterator( CdbItr<CdbConfigElement>& theItr ) const
{
    CdbStatus result = CdbStatus::NotFound;
    do {

        BdbRef(CdbBdbSConfigCollectionP) configCollRef = _viewH->defaultConfig( );
        if( BdbIsNull(configCollRef)) break;

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

        theItr = CdbItr<CdbConfigElement>( new CdbBdbSConfigItr( configCollRef->iterator( )));

      // Done

        result = CdbStatus::Success;

    } while( false );

    return result;
}

CdbStatus
CdbBdbSView::get( const char*       theName,
                  const BdbTime&    theValidityTime,
                  CdbConfigElement& theConfigElement ) const
{
    const char* errorStr = "CdbBdbSView::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 <  _viewH->minValidity( )) ||
           ( theValidityTime >= _viewH->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: " << _viewH->minValidity( ) << endl
                 << "        Maximum validity time: " << _viewH->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.

        BdbRef(CdbBdbSConditionAtFolderP) cRef;
        if( CdbStatus::Success != _viewH->findCondition( theName,
                                                         cRef )) {
            result = CdbStatus::NotFound;
            break;
        }

        BdbRef(CdbBdbSConfigCollectionP) configCollRef = cRef->config( );
        if( BdbIsNull(configCollRef)) {

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

            configCollRef = _viewH->defaultConfig( );
            if( BdbIsNull(configCollRef)) {
                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.

        CdbBdbSConfigInterval configInterval;
        if( CdbStatus::Success != configCollRef->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
CdbBdbSView::configIterator( const char*               theName,
                             CdbItr<CdbConfigElement>& theItr ) const
{
    const char* errorStr = "CdbBdbSView::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.

        BdbRef(CdbBdbSConditionAtFolderP) cRef;
        if( CdbStatus::Success != _viewH->findCondition( theName,
                                                         cRef )) {
            result = CdbStatus::NotFound;
            break;
        }

        BdbRef(CdbBdbSConfigCollectionP) configCollRef = cRef->config( );
        if( BdbIsNull(configCollRef)) {

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

            configCollRef = _viewH->defaultConfig( );
            if( BdbIsNull(configCollRef)) {
                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 CdbBdbSConfigItr( configCollRef->iterator( )));

      // Done

        result = CdbStatus::Success;

    } while( false );

    return result;
}

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

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

      // 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
        {
            BdbRef(CdbBdbSPartitionsLayoutP) pLayoutRef = _masterRegistryH->partitionsLayout( );
            assert( !BdbIsNull(pLayoutRef));

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

            BdbRef(CdbBdbSPartitionP) pRef;
            if( CdbStatus::Success == pLayoutRef->topmost( theValidityTime,
                                                           pRef )) {

              // Refine which partition object to use

                if( !pRef->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( _masterRegistryH->originId( ) != _localRegistryH->originId( )) {
                        if( _localRegistryH->originId( ) == pRef->originId( )) {

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

                            pLayoutRef = _localRegistryH->partitionsLayout( );
                            assert( !BdbIsNull(pLayoutRef));

                          // 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".

                            BdbRef(CdbBdbSPartitionP) pFinalRef;
                            if( CdbStatus::Success != pLayoutRef->find( pRef->id( ),
                                                                        pFinalRef )) {
                                cout << errorStr << endl
                                     << "    Failed to locate a final partition with ID=" << pRef->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.

                            pRef = pFinalRef;
                        }
                    }
                }

              // 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( pRef->isClosed( )) {

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

                    partitionModificationTime = pRef->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( pRef->isInstantiated( )) {
                        partitionModificationTime = pRef->modified( );
                    } else {
                        if( _localRegistryH->originId( ) == pRef->originId( )) {
                            cout << errorStr << endl
                                 << "    The partition with ID=" << pRef->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 = pRef->created( );
                        }
                    }
                }
            }
        }

      // Build the valid state identifier

        result = CdbStateId( id( ), partitionModificationTime );

    } while( false );

    return result;
}

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

CdbStatus
CdbBdbSView::historyEventTypeIterator( CdbHistoryEventTypeItr& theItr )
{
    return CdbStatus::Error;
}

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

---