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

                 

---

/BdbAdminTools/BdbCloseDbs.cc

Go to the documentation of this file.

//------------------------------------------------------------------------------
// File and Version Information:
//      $Id: BdbCloseDbs.cc,v 1.4 2002/06/24 19:11:06 becla Exp $
//
// Description:
//      Transient class. Changes clustering hint internal information
//      such that next time clustering hint will start with new databases
//      and will never come back to existing ones.
//
// 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
//
//------------------------------------------------------------------------------

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


//-------------------------------
// Collaborating Class Headers --
//-------------------------------
#include "BdbApplication/BdbDomain.hh"
#include "BdbApplication/BdbDebug.hh"
#include "BdbApplication/BdbErrorSignal.hh"
#include "BdbAccess/BdbGenericDomain.hh"
#include "BdbClustering/BdbClustHAccess.hh"

#include "ooMap.h"


// global, for simplicity
char* clustName = 0;  // 0 -> this will pick up all clusters
char authLevel  = 0;  // 0 -> this will pick up all auth levels
char* authName  = 0;  // 0 -> this will pick up all auth names
char* compName  = 0;  // 0 -> this will pick up all components


d_Boolean verbose     = d_True;
d_Boolean reallyClose = d_True;


BdbCloseDbs::BdbCloseDbs(d_Boolean verbose, d_Boolean reallyClose)
    : _reallyClose(reallyClose)
{
    if ( verbose ) {
        stream.attach(1); // stream becomes cout
    }
    _locatorMgr = new BdbClustHAccess("evs", d_False, 0);
}



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






/**
 **  BdbCloseDbs::run()
 **
 **  The function processes all containers in all clustering hint databases
 **  in evs domain.
 **/

int 
BdbCloseDbs::run()
{
    BdbApplicationOrDomain* app = BdbApplicationOrDomain::activeInstance();
    ooMode openMode;
    // initialize transaction

    if( ! app->isAuthorized( BdbDomain::System ) ) {
       cerr << "You must have system authorization to use this"
            << " utility."
            << endl;
       return( -1 ) ;
    }

    app->startUpdate("t");
    openMode = oocUpdate;

    
    if ( 0 != clustName ) {
        char dbName[64];
        sprintf(dbName, "evs_clustHintConfig_%s", clustName);
        if ( BdbcSuccess != runInOneDb(dbName, BdbcUpdate) ) {
            stream << "failed for db " << dbName << ", aborting all changes" << endl;
            app->abort("t");
            return BdbcError;
        }
    } else {
        // do it for every clustering hint database
        ooItr(ooDBObj) dbItr;
        if ( BdbcSuccess != app->fd().contains(dbItr) ) {
            app->commit("t");
            return BdbcError;
        }

        while ( dbItr.next() ) {
            const char* dbName = dbItr.name();
            if ( 0 != strstr(dbName, "clustHintConfig") &&  0 != strstr(dbName, "evs_") ) {
                if ( BdbcSuccess != runInOneDb(dbName, BdbcUpdate) ) {
                    cerr << "failed for db " << dbName << ", aborting all changes" << endl;
                    app->abort("t");
                    return BdbcError;
                }
            }
        }
    }
    

    app->commit("t");

    return BdbcSuccess;
}



BdbStatus
BdbCloseDbs::runInOneDb(const char* dbName, ooMode openMode)
{
    stream << "\n ====> Running in db: " << dbName << endl;
    
    // open database
    BdbHandle(BdbDBObj) dbH;
    if ( BdbcSuccess != dbH.open(BdbApplicationOrDomain::activeInstance()->fd(), dbName, openMode) ) {
        stream << "Cannot open clustering hint database " << dbName << endl;
        return BdbcError;
    }

    // initialize iterator over all container
    ooItr(ooContObj) contItr;
    if ( dbH.contains(contItr, openMode) != BdbcSuccess ) {
        stream << "Cannot initialize cont iterator" << endl;
        return BdbcError;
    }

    // iterator over all containers in the database and
    // make the appropriete action (depending on container name)
    while ( contItr.next() ) {
        const char* contName = contItr.name();        
        if ( ! strncmp(contName, "evs_", 4) ) {
            if ( skipIt(contName) ) {
                continue;
            }   
            stream << "Closing in container:    \"" << contName << "\"" << endl;
            BdbHandle(BdbContObj) contH = contItr;
            if ( runInOneCont(contH) != BdbcSuccess ) {
                stream << "Closing dbs in container: \"" << contName 
                       << "\" failed, aborting." << endl;
                return BdbcError;
            }
        } else {
            stream << "Ignoring container:      \"" << contName << "\"" << endl;
        }
    }

    return BdbcSuccess;
}



/**
 **  The function decides whether the container should
 **  be skipped or not (whether it is of the right type
 **  (auth level, auth name, component name)
 **/
d_Boolean
BdbCloseDbs::skipIt(const char* contName)
{
    if ( 0 != authLevel ) { // pick only a subset with one authLevel
        char s[4];
        s[0] = '_';
        s[1] = authLevel;
        s[2] = '_';
        s[3] = '\0';
        if ( 0 == strstr(contName, s) ) {
            stream  << "Skipping " << contName 
                    << ", does not contain " << s << endl;
            return d_True;
        }
    }
    
    if ( 0 != authName ) { // pick only a subset with one authName
        char* s = new char[strlen(authName)+3];
        sprintf(s, "_%s_", authName);
        const char* s1 = strstr(contName, s);
        delete [] s;
        if ( 0 == s1 ) {
            stream  << "Skipping " << contName 
                    << ", does not contain " << s << endl;
            return d_True;
        }
    }

    if ( 0 != compName ) { // pick only a subset with one componentName
        char* s = new char[strlen(compName)+3];
        sprintf(s, "_%s_", compName);
        const char* s1 = strstr(contName, s);
        delete [] s;
        if ( 0 == s1 ) {
            stream  << "Skipping " << contName 
                    << ", does not contain " << s << endl;
            return d_True;
        }
    }

    return d_False;
}



BdbStatus 
BdbCloseDbs::runInOneCont(BdbHandle(BdbContObj)& contH)
{
    const char* pcName = contH.name();
    if ( 0 == pcName ) {
        stream << "Unable to find param cont name for " << BdbPrintOID(contH) << endl;
        return BdbcError;
    }
    int len = strlen(pcName);
    if ( len < 4 ) {
        stream << "Incorrect paramContName: " << pcName << endl;
        return BdbcError;
    }
    len -=3;// skip "_v1" at the end
    char* paramContName = new char [len+1];
    strncpy(paramContName, pcName, len);
    *(paramContName+len) = '\0';
    
    
    // iterate over all named objects in the container
    // each object corresponds to one stream

    ooItr(ooObj) objI;
    if ( contH.getNameObj(objI) != BdbcSuccess ) {
        stream << "Cannot initialize container iterator" << endl;
        return BdbcError;
    }

    while ( objI.next() ) {
        stream << "Closing for stream:      \"" << objI.getObjName(contH) << "\"" << endl;
        if ( strcmp(objI.typeName(), "BdbPCompParam_001") ) {
            stream << "Unexpected object of type " << objI.typeName() << " expected" << endl;
            return BdbcError;
        }
        BdbHandle(BdbPCompParam_001) h = (BdbHandle(BdbPCompParam_001)) objI;
        int i, max = h->_activeDbs.size();
        for (i=0 ; i<max ; i++) {
            int id = h->_activeDbs[i];
            ooRef(ooDBObj) dbRef;
            dbRef.set_DB(id);
            const char* name = dbRef.name();
            if ( 0 != name ) {
                stream << "Closing db \"" << name << "\" [" << id << "]" << endl;
            } else {
                stream << "Closing db [" << id << "]" << endl;
            }
            // delete the counter   
            ooHandle(ooContObj) cH;
            if ( BdbcSuccess != _locatorMgr->locateDbPageCounterCont(id, cH, oocUpdate) ) {
                stream << "Unable to locate page counter for " << id << endl;
            } else {
                if ( _reallyClose ) {
                    stream << "Deleting " << cH.name() << endl;
                    ooDelete(cH);
                }
            }
            // now register the db as full
            BdbHandle(BdbPFullDbsReg) theReg;
            if ( BdbcSuccess != _locatorMgr->locateFullDbsReg(theReg, BdbcUpdate) ) {
                stream << "Failed to locate full dbs registry" << endl;
                return BdbcError;
            }
            if ( _reallyClose ) {
                if ( BdbcSuccess != theReg->add(id) ) {
                    stream << "Failed to register " << id << " on the list of full dbs" << endl;
                    return BdbcError;
                }
                stream << id << " registered on the list of full dbs" << endl;
            }
        }
    }

    if ( _reallyClose ) {
        // delete the container containing BdbPCompParam(s)
        const char* n = contH.name();
        if ( BdbcSuccess != ooDelete(contH) ) {
            stream << "Failed to delete " << n << endl;
            return BdbcError;
        }
        stream << "Container " << n << " deleted" << endl;


        // delete the registry of dbs with extra pages
        BdbHandle(BdbContObj) dbwepH;
        if ( BdbcSuccess == _locatorMgr->locateDbsWEPRegistry(dbwepH, paramContName, oocUpdate) ) {
            const char* n = dbwepH.name();
            if ( BdbcSuccess != ooDelete(dbwepH) ) {
                stream << "Failed to delete dbsWEPRegistry for " << pcName << endl;
                return BdbcError;
            }
            stream << "Container " << n << " deleted" << endl;
        }
    }

    return BdbcSuccess;
}





int
processArgs(int argc, char** argv)
{
    d_Boolean all   = d_False;
    d_Boolean other = d_False; // -authLevel, authName, -compName or -clustName
    
    for (int i=1 ; i<argc ; i++) {
        if ( !strcmp(argv[i], "-quiet") ) {
            verbose = d_False;
        } else if ( !strcmp(argv[i], "-all") ) {
            if ( other ) {
                cerr << "-all and [-authLevel | -authName | -compName | -clustName]"
                     << " are mutually exclusive" << endl;
                return 1;
            }
            all       = d_True;
            clustName = 0;
            authLevel = 0;
            authName  = 0;
            compName  = 0;
        } else if ( !strcmp(argv[i], "-authLevel") ) {
            if ( all ) {
                cerr << "-all and -authLevel are mutually exclusive" << endl;
                return 1;
            }
            other = d_True;
            i++;
            if ( i >= argc ) {
                cerr << "Missing authorization level name after -authLevel" << endl;
                return 1;
            }
            if ( argv[i][0] != 's' && argv[i][0] != 'g' && argv[i][0] != 'u' ) {
                cerr << "Expected argument after -authLevel: s  g  u" << endl;
                return 1;
            }
            authLevel = argv[i][0];
        } else if ( !strcmp(argv[i], "-authName") ) {
            if ( all ) {
                cerr << "-all and -authName are mutually exclusive" << endl;
                return 1;
            }
            other = d_True;
            i++;
            if ( i >= argc ) {
                cerr << "Missing authorization name after -authName" << endl;
                return 1;
            }
            authName = new char[strlen(argv[i])+1];
            strcpy(authName, argv[i]);
        } else if ( !strcmp(argv[i], "-compName") ) {
            if ( all ) {
                cerr << "-all and -compName are mutually exclusive" << endl;
                return 1;
            }
            other = d_True;
            i++;
            if ( i >= argc ) {
                cerr << "Missing component name after -compName" << endl;
                return 1;
            }
            compName = new char[strlen(argv[i])+1];
            strcpy(compName, argv[i]);
        } else if ( !strcmp(argv[i], "-clustName") ) {
            if ( all ) {
                cerr << "-all and -clustName are mutually exclusive" << endl;
                return 1;
            }
            other = d_True;
            i++;
            if ( i >= argc ) {
                cerr << "Missing cluster name after -clustName" << endl;
                return 1;
            }
            clustName = new char[strlen(argv[i])+1];
            strcpy(clustName, argv[i]);
        } else {
            cerr << "Incorrect argument: " << argv[i] 
                 << ", expected -authLevel, -authName, -compName, -clustName" << endl;
            return 1;
        }
    }
    cout << "Arguments ok" << endl;
    
    return 0;         
}


void printHelp()
{
    cout << "\nBdbCloseDbs. This utility permanently closes databases.\n"
         << "Expected arguments:\n"
         << "   [-all] [-quiet] [-authLevel s/g/u] [-authName authName] [-compName compName] [-clustName clusterName]\n"
         << "   If you specify -all, you cannot specify any of -authLevel, -authName, -compName, -clustName\n"
         << "Examples:\n"
         << "     1) to close all isPhysicsEvents dbs (all components):\n"
         << "           BdbCloseDbs -authLevel g -authName isPhysicsEvents\n"
         << "     2) to close all \"sim\":\n"
         << "           BdbCloseDbs -compName sim\n"
         << "     3) to close all \"aod dbs in isMultiHadron:\n"
         << "           BdbCloseDbs -compName aod -authLevel g -authName isMultiHadron\n"
         << "     4) to close all \"calibEvents\" databases:\n"
         << "           BdbCloseDbs -authLevel g -authName calibEvents\n"
         << "     5) to close all dbs in the cluster \"cl1\":\n"
         << "           BdbCloseDbs -clustName cl1\n"  << endl;
}

int main(int argc, char* argv[])
{    
    if ( argc == 1 ) {
        printHelp();
        return 1;
    }
    
    if ( 0 != processArgs(argc, argv) ) {
        return 1;
    }

    // Start a domain (any domain)
    BdbGenericDomain domain( "events" ) ;
    domain.activate() ;

    BdbCloseDbs theClass(verbose, reallyClose);
    if ( BdbcSuccess != theClass.run() ) {
        domain.deactivate() ;
        return 1;
    }

    domain.deactivate() ;
    return 0;    
}

 

---

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

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