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

                 

---

/BdbEventStore/BdbEventStore.cc

Go to the documentation of this file.

//--------------------------------------------------------------------------
// File and Version Information:
//  $Id: BdbEventStore.cc,v 1.103 2002/06/21 21:56:54 becla Exp $
//
// Description:
//  Class BdbEventStore implementation file. This class represents the 
//  BaBar database application event store domain.
//
// Environment:
//  Software developed for the BaBar Detector at the SLAC B-Factory.
//
// Author List:
//  David R. Quarrie        Original Author
//
// History:
//
//------------------------------------------------------------------------
//-----------------------
// This Class's Header --
//-----------------------
#include "BdbEventStore/BdbEventStore.hh"

//-------------
// C Headers --
//-------------
extern "C" {
#include <assert.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
}

//---------------
// C++ Headers --
//---------------
#include <iostream.h>

//-------------------------------
// Collaborating Class Headers --
//-------------------------------
#include "ErrLogger/ErrLog.hh"
#include "BdbUtil/BdbPathName.hh"
#include "BdbDomainOODB/BdbDomainOODB.hh"
#include "BdbApplication/BdbDebug.hh"
#include "BdbApplication/BdbRWMultiInhibitPolicy.hh"
#include "BdbApplication/BdbEvsFSNamesStr.hh"
#include "BdbAccess/BdbAuth.hh"
#include "BdbAccess/BdbSingleBootInhibitFactory.hh"
#include "BdbAccess/BdbDbTreeSingleton.hh"
#include "BdbClustering/BdbEvsClusteringHint.hh"
#include "BdbClustering/BdbSpClusteringHint.hh"
#include "BdbEvent/BdbEventT.hh"
#include "BdbEvent/BdbEventTag.hh"
#include "BdbEventStore/BdbCollectionTCollTIterator.hh"
#include "BdbEventStore/BdbEventStoreErrors.hh"
#include "BdbEventStore/BdbEventStoreIterator.hh"
#include "BdbEventStore/BdbFetchCollTFactory.hh"
#include "BdbEventStore/BdbCollectionTFactory.hh"
#include "BdbEventStore/BdbBridgeCollTIterator.hh"
#include "BdbEventStore/BdbTreeCollTIterator.hh"
#include "BdbEventStore/BdbVectorCollTIterator.hh"
#include "BdbEventStore/BdbCollectionTIterator.hh"
#include "BdbEventStore/BdbBridgeCollectionT.hh"
#include "BdbEventStore/BdbTreeCollectionT.hh"
#include "BdbEventStore/BdbVectorCollectionT.hh"
#include "BdbEventStore/BdbTreeNodeCollectionTIterator.hh"
#include "BdbTrees/BdbDbRegistrator.hh"
#include "BdbEventStore/BdbCollTItemIterator.hh"


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

static const char rcsid[] = "$Id: BdbEventStore.cc,v 1.103 2002/06/21 21:56:54 becla Exp $";

//      ------------------------------------
//      -- Static Data Member Definitions --
//      ------------------------------------

BdbEventStore* BdbEventStore::_instance = 0;

d_Boolean BdbEventStore::_isClusteringConfigured( d_False );
d_Boolean BdbEventStore::_ownsClustering( d_False );
d_Boolean BdbEventStore::_useNestedCollTrans( 0 == getenv("BDB_NO_NESTED_COLL_TRANS") );

BdbAbstractClusteringHint* BdbEventStore::_nodeHint( 0 );
BdbAbstractClusteringHint* BdbEventStore::_treeCollHint( 0 );
BdbAbstractClusteringHint* BdbEventStore::_vecCollHint( 0 );
BdbAbstractClusteringHint* BdbEventStore::_bridgeCollHint( 0 );

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

//----------
// Public --
//----------

bool
BdbEventStore::exists( )
{
    bool result = ( 0 != _instance );
    return result;
}

BdbEventStore* 
BdbEventStore::instance( )
{
    if ( 0 == _instance ) {
        _instance = new BdbEventStore( );

        static BdbDbRegistrator registrator;
        BdbDbTreeSingleton::instance()->setRegistrator(&registrator);
        if ( ! _instance->hasInhibitPolicy( ) ) {
            _instance->setInhibitPolicy( new BdbRWMultiInhibitPolicy( new BdbSingleBootInhibitFactory() ) );
        }
    }
    return _instance;
}

d_Boolean
BdbEventStore::useNestedCollTrans()
{
   return _useNestedCollTrans;
}


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

//------------------
// Constructor(s) --
//------------------

const size_t kInitialRetainedLength( 2 );

BdbEventStore::BdbEventStore( )
    : BdbDomain( Events, BdbDomainOODB::Optional ),
      _intermediateNodes( d_True ) ,
      _retainedList( new RetainedToken[ kInitialRetainedLength ] ) ,
      _retainedDepth( 0 ) ,
      _retainedLength( kInitialRetainedLength ) ,
      _lastPath( 0 )
{
    setStrategyObj(new BdbEvsFSNamesStr);
    setInitialAuthLevel( User );
}

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

BdbEventStore::~BdbEventStore( ) 
{
}

//------------------------------------
// Federation retention and release --
// -----------------------------------

BdbTransToken
BdbEventStore::currentTrans() const
{
    return( currentTransToken() );
}

size_t
BdbEventStore::findRetainedTrans( const BdbTransToken& token ) const
{
    size_t index( 0 );
    while( ( _retainedDepth != index ) &&
           ( token != (_retainedList[ index ])._token ) ) {
        index++;
    }

    return( index );
}

BdbTransToken
BdbEventStore::retainTrans()
{
    const BdbTransToken token( currentTrans() );

    if( BdbcInValidTransToken == token ) {
        ErrMsg( fatal ) << "There is no valid transaction for this domain"
                        << endmsg;
        ::abort();
    }

    size_t index( findRetainedTrans( token ) );

    // If already in the list increase count
    if( _retainedDepth != index ) {
        (_retainedList[ index ])._count++;

        // If count was originally zero, re-hold the transaction
        if( 1 == ((_retainedList[ index ])._count) ) {
            holdCurrentTrans();
        }
        return( _retainedList[ index ]._token );
    }

    // Expand the list if necessary
    if( _retainedDepth == _retainedLength ) {
        RetainedToken* newList = new RetainedToken[ _retainedLength * 2 ];
        memcpy( newList ,
                _retainedList ,
                _retainedLength * sizeof( RetainedToken ) );
        delete [] _retainedList;
        _retainedList = newList;
        _retainedLength = _retainedLength * 2;
    }

    // place transaction into retained list
    _retainedList[ _retainedDepth ]._token = token;
    _retainedList[ _retainedDepth ]._count = 1;
    _retainedDepth++;

    // hold the Transaction
    holdCurrentTrans();

    return( token );
}

void
BdbEventStore::releaseTrans( const BdbTransToken& token )
{
    size_t index( findRetainedTrans( token ) );

    // If not in the list then abort
    if( _retainedDepth == index ) {
        ErrMsg( fatal ) << "Can not release and transaction when it has not"
                        << " been retained"
                        << endmsg;
        ::abort();
    }

    // decrement count and finished is still retained
    (_retainedList[ index ])._count--;
    if( 0 != (_retainedList[ index ])._count ) {
        return;
    }

    // If we are releasing the current transaction simply unlock it and
    // finish.
    if( token == currentTrans() ) {
        dropCurrentTrans();
        return;
    }

    // Otherwise lock the current transaction if necessary, unlock the
    /// requested transaction and the retore the original
    bool tempLock( false );
    if( !currentTransIsHeld() ) {
        holdCurrentTrans();
        tempLock = !false;
    }

    const BdbTransToken originalToken( setCurrentTrans( token ) );
    dropCurrentTrans();
    setCurrentTrans( originalToken );

    if( tempLock ) {
        dropCurrentTrans();
    }
}

BdbTransToken
BdbEventStore::setCurrentTrans( const BdbTransToken& token )
{
    BdbTransToken originalToken( currentTransToken() );
    BdbDomain::setCurrentTrans( token );
    return( originalToken );
}

void
BdbEventStore::changeDefaultFed( const char* name )
{
    // If the requested federation matches the current one do nothing.
    if( 0 == strcmp( bootName() ,
                     name ) ) {
        return;
    }

    setLastPath( 0 );
    setDefaultBootName( name );
}

void
BdbEventStore::newEvsTrans( const char* name )
{
    changeDefaultFed( name );
    newCurrentTrans();
}

// phase 3.3 extension to allow creation of output transaction 
//         associated with a different federation
//
BdbTransToken BdbEventStore::createOutputTrans(const char *bootName){

    BdbTransToken originalTrans(currentTrans());
    newCurrentTrans(bootName);
    retainTrans();
    return (originalTrans);

}

//---------------------------------------------
// General Selectors, Modifiers & Operations --
// --------------------------------------------

void 
BdbEventStore::configureClustering( )
{
    BdbAbstractClusteringHint* treeCollHint;
    BdbAbstractClusteringHint* vecCollHint;
    BdbAbstractClusteringHint* bridgeCollHint;

    if ( ! _isClusteringConfigured ) {

        activate();

        // Setup clustering hints for the Tree Nodes
        _nodeHint = new BdbSpClusteringHint( *this );
        _nodeHint->setComponent( "nod" );
        BdbHintSetDelegate( BdbTreeNodeP, _nodeHint );

        // Setup clustering hints for the Collections
        treeCollHint = new BdbEvsClusteringHint( *this );
        vecCollHint = new BdbEvsClusteringHint( *this );
        bridgeCollHint = new BdbEvsClusteringHint( *this );
        treeCollHint->setComponent( "col" );
        vecCollHint->setComponent( "col" );
        this->configureClustering( treeCollHint ,
                                   vecCollHint ,
                                   bridgeCollHint);
        _ownsClustering = d_True;

        deactivate();

        _isClusteringConfigured = d_True;
    }
}

void 
BdbEventStore::configureClustering( BdbAbstractClusteringHint* aTreeCollHint ,
                                    BdbAbstractClusteringHint* aVecCollHint ,
                                    BdbAbstractClusteringHint* aBridgeCollHint )
{
    if ( _ownsClustering ) {
        delete _treeCollHint;
        delete _vecCollHint;
        delete _bridgeCollHint;
        _ownsClustering = d_False;
    }

    _treeCollHint = aTreeCollHint;
    BdbHintSetDelegate( BdbTreeCollectionP, _treeCollHint );
    _vecCollHint = aVecCollHint;
    BdbHintSetDelegate( BdbVectorCollectionP, _vecCollHint );
    _bridgeCollHint = aVecCollHint;
    BdbHintSetDelegate( BdbBridgeCollectionP, _bridgeCollHint );
}


bool
BdbEventStore::isAccessAllowed( const char* userName ) const
{
    BdbAuth* theAuth = BdbAuth::instance( );
    activate();
    bool result( theAuth->isAccessAllowed( Events, userName ) );
    deactivate();
    return result;
}

BdbStatus
BdbEventStore::readAttempt( BdbHandleAny& theObj )
{
    BdbStatus result;
    d_Long oldWait   = lockWait( );
    setLockWait( BdbcNoWait );
    result = theObj.open( BdbcRead );
    setLockWait( oldWait );
    return result; 
}

//------------------------------------------------
// Collection Selectors, Modifiers & Operations --
// -----------------------------------------------
BdbAbsCollectionT< BdbEventT >*
BdbEventStore::collection( const char* theCollPath,
                           const BdbEventT&,
                           bool allowNestedCollTrans )
{
    bool useNestedCollTrans( ( _useNestedCollTrans ) &&
                             ( allowNestedCollTrans ) );

    BdbAbsCollectionT< BdbEventT >* theTransient( 0 );

    char* theCollStem = BdbPathName::stem( theCollPath,
                                           true);
    char* theNodePath = BdbPathName::absolute( validLastPath() ,
                                               theCollStem );
    delete [] theCollStem;

    if( useNestedCollTrans ) {
        startNestedUpdate();
    }
    BdbTreeNode collectionNode;
    BdbStatus result = treeNode( collectionNode, theNodePath );
    if ( BdbcSuccess == result ) {

        // Ok, the node exists, now see whether the specified collection
        // exists.  The following code attempts to locate the collection
        // by name, and checks that the returned object is of the
        // desired type.
        const char* theCollName = BdbPathName::leaf( theCollPath );
        ooTypeNumber theTypes[] = {
            ooTypeN(BdbCollectionP) ,
            ooTypeN(BdbTreeCollectionP) ,
            ooTypeN(BdbVectorCollectionP) ,
            ooTypeN(BdbBridgeCollectionP)
        };
        BdbHandle(BdbCollectionP) theCollP;
        result = collectionNode.child( theCollP, theCollName, theTypes, 4 );
        delete [] theCollName;
        if ( BdbcSuccess == result ) {
            theTransient = getCollection( theCollP );
        }
    }
    if( 0 != theTransient ) {
        if( useNestedCollTrans ) {
            theTransient->invalidateCachedHandle();
        }
       setLastPath( theNodePath );
    } else {
        delete [] theNodePath;
    }

    if( useNestedCollTrans ) {
        commitNested();
    }

    return theTransient;
}


BdbAbsCollectionT< BdbEventT >*
BdbEventStore::getCollection( BdbHandle( BdbCollectionP )& thePersistent )
{
    // There is a problem with using ooIsKindOf, which would be the
    // "correct" approach.  Using this puts a read lock on the returned
    // item, which can cause unnecessary interference. The following list
    // should contain the Type Numbers for all known subclasses of the
    // BdbCollectionP persistent collection base class. This is obviously
    // not ideal since this list will have to be maintained by hand.
    ooTypeNumber theTypes[] = {
        ooTypeN(BdbCollectionP) ,
        ooTypeN(BdbTreeCollectionP) ,
        ooTypeN(BdbVectorCollectionP) ,
        ooTypeN(BdbBridgeCollectionP)
    };
    ooTypeNumber persistentType( thePersistent.typeN( ) );
    if( persistentType == theTypes[1] ) {
        return( new BdbTreeCollectionT<BdbEventT>( (BdbHandle(BdbTreeCollectionP)&)thePersistent ) );
    } else if ( persistentType == theTypes[2] ) {
        return( new BdbVectorCollectionT<BdbEventT>( (BdbHandle(BdbVectorCollectionP)&)thePersistent ) );
    } else if ( persistentType == theTypes[3] ) {
        return( new BdbBridgeCollectionT<BdbEventT>( (BdbHandle(BdbBridgeCollectionP)&)thePersistent ) );
    }
    return( 0 );
}



BdbCollectionTIterator< BdbEventT >*
BdbEventStore::getIterator( BdbAbsCollectionT< BdbEventT >& theDescrOverrideTarget ,
                            BdbHandle( BdbCollectionP )& thePersistent ,
                            d_ULong initialIndex )
{
    // There is a problem with using ooIsKindOf, which would be the
    // "correct" approach.  Using this puts a read lock on the returned
    // item, which can cause unnecessary interference. The following list
    // should contain the Type Numbers for all known subclasses of the
    // BdbCollectionP persistent collection base class. This is obviously
    // not ideal since this list will have to be maintained by hand.
    ooTypeNumber theTypes[] = {
        ooTypeN(BdbCollectionP) ,
        ooTypeN(BdbTreeCollectionP) ,
        ooTypeN(BdbVectorCollectionP) ,
        ooTypeN(BdbBridgeCollectionP)
    };
    ooTypeNumber persistentType( thePersistent.typeN( ) );
    if( persistentType  == theTypes[1] ) {
        return( new BdbTreeCollTIterator<BdbEventT>( theDescrOverrideTarget ,
                                                   (BdbHandle(BdbTreeCollectionP)&)thePersistent ,
                                                   initialIndex ) );
    } else if ( persistentType == theTypes[2] ) {
        return( new BdbVectorCollTIterator<BdbEventT>( theDescrOverrideTarget ,
                                                     (BdbHandle(BdbVectorCollectionP)&)thePersistent ,
                                                     initialIndex ) );
    } else if ( persistentType == theTypes[3] ) {
        return( new BdbBridgeCollTIterator<BdbEventT>( theDescrOverrideTarget ,
                                                     (BdbHandle(BdbBridgeCollectionP)&)thePersistent ,
                                                     initialIndex ) );
    }
    return( 0 );
}


BdbStatus
BdbEventStore::moveCollection( BdbAbsCollectionT<BdbEventT>*& theCollection, 
                               const char* const theCollPath )
// Move an existing collection to the specified collection path name. 
{
    char* theCollName = BdbPathName::leaf( theCollPath );
    BdbStatus result = BdbcError;

    // Check for valid name
    if ( 0 != theCollName ) {

        // New name is valid - remove the collection from event store but don't delete it
        result = removeCollection( theCollection, d_True );
        if ( BdbcSuccess == result ) {

            char* theCollStem = BdbPathName::stem( theCollPath,
                                                   true );
            char* theNodePath = BdbPathName::absolute( validLastPath() ,
                                                       theCollStem );
            delete [] theCollStem;

            AuthLevels  theAuthLevel = getAuthLevel ( theNodePath );
            const char* theAuthName  = getAuthName  ( theNodePath );

            // Check that we have update access to the new location
            if ( setAuthLevel( theAuthLevel, theAuthName ) ) {

                // Update access granted.
                // Fetch the node, creating it if necessary.
                // BdbTreeNode origNode = currentNode();
                BdbTreeNode collectionNode;
                result = fetchTreeNode( collectionNode, theNodePath );
                if ( BdbcSuccess == result ) {

                    // Now we have to lock both the collection
                    // and tree node for update in order to be sure that we
                    // have sole update access to them both.
                    BdbHandle(BdbCollectionP) theCollP = theCollection->persistent( );
                    BdbHandle(BdbTreeNodeP)   theNodeP = collectionNode.persistent( );
                    BdbHandleAny theHandles[2];
                    theHandles[0] = theCollP;
                    theHandles[1] = theNodeP;
                    BdbDomain* theApp = BdbDomain::activeInstance( );
                    result = updateAndWait( theHandles, 2,
                                            BdbDomain::DomainNames[BdbDomain::Events] ); 
                    if ( BdbcSuccess == result ) {

                        // 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
                        result = theNodeP->hasChild( theCollName );
                        if ( BdbcSuccess != result ) {

                            // Collection doesn't already exist - create it
                            theCollP->setCollName( theCollName );
                            theCollP->setTreeNode( theNodeP );
                            result = theNodeP->add( theCollP, theCollName );
                        }
                    } else {
                        BdbSignal( BdbcUserError, BdbEventStoreErrUnableToUpdate, 0, 
                                   "BdbEventStore::moveCollection", theCollName ); 
                    }
                }
                if ( BdbcSuccess == result ) {
                    setLastPath( theNodePath );
                    theNodePath = 0;
                }
            }
            delete [] theNodePath;
        }
    } else {
        BdbSignal( BdbcUserError, BdbEventStoreErrCollectionNotNamed, 0, 
                   "BdbEventStore::moveCollection" );
    }
    delete [] theCollName;
    return result;
}

BdbStatus
BdbEventStore::removeCollection( BdbAbsCollectionT<BdbEventT>*& theCollection, 
                                 d_Boolean bypassDelete )
{
    BdbStatus result = BdbcError;
    if ( 0 != theCollection && ! theCollection->isNull( ) ) {

        // Check whether the we have privilege to remove this collection
        const char* theFullName = theCollection->pathName( );
        char* theNodePath = BdbPathName::stem( theFullName );
        AuthLevels  theAuthLevel = getAuthLevel ( theNodePath );
        const char* theAuthName  = getAuthName  ( theNodePath );
        delete [] theNodePath;

        if ( setAuthLevel( theAuthLevel, theAuthName ) ) {

            // Remove the collection from the event store
            BdbTreeNode theNode;
            result = theCollection->treeNode( theNode );
            if ( BdbcSuccess == result ) {
                theNode.remove( theCollection->name( ) );
            }
            if ( ! bypassDelete ) {
                theCollection->setDeleted( );
            }
            result = BdbcSuccess;
        }
    }
    return result;
}

BdbStatus
BdbEventStore::removeCollection( const char* const theCollPath, d_Boolean bypassDelete )
{
    BdbStatus result = BdbcError;
    BdbAbsCollectionT<BdbEventT>* theCollection = collection( theCollPath, (*(BdbEventT*)0) );
    if ( 0 != theCollection ) {
        result = removeCollection( theCollection, bypassDelete );
    }
    return result;
}


BdbStatus
BdbEventStore::fetchCollection( BdbAbsCollectionT<BdbEventT>*& theCollection, 
                                const char* const theCollPath,
                                BdbCollectionTFactory<BdbEventT>& factory,
                                d_ULong initialSize )
// Locate Collection for the specified collection path name, creating 
// it as a tree collection if it doesn't already exist. Note that we use
// a pessimistic algorithm for determining whether the user has adequate
// authorization rights to create the collection. If they don't have
// adequate rights the request will fail even if the specified collection
// already exists. This assumes that their intent in using this function
// is to add to the specified collection.
{
    BdbStatus result( BdbcError );
    theCollection = 0;
    
    char* theFullCollName = BdbPathName::absolute( validLastPath(),
                                                   theCollPath );
    BdbFetchCollTFactory< BdbEventT > factoryToUse( factory );
    theCollection = factoryToUse.getCollection( theFullCollName, initialSize );

    if ( ( 0 != theCollection ) && (! theCollection->isNull( ) ) ) {
        result = BdbcSuccess;
    }

    delete [] theFullCollName;

    return result;
}


//-----------------------------------------------
// Tree-Node Selectors, Modifiers & Operations --
// ----------------------------------------------

BdbStatus
BdbEventStore::fetchTreeNode( BdbTreeNode& theNode,
                              const char* const theNodePath )
// Fetch and create if necessary the tree-node for the specified 
// node path name. 
// Note that we use a pessimistic algorithm for determining whether the user 
// has adequate authorization rights to create the node. If they don't have
// adequate rights the request will fail even if the specified node
// already exists. This assumes that their intent in using this function
// is to add to the specified node.
{
    AuthLevels  theAuthLevel = getAuthLevel ( theNodePath );
    const char* theAuthName  = getAuthName  ( theNodePath );
    BdbTreeNode origNode = theNode;
    BdbStatus result = BdbcError;

    if ( setAuthLevel( theAuthLevel, theAuthName ) ) {
        result = treeNode( theNode, theNodePath );
        if ( BdbcSuccess != result ) {
            result = createTreeNode( theNode, theNodePath );
        }
    }
    if ( BdbcSuccess != result ) {
        theNode = origNode;
    }
    return result;
}

BdbStatus
BdbEventStore::fetchTreeNode( BdbTreeNode& theNode,
                              AuthLevels theAuthLevel, 
                              const char* const theAuthName )
// Fetch and create if necessary the top-level tree-node for the specified 
// authorization level and name. 
// Note that we use a pessimistic algorithm for determining whether the user 
// has adequate authorization rights to create the node. If they don't have
// adequate rights the request will fail even if the specified node
// already exists. This assumes that their intent in using this function
// is to add to the specified node.
{
    assert( isAuthLevelValid( theAuthLevel ) );
    BdbTreeNode origNode = theNode;
    BdbStatus result = BdbcError;

    if ( setAuthLevel( theAuthLevel, theAuthName ) ) {
        result = treeNode( theNode, theAuthLevel, theAuthName );
        if ( BdbcSuccess != result ) {
            result = createTreeNode( theNode, theAuthLevel, theAuthName );
        }
    }
    if ( BdbcSuccess != result ) {
        theNode = origNode;
    }
    return result;
}

BdbStatus
BdbEventStore::treeNode( BdbTreeNode& theNode,
                         const char* const theNodePath )
// Locate the tree-node for the specified node path name. 
{
    BdbStatus result = BdbcSuccess;
    if ( ( 0 == theNodePath ) || ( '/' != *theNodePath ) ) {

        // Relative path - Move to initial default location if necessary.
        if ( theNode.isNull( ) ) {
            result = treeNode( theNode, User );
        }
    }
    if ( BdbcSuccess == result ) {
        result = theNode.moveTo( theNodePath );
    }
    return result;
}

BdbStatus
BdbEventStore::treeNode( BdbTreeNode& theNode,
                         AuthLevels theAuthLevel, 
                         const char* const theAuthName )
// Locate the top-level tree-node for the specified authorization level 
// & name. 
{
    assert( isAuthLevelValid( theAuthLevel ) );
    const char* topName = authLevelName( theAuthLevel );
    const char* useName = useAuthName( theAuthLevel, theAuthName );
    BdbStatus result = theNode.moveToRootChild( topName );
    if ( ( BdbcSuccess == result ) && ( 0 != useName ) ) {
        result = theNode.moveTo( useName );
    }
    return result;
}

//-------------
// Operators --
//-------------

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

void 
BdbEventStore::initialize( )
{
}

bool
BdbEventStore::isAuthorized( AuthLevels theAuthLevel, 
                             const char* const theAuthName )
{
    assert( isAuthLevelValid( theAuthLevel ) );
    BdbAuth* theAuth = BdbAuth::instance( );
    activate();
    bool result( theAuth->isAuthorized( domain(),
                                        theAuthLevel,
                                        theAuthName ) );
    deactivate();
    return result;
}

BdbStatus
BdbEventStore::createTreeNode( BdbTreeNode& theNode,
                               const char* const theNodePath )
// Create the tree-node for the specified tree-node path name
{
    AuthLevels  theAuthLevel = getAuthLevel( theNodePath );
    const char* theAuthName  = getAuthName ( theNodePath );
    BdbStatus result;

    result = createTreeNode( theNode, theAuthLevel, theAuthName );
    if ( BdbcSuccess == result ) {
        // Top-level tree-node exists - walk down node tree
        const char* theRelPath = skipAuthName( theNodePath );
        result = theNode.makeTo( theRelPath, _intermediateNodes );
    }
    return result;
}

BdbStatus
BdbEventStore::createTreeNode( BdbTreeNode& theNode,
                               AuthLevels theAuthLevel, 
                               const char* const theAuthName )
// Create the top-level tree-node for the specified authorization level & name
{
    BdbTreeNode aNode;
    BdbStatus result = BdbcError;

    assert( isAuthLevelValid( theAuthLevel ) );
    const char* useName = useAuthName( theAuthLevel, theAuthName );

    theNode.setNull( );

    // Check whether the top-most tree node exists & create it if necessary
    const char* topName = authLevelName( theAuthLevel );
    result = aNode.makeRootChild( topName );
    if ( ( BdbcSuccess == result ) && ( 0 != useName ) ) {
        result = aNode.makeTo( useName, _intermediateNodes );
    }
    if ( BdbcSuccess == result ) {
        BdbHandle(BdbTreeNodeP) aNodeP = aNode.persistent( );
        theNode.setPersistent( aNodeP );
    }
    return result;
}


void
BdbEventStore::removeCollection( BdbTreeNode& theNode, 
                                 BdbAbsCollectionT<BdbEventT>*& theCollection )
// Search collections in the specified tree node for other collections that
// the specified collection has been added to, removing it from them prior to
// removing the collection itself from the event store.
{
    BdbAbsCollectionT<BdbEventT>* aCollection;
    BdbTreeNode aNode;
    BdbStatus status;

    // Iterate over collections in this node
    BdbTreeNodeCollectionTIterator nodeIter( theNode );

    while ( BdbcSuccess == ( status = nodeIter.nextCollection( aCollection ) ) ) {
        if ( *theCollection == *aCollection ) {

            // Remove the collection itself from this node
            BdbHandle(BdbCollectionP) theCollP = theCollection->persistent( );
            status = theNode.remove( theCollP );
        } else {

            // Attempt to remove the collection from the other collection
            status = aCollection->removeCollection( *theCollection );
        }
    }

    // Iterate over child nodes
    while ( BdbcSuccess == ( status = nodeIter.next( aNode ) ) ) {
        removeCollection( aNode, theCollection );
    }
}

const char*
BdbEventStore::validLastPath() const
{
    if( 0 != _lastPath ) {
        return( _lastPath );
    }

    const char* topName = authLevelName( User );
    const char* useName = const_cast< BdbEventStore* >( this )->useAuthName( User, 0 );
    // need four extra char for three separators and the trminating '\0'
    size_t lengthTopName( strlen( topName ) );
    size_t lengthUseName( strlen( useName ) );
    char* result( new char[ lengthTopName + lengthUseName + 4 ] );
    const char localSeparator( BdbPathName::separator() );
    result[ 0 ] = localSeparator;
    strcpy( result + 1, topName );
    result[ lengthTopName + 1 ] = localSeparator;
    strcpy( result + lengthTopName + 2, useName );
    result[ lengthTopName + lengthUseName + 2 ] = localSeparator;
    result[ lengthTopName + lengthUseName + 3 ] = '\0';
    // _lastPath should really be mutable
    const_cast< BdbEventStore* >( this )->_lastPath = result;
    return( result );
}

void
BdbEventStore::setLastPath( char* lastPath )
{
    delete [] _lastPath;
    _lastPath = lastPath;
}

 

---

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

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