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

                 

---

/BdbAdminTools/BdbAdminDbgMgr.cc

Go to the documentation of this file.

//------------------------------------------------------------------------------
// File:
//      BdbAdminDbgMgr.cc
//
// Description:
//      Transient class. Allows to debug Objectivity Federation including:
//      - dumping database names
//      - dumping containers
//      - converting oids to names and vice versa
//      - dumping db/container sizes
//      - others
//
// Environment:
//      Software developed for the BaBar Detector at the SLAC B-Factory
//
// Author List:
//      Jacek Becla                Original Author
//
// Copyright Information:
//      Copyright (C) 1999      Stanford Linear Accelerator Center
//
//------------------------------------------------------------------------------
#include "BaBar/BaBar.hh"


//-----------------------
// This Class's Header --
//-----------------------
#include "BdbAdminTools/BdbAdminDbgMgr.hh"



//-------------------------------
// Collaborating Class Headers --
//-------------------------------
#include "BdbApplication/BdbDomain.hh"
#include "BdbApplication/BdbDebug.hh"
#include "BdbApplication/BdbErrorSignal.hh"
#include "BdbAccess/BdbContAccessMgr.hh"
#include "BdbClustering/BdbPCounter.hh"
#include "BdbClustering/BdbPCompParam.hh"
#include "BdbClustering/BdbClustHAccess.hh"
#include "BdbAdminTools/BdbAdminDbgIOMgr.hh"

//-------------
// C Headers --
//-------------
extern "C" {
#include <stdlib.h>
#include <sys/stat.h>     /* stat */
#include <unistd.h>
}


//---------------
// C++ Headers --
//---------------
#include "ooMap.h"

#include <strstream.h>
#include <iostream.h>
#include <iomanip.h>





BdbAdminDbgMgr::BdbAdminDbgMgr(BdbAdminDbgIOMgr* ioMgr, d_Boolean display)
      : _ioMgr(ioMgr),
        _display(display)
{
    _verbose = d_True;

    ooSetLockWait(0);
    _noDatabases = 0;

    _locatorMgr = new BdbClustHAccess("evs", d_True, 0);
}


BdbAdminDbgMgr::~BdbAdminDbgMgr()
{
    delete _locatorMgr;
}




/**
 **  The function iterates over all databases in the federation
 **  and stores database names in an ascii file.
 **  It puts a readlock on the federation.
 **/

BdbStatus
BdbAdminDbgMgr::dumpDbs2File()
{
    if ( _ioMgr->openFile_AllDbNames(d_False) != BdbcSuccess ) {
        COUT1 << "Cannot open output file" << endl;
        return BdbcError;
    }


    BdbApplicationOrDomain::activeInstance()->startRead("fd iteration");

    ooItr(ooDBObj) dbItr;
    if ( BdbApplicationOrDomain::activeInstance()->fd().contains(dbItr) != BdbcSuccess ) {
        COUT1 << "Cannot initialize fd iterator" << endl;
        BdbApplicationOrDomain::activeInstance()->commit("fd iteration");
        return BdbcError;
    }
    
    _noDatabases = 0;

    while ( dbItr.next() ) {
        const char* theName = dbItr.name();
        if ( _display ) {
            cout << "Found db: " << theName << endl;
        }
        _ioMgr->_outFile << theName << endl;
        _noDatabases ++;
    }

    BdbApplicationOrDomain::activeInstance()->commit("fd iteration");

    _ioMgr->_outFile.close();

    if ( _display  || _verbose ) {
        cout << "Total number of databases found: " << _noDatabases << endl;
    }

    return BdbcSuccess;
}




/**
 **  The function processes databases (all or selected).
 **
 **/

BdbStatus
BdbAdminDbgMgr::processDatabases(d_Boolean allDbs,
                                 const char* outFileName, 
                                 d_Boolean showNrConts,
                                 d_Boolean showPgCounters,
                                 d_Boolean showFileSize,
                                 d_Boolean showContSize)
{
    // open file containing list of all databases or selected list for reading
    if ( _ioMgr->openFile_DbNames(allDbs, d_True) != BdbcSuccess ) {
        cout << "Cannot open input file" << endl;
        return BdbcError;
    }

    // open output file 
    d_Boolean printToFile = outFileName != (char*)0;
    if ( printToFile ) {
        if ( _ioMgr->openOutFile(outFileName) != BdbcSuccess ) {
            COUT1 << "Cannot open output file" << endl;
            return BdbcError;
        }
    }

    cout << "dbName                         dbid";
    if ( showNrConts ) {
        cout << "  #conts";
    }
    if ( showPgCounters ) {
        cout << "  #pgCnt";
    }
    if ( showFileSize ) {
        cout << "  fileSize";
    }
    cout << "\n--------------------------------------------" << endl;

    while ( ! _ioMgr->_inFile.eof() ) {
        char dbName[64];
        _ioMgr->_inFile.getline(dbName, 64);
        if ( dbName[0] == '\0' ) {
            continue;
        }
        processOneDb(dbName, printToFile, showNrConts, showPgCounters, showFileSize, showContSize);
    }

    _ioMgr->_inFile.close();
    if ( printToFile ) {
       _ioMgr->_outFile.close();
    } 

    return BdbcSuccess;
}



/**  The function processes one database
 **  It can be called independently.
 **/

BdbStatus
BdbAdminDbgMgr::processOneDb(const char* dbName,
                             d_Boolean printToFile,
                             d_Boolean showNrConts,
                             d_Boolean showPgCounters,
                             d_Boolean showFileSize,
                             d_Boolean showContSize)
{
    d_ULong noContainers = 0;

    BdbApplicationOrDomain::activeInstance()->startRead("processOneDb");

    ooRef(ooDBObj) dbRef;
    if ( dbRef.open(BdbApplicationOrDomain::activeInstance()->fd(), dbName, oocRead) != BdbcSuccess ) {
        cout << "Cannot open db; \"" << dbName << "\" for reading" << endl;
        BdbApplicationOrDomain::activeInstance()->commit("processOneDb");
        return BdbcError;
    }

    int dbid = dbRef.get_DB();

    cout.setf(ios::left);
    cout << setw(29) << dbName << "  " << setw(5) << dbid;
    cout.setf(ios::right);
    if ( printToFile ) {
        _ioMgr->_outFile.setf(ios::left);
        _ioMgr->_outFile << setw(29) << dbName << "  " << setw(5) << dbid;
        _ioMgr->_outFile.setf(ios::right);
    }

    if ( showNrConts ) {
        int nr = dbRef.numContObjs();
        noContainers += nr;
        cout << "  " << setw(4) <<  nr;
        if ( printToFile ) {
            _ioMgr->_outFile << "  " << setw(4) <<  nr;
        }
    }

    d_ULong counterValue = 0;
    if ( showPgCounters ) {
        char* buf = new char [64];
        
        readPageCounter(buf, dbid, counterValue);
        cout << "  " << buf;
        if ( printToFile ) {
            _ioMgr->_outFile << "  " << buf;
        }
        delete [] buf;
    }
   
    const char* thePath = dbRef.fileName();
    const char* theHost = dbRef.hostName();

    BdbApplicationOrDomain::activeInstance()->commit("processOneDb");

    if ( showFileSize ) {
        d_ULong size = readFileSize(thePath, theHost);
        size /= 1024;
        char buf[64];
        ostrstream theStream(buf, 64);
        theStream << setw(10) << size << " [KB]" << ends;
        cout << buf;
        if ( printToFile ) {
            _ioMgr->_outFile << buf;
        }
    }

    cout << endl;
    if ( printToFile ) {
        _ioMgr->_outFile << endl;
    }


    d_ULong threshold = 100000;
    if ( counterValue > threshold ) {
        cout << "\n\n Warning: value > " << threshold << ". Try to fix? (y/n)" << endl;
        char c; cin >> c;
        if ( c == 'y' ) {
            fixPageCounter(dbid);
        }
    }

    return BdbcSuccess;
}




BdbStatus
BdbAdminDbgMgr::fixPageCounter(int dbid)
{
    BdbApplicationOrDomain::activeInstance()->startUpdate("fixPageCounter");

    BdbRef(BdbPCounter) counterRef;
    if ( _locatorMgr->locateDbPageCounter(counterRef, dbid, oocUpdate) != BdbcSuccess ) {
        BdbApplicationOrDomain::activeInstance()->commit("fixPageCounter");
        return BdbcError;
    }

    cout << "Value of extraPage counter = " << counterRef->counter() << endl;
    cout << "Resetting the value to 0" << endl;

    counterRef->force(0);

    BdbApplicationOrDomain::activeInstance()->commit("fixPageCounter");

    return BdbcSuccess;
}


BdbStatus
BdbAdminDbgMgr::readPageCounter(char*& buf, int dbid, d_ULong& value)
{
    BdbRef(BdbPCounter) counterRef;
    if ( _locatorMgr->locateDbPageCounter(counterRef, dbid, oocRead) != BdbcSuccess ) {
        return BdbcError;
    }

    value =  counterRef->counter();

    ostrstream theStream(buf, 64);
    theStream << setw(6) << value << ends;

    return BdbcSuccess;
}



d_ULong
BdbAdminDbgMgr::readFileSize(const char* thePath, const char* theHost)
{
    d_ULong theSize = 0;

    char* buf = new char [64];

    gethostname( buf, 64);

    int length = (strlen(theHost)<strlen(buf)) ? strlen(theHost) : strlen(buf);
    if ( ! strncmp(theHost, buf, length) ) {
        //cout << "The file is local" << endl;
        struct stat statbuf;
        if (stat(thePath, &statbuf) == 0) {
            theSize = statbuf.st_size;
        } else {
          cout << "Cannot get size of a file " << thePath << endl;
        }
    } else { 
        //cout << "The file is remote" << endl;

        //BdbPud::setTimeOut(1);
        //BdbPud daemon(theHost, 3333, d_True);
        //off_t nr = 0;
        //if ( daemon.getFileSize(thePath, (off_t&)nr) == BdbcSuccess ) {
        //    theSize = nr;
        //}
    }

    return theSize;
}


BdbStatus 
BdbAdminDbgMgr::fixBdbPCompParam(const char* contName, const char* objName)
{

    BdbApplicationOrDomain::activeInstance()->startUpdate("fixBdbPCompParam");

    ooMode openMode = oocUpdate;

    BdbRef(BdbPCompParam_001) theParamRef;

    if ( _locatorMgr->locatePCompParamObj(contName, objName,
                         theParamRef, oocUpdate) != BdbcSuccess ) {
        BdbApplicationOrDomain::activeInstance()->commit("fixBdbPCompParam");
        return BdbcError;
    }

    cout << "Value of extraConts = " << theParamRef->extraConts() << endl;

    cout << "Reset to 0? (y/n) ";
    char c; cin >> c;
    if ( c == 'y' ) {
        cout << "Resetting the value to 0" << endl;
        theParamRef->forceExtraConts(0);
    }

    BdbApplicationOrDomain::activeInstance()->commit("fixBdbPCompParam");

    return BdbcSuccess;
}



/**
 **  This function displays all containers in the clustering hint
 **  database (per one domain) which ends with "v1".
 **  In practice these are containers which contain BdbPCompParam objects.
 **  It will also print BdbPCompParam objects and their values.
 **
 **  If _extraConts > 500, it will ask if the value should be reset to 0.
 **  If yes, it resets chosen values inside separate update transaction.
 **
 **  All reading is done inside one read transaction, it may take long
 **/


BdbStatus 
BdbAdminDbgMgr::displayBdbPCompParamObjects()
{
    d_Boolean displayAll = d_False;
    char theFilter[64];
    d_Boolean filter = d_False;
    cout << "All? (y/n) "; char c; cin >> c;
    if ( c == 'y' ) {
        displayAll = d_True;
    } else {
        cout << "filter? (y/n) "; cin >> c;
        if ( c == 'y' ) {
            cout << "should contain: "; cin >> theFilter; 
            displayAll = d_True;
            filter = d_True;
        }
    }

    BdbApplicationOrDomain::activeInstance()->startRead("displayBdbPCompParamObjects");

    // open the db
    BdbHandle(BdbDBObj) dbH;
    if ( _locatorMgr->openClustHintDb(dbH, oocRead) != BdbcSuccess ) {
        BdbApplicationOrDomain::activeInstance()->commit("displayBdbPCompParamObjects");
        return BdbcError;
    }

    // cache up to 1000 elements which will be fixed after the
    // read transaction is commited
    _entries2Fix = new Entry2Fix[1000];
    _nrElems2Fix = 0;

    // cache all active databases
    _allActiveDbs = new d_ULong[64000];
    _nrActiveDbsFound = 0;

    _nrHasExtraneousActiveDbs = 0;


    if ( displayAll ) {
        // iterate through all containers and find these with "v1"
        ooItr(ooContObj) contItr;
        if ( dbH.contains(contItr) != BdbcSuccess ) {
            cout << "Cannot initialize container iterator" << endl;
            BdbApplicationOrDomain::activeInstance()->commit("displayBdbPCompParamObjects");
            delete [] _entries2Fix;
            _nrElems2Fix = 0;
            delete [] _allActiveDbs;
            _nrActiveDbsFound = 0;
            _nrHasExtraneousActiveDbs = 0;
            return BdbcError;
        }

        while ( contItr.next() ) {
            ooRef(ooContObj) contRef = contItr;
            const char* contName = contRef.name();
            int len = strlen(contName);
            if ( *(contName+len-2) == 'v' && *(contName+len-1) == '1' ) {
                d_Boolean display;
                if ( ! filter ) {
                   displayBdbPCompPObjInCont(contRef);
                } else {
                    if ( strstr(contName, theFilter) != 0 ) {
                        displayBdbPCompPObjInCont(contRef); 
                    } else {
                        cout << "Container: " << contName << " filtered out" << endl;
                    }
                } 
            //} else {
            //    cout << "Skipping container: " << contName << endl;
            }
        }
    } else {
        ooRef(ooContObj) contRef;
        char contName[64];
        cout << "Container name: "; cin >> contName;
        if ( contRef.open(dbH, contName, oocRead) != BdbcSuccess ) {
            cout << "Cannot open cont " << contName << endl;
            BdbApplicationOrDomain::activeInstance()->commit("displayBdbPCompParamObjects");
            delete [] _entries2Fix;
            _nrElems2Fix = 0;
            delete [] _allActiveDbs;
            _nrActiveDbsFound = 0;
            _nrHasExtraneousActiveDbs = 0;
            return BdbcError;
        }
        displayBdbPCompPObjInCont(contRef);
    }

    BdbApplicationOrDomain::activeInstance()->commit("displayBdbPCompParamObjects");


    if ( _nrElems2Fix > 0 ) {
        BdbApplicationOrDomain::activeInstance()->startUpdate("displayBdbPCompParamObjects-fixing");

        for ( int i=0 ; i<_nrElems2Fix ; i++) {
            ooRef(BdbPCompParam_001) theRef;
            _entries2Fix[i].buildRef(theRef);
            if ( theRef.update() != BdbcSuccess ) {
                cout << "Cannot obtain update lock on: ";
            } else {
                theRef->forceExtraConts(0);
                cout << "Resetting extraPages for: ";
            }
            _entries2Fix[i].print();
        }
        BdbApplicationOrDomain::activeInstance()->commit("displayBdbPCompParamObjects-fixing");
    }

    if ( _nrHasExtraneousActiveDbs > 0 ) {
        cout << "Eextraneous active dbs found in " << _nrHasExtraneousActiveDbs << " places." << endl;
    }

    delete [] _entries2Fix;
    _nrElems2Fix = 0;

    delete [] _allActiveDbs;
    _nrActiveDbsFound = 0;

    _nrHasExtraneousActiveDbs = 0;

    return BdbcSuccess;
}




BdbStatus 
BdbAdminDbgMgr::displayBdbPCompPObjInCont(ooRef(ooContObj)& contRef)
{
    const char* contName = contRef.name();

    cout << "In container: " << contName << endl;

    ooItr(ooObj) objItr;
    if ( contRef.getNameObj(objItr) != BdbcSuccess ) {
        cout << "getNameObj failed" << endl;
        return BdbcError;
    }

    while ( objItr.next() ) {
        cout << "   object name: " << objItr.getObjName(contRef) << endl;
        BdbRef(BdbPCompParam_001) theRef = (BdbRef(BdbPCompParam_001)) objItr;
        theRef->print();

        // keep all found active database ids
        int actDbNo = theRef->nrActiveDbs();
        for(int i=0 ; i<actDbNo; i++) {
            d_ULong dbid = theRef->_activeDbs[i];
            _allActiveDbs[_nrActiveDbsFound] = dbid;
            _nrActiveDbsFound++;
            if ( i==5 ) {
                _nrHasExtraneousActiveDbs++;
            }
        }

        if ( theRef->extraConts() > 500 ) {
            cout << "\n\nWarning: number of extra containers = " 
                 <<  theRef->extraConts() << ". Fix that? (y/n) ";
            char c; cin >> c;
            if ( c == 'y' ) {
                _entries2Fix[_nrElems2Fix].keep(theRef);
                _nrElems2Fix++;
              } 
          }
    }

    return BdbcSuccess;
}








/**
 **  This function displays all page counters
 **
 **  All reading is done inside one read transaction, it may take long
 **/


BdbStatus 
BdbAdminDbgMgr::displayAllPageCounters(const char* outFileName)
{
    // open output file
    if ( _ioMgr->openOutFile(outFileName) != BdbcSuccess ) {
        COUT1 << "Cannot open output file" << endl;
        return BdbcError;
    }

    BdbApplicationOrDomain::activeInstance()->startRead("displayAllPageCounters");

    // open the db
    BdbHandle(BdbDBObj) dbH;
    if ( _locatorMgr->openClustHintDb(dbH, oocRead) != BdbcSuccess ) {
        BdbApplicationOrDomain::activeInstance()->commit("displayAllPageCounters");
        return BdbcError;
    }


    // initialize iterator
    ooItr(ooContObj) contItr;
    if ( dbH.contains(contItr) != BdbcSuccess ) {
        cout << "Cannot initialize container iterator" << endl;
        BdbApplicationOrDomain::activeInstance()->commit("displayAllPageCounters");
        return BdbcError;
    }

    // cache all found ids
    d_ULong foundIds[64000];
    d_ULong noPCFound = 0;
    d_ULong threshold = 50000;
    cout << "output goes to file " << outFileName << endl;
    cout << "Printing only values > " << threshold << endl;

    // iterate through all containers and find these with "counter4:"
    while ( contItr.next() ) {
        ooRef(ooContObj) contRef = contItr;
        const char* contName = contRef.name();
        int len = strlen(contName);
        if ( ! strncmp(contName, "counter4:", 9) ) {
            //cout << "Found container: " << contName << endl;

            BdbRef(BdbPCounter) counterRef;
            if ( counterRef.lookupObj(contRef, contName, BdbcRead) != BdbcSuccess ) {
                cout << "Cannot locate object: " << contName << endl;
                continue;
            }
            d_ULong id = counterRef->dbNr();
            d_ULong value = counterRef->counter();
            _ioMgr->_outFile << "Db id=" << id << ", counter = " << setw(8) << value
                             << "   (" << setw(8) << value *16 << " KB)";

            if ( value > threshold ) {
                _ioMgr->_outFile << "   ***** > " << threshold << " *****";
                cout << "Db id=" << id << ", counter = " << setw(8) << value
                     << "   (" << setw(8) << value *16 << " KB)" << endl;
            }
            _ioMgr->_outFile << endl; 
            foundIds[noPCFound] = id;
            noPCFound++;
        } else {
            //cout << "Skipping container: " << contName << endl;
        }
    }

    BdbApplicationOrDomain::activeInstance()->commit("displayAllPageCounters");

    cout << "Total number of page counters found: " << noPCFound << endl;

    _ioMgr->_outFile.close();

    return BdbcSuccess;
}





// ----------------------------------------------------------
// ----------------------------------------------------------
// ----------------------------------------------------------
// ----------------------------------------------------------
// ----------------------------------------------------------
// ----------------------------------------------------------
// ----------------------------------------------------------
//                garbage below






void 
BdbAdminDbgMgr::displayAllConts(d_Boolean showNrPagesPerCont)
{
    countDatabases();

    char** allDbsNames = new char* [dbCounter];

    loadDbNames(allDbsNames);

    for(int i=0 ; i<dbCounter ; i++) {
        char* name = allDbsNames[i];

        cout << "\n *** *** Db: " << name << " *** *** " << endl;
        displayAllContsInOneDb(name, showNrPagesPerCont, d_True);
        delete [] name;
    }
    delete [] allDbsNames;
}



void 
BdbAdminDbgMgr::countDatabases()
{
    BdbApplicationOrDomain::activeInstance()->startRead("a");

    ooItr(ooDBObj) dbItr;
    if ( BdbApplicationOrDomain::activeInstance()->fd().contains(dbItr) != BdbcSuccess ) {
        return;
    }

    dbCounter = 0;

    while ( dbItr.next() ) {
        dbCounter++;
    }

    BdbApplicationOrDomain::activeInstance()->commit("a");
}




void
BdbAdminDbgMgr::loadDbNames(char**&theArray)
{
    BdbApplicationOrDomain::activeInstance()->startRead("a");

    ooItr(ooDBObj) dbItr;
    if ( BdbApplicationOrDomain::activeInstance()->fd().contains(dbItr) != BdbcSuccess ) {
        return;
    }

    int cur = 0;
    while ( dbItr.next() ) {
        if ( cur<dbCounter ) {
            const char* name = dbItr.name();
            theArray[cur] = new char [strlen(name)+1];
            strcpy(theArray[cur], name);
        }
        cur++;
    }
    BdbApplicationOrDomain::activeInstance()->commit("a");
}



void 
BdbAdminDbgMgr::displayAllContsInOneDb(const char* name, 
                                       d_Boolean showNrPagesPerCont, 
                                       d_Boolean printToFile)
{
    BdbApplicationOrDomain::activeInstance()->startRead("a");

    ooRef(BdbDBObj) dbRef;
    if ( dbRef.exist(BdbApplicationOrDomain::activeInstance()->fd(), name, oocRead) != BdbcSuccess ) {
        cout << "Db \"" << name << "\" cannot be open for reading" << endl;
        return;
    }

    ooItr(ooContObj) contItr;
    if ( dbRef.contains(contItr) != BdbcSuccess ) {
        return;
    }

    if ( printToFile ) {
        char outFName[64];
        sprintf(outFName, "allConts4%s",  name);
        _ioMgr->openOutFile(outFName);
    }

    long totalNrPages = 0;
    long totalNrConts = 0;
    long minNrPages   = 90000;
    while ( contItr.next() ) {
        ooRef(ooContObj) contRef = contItr;
        const char* name = contRef.name();
        int dbid = contRef.get_DB();
        int contid = contRef.get_OC();
        if ( showNrPagesPerCont ) {
            int nrPages = contRef.nPage();
            cout << "     container \"" << setw(20) << name << "\" [" 
                 << dbid << "-" << contid << "]" 
                 << ", nr of pages = " << setw(4) << nrPages 
                 << " (" << setw(6) << nrPages*16 << " KB)" << endl;
            if ( printToFile ) {
                _ioMgr->_outFile << "     container \"" << setw(20) << name << "\" ["
                     << dbid << "-" << contid << "]"
                     << ", nr of pages = " << setw(4) << nrPages
                     << " (" << setw(6) << nrPages*16 << " KB)" << endl;
            }
            if ( contid != 2 ) { // skip default container
                totalNrPages += nrPages;
                if ( nrPages < minNrPages ) {
                    minNrPages = nrPages;
                }
            }
        } else {
            cout << "     container \"" << setw(20) << name << "\" [" 
                 << dbid << "-" << contid << "-0-0]" << endl;
            if ( printToFile ) {
                _ioMgr->_outFile << "     container \"" << setw(20) << name << "\" ["
                     << dbid << "-" << contid << "-0-0]" << endl;
            }
        }
        if ( contid != 2 ) { // skip default container
            totalNrConts ++;
        }
    }

    BdbApplicationOrDomain::activeInstance()->commit("a");

    cout << "Total number of containers (without default) = " << totalNrConts << endl;
    if ( showNrPagesPerCont ) {
        long averNrPages = totalNrPages / totalNrConts;
        long size = totalNrPages * 16; // in KB
        cout << "Total number of pages (without default) = " << totalNrPages
             << " (" << size << " KB)" << endl;
        cout << "Min number of pages = " << minNrPages << endl;
        cout << "Average number of pages = " << averNrPages << endl;
        if ( printToFile ) {
            _ioMgr->_outFile << "Total number of pages = " << totalNrPages
                 << " (" << size << " KB)" << endl;
            _ioMgr->_outFile << "Min number of pages = " << minNrPages << endl;
            _ioMgr->_outFile << "Average number of pages = " << averNrPages << endl;
        }
    }

    if ( printToFile ) {
        _ioMgr->_outFile.close();
    }
}


BdbStatus
BdbAdminDbgMgr::displayRegistryDbsWEP(const char* theName)
{
    char contName[64];
    sprintf(contName, "dbsWEP_%s", theName);
    
    BdbApplicationOrDomain::activeInstance()->startNestedRead();


    // open the db
    BdbHandle(BdbDBObj) dbH;
    if ( _locatorMgr->openClustHintDb(dbH, oocRead) != BdbcSuccess ) {
        BdbApplicationOrDomain::activeInstance()->commitNested() ;
        return BdbcError;
    }

    BdbHandle(BdbContObj) contH;
    BdbRef(ooMap) theMap;
    BdbRef(BdbPCounter) counterRef;
    ooMapItr mapI(theMap);

    BdbContAccessMgr contMgr;

    if ( contH.exist(dbH, contName, oocRead) != BdbcSuccess ) {
        cout << theName << " locked";
        goto done;
    }

    if ( ! theMap.lookupObj(contH, "theRegistry", BdbcRead) ) {
        cout << "map ! found";
        goto done;
    }
    cout << "Registered databases:" << endl;
     
    while ( mapI.next() ) {
        BdbRef(ooObj) cRef = mapI->oid();
        counterRef = (BdbRef(BdbPCounter)&) cRef;
        cout << "   " << mapI->name() << endl;
    }
done:
    BdbApplicationOrDomain::activeInstance()->commitNested() ;

    return BdbcSuccess;
}

 

---

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

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