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

                 

---

/BdbModules/BdbCollectionCommand.cc

Go to the documentation of this file.

//--------------------------------------------------------------------------
// File and Version Information:
//      $Id: BdbCollectionCommand.cc,v 1.76.2.1 2002/06/29 00:34:48 becla Exp $
//
// Description:
//      Class BdbCollectionCommand. Command handler for the "collection"
//      command for the event store input module. Valid subcommands are:
//
// collection add[To] <source> [<source>] <dest>
//                                    Add the source collection to the
//                                      destination collection
// collection cleanup -t[ree] <tree> -t[ree] <tree> <name>
//                                    Cleanup the specified collection
// collection contents [-[no]size] <name>
//                                    Display the contents (collections)
//                                      of the specified collection
// collection create [-tree] [-vector] [-bridge] [-stream stream ]
//                          <name> [<name>]
//                                    Create the specified collection(s)
// collection delete <name> [<name>]  Delete the specified collection(s)
// collection events <name>           Display the contents (events) of
//                                      the specified collection
// collection help                    Show help information
// collection list                    List collections for current user
// collection list <collection>       List a single collection
// collection list <node>             List collections for node <node>
// collection list -a[ll]             List all collections
// collection list -g[roup] <group>   List collections for group <group>
// collection list -n[ode] <node>     Synonym for list <node>
// collection list -s[ystem]          List system collections
// collection list -u[ser] <user>     List collections for user <user>
// collection map <source> [<source>] <federation>
//                                    Map collections in specified
//                                      federation onto matching bridge
//                                      collections in this federation
// collection moveTo <source> <dest>  Move the specified source
//                                      collection to the destination
// collection precreateCleanup        Cleanup following collection
//                                      precreation
// collection remove[From] <source> [<source>] <dest>
//                                    Remove the source collection from
//                                      the destination collection
// collection rename <source> <dest>  Synonym for moveTo
//
//  Where <tree> is a tree name (and multiple of them may be specified
//  and <name> is a collection name. The specified tree(s) will be
//  removed for all events.
//
// Environment:
//      Software developed for the BaBar Detector at the SLAC B-Factory.
//
// Author List:
//      David R. Quarrie            Original Author
//
// Copyright Information:
//      Copyright (C) 1999          Lawrence Berkeley Laboratory
//
//------------------------------------------------------------------------
#include "BaBar/BaBar.hh"

//-----------------------
// This Class's Header --
//-----------------------
#include "BdbModules/BdbCollectionCommand.hh"

//-------------
// C Headers --
//-------------
#include <assert.h>
#include <string.h>
#include <stdlib.h>

//-------------------------------
// Collaborating Class Headers --
//-------------------------------
#include "BdbClustering/BdbEvsClusteringHint.hh"
#include "BdbModules/BdbModulesUtility.hh"
#include "BdbEventStore/BdbMetaDataCollTFactory.hh"
#include "BdbEventStore/BdbFetchCollTFactory.hh"
#include "BdbEventStore/BdbCollectionTCollTIterator.hh"
#include "BdbEventStore/BdbCollectionTIterator.hh"
#include "BdbEventStore/BdbEventStore.hh"
#include "BdbEventStore/BdbEventStoreIterator.hh"
#include "BdbEventStore/BdbBridgeCollTFactory.hh"
#include "BdbEventStore/BdbTreeCollTFactory.hh"
#include "BdbEventStore/BdbVectorCollTFactory.hh"
#include "BdbEventStore/BdbCollPlacementManager.hh"
#include "BdbEventStore/BdbTreeNodeCollectionTIterator.hh"
#include "BdbTrees/BdbTreeNodeP.hh"
#include "BdbTrees/BdbTreeNodeSimpleIterator.hh"
#include "BdbUtil/BdbPathName.hh"
#include "ErrLogger/ErrLog.hh"
#include "Framework/APPFramework.hh"
#include "Framework/APPModule.hh"
#include "FrameUtil/AbsInterp.hh" 
#include "BdbEventStore/BdbBridgeCollItemDesc.hh"
#include "BdbEventStore/BdbCollTItemIterator.hh"

//------------------------------------
// Collaborating Class Declarations --
//------------------------------------
class BdbAbstractClusteringHint;

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


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

const int
BdbCollectionCommand::_defaultMaxNodeCount = 32;
int
BdbCollectionCommand::_maxNodeCount = _defaultMaxNodeCount;

int 
BdbCollectionCommand::maxNodeCount( )
{
    return _maxNodeCount;
}

void 
BdbCollectionCommand::setMaxNodeCount( int maxCount )
{
    if ( maxCount > 0 ) {
        _maxNodeCount = maxCount;
    } else {
        _maxNodeCount = _defaultMaxNodeCount;
    }
}

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

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

BdbCollectionCommand::BdbCollectionCommand(const char* const theCommand, AppModule* theTarget )
    : APPCommand( theCommand, theTarget ),
      _isInitialized( d_False ),
      _placement( 0 ),
      _streamPlacement( 0 ),
      _isDifferentStream( true )
{
}

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

BdbCollectionCommand::~BdbCollectionCommand( )
{
    delete [] _streamPlacement;
    delete _placement;
}

//-----------
// Handler --
//-----------

int 
BdbCollectionCommand::handle( int argc, char* argv[] )
{
    int result = AbsInterp::ERROR;

    // Setup the default mode flags
    _oneLine    = d_False;
    _listEvents = d_True;
    _listMeta   = d_False;
    _checkOwner = d_False;
    _fixupOwner = d_False;
    _badOnly    = d_False;
    _descend    = d_True;
    _listOwned  = d_False;
    _listOID    = d_False;
    _listColl   = d_False;

    setArgs( argc, argv );
    if ( 2 <= argc ) {
        if        ( 0 == strcmp( argv[1], "addTo" ) || 
                    0 == strcmp( argv[1], "add"   ) ) { 
            result = addHandler( argc, argv );
        } else if ( 0 == strcmp( argv[1], "cleanup" ) || 
                    0 == strcmp( argv[1], "cl"      ) ) { 
            result = cleanupHandler( argc, argv );
        } else if ( 0 == strcmp( argv[1], "contents" ) || 
                    0 == strcmp( argv[1], "co"       ) ) { 
            result = contentsHandler( argc, argv );
        } else if ( 0 == strcmp( argv[1], "create" ) || 
                    0 == strcmp( argv[1], "cr"     ) ) { 
            result = createHandler( argc, argv );
        } else if ( 0 == strcmp( argv[1], "delete" ) ) {
            result = deleteHandler(  argc, argv );
        } else if ( 0 == strcmp( argv[1], "events" ) || 
                    0 == strcmp( argv[1], "ev"     ) ) { 
            result = eventsHandler( argc, argv );
        } else if ( 0 == strcmp( argv[1], "help" ) ||
                    0 == strcmp( argv[1], "he"   ) ) {
            result = helpHandler( );
        } else if ( 0 == strcmp( argv[1], "list" ) || 
                    0 == strcmp( argv[1], "li"   ) ) {
            result = listHandler( argc, argv );
        } else if ( 0 == strcmp( argv[1], "map" ) || 
                    0 == strcmp( argv[1], "ma"   ) ) {
            result = mapHandler( argc, argv );
        } else if ( 0 == strcmp( argv[1], "moveTo" ) ||
                    0 == strcmp( argv[1], "move"   ) ||
                    0 == strcmp( argv[1], "rename" ) ||
                    0 == strcmp( argv[1], "rena"   ) ) {
            result = moveHandler( argc, argv );
        } else if ( 0 == strcmp( argv[1], "precreateCleanup" ) ||
                    0 == strcmp( argv[1], "precreate"        ) ||
                    0 == strcmp( argv[1], "prec"             ) ) {
            result = precreateCleanupHandler( argc, argv );
        } else if ( 0 == strcmp( argv[1], "removeFrom" ) ||
                    0 == strcmp( argv[1], "remove"     ) ) {
            result = removeHandler( argc, argv );
        } else {
            target( )->setError( "invalid command name" );
        }
    } else {
        target( )->setError( "wrong # args" );
    }
    return result;
}

int 
BdbCollectionCommand::helpHandler( )
{
    AppFramework* theFrame = target( )->framework( );
  
    theFrame->fullReport( "" );
    theFrame->partialReport( "collection addTo <source> <dest>        " );
    theFrame->fullReport("Add the source collection to the" ); 
  
    theFrame->partialReport( "                                        " );  
    theFrame->fullReport( "destination collection" );
  
    theFrame->fullReport( "collection cleanup -t[ree] <tree> <name>" );
    theFrame->partialReport( "                                        " );  
    theFrame->fullReport("Cleanup a collection." );
    theFrame->partialReport( "                                        " );  
    theFrame->fullReport( "Multiple trees may be specified." );
  
    theFrame->fullReport( "collection contents [-[no]events] <name>" );
    theFrame->partialReport( "                                        " );  
    theFrame->fullReport("Display the contents (collections)" ); 
    theFrame->partialReport( "                                        " );  
    theFrame->fullReport( "of a collection" );
  
    theFrame->fullReport( "collection create [-tree] [-vector] <name> [<name>]");
    theFrame->partialReport( "                                        " );  
    theFrame->fullReport("Create the specified collection(s)" );

    theFrame->partialReport( "collection delete <name> [<name>]       " );
    theFrame->fullReport("Delete the specified collection(s)" );

    theFrame->partialReport( "collection events <name>                " );
    theFrame->fullReport("Display the contents (events) of" ); 
    theFrame->partialReport( "                                        " );  
    theFrame->fullReport( "a collection" );

    theFrame->partialReport( "collection help                         " );
    theFrame->fullReport("Show this help information" );

    theFrame->partialReport( "collection list                         " );
    theFrame->fullReport("List collections for current user" );

    theFrame->partialReport( "collection list <node>                  " );
    theFrame->fullReport("List collections for node <node>" );

    theFrame->partialReport( "collection list -a[ll]                  " );
    theFrame->fullReport("List all collections" );

    theFrame->partialReport( "collection list -g[roup] <group>        " );
    theFrame->fullReport("List collections for group <group>" );
  
    theFrame->partialReport( "collection list -n[ode] <node>          " );
    theFrame->fullReport("List collections for node <node>" );
  
    theFrame->partialReport( "collection list -s[ystem]               " );
    theFrame->fullReport("List system collections" );
  
    theFrame->partialReport( "collection list -u[ser] <user>          " );
    theFrame->fullReport("List collections for user <user>" );
  
    theFrame->partialReport( "  list options are: -o[neline]          " );
    theFrame->fullReport("List one line per node/collection" );
    theFrame->partialReport( "                  : -m[ultiline]        " );
    theFrame->fullReport( "List multi-line per node/collection" ); 
    theFrame->partialReport( "                  : -e[vents]           " );
    theFrame->fullReport( "List events per collection (default)" );
    theFrame->partialReport( "                  : -noe[events]        " );
    theFrame->fullReport( "Don't list events per collection" );
    theFrame->partialReport( "                  : -r[ecursive]        " );
    theFrame->fullReport( "Recursively descend into child nodes" );
    theFrame->partialReport( "                  : -nor[ecursive]      " );
    theFrame->fullReport( "Don't recursively descend into child" );
    theFrame->partialReport( "                                        " );
    theFrame->fullReport("nodes");
    theFrame->partialReport( "                  : -meta               " );
    theFrame->fullReport("Show metainformation" );
    theFrame->partialReport( "                  : -ow[ned]            " );
    theFrame->fullReport("Show owned events" );
    theFrame->partialReport( "                  : -oid                " );
    theFrame->fullReport("Show collection OID" );

    theFrame->partialReport( "collection moveTo <source> <dest>       " );
    theFrame->fullReport( "Move the source collection to the" );
    theFrame->partialReport( "                                        " );
    theFrame->fullReport( "destination location" );

    theFrame->partialReport( "collection precreateCleanup             " );
    theFrame->fullReport( "Cleanup following collection" );
    theFrame->partialReport( "                                        " );
    theFrame->fullReport( "precreation" );

    theFrame->partialReport( "collection removeFrom <source> <dest>   " );
    theFrame->fullReport("Remove the source collection" );
    theFrame->partialReport( "                                        " ); 
    theFrame->fullReport( "from the destination collection" );

    theFrame->partialReport( "collection rename <source> <dest>       " );
    theFrame->fullReport("Synonym for moveTo" );

    return AbsInterp::OK;
}

void
BdbCollectionCommand::show( ) const 
{
}

bool
BdbCollectionCommand::isShowable( ) const 
{
    return false; 
}

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

//      ---------------------
//      --Primary Handlers --
//      ---------------------

int 
BdbCollectionCommand::addHandler( int argc, char* argv[] )
{
    BdbEventStore* theStore = BdbEventStore::instance( );
    BdbStatus status = BdbcError;
    AppFramework* theFrame = target( )->framework( );
    AbsInterp* interp = AbsInterp::theInterpreter();

    int result = AbsInterp::OK;

    if ( 4 <= argc ) {

        // Ensure the event store is initialized
        initialize( );

        // Start an update transaction if not already in one
        theStore->activate( );
        BdbMode theMode = theStore->change( BdbcUpdate );

        // Test whether the destination collection exists
        int last = argc - 1;
        BdbAbsCollectionT<BdbEventT>* theDestination = 
              theStore->collection( argv[last], (*(BdbEventT*)0) );
        if ( 0 != theDestination ) {

            status = BdbcSuccess;

            // Loop over source collection(s). All arguments apart from
            // the last one are treated as source collections to be added
            // to the destination, which is the last one.
            int i = 1; 
            const int finished( last - 1 );
            while ( i != finished ) {
                i++;

                // Check to see if source collection can be added to
                // destination and if so switch to federation containing
                // source collection
                const char* collName;
                const char* collFed;
                BdbModulesUtility::parseCollectionSpecifier( argv[i],
                                                             collName,
                                                             collFed );
                if( 0 == collName ) {
                    cerr << "Error: Invalid specification of a collection \""
                         << argv[i] << "\"" << endl;
                    delete [] const_cast< char* >( collName );
                    delete [] const_cast< char* >( collFed );
                    continue;
                }

                status = theDestination->setFed( collFed );
                delete [] const_cast< char* >( collFed );
                if( BdbcSuccess != status ) {
                    cerr << "Error: Collection "
                         << argv[i]
                         << " can not be added to collection "
                         << argv[last]
                         << endl;
                    delete [] const_cast< char* >( collName );
                    continue;
                }

                // Check whether the source collection exists
                BdbAbsCollectionT<BdbEventT>* theSource = 
                    theStore->collection(  collName, (*(BdbEventT*)0) );
                delete [] const_cast< char* >( collName );
                if ( 0 == theSource ) {
                    status = BdbcError;
                    cerr << "Error: Collection " << argv[i]
                         << " doesn't exist" << endl;
                    continue;
                }

                // Source and destination both exist. Is the source
                // already contained within the destination?
                addNonDuplicate( argv[ i ], theSource,
                                 argv[ last ], theDestination );
                delete theSource;
            }

            // Return to original federation
            theDestination->setFed();
            delete theDestination;
        } else {
            cout << "Error: Collection " << argv[last]
                 << " doesn't exist" << endl;
        }

        // Restore the previous transaction state, forcing a commit if
        // necessary
        theStore->change( theMode, d_True );
        theStore->deactivate( );
    } else {
        cout << "Error: no collection(s) specified - request ignored"
             << endl;
        target( )->setError( "invalid command name" );
    } 
    return result;
}

int
BdbCollectionCommand::addNonDuplicate( const char* sourceName ,
                                       BdbAbsCollectionT<BdbEventT>* sourceColl,
                                       const char* destName,
                                       BdbAbsCollectionT<BdbEventT>* destColl )
{
    AbsInterp* interp = AbsInterp::theInterpreter();
    int result = AbsInterp::ERROR;

    if ( destColl->containsCollection( *sourceColl, d_True ) ) {
        ErrMsg( warning ) << "Collection " << sourceName
                          << " is already contained by collection "
                          << destName << endmsg;
        return( result );
    }

    // All checked ok - add the source to the destination
    BdbStatus status( destColl->addCollection( *sourceColl ) );
    if ( BdbcSuccess != status ) {
        ErrMsg( error ) << "Unable to add collection "
                        << sourceName << " to " << destName << endmsg;
        return( result );
    }
    interp->appendResult( "Collection " );
    interp->appendResult( sourceName );
    interp->appendResult( " added to collection " );
    interp->appendResult( destName );
    interp->appendResult( "\n" );
    result = AbsInterp::OK;
    return( result );
}

int 
BdbCollectionCommand::cleanupHandler( int argc, char* argv[] )
{
    const char* theName = 0;
    const char* theTrees[64];
    d_ULong nTrees = 0;
    int result = AbsInterp::OK;

    int i = 2;
    while ( i < argc ) {
        if ( 0 == strcmp( argv[i], "-t" ) ) {
            i++;
            theTrees[nTrees] = argv[i];
            nTrees++;
        } else if ( 0 == strcmp( argv[i], "-tree" ) ) {
            i++;
            theTrees[nTrees] = argv[i];
            nTrees++;
        } else {
            theName = argv[i];
        }
        i++;
    }

    if ( NULL != theName ) {

        BdbEventStore* theStore = BdbEventStore::instance( );
        BdbEventT::ObjyRef nullRef;
        BdbEventT anEvent(nullRef, d_True);
        BdbStatus status;

        // Ensure the event store is initialized
        initialize( );

        // Start an update transaction if not already in one
        theStore->activate( );
        BdbMode theMode = theStore->change( BdbcUpdate );

        // Check whether the collection exists
        BdbAbsCollectionT<BdbEventT>* theCollection = theStore->collection( theName, (*(BdbEventT*)0) );
        if ( 0 != theCollection ) {
            status = BdbcSuccess;
            BdbCollectionTIterator<BdbEventT>* collIter( theCollection->getIterator() );
            while ( BdbcSuccess == ( status = collIter->next( anEvent )) ) {
                status = anEvent.cleanup( nTrees, theTrees );
            }
            delete collIter;
        } else {
            cout << "Error: collection " << theName << " doesn't exist" << endl;
        }

        // Restore the previous transaction state, forcing a commit if necessary
        theStore->change( theMode, d_True );
        theStore->deactivate( );
    } else {
        cout << "Error: no collection specified - request ignored" << endl;
    }
    return result;
}

int 
BdbCollectionCommand::contentsHandler( int argc, char* argv[] )
{
    BdbEventStore* theStore = BdbEventStore::instance( );
    BdbStatus status;
    const char* theName = 0;

    int result = AbsInterp::OK;

    int i = 2; 
    while ( i < argc ) {
        if        ( 0 == strcmp( argv[i], "-events" ) || 
                    0 == strcmp( argv[i], "-e"      ) ||
                    0 == strcmp( argv[i], "-size"   ) ||
                    0 == strcmp( argv[i], "-s"      ) ) {
            _listEvents = d_True;
        } else if ( 0 == strcmp( argv[i], "-noevents" ) || 
                    0 == strcmp( argv[i], "-noe"      ) ||
                    0 == strcmp( argv[i], "-nosize"   ) ||
                    0 == strcmp( argv[i], "-nos"      ) ) {
            _listEvents = d_False;
        } else if ( 0 == strcmp( argv[i], "-meta" ) ||
                    0 == strcmp( argv[i], "-m"    ) ) {
            _listMeta = d_True;
        } else if ( 0 == strcmp( argv[i], "-owned" ) ||
                    0 == strcmp( argv[i], "-ow"    ) ) {
                        _listOwned = d_True;
        } else if ( 0 == strcmp( argv[i], "-noowned" ) ||
                    0 == strcmp( argv[i], "-noow"    ) ) {
            _listOwned = d_False;
        } else if ( 0 == strcmp( argv[i], "-oid" ) ||
                    0 == strcmp( argv[i], "-OID" ) ) {
            _listOID = d_True;
        } else if ( 0 == strcmp( argv[i], "-nooid" ) ||
                    0 == strcmp( argv[i], "-noOID" ) ) {
            _listOID = d_False;
        } else if ( 0 == strcmp( argv[i], "-norecursive" ) ||
                    0 == strcmp( argv[i], "-nor"         ) ) {
            _descend = d_False;
        } else if ( 0 == strcmp( argv[i], "-collections" ) ||
                    0 == strcmp( argv[i], "-coll" ) ) {
            _listColl = d_True;
        } else {
            theName = argv[i];
        }
        i++;
    }
    if ( 0 != theName ) {

        // Ensure the event store is initialized
        initialize( );
        
        // Start a read transaction if necessary
        theStore->activate( );
        BdbMode oldMode = theStore->change( BdbcRead );

        // Check whether the collection exists
        BdbAbsCollectionT<BdbEventT>* theCollection = 
            theStore->collection( theName, (*(BdbEventT*)0) );
        if ( 0 != theCollection ) {
            // Collection exists - display the contents
            int stackDepth = 0;
            contentsCollHandler( theName, theCollection, stackDepth );
            delete theCollection;
        } else {
            cout << "Error: collection " << theName << " doesn't exist" << endl;
        }

        // Restore the transaction state - commiting the transaction if necessary
        theStore->change( oldMode, d_True );
        theStore->deactivate( );
    } else {
        cout << "Error: no collection specified - request ignored" << endl;
        target( )->setError( "invalid command name" );
    } 
    return result;
}

int 
BdbCollectionCommand::createHandler( int argc, char* argv[] )
{
    AbsInterp* interp = AbsInterp::theInterpreter();
    int result = AbsInterp::OK;

    d_Boolean createBridge = d_False;
    d_Boolean createTree   = d_False;

    bool streamSpecified( false );
    int collectionBegin( 2 );
    bool finishedModifiers = false;
    while( ( !finishedModifiers ) && 
           ( collectionBegin  != argc ) ) {
       
        if( 0 == strcmp( argv[ collectionBegin ], "-bridge" ) ||
            0 == strcmp( argv[ collectionBegin ], "-b"      ) ) {
            createBridge = d_True;
            collectionBegin++;
        } else if ( 0 == strcmp( argv[ collectionBegin ], "-tree" ) ||
                    0 == strcmp( argv[ collectionBegin ], "-t"      ) ) {
            createBridge = d_False;
            createTree = d_True;
            collectionBegin++;
        } else if ( 0 == strcmp( argv[ collectionBegin ], "-vector" ) ||
                    0 == strcmp( argv[ collectionBegin ], "-v"      ) ) {
            createBridge = d_False;
            createTree = d_False;
            collectionBegin++;
        } else if ( 0 == strcmp( argv[ collectionBegin ], "-stream" ) ||
                    0 == strcmp( argv[ collectionBegin ], "-s"      ) ) {
            collectionBegin++;
            if( argc == collectionBegin ) {
                finishedModifiers = !false;
            }
            else {
                const char* streamName( argv[ collectionBegin ] );
                if( ( 0 == _streamPlacement ) ||
                    ( 0 != strcmp( _streamPlacement,
                                   streamName ) ) ) {
                    delete [] _streamPlacement;
                    _isDifferentStream = true;
                    _streamPlacement = new char[ strlen( streamName )+1 ];
                    strcpy( _streamPlacement,
                            streamName);
                }
                streamSpecified = true;
                collectionBegin++;
            }
        } else {
            finishedModifiers = !false;
        }
    }

    const char* defaultName( BdbCollPlacementManager::defaultPlacementName() );
    if( ( !streamSpecified ) &&
        ( ( 0 == _streamPlacement ) ||
          ( 0 != strcmp( _streamPlacement, defaultName ) ) ) ) {
        delete [] _streamPlacement;
        _isDifferentStream = true;
        _streamPlacement = new char[ strlen( defaultName )+1 ];
        strcpy( _streamPlacement, defaultName );
    }

    int collectionCount( argc - collectionBegin );
    if( 0 < collectionCount ) {
        result = createCollections( collectionCount,
                                    &(argv[ collectionBegin ]),
                                    createTree,
                                    createBridge );
    } else {
        target()->setError( "No collection specified, creation request ignored" );
        result = AbsInterp::ERROR;
    }
    return result;

}


BdbCollPlacementManager*
BdbCollectionCommand::placement()
{
    BdbEventStore& evs( *BdbEventStore::instance() );

    if( ( 0 == _placement ) ||
        ( _isDifferentStream ) ||
        ( ! _placement->isBuiltInTrans( evs.currentTrans() ) ) ) {
        char* name( BdbModulesUtility::placementName( _streamPlacement,
                                                      evs ) );
        delete _placement;
        _placement = new BdbCollPlacementManager( evs,
                                                  name );
        _isDifferentStream = false;
        delete [] name;
    }
    return( _placement );
}

int
BdbCollectionCommand::createCollections( int nameCount,
                                         char* names[],
                                         d_Boolean createTree,
                                         d_Boolean createBridge )
{
    AbsInterp* interp = AbsInterp::theInterpreter();
    int result = AbsInterp::OK;

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

    // Ensure the event store is ready
    initialize( );
    evs.activate( );
    BdbMode theMode( evs.change( BdbcUpdate,
                                 d_True ) );

    d_Long oldWait = evs.lockWait( );
    evs.setLockWait(120); // wait max 2 minutes

    // Create collection for each name which does not already exist
    int name( 0 );
    BdbAbsCollectionT< BdbEventT >* theColl( 0 );
    BdbCollectionTFactory< BdbEventT >* factory( 0 );
    while( ( AbsInterp::OK == result ) &&
           ( nameCount != name ) ) {
        // the 'false' needs to be removed in collection creation is
        // moved into a nested factory.
        theColl = evs.collection( names[ name ],
                                  (*(BdbEventT*)0),
                                  false);
        if( 0 != theColl ) {

            // Collection already exists
            interp->appendResult( "Collection " );
            interp->appendResult( names[ name ] );
            interp->appendResult( " already exists.\n" );
        } else {

            if( ( ! createBridge ) &&
                ( ! createTree ) ) {
                // We call forceNewContainer( ) on the hint to force each
                // collection to be created in a new container.
                BdbAbstractClusteringHint* collectionHint( placement()->vectorCollectionHint() );
                ((BdbEvsClusteringHint*)collectionHint)->forceNewContainer( );
            }

            // First collection that needs creation, prepare factory
            if( 0 == factory ) {
                if( createBridge ) {
                    factory = new BdbBridgeCollTFactory< BdbEventT >( *(placement()->bridgeCollectionHint()),
                                                                      *(placement()->nodeHint()) );
                }
                else if( createTree ) {
                    factory = new BdbTreeCollTFactory< BdbEventT >( *(placement()->treeCollectionHint()),
                                                                    *(placement()->nodeHint()) );
                }
                else {
                    factory = new BdbVectorCollTFactory< BdbEventT >( *(placement()->vectorCollectionHint()),
                                                                      *(placement()->nodeHint()) );
                }

                factory = new BdbFetchCollTFactory< BdbEventT >( factory,
                                                                 120 );
                factory = new BdbMetaDataCollTFactory< BdbEventT >( factory );
            }

            // Collection doesn't already exist, create it.
            char* theFullCollName = BdbPathName::absolute( evs.validLastPath(),
                                                           names[ name ] );
            BdbAbsCollectionT<BdbEventT>* theColl( factory->getCollection( theFullCollName ) );

            if ( ( 0 != theColl ) &&
                 ( ! theColl->isNull( ) ) ) {
                if( BdbCollectionTFactory<BdbEventT>::kExistsFailure == factory->getResult() ) {
                    interp->appendResult( "Collection " );
                    interp->appendResult( names[ name ] );
                    interp->appendResult( " was created by another process.\n" );
                    target()->setError( "Collection created by other process" );
                    result = AbsInterp::ERROR;
                }
                else {
                    interp->appendResult( factory->typeName() );
                    interp->appendResult( " collection " ); 
                    interp->appendResult( names[ name ] ); 
                    interp->appendResult( " created ok\n" ); 
                }
            } else {
                interp->appendResult( "Failed to create " );
                interp->appendResult( factory->typeName() );
                interp->appendResult( " collection " ); 
                interp->appendResult( names[ name ] ); 
                interp->appendResult( ".\n" ); 
                target()->setError( "Failed to create collection" );
                result = AbsInterp::ERROR;
            }
            delete [] theFullCollName;
        }
        delete theColl;
        name++;
    }
    delete factory;

    // Restore the previous transaction state, forcing a commit
    // if necessary (and cleanin up the clustering hint!)
    evs.setLockWait(oldWait);
    evs.change( theMode, d_True );
    evs.deactivate( );

    return result;
}

int 
BdbCollectionCommand::deleteHandler( int argc, char* argv[] )
{
    BdbEventStore* theStore = BdbEventStore::instance( );
    BdbStatus status;

    AbsInterp* interp = AbsInterp::theInterpreter();
    int result = AbsInterp::OK;

    if ( 3 <= argc ) {

        // Ensure the event store is initialized
        initialize( );

        int i = 2; 
        while ( i < argc ) {

            // Start an update transaction, forcing any previous one to be committed.
            theStore->activate( );
            BdbMode theMode = theStore->change( BdbcUpdate, d_True );

            // Check whether the collection exists
            BdbAbsCollectionT<BdbEventT>* theCollection = 
                theStore->collection( argv[i], (*(BdbEventT*)0) );
            if ( 0 != theCollection ) {

                // First remove the collection from the store but don't delete it
                status = theStore->removeCollection( theCollection, d_True );
                if ( BdbcSuccess == status ) {

                    // Removal successful - now delete the collection within another transaction.
                    // This minimizes the duration of any locking of the tree nodes.
                    theStore->change( BdbcUpdate, d_True );
                    theCollection->setDeleted( );
                    AppFramework* theFrame = target( )->framework( );
                    interp->appendResult( "collection " ); 
                    interp->appendResult( argv[i] ); 
                    interp->appendResult( " deleted ok\n" ); 
                } else {
                    cout << "Error: Unable to delete collection " << argv[i] << endl;
                }

            } else {
                cout << "Error: collection " << argv[i] << " doesn't exist" << endl;
            }

            // Restore the previous transaction state, forcing a commit it necessary
            theStore->change( theMode, d_True );
            theStore->deactivate( );
            i++;
        }
    } else {
        cout << "Error: no collection specified - request ignored" << endl;
    }
    return result;
}

int 
BdbCollectionCommand::eventsHandler( int argc, char* argv[] )
{
    BdbEventStore* theStore = BdbEventStore::instance( );

    AbsInterp* interp = AbsInterp::theInterpreter();
    int result = AbsInterp::OK;

    if ( 3 <= argc ) {

        // Ensure the event store is initialized
        initialize( );

        // Start a read transaction if necessary
        theStore->activate( );
        BdbMode theMode = theStore->change( BdbcRead );

        // Check whether the collection exists
        BdbAbsCollectionT<BdbEventT>* theCollection = 
            theStore->collection( argv[2], (*(BdbEventT*)0) );
        if ( 0 != theCollection ) {

            // Collection exists - display the events contents
            AppFramework* theFrame = target( )->framework( );
            interp->appendResult( "This command isn't implemented yet\n" ); 
        } else {
            cout << "Error: collection " << argv[2] << " doesn't exist" << endl;
        }

        // Restore the previous transaction state, forcing a commit if necessary
        theStore->change( theMode, d_True );
        theStore->deactivate( );
    } else {
        cout << "Error: no collection specified - request ignored" << endl;
        target( )->setError( "invalid command name" );
    } 
    return result;
}

int 
BdbCollectionCommand::listHandler( int argc, char* argv[] )
{
    int result = AbsInterp::OK;

    BdbEventStore* theStore = BdbEventStore::instance( );

    _nodeCount = 0;

    // Ensure the event store is initialized
    initialize( );

    // Start a read transaction if necessary
    theStore->activate( );
    BdbMode theMode = theStore->change( BdbcRead );

    if ( 2 == argc ) {
        result = listLevelHandler( BdbDomain::User, NULL );
    } else {
        int i = 2; 
        while ( i < argc && AbsInterp::OK == result ) {
            if        ( 0 == strcmp( argv[i], "-all" ) ||
                        0 == strcmp( argv[i], "-a"   ) ) {
                result = listAllHandler( );
            } else if ( 0 == strcmp( argv[i], "-bad" ) ||
                        0 == strcmp( argv[i], "-b"   ) ) {
                _badOnly = d_True;
                _oneLine = d_True;
            } else if ( 0 == strcmp( argv[i], "-nobad" ) ||
                        0 == strcmp( argv[i], "-nob"   ) ) {
                _badOnly = d_False;
            } else if ( 0 == strcmp( argv[i], "-check" ) ||
                        0 == strcmp( argv[i], "-c"     ) ) {
                _checkOwner = d_True;
            } else if ( 0 == strcmp( argv[i], "-nocheck" ) ||
                        0 == strcmp( argv[i], "-noc"     ) ) {
                _checkOwner = d_False;
            } else if ( 0 == strcmp( argv[i], "-events" ) ||
                        0 == strcmp( argv[i], "-e"      ) ) {
                _listEvents = d_True;
            } else if ( 0 == strcmp( argv[i], "-noevents" ) ||
                        0 == strcmp( argv[i], "-noe"      ) ) {
                _listEvents = d_False;
            } else if ( 0 == strcmp( argv[i], "-fixup" ) ||
                        0 == strcmp( argv[i], "-f"     ) ) {
                _checkOwner = d_True;
                _fixupOwner = d_True;
            } else if ( 0 == strcmp( argv[i], "-nofixup" ) ||
                        0 == strcmp( argv[i], "-nof"     ) ) {
                _fixupOwner = d_False;
            } else if ( 0 == strcmp( argv[i], "-recursive" ) ||
                        0 == strcmp( argv[i], "-r"         ) ) {
                _descend = d_True;
            } else if ( 0 == strcmp( argv[i], "-norecursive" ) ||
                        0 == strcmp( argv[i], "-nor"         ) ) {
                _descend = d_False;
            } else if ( 0 == strcmp( argv[i], "-meta" ) ) {
                _listMeta = d_True;
            } else if ( 0 == strcmp( argv[i], "-group" ) ||
                        0 == strcmp( argv[i], "-g"     ) ) {
                i++;
                if ( i < argc ) {
                    result = listLevelHandler( BdbDomain::Group, argv[i] );
                } else {
                    result = AbsInterp::ERROR;
                }
            } else if ( 0 == strcmp( argv[i], "-node" ) ||
                        0 == strcmp( argv[i], "-n"     ) ) {
                i++;
                if ( i < argc ) {
                    result = listNodeHandler( argv[i] );
                } else {
                    result = AbsInterp::ERROR;
                }
            } else if ( 0 == strcmp( argv[i], "-owned" ) ||
                        0 == strcmp( argv[i], "-ow"    ) ) {
                _listOwned = d_True;
            } else if ( 0 == strcmp( argv[i], "-noowned" ) ||
                        0 == strcmp( argv[i], "-noow"    ) ) {
                _listOwned = d_False;
            } else if ( 0 == strcmp( argv[i], "-oid" ) ||
                        0 == strcmp( argv[i], "-OID" ) ) {
                _listOID = d_True;
            } else if ( 0 == strcmp( argv[i], "-nooid" ) ||
                        0 == strcmp( argv[i], "-noOID" ) ) {
                _listOID = d_False;
            } else if ( 0 == strcmp( argv[i], "-oneline" ) ||
                        0 == strcmp( argv[i], "-one"     ) ||
                        0 == strcmp( argv[i], "-o"       ) ) {
                _oneLine = d_True;
            } else if ( 0 == strcmp( argv[i], "-multiline" ) ||
                        0 == strcmp( argv[i], "-multi"     ) ||
                        0 == strcmp( argv[i], "-m"         ) ) {
                _oneLine = d_False;
            } else if ( 0 == strcmp( argv[i], "-system" ) ||
                        0 == strcmp( argv[i], "-s"      ) ) {
                result = listLevelHandler( BdbDomain::System, NULL);
            } else if ( 0 == strcmp( argv[i], "-user" ) ||
                        0 == strcmp( argv[i], "-u"    ) ) {
                i++;
                if ( i < argc ) {
                    result = listLevelHandler( BdbDomain::User, argv[i] );
                } else {
                    result = AbsInterp::ERROR;
                }
            } else {
                result = listNodeHandler( argv[i] );
            }
            i++;
        }
    }

    // Restore the previous transaction state, forcing a commit if necessary
    theStore->change( theMode, d_True );
    theStore->deactivate( );
    if ( AbsInterp::OK != result ) {
        target( )->setError( "invalid command name" );
    }
    return result;
}

int
BdbCollectionCommand::mapHandler( int argc, char* argv[] )
{
    BdbEventStore& evs( *BdbEventStore::instance() );
    AppFramework* theFrame = target( )->framework( );

    AbsInterp* interp = AbsInterp::theInterpreter();
    int result = AbsInterp::OK;

    BdbStatus status;
    if ( 4 <= argc ) {

        // Ensure the event store ready for use
        initialize( );
        evs.activate( );

        // create list of existing slave collections
        BdbTransToken bridgeTrans( evs.retainTrans() );
        size_t last = argc - 1;
        char* slaveFed( BdbPathName::absolute( evs.bootName(),
                                               argv[ last ] ) );
        evs.newEvsTrans( slaveFed );
        delete [] slaveFed;
        BdbMode slaveMode( evs.change( BdbcRead ) );
        BdbTransToken slaveTrans( evs.retainTrans() );

        const size_t SOURCE_INDEX_BEGIN( 2 );
        char** sourceNames( new char*[last - SOURCE_INDEX_BEGIN ] );
        BdbAbsCollectionT<BdbEventT>** sourceColls( new BdbAbsCollectionT<BdbEventT>* [last - SOURCE_INDEX_BEGIN ]);
        size_t sourceCount( 0 );
        BdbAbsCollectionT<BdbEventT>* sourceColl = 0;
        for( size_t sourceIndex( SOURCE_INDEX_BEGIN ) ; last != sourceIndex ; sourceIndex++ ) {
            sourceColl = evs.collection( argv[ sourceIndex ], (*(BdbEventT*)0) );
            if ( 0 != sourceColl ) {
                sourceNames[ sourceCount ] = argv[ sourceIndex ];
                sourceColls[ sourceCount ] = sourceColl;
                sourceCount++;
            } else {
                ErrMsg( warning ) << "Collection " << argv[ sourceIndex ]
                                  << " doesn't exist, and will not be mapped." << endmsg;
            }
        }
        evs.setCurrentTrans( bridgeTrans );

        // build a bridge collection for each valid slave collection
        BdbMode bridgeMode( evs.change( BdbcUpdate ) );
        int creationResult = createCollections( sourceCount,
                                                sourceNames,
                                                d_False,
                                                d_True );
        if( ( AbsInterp::OK != creationResult ) &&
            ( AbsInterp::OK == result ) ) {
            result == AbsInterp::ERROR;
            target( )->setError( "Unable to create all bridge collections" );
        }

        // fill each bridge collection with appropriate slave
        for( size_t source( 0 );
             sourceCount != source;
             source++ ) {
            evs.setCurrentTrans( bridgeTrans );
            BdbAbsCollectionT<BdbEventT>* destColl =
                evs.collection( sourceNames[ source ], (*(BdbEventT*)0) );
            if ( 0 != destColl ) {
                evs.setCurrentTrans( slaveTrans );
                addNonDuplicate( sourceNames[ source ],
                                 *(sourceColls+source),
                                 sourceNames[ source ],
                                 destColl );
            } else {
                ErrMsg( warning ) << "Collection " << sourceNames[ source ]
                                  << " failed to be mapped." << endmsg;
            }
        }
        evs.setCurrentTrans( slaveTrans );
        delete [] sourceColls;
        delete [] sourceNames;
        evs.change( slaveMode );
        evs.releaseTrans( slaveTrans );

        evs.setCurrentTrans( bridgeTrans );
        evs.change( bridgeMode,
                    d_True );
        evs.releaseTrans( bridgeTrans );
    }
    else {
        result == AbsInterp::ERROR;
        target( )->setError( "invalid command name" );
    }
    return result;
}

int
BdbCollectionCommand::moveHandler( int argc, char* argv[] )
{
    BdbEventStore* theStore = BdbEventStore::instance( );
    BdbStatus status;
    AppFramework* theFrame = target( )->framework( );

    AbsInterp* interp = AbsInterp::theInterpreter();
    int result = AbsInterp::OK;

    if ( 4 <= argc ) {

        // Ensure the event store is initialized
        initialize( );

        // Start an update transaction if not already in one
        theStore->activate( );
        BdbMode theMode = theStore->change( BdbcUpdate );

        // Check whether the source collection exists
        BdbAbsCollectionT<BdbEventT>* theSource = 
            theStore->collection( argv[2], (*(BdbEventT*)0) );
        if ( 0 != theSource ) {

            // Check whether the destination collection exists
            BdbAbsCollectionT<BdbEventT>* theDestination = 
                theStore->collection( argv[3], (*(BdbEventT*)0) );
            if ( 0 == theDestination ) {

                // All checked ok - move the source to the destination.
                // Ensure that the clustering is configured for the event
                // store since we are possibly about to create new tree
                // nodes.
                theStore->configureClustering( );

                status = theStore->moveCollection( theSource, argv[3] );
                if ( BdbcSuccess == status ) {
                    interp->appendResult( "Collection " );
                    interp->appendResult( argv[2] );
                    interp->appendResult( " moved to " );
                    interp->appendResult( argv[3] );
                    interp->appendResult( "\n" );
                } else {
                    cout << "Error: Unable to move collection " << argv[3] << endl;
                }
            } else {
                cout << "Error: Collection " << argv[3] << " already exists" << endl;
            }
        } else {
            cout << "Error: Collection " << argv[2] << " doesn't exist" << endl;
        }

        // Restore the previous transaction state, forcing a commit if necessary
        theStore->change( theMode, d_True );
        theStore->deactivate( );
    } else {
        cout << "Error: no collection specified - request ignored" << endl;
        target( )->setError( "invalid command name" );
    }
    return result;
}

int
BdbCollectionCommand::precreateCleanupHandler( int argc, char* argv[] )
{
    BdbStatus status = BdbcSuccess;
    AppFramework* theFrame = target( )->framework( );
    int result = AbsInterp::OK;

    // Ensure the event store is initialized
    initialize( );

    // Cleanup following Collection precreation
    BdbEventStore* theStore = BdbEventStore::instance( );
    theStore->activate();
    status = BdbEvsClusteringHint::returnCollectedConts( );
    theStore->deactivate();
    if ( BdbcSuccess != status ) {
        cout << "Error: Bad status from BdbEvsClusteringHint::returnCollectedConts" << endl;
        target( )->setError( "bad command status" );
    }
    return result;
}

int
BdbCollectionCommand::removeHandler( int argc, char* argv[] )
{
    BdbEventStore* theStore = BdbEventStore::instance( );
    BdbStatus status;
    AppFramework* theFrame = target( )->framework( );

    AbsInterp* interp = AbsInterp::theInterpreter();
    int result = AbsInterp::OK;

    if ( 4 <= argc ) {

        // Ensure the event store is initialized
        initialize( );

        // Start an update transaction if not already in one
        theStore->activate( );
        BdbMode theMode = theStore->change( BdbcUpdate );

        // Test whether the destination collection exists
        int last = argc - 1;
        BdbAbsCollectionT<BdbEventT>* theDestination = 
            theStore->collection( argv[last], (*(BdbEventT*)0) );
        if ( 0 != theDestination ) {

            // Loop over source collection(s). All arguments apart from
            // the last one are treated as source collections to be added
            // to the destination, which is the last one.
            int i = 1; 
            const int finished( last - 1 );
            while ( i != finished ) {
                i++;

                // Check to see if source collection can be added to
                // destination and if so switch to federation containing
                // source collection
                const char* collName;
                const char* collFed;
                BdbModulesUtility::parseCollectionSpecifier( argv[i],
                                                             collName,
                                                             collFed );
                if( 0 == collName ) {
                    cerr << "Error: Invalid specification of a collection \""
                         << argv[i] << "\"" << endl;
                    delete [] const_cast< char* >( collName );
                    delete [] const_cast< char* >( collFed );
                    continue;
                }

                status = theDestination->setFed( collFed );
                delete [] const_cast< char* >( collFed );
                if( BdbcSuccess != status ) {
                    cerr << "Error: Collection " << argv[i]
                         << " can not be removed from collection "
                         << argv[last] << endl;
                    delete [] const_cast< char* >( collName );
                    continue;
                }

                // Check whether the source collection exists
                BdbAbsCollectionT<BdbEventT>* theSource = 
                    theStore->collection( collName, (*(BdbEventT*)0) );
                delete [] const_cast< char* >( collName );
                if ( 0 == theSource ) {
                    cerr << "Error: Collection " << argv[i] << " doesn't exist" << endl;
                    continue;
                }

                // Source and destination both exist. Is the source
                // already contained within the destination?
                if ( ! theDestination->containsCollection( *theSource, d_True ) ) {
                    cerr << "Error: Collection " << argv[i] << " is not contained by collection "
                         << argv[last] << endl;
                    continue;
                }

                // All checked ok - add the source to the destination
                status = theDestination->removeCollection( *theSource );
                if ( BdbcSuccess == status ) {
                    interp->appendResult( "Collection " );
                    interp->appendResult( argv[2] );
                    interp->appendResult( " removed from collection " );
                    interp->appendResult( argv[3] );
                    interp->appendResult( "\n" );
                } else {
                    cout << "Error: Unable to remove collection "
                         << argv[i] << " to " << argv[last] << endl;
                }

            }

            // Return to original federation
            theDestination->setFed();
        } else {
            cout << "Error: Collection " << argv[last] << " doesn't exist" << endl;
        }

        // Restore the previous transaction state, forcing a commit if
        // necessary
        theStore->change( theMode, d_True );
        theStore->deactivate( );
    } else {
        cout << "Error: no collection(s) specified - request ignored" << endl;
        target( )->setError( "invalid command name" );
    } 
    return result;
}

//      ------------------------
//      -- Secondary Handlers --
//      ------------------------

void 
BdbCollectionCommand::contentsCollHandler( const char* const theName, 
                                           BdbAbsCollectionT<BdbEventT>* theCollection, 
                                           int& stackDepth )
{
    AbsInterp* interp = AbsInterp::theInterpreter();
    BdbStatus status;
    BdbEventStore* theStore = BdbEventStore::instance( );
    AppFramework* theFrame = target( )->framework( );
    BdbHandle(BdbCollectionP) aCollP;
    char charbuf[256];
    for ( int i=0; i < 2*stackDepth; i++ ) {
        charbuf[i] = ' ';
    }
    charbuf[2*stackDepth] = '\0';
    interp->appendResult( charbuf );
    d_Long oldWait = theStore->lockWait( );
    theStore->setLockWait( BdbcNoWait );
    aCollP = theCollection->persistent( );
    if ( BdbcSuccess == ( status = theStore->readAttempt( aCollP ) ) ) {
        interp->appendResult( theCollection->pathName( ) );
        if ( _listOID ) {
            interp->appendResult( " [" );
            interp->appendResult( aCollP.sprint( ) );
            interp->appendResult( "] " );
        }
        if ( _listEvents ) {
            interp->appendResult( ": " );
            sprintf( charbuf, "%d", theCollection->size( ) );
            interp->appendResult( charbuf );
            interp->appendResult( " events" );
            if ( _listOwned ) {
                interp->appendResult( " [" );
                sprintf( charbuf, "%d", theCollection->ownedSize( ) );
                interp->appendResult( charbuf );
                interp->appendResult( " owned]" );
            }
        }
        interp->appendResult( "\n" );
        if ( _listMeta ) {
            BdbMetaData meta;
            theCollection->metaData(meta);
            if ( ! meta.isNull( ) ) {
                d_Long count;
                int i;
                // display bools
                count = meta.numBools();
                for ( i=0; i< count; i++ ) {
                    interp->appendResult(meta.getBoolKey(i));
                    d_Boolean value;
                    meta.getBool(value, i);
                    sprintf( charbuf, " == %d\n", value);
                    interp->appendResult(charbuf);
                }
                // display longs
                count = meta.numLongs();
                for ( i=0; i< count; i++ ) {
                    interp->appendResult(meta.getLongKey(i));
                    int value;
                    meta.getLong(value, i);
                    sprintf( charbuf, " == %d\n", value);
                    interp->appendResult(charbuf);
                }
                // display floats
                count = meta.numFloats();
                for ( i=0; i< count; i++ ) {
                    interp->appendResult(meta.getFloatKey(i));
                    d_Float value;
                    meta.getFloat(value, i);
                    sprintf( charbuf, " == %g\n", value);
                    interp->appendResult(charbuf);
                }
                // display strings
                count = meta.numStrings();
                for ( i=0; i< count; i++ ) {
                    interp->appendResult(meta.getStringKey(i));
                    const char* value;
                    value = meta.getString(i);
                    sprintf( charbuf, " == ");
                    interp->appendResult(" == ");
                    interp->appendResult(value);
                    interp->appendResult("\n");
                }
            }
        }
        if ( ( _descend ) &&
             ( ! _listColl ) ) {
            BdbAbsCollectionT<BdbEventT>* aMember;
            BdbCollectionTCollTIterator theIter( *theCollection );
            while ( BdbcSuccess == theIter.next( aMember ) ) {
                aCollP = aMember->persistent( );
                if ( BdbcSuccess == ( status = theStore->readAttempt( aCollP ) ) ) {
                    if ( 0 != aMember->name( ) ) {
                        stackDepth++;
                        contentsCollHandler( aMember->pathName( ), aMember, stackDepth );
                        stackDepth--;
                    }
                } else {
                    interp->appendResult( "?? [member locked - no information available]\n" );
                }
            }
        }
        if ( _listColl ) {
            interp->appendResult( "Bridge Collection:  " );
            interp->appendResult( theName );
            interp->appendResult( " contains the following collections:\n" );
            BdbBridgeCollItemDesc theDesc;
            BdbCollTItemIterator<BdbEventT>* theIter =  theCollection->getCollItemIterator();
            while ( BdbcSuccess == theIter->next( theDesc  ) ) {
                interp->appendResult( "\t" );
                interp->appendResult( theDesc.collName() );
                interp->appendResult( "@" );
                interp->appendResult( theDesc.bootName() );
        
                interp->appendResult( "\n" );
            }
            delete theIter;
        }
    }else {
        interp->appendResult( theName );
        interp->appendResult( ": [locked - no information available]\n" );
    }
    theStore->setLockWait( oldWait );
}

int
BdbCollectionCommand::listAllHandler( )
{
    AbsInterp* interp = AbsInterp::theInterpreter();
    int result = AbsInterp::OK;
    BdbTreeNode aNode;
    BdbEventStoreIterator evsIter;
    BdbStatus status;
    bool empty = true;

    while ( BdbcSuccess == ( status = evsIter.next( aNode ) ) ) {
        listNodeHandler( &aNode );
        empty = false;
    }
    if ( empty ) {
        AppFramework* theFrame = target( )->framework( );
        interp->appendResult( "Event Store empty - no collections exist\n" );
    }
    return result;
}

int
BdbCollectionCommand::listLevelHandler( BdbDomain::AuthLevels theLevel,
                                        const char* const theName )
{
    BdbEventStore* theStore = BdbEventStore::instance( );
    BdbTreeNode theNode;
    AbsInterp* interp = AbsInterp::theInterpreter();
    int result = AbsInterp::OK;
    AppFramework* theFrame = target( )->framework( );

    BdbStatus status = theStore->treeNode( theNode, theLevel, theName );
    if ( BdbcSuccess == status ) {
        listNodeHandler( &theNode );
    } else {
        interp->appendResult( BdbDomain::AuthLevelNames[theLevel] );
        if ( 0 != theName ) {
            interp->appendResult( "/" );
            interp->appendResult( theName );
        }
        interp->appendResult( " non-existent\n" );
    }
    return result;
}

int
BdbCollectionCommand::listNodeHandler( const char* const theName )
{
    BdbEventStore* theStore = BdbEventStore::instance( );
    BdbTreeNode theNode;
    int result = AbsInterp::ERROR;

    // First test whether the supplied name is in fact a collection
    BdbAbsCollectionT<BdbEventT>* theCollection = 
        theStore->collection( theName, (*(BdbEventT*)0) );
    if ( 0 != theCollection ) {

        // The supplied name is a collection
        int stackDepth = 0;
        contentsCollHandler( theName, theCollection, stackDepth );
                result = AbsInterp::OK;
    } else {

        // The supplied name isn't a collection - assume it's a tree node
        BdbStatus status = theStore->treeNode( theNode, theName );
        if ( BdbcSuccess == status ) {
            result = listNodeHandler( &theNode );
        } else {
            cout << "Error: " << theName << " doesn't exist" << endl;
        }
    }
    return result;
}

int
BdbCollectionCommand::listNodeHandler( BdbTreeNode* theNode )
{
    BdbEventStore* theStore = BdbEventStore::instance( );
    BdbHandleAny anItemP;
    BdbHandle(BdbCollectionP) aCollP;
    BdbHandle(BdbTreeNodeP) theNodeP = theNode->persistent( );
    BdbTreeNode aNode;
    const char* nodeName;
    BdbStatus status;
    AbsInterp* interp = AbsInterp::theInterpreter();
    int result = AbsInterp::OK;
    d_Boolean first = d_True;
    d_Boolean wasBad;
    d_Boolean wasFixed;
    ooTypeNumber theType = ooTypeN( BdbCollectionP );
    AppFramework* theFrame = target( )->framework( );
    BdbMode oldMode = theStore->mode( );

    // Force a transaction commit if the maximum node count has been exceeded
    _nodeCount++;
    if ( _nodeCount > _maxNodeCount ) {
        theStore->change( oldMode, d_True );
        _nodeCount = 0;
    }

    // Iterate over the collection contents of the node
    BdbTreeNodeSimpleIterator collIter( *theNode );
    if ( collIter.count( ) > 0 ) {

        // Disable lock waiting while examining the collections in this node
        d_Long oldWait = theStore->lockWait( );
        theStore->setLockWait( BdbcNoWait );
        while ( BdbcSuccess == ( status = collIter.next( anItemP ) ) ) {
            if ( first ) {
                nodeName = theNode->pathName( );
                if ( ! _oneLine ) {
                    interp->appendResult( "\n" );
                    interp->appendResult( nodeName );
                    interp->appendResult( "\n" );
                    first = d_False;
                }
            }

            // Attempt to open the collection for reading
            if ( BdbcSuccess == ( status = theStore->readAttempt( anItemP ) ) ) {

                // Read attempt successful - Check that this really is a collection
                if ( anItemP->ooIsKindOf( theType ) ) {

                    // This is a collection
                    aCollP   = (BdbHandle(BdbCollectionP)&) anItemP;
                    wasBad   = d_False;
                    wasFixed = d_False;
                    if ( _checkOwner ) {

                        // Check for ownership consistency
                        BdbHandle(BdbTreeNodeP) ownerNodeP;
                        status = aCollP->treeNode( ownerNodeP );
                        if ( theNodeP != ownerNodeP ) {

                            // Ownership is inconsistent
                            wasBad = d_True;
                            if ( _fixupOwner ) {

                                // Collection has a bad owner pointer and should be fixed
                                // Promote the transaction to update mode if necessary
                                theStore->change( BdbcUpdate, d_False );
                                theStore->setLockWait( BdbcWait );
                                aCollP->setTreeNode( theNodeP );
                                theStore->setLockWait( BdbcNoWait );
                                wasFixed = d_True;
                            }
                        }
                    }
                    if ( ( ! _badOnly ) || wasBad ) {
                        interp->appendResult( "    " );
                        if ( _oneLine ) {
                            interp->appendResult( nodeName );
                        }
                        interp->appendResult( collIter.name( ) );
                                                if ( _listOID ) {
                                                interp->appendResult( " [" );
                                        interp->appendResult( aCollP.sprint( ) );
                                        interp->appendResult( "] " );
                                        }
                        if ( _listEvents ) {
                            interp->appendResult( ": " );
                            char charbuf[256];
                            sprintf( charbuf, "%d", aCollP->size( ) );
                            interp->appendResult( charbuf );
                            interp->appendResult( " events" );
                                                        if ( _listOwned ) {
                                                interp->appendResult( " [" );
                                                sprintf( charbuf, "%d", aCollP->ownedSize( ) );
                                                interp->appendResult( charbuf );
                                                interp->appendResult( " owned]" );
                                                }
                                                }
                        if ( wasBad ) {
                            interp->appendResult( " - bad owner" );
                            if ( wasFixed ) {
                                interp->appendResult( " - fixed" );
                            }
                        }
                        interp->appendResult( "\n" );
                    }
                }
            } else {
                interp->appendResult( "    " );
                if ( _oneLine ) {
                    interp->appendResult( nodeName );
                }
                interp->appendResult( collIter.name( ) );
                interp->appendResult( ": [locked - no information available]\n" );
            }
        }
        theStore->setLockWait( oldWait );
    }

    // Restore the original transaction mode if necessary
    theStore->change( oldMode, d_False );

    if ( _descend ) {

        // Descend flag set - Now iterate over child tree nodes
        BdbTreeNodeSimpleIterator nodeIter( *theNode );
        while ( BdbcSuccess == ( status = nodeIter.next( anItemP ) ) ) {
            if ( BdbcSuccess == ( status = theStore->readAttempt( anItemP ) ) ) {
                if ( BdbTreeNodeP::isTreeNode( anItemP ) ) {
                    aNode.setPersistent( (BdbHandle(BdbTreeNodeP)&) anItemP );
                    result = listNodeHandler( &aNode );
                }
            }
        }
    }
    return result;
}

void
BdbCollectionCommand::initialize( )
{
    BdbEventStore* theStore = BdbEventStore::instance( );
    // If clustering already configured this does nothing
    theStore->configureClustering( );

    if ( ! _isInitialized ) {

        // Ensure that data is readable only by users who belong to the
        // eventstore domain
        theStore->activate( );
        BdbMode oldMode = theStore->change( BdbcRead );
        if ( ! theStore->isAccessAllowed( theStore->userName( ) ) ) {
            ErrMsg( fatal ) << "**************************************************" << endl
                            << "User " << theStore->userName( ) 
                            << ", you are not a registered user of the "            << endl
                            << "event store for this federation. Access is denied." << endl
                            << "**************************************************" << endmsg;
            theStore->commit( );
            ::abort( );
        }
        theStore->change( oldMode );
        theStore->deactivate( );
        _isInitialized = d_True;
    }
}

 

---

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

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