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

                 

---

/BdbClusteringServer/BdbClustHintConsole.cc

Go to the documentation of this file.

//------------------------------------------------------------------------------
// File and Version Information:
//      $Id: BdbClustHintConsole.cc,v 1.12 2002/08/30 01:13:31 ryd Exp $
//
// Description:
//      "Console" to the clustering server.
//  
// Environment:
//      Software developed for the BaBar Detector at the SLAC B-Factory.
//
// Author List:
//      Jacek Becla
//
// Copyright Information:
//      Copyright (C) 2000      Stanford Linear Accelerator Center
//
//------------------------------------------------------------------------------
#include "BaBar/BaBar.hh"

// Workaround for CXX6.3
#include <string.h>

#include "BdbUtil/Bdb.hh"
#include "BdbUtil/BdbTestPersObj_16K.hh"
#include "BdbApplication/BdbApplication.hh"
#include "BdbApplication/BdbDebug.hh"
#include "BdbApplication/BdbDomain.hh"
#include "BdbClusteringServer/BdbClusteringServerC.h"
#include "BdbClusteringServer/BdbClSrvCRef.hh"
#include "BdbEventStore/BdbEventStore.hh"

#include <set>
using std::set;

class Console
{
    BdbClustSrvModule::ClientDescr              _client;
    BdbClustSrvModule::BdbClusteringServer_var  _theRef;
    d_Boolean                                   _orbIsInit;

public:

    Console();
    BdbStatus initORB(int argc, char** argv);
    void waitUntilItIsReady(CORBA::Boolean wait4Precr);
    BdbStatus ping();
    BdbStatus shutdown(CORBA::Boolean try2ReleaseConts,
                       CORBA::Boolean force);
    BdbStatus recoverNow();
    BdbStatus resynchronize();
    void automaticPrecr(CORBA::Boolean enable);
    BdbStatus dumpAllGroups(CORBA::Boolean allGroups);
    BdbStatus listGroups(CORBA::Boolean all, CORBA::Boolean withDbs);
    BdbStatus listDbs(CORBA::Boolean all);
    BdbStatus printConts(CORBA::Boolean allGroups, 
                         CORBA::Short whichConts);
    BdbStatus initGroup(const BdbClustSrvModule::GroupDescr& descr,
                        CORBA::Short no2Precr);
    BdbStatus shutdownGroup(const BdbClustSrvModule::GroupDescr& descr,
                            CORBA::Boolean try2Recover);
    BdbStatus deleteGroup(const BdbClustSrvModule::GroupDescr& descr);
    BdbStatus precreateDbs(const BdbClustSrvModule::GroupDescr& descr,
                           int nr2Precreate);
    BdbStatus closeActiveDbs(const BdbClustSrvModule::GroupDescr& descr, 
                             CORBA::Boolean force, 
                             CORBA::ULong onlyThisDbId);
    BdbStatus closeAllActiveDbs();
    BdbStatus getOneContainer(const BdbClustSrvModule::GroupDescr& descr,
                              BdbClustSrvModule::OID& oid);
    BdbStatus returnContainers(set<BdbClSrvCRef*,babar::Collection::PtrLess>& s, int setNPage);
    BdbStatus returnAllContainers(const char* hostName=0, int pid=0);
    BdbStatus loadSrv(const BdbClustSrvModule::GroupDescr& descr, 
                      CORBA::Boolean randomize);
    BdbStatus storeObjects(int nrObjects, BdbClustSrvModule::OID oid, int& nPage);
    BdbStatus storeObjects(int nrObjects, BdbClustSrvModule::OID oid);
    void test1(int nr);
    void test2(int nr);
};



Console::Console()
{
    char hN[64];
    memset(hN, 0, 64);
    gethostname(hN, 64); // this does not contain domain name
    struct hostent* hent1 = gethostbyname(hN);
    if ( 0 != hent1 ) {
        strcpy(hN, "console: ");
        strcat(hN, hent1->h_name);
    }

    _client.hostName = CORBA::string_dup(hN);
    _client.pid      = getpid();
    _orbIsInit       = d_False;
}




BdbStatus 
Console::initORB(int argc, char** argv)
{
    CORBA::Environment theEnv;
    CORBA::ORB_ptr     theOrb;

    theOrb = CORBA::ORB_init(argc, argv, "hello", theEnv);
    if( theEnv.exception() != 0 ) {
        cerr << "CLIENT: theEnv = " << theEnv.exception() << endl;
        return BdbcError;
    }

    char theStr[1024];
    ifstream theIORFile(argv[1]);
    theIORFile >> theStr;
    theIORFile.close();

    CORBA::Object_var theObject;
    theObject = theOrb->string_to_object(theStr);
    if( CORBA::is_nil(theObject) ) {
        cerr << "CLIENT: Failed to translate specified IOR into object reference." << endl;
        return BdbcError;
    }

    // Narrow obtained object reference into an object reference
    // of a specific class.
    _theRef = BdbClustSrvModule::BdbClusteringServer::_narrow(theObject);
    if( CORBA::is_nil(_theRef.in()) ) {
        cerr << "CLIENT: Failed to narrow the object reference into BdbClusteringServer." << endl;
        return BdbcError;
    }

    _orbIsInit = d_True;
    return BdbcSuccess;
}


void 
Console::waitUntilItIsReady(CORBA::Boolean checkPrecr)
{
    while ( ! _theRef->isReady(checkPrecr, _client) ) {
        sleep(5);
        COUT1 << "not ready" << endl;
    }
}


BdbStatus
Console::ping()
{
    BdbApplicationOrDomain* app = BdbApplicationOrDomain::activeInstance();
    d_Boolean inTrans = ( BdbcNoOpen != app->mode() );
    if ( ! inTrans ) {
        if ( BdbcSuccess != app->startRead("getfdid") ) {
            return BdbcError;
        }
    }
    int my_fdid = app->fd().number();
    if ( ! inTrans ) {
        app->commit("getfdid");
    }
    int server_fdid = 0;
    
    if ( ! _theRef->ping(server_fdid, _client)) {
        cerr << "Server not responding" << endl;
        return BdbcError;
    }
    if ( server_fdid == my_fdid ) {
        cout << "Server is running" << endl;
    } else {
        cout << "Server is running. \n"
             << "Warning: OO_FD_BOOT does not correspond to fd "
             << "served by the server: OO_FD_BOOT's fdid = " << my_fdid 
             << ", server's fdid = " << server_fdid << endl;
        return BdbcError;
    }
    
    return BdbcSuccess;
}



BdbStatus 
Console::shutdown(CORBA::Boolean try2ReleaseConts,
                  CORBA::Boolean force)
{
    BdbClustSrvModule::RetStatus* ret;
    ret  = _theRef->shutdown(try2ReleaseConts, force, _client);
    if ( 0 == ret ) {
        cerr << "Returned RetStatus object = 0" << endl;
        return BdbcError;
    }
    if ( ret->level != BdbClustSrvModule::Success ) {
        if ( ret->level == BdbClustSrvModule::Warning ) {
            cout << "Warning: " << ret->msg << endl;
        } else {
            cout << "Error: " << ret->msg << endl;
            return BdbcError;
        }
    }
    delete ret;

    return BdbcSuccess;   
}


BdbStatus 
Console::recoverNow()
{
    BdbClustSrvModule::RetStatus* ret;
    ret  = _theRef->recoverNow(_client);
    if ( 0 == ret ) {
        cerr << "Returned RetStatus object = 0" << endl;
        return BdbcError;
    }
    if ( ret->level != BdbClustSrvModule::Success ) {
        if ( ret->level == BdbClustSrvModule::Warning ) {
            cout << "Warning: " << ret->msg << endl;
        } else {
            cout << "Error: " << ret->msg << endl;
            return BdbcError;
        }
    }
    delete ret;

    return BdbcSuccess;   
}



BdbStatus 
Console::resynchronize()
{
    BdbClustSrvModule::RetStatus* ret;
    ret  = _theRef->resynchronize(_client);
    if ( 0 == ret ) {
        cerr << "Returned RetStatus object = 0" << endl;
        return BdbcError;
    }
    if ( ret->level != BdbClustSrvModule::Success ) {
        if ( ret->level == BdbClustSrvModule::Warning ) {
            cout << "Warning: " << ret->msg << endl;
        } else {
            cout << "Error: " << ret->msg << endl;
            return BdbcError;
        }
    }
    delete ret;

    return BdbcSuccess;   
}


void
Console::automaticPrecr(CORBA::Boolean enable)
{
    if ( enable ) {
        _theRef->enableAutomaticPrecr(_client);
    } else {
        _theRef->disableAutomaticPrecr(_client);
    }    
}


BdbStatus
Console::dumpAllGroups(CORBA::Boolean allGroups)
{
    if ( ! _orbIsInit ) {
        return BdbcError;
    }
    
    char* output = 0;
    _theRef->print("send", allGroups, _client, output);
    if ( 0 != output ) {
        cout << output << endl;
        delete [] output;
    }
    return BdbcSuccess;
}


BdbStatus
Console::listGroups(CORBA::Boolean all, 
                    CORBA::Boolean withDbs)
{
    if ( ! _orbIsInit ) {
        return BdbcError;
    }
    
    char* output = 0;
    BdbClustSrvModule::RetStatus* ret;
    ret  = _theRef->listGroups("send", all, withDbs, _client, output);
    if ( 0 == ret ) {
        cerr << "Returned RetStatus object = 0" << endl;
        return BdbcError;
    }
    if ( ret->level != BdbClustSrvModule::Success ) {
        if ( ret->level == BdbClustSrvModule::Warning ) {
            cout << "Warning: " << ret->msg << endl;
        } else {
            cout << "Error: " << ret->msg << endl;
            return BdbcError;
        }
    }
    delete ret;

    if ( 0 != output ) {
        cout << output << endl;
        delete [] output;
    }
    return BdbcSuccess;
}



BdbStatus
Console::listDbs(CORBA::Boolean all)
{
    if ( ! _orbIsInit ) {
        return BdbcError;
    }
    
    char* output = 0;
    BdbClustSrvModule::RetStatus* ret;
    ret = _theRef->listDbs("send", all, _client, output);
    if ( 0 == ret ) {
        cerr << "Returned RetStatus object = 0" << endl;
        return BdbcError;
    }
    if ( ret->level != BdbClustSrvModule::Success ) {
        if ( ret->level == BdbClustSrvModule::Warning ) {
            cout << "Warning: " << ret->msg << endl;
        } else {
            cout << "Error: " << ret->msg << endl;
            return BdbcError;
        }
    }
    delete ret;
    if ( 0 != output ) {
        cout << output << endl;
        delete [] output;
    }
    return BdbcSuccess;
}


void
Console::test1(int nr)
{
    if ( _orbIsInit ) {
        for ( int i=0 ; i<nr ; i++ ) {
            _theRef->test1(123);
        }
    }
}


void
Console::test2(int nr)
{
    if ( _orbIsInit ) {
        for ( int i=0 ; i<nr ; i++ ) {
            _theRef->test2(_client);
        }
    }
}






BdbStatus 
Console::printConts(CORBA::Boolean allGroups, 
                    CORBA::Short whichConts)
{
    if ( ! _orbIsInit ) {
        return BdbcError;
    }
    
    char* output = 0;
    BdbClustSrvModule::RetStatus* ret;
    ret = _theRef->printConts("send", allGroups, whichConts, _client, output);
    if ( 0 == ret ) {
        cerr << "Returned RetStatus object = 0" << endl;
        return BdbcError;
    }
    if ( ret->level != BdbClustSrvModule::Success ) {
        if ( ret->level == BdbClustSrvModule::Warning ) {
            cout << "Warning: " << ret->msg << endl;
        } else {
            cout << "Error: " << ret->msg << endl;
            return BdbcError;
        }
    }
    delete ret;
    if ( 0 != output ) {
        cout << output << endl;
        delete [] output;
    }
    return BdbcSuccess;
}



BdbStatus
Console::initGroup(const BdbClustSrvModule::GroupDescr& descr,
                   CORBA::Short no2Precr)
{
    if ( ! _orbIsInit ) {
        return BdbcError;
    }

    BdbClustSrvModule::RetStatus* ret;
    ret  = _theRef->initializeGroup(descr, no2Precr, _client);
    if ( 0 == ret ) {
        cerr << "Returned RetStatus object = 0" << endl;
        return BdbcError;
    }
    if ( ret->level != BdbClustSrvModule::Success ) {
        if ( ret->level == BdbClustSrvModule::Warning ) {
            cout << "Warning: " << ret->msg << endl;
        } else {
            cout << "Error: " << ret->msg << endl;
            return BdbcError;
        }
    }
    delete ret;

    return BdbcSuccess;
}



BdbStatus
Console::shutdownGroup(const BdbClustSrvModule::GroupDescr& descr,
                       CORBA::Boolean try2Recover)
{
    if ( ! _orbIsInit ) {
        return BdbcError;
    }

    BdbClustSrvModule::RetStatus* ret;
    ret  = _theRef->shutdownGroup(descr, try2Recover, _client);
    if ( 0 == ret ) {
        cerr << "Returned RetStatus object = 0" << endl;
        return BdbcError;
    }
    if ( ret->level != BdbClustSrvModule::Success ) {
        if ( ret->level == BdbClustSrvModule::Warning ) {
            cout << "Warning: " << ret->msg << endl;
        } else {
            cout << "Error: " << ret->msg << endl;
            return BdbcError;
        }
    }
    delete ret;

    return BdbcSuccess;
}



BdbStatus
Console::deleteGroup(const BdbClustSrvModule::GroupDescr& descr)
{
    if ( ! _orbIsInit ) {
        return BdbcError;
    }

    BdbClustSrvModule::RetStatus* ret;
    ret  = _theRef->deleteGroup(descr, _client);
    if ( 0 == ret ) {
        cerr << "Returned RetStatus object = 0" << endl;
        return BdbcError;
    }
    if ( ret->level != BdbClustSrvModule::Success ) {
        if ( ret->level == BdbClustSrvModule::Warning ) {
            cout << "Warning: " << ret->msg << endl;
        } else {
            cout << "Error: " << ret->msg << endl;
            return BdbcError;
        }
    }
    delete ret;

    return BdbcSuccess;
}




BdbStatus 
Console::precreateDbs(const BdbClustSrvModule::GroupDescr& descr,
                      int nr2Precreate)
{
    if ( ! _orbIsInit ) {
        return BdbcError;
    }
        
    BdbClustSrvModule::RetStatus* ret;            
    ret = _theRef->precreateDbs(descr, nr2Precreate, _client);
    if ( 0 == ret ) {
        cerr << "Returned RetStatus object = 0" << endl;
        return BdbcError;
    }
    if ( ret->level != BdbClustSrvModule::Success ) {
        if ( ret->level == BdbClustSrvModule::Warning ) {
            cout << "Warning: " << ret->msg << endl;
        } else {
            cout << "Error: " << ret->msg << endl;
            return BdbcError;
        }
    }
    delete ret;
    ret = 0;
    return BdbcSuccess;
}



BdbStatus
Console::closeActiveDbs(const BdbClustSrvModule::GroupDescr& descr, 
                        CORBA::Boolean force, 
                        CORBA::ULong onlyThisDbId)
{
    if ( ! _orbIsInit ) {
        return BdbcError;
    }
        
    BdbClustSrvModule::RetStatus* ret;            
    ret = _theRef->closeActiveDbs(descr, force, onlyThisDbId, _client);
    if ( 0 == ret ) {
        cerr << "Returned RetStatus object = 0" << endl;
        return BdbcError;
    }
    if ( ret->level != BdbClustSrvModule::Success ) {
        if ( ret->level == BdbClustSrvModule::Warning ) {
            cout << "Warning: " << ret->msg << endl;
        } else {
            cout << "Error: " << ret->msg << endl;
            return BdbcError;
        }
    }
    delete ret;
    ret = 0;
    return BdbcSuccess;
}


    
BdbStatus 
Console::closeAllActiveDbs()
{
    if ( ! _orbIsInit ) {
        return BdbcError;
    }
        
    BdbClustSrvModule::RetStatus* ret;            
    ret = _theRef->closeAllActiveDbs(_client);
    if ( 0 == ret ) {
        cerr << "Returned RetStatus object = 0" << endl;
        return BdbcError;
    }
    if ( ret->level != BdbClustSrvModule::Success ) {
        if ( ret->level == BdbClustSrvModule::Warning ) {
            cout << "Warning: " << ret->msg << endl;
        } else {
            cout << "Error: " << ret->msg << endl;
            return BdbcError;
        }
    }
    delete ret;
    ret = 0;
    return BdbcSuccess;
}



BdbStatus 
Console::getOneContainer(const BdbClustSrvModule::GroupDescr& descr,
                         BdbClustSrvModule::OID& oid)
{
    if ( ! _orbIsInit ) {
        return BdbcError;
    }

    BdbClustSrvModule::RetStatus* ret;            
    ret = _theRef->getOneContainer(descr, _client, oid);
    if ( 0 == ret ) {
        cerr << "Returned RetStatus object = 0" << endl;
        return BdbcError;
    }
    if ( ret->level != BdbClustSrvModule::Success ) {
        if ( ret->level == BdbClustSrvModule::Warning ) {
            cout << "Warning: " << ret->msg << endl;
            if ( ! strcmp(ret->msg, "wait") ) {
                cout << "Waiting " << oid.sl << " sec for precreation to finish" 
                     << ", precreation started " << oid.pg << " sec ago" << endl;
                sleep(oid.sl);
                
                cout << "Attempting to get container again" << endl;
                delete ret;
                return getOneContainer(descr, oid);
            }
        } else {
            cout << "Error: " << ret->msg << endl;
            return BdbcError;
        }
    }
    delete ret;
    ret = 0;
    COUT1 << "Got: [" << oid.db << "-" << oid.oc << "-" << oid.pg << "-" << oid.sl << "]" << endl;
    return BdbcSuccess;
}


BdbStatus
Console::returnAllContainers(const char* host, int pid)
{
    if ( ! _orbIsInit ) {
        return BdbcError;
    }

    BdbClustSrvModule::RetStatus* ret = 0;

    if ( 0 == host ) {
        ret = _theRef->returnAllContainers(_client);
    } else {
        BdbClustSrvModule::ClientDescr client;
        client.hostName = CORBA::string_dup(host);
        client.pid      = pid;
        ret = _theRef->returnAllContainers(client);
    }
    
    if ( 0 == ret ) {
        cerr << "Returned RetStatus object = 0" << endl;
        return BdbcError;
    }
    if ( ret->level != BdbClustSrvModule::Success ) {
        if ( ret->level == BdbClustSrvModule::Warning ) {
            cout << "Warning: " << ret->msg << endl;
        } else {
            cout << "Error: " << ret->msg << endl;
            return BdbcError;
        }
    }
    delete ret;
    ret = 0;
    return BdbcSuccess;
}
 



BdbStatus
Console::returnContainers(set<BdbClSrvCRef*,babar::Collection::PtrLess>& s, int setNPage)
{
    if ( ! _orbIsInit ) {
        return BdbcError;
    }

    BdbClSrvCRef* cr;
    int i = 0, len = s.size();
    BdbClustSrvModule::OIDArray array(len);
    array.length(len);
    set<BdbClSrvCRef*,babar::Collection::PtrLess>::iterator iter=s.begin();

    if ( setNPage ) {
        BdbApplicationOrDomain::activeInstance()->startRead("a");
    }
    
    while ( iter!=s.end() ) {
      cr=*iter;
        ooRef(ooContObj) r = cr->getContRef();
        BdbClustSrvModule::OID oid;
        oid.db    = r.get_DB();
        oid.oc    = r.get_OC();
        oid.pg    = r.get_page();
        oid.sl    = r.get_slot();
        if ( setNPage ) {
            oid.noPg = r.nPage();
            r.unlock();
        } else {
            oid.noPg = 0;
        }
        array[i++] = oid;
        iter++;
    }

    if ( setNPage ) {
        BdbApplicationOrDomain::activeInstance()->commit("a");    
    }
    
    BdbClustSrvModule::RetStatus* ret = _theRef->returnContainers(array, _client);
    
    if ( 0 == ret ) {
        cerr << "Returned RetStatus object = 0" << endl;
        return BdbcError;
    }
    if ( ret->level != BdbClustSrvModule::Success ) {
        if ( ret->level == BdbClustSrvModule::Warning ) {
            cout << "Warning: " << ret->msg << endl;
        } else {
            cout << "Error: " << ret->msg << endl;
            return BdbcError;
        }
    }
    delete ret;
    ret = 0;
    return BdbcSuccess;
}
 




BdbStatus 
Console::loadSrv(const BdbClustSrvModule::GroupDescr& descr, d_Boolean randomize)
{
    if ( ! _orbIsInit ) {
        return BdbcError;
    }

    long startTime = time(0);
    long number = 0;
    
    while ( 1 ) {
        number++;
        // get container
        BdbClustSrvModule::OID oid;
        COUT1 << "--> Asking for container" << endl;
        if ( BdbcSuccess != getOneContainer(descr, oid) ) {
            cerr << "getOneContainer failed" << endl;
            return BdbcError;
        }

        int nr = 0;
        if ( randomize ) {
            // write some objects (0-8)
            srand(time(0));
            nr = rand() % 9;
        }
        COUT1 << "--> Writing " << nr << " objects" << endl;    
        storeObjects(nr, oid);
        
        // return containers
        COUT1 << "--> Returning containers" << endl;
        if ( BdbcSuccess != returnAllContainers() ) {
            cout << "returning containers failed" << endl;
            return BdbcError;
        }

        if ( randomize ) {
            // sleep some time (0-10 sec)
            nr = rand() % 10; COUT1 << "Sleeping " << nr << " sec" << endl;  sleep(nr);
        }
        
        // maybe stop all the process
        if ( 0 == access("/u/sf/becla/temp/stopCSLoad", F_OK) ) {
            break;
        }
    }

    long diff = time(0) - startTime;
    if ( diff > 0 ) {
        double speed = ((double) number) / ((double) diff);
        cout << "total time = " << diff << ", number = " << number << " [" << speed << " Hz]" << endl;
    }
    
    return BdbcSuccess;
}



BdbStatus
Console::storeObjects(int nrObjects, BdbClustSrvModule::OID oid)
{
    int nPage = 0;
    return storeObjects(nrObjects, oid, nPage);
}



BdbStatus
Console::storeObjects(int nrObjects, BdbClustSrvModule::OID oid, int& nPage)
{
    if ( nrObjects <= 0 ) {
        return BdbcSuccess;
    }    

    const char* fdName = getenv("OO_FD_BOOT");
    if ( 0 == fdName ) {
        cerr << "OO_FD_BOOT not set" << endl;
        return BdbcError;
    }
    
    ooTrans trans;
    trans.start();
    ooHandle(ooFDObj) fdH;
    if ( oocSuccess != fdH.open(fdName, oocUpdate) ) {
        cerr << "Unable to open fd" << endl;
        return BdbcError;
    }
    ooRef(ooContObj) r;
    r.set_DB(oid.db);
    r.set_OC(oid.oc);
    r.set_page(oid.pg);
    r.set_slot(oid.sl);
    ooHandle(ooContObj) h = r;
    if ( oocSuccess != h.open(oocUpdate) ) {
        cerr << "Unable to open container" << endl;
        return BdbcError;
    }
    
    //cout << "nPage before creating " << nrObjects << " objects = " << h.nPage() << endl;
    
    ooHandle(BdbTestPersObj_16K) obj;
    for ( int i=0 ; i<nrObjects ; i++) {
        obj = new (h) BdbTestPersObj_16K();
        if ( h.nPage() > oid.noPg ) {
            cout << "container full, " << i << " objects stored" << endl;
            break;
            
        }
    }
    
    //cout << "nPage after creating objects = " << h.nPage() << endl;

    nPage = h.nPage();

    trans.commit();
    return BdbcSuccess;
}


// ========================================================
// ========================================================
// ========================================================

int  runCommand(int argc, char** argv);
void help();

Console cc;

int main(int argc, char** argv)
{
    if ( argc < 3 ) {
        help();
        return 1;
    }
   
    // Start a domain (any domain)
    BdbEventStore::instance()->activate();

    if ( BdbcSuccess != cc.initORB(argc, argv) ) {
        return 1;
    }

    return runCommand(argc, argv);
}



// ========================================================
// ========================================================
// ========================================================


int runCommand(int argc, char** argv)
{
    if ( 3 > argc ) {
        cout << "incorrect number of arguments" << endl;
        return 1;
    }
    if ( 0 == strcmp(argv[2], "-ping") ) {
        if ( BdbcSuccess == cc.ping() ) {
            return 0;
        }
        return 1;
    }
    if ( 0 == strcmp(argv[2], "-print") ) {
        if ( 4 != argc ) {
            cout << "-print: expected more arguments" << endl;
            return 2;
        }
        CORBA::Boolean allGroups = 0;
        if ( argv[3][0] == '1' ) {
            allGroups = 1;
        }
        return BdbcSuccess != cc.dumpAllGroups(allGroups);
    } else if ( 0 == strcmp(argv[2], "-listGroups") ) {
        if ( 5 != argc ) {
            cout << "-listGroups: expected more arguments" << endl;
            return 2;
        }
        CORBA::Boolean all = 0;
        if ( argv[3][0] == '1' ) {
            all = 1;
        }
        CORBA::Boolean withDbs = 0;
        if ( argv[4][0] == '1' ) {
            withDbs = 1;
        }
        return BdbcSuccess != cc.listGroups(all, withDbs);
    } else if ( 0 == strcmp(argv[2], "-listDbs") ) {
        if ( 4 != argc ) {
            cout << "-listDbs: expected more arguments" << endl;
            return 2;
        }
        CORBA::Boolean all = 0;
        if ( argv[3][0] == '1' ) {
            all = 1;
        }
        return BdbcSuccess != cc.listDbs(all);
    } else if ( 0 == strcmp(argv[2], "-printConts") ) {
        if ( 5 != argc ) {
            cout << "-printConts: expected more arguments" << endl;
            return 2;
        }
        CORBA::Boolean all = 0;
        if ( argv[3][0] == '1' ) {
            all = 1;
        }
        CORBA::Short whichConts = (CORBA::Short) atoi(argv[4]);
        return BdbcSuccess != cc.printConts(all, whichConts);
    } else if ( 0 == strcmp(argv[2], "-shutdown") ) {
        if ( 5 != argc ) {
            cout << "-shutdown: expected more arguments" << endl;
            return 2;
        }
        CORBA::Boolean try2ReleaseConts = 0;
        if ( argv[3][0] == '1' ) {
            try2ReleaseConts = 1;
        }
        CORBA::Boolean force = 0;
        if ( argv[4][0] == '1' ) {
            force = 1;
        }
        return BdbcSuccess != cc.shutdown(try2ReleaseConts, force);
    } else if ( 0 == strcmp(argv[2], "-recoverNow") ) {
        return BdbcSuccess != cc.recoverNow();
    } else if ( 0 == strcmp(argv[2], "-resynchronize") ) {
        return BdbcSuccess != cc.resynchronize();
    } else if ( 0 == strcmp(argv[2], "-automaticPrecr") ) {
        if ( 4 != argc ) {
            cout << "-automaticPrecr: expected more arguments" << endl;
            return 2;
        }
        CORBA::Boolean enable = 0;
        if ( argv[3][0] == '1' ) {
            enable = 1;
        }
        cc.automaticPrecr(enable);
        return 0;
    } else if ( 0 == strcmp(argv[2], "-initGroup") ) {
        if ( 9 != argc ) {
            cout << "-initGroup: incorrect number of arguments" << endl;
            help();
            return 2;
        }
        BdbClustSrvModule::GroupDescr descr;
        descr.clusterName = CORBA::string_dup(argv[3]);
        descr.sdName      = CORBA::string_dup("evs");
        descr.authLevel   = argv[4][0];
        descr.authName    = CORBA::string_dup(argv[5]);
        descr.compName    = CORBA::string_dup(argv[6]);
        descr.streamName  = CORBA::string_dup(argv[7]);
        CORBA::Short no2Precr = atoi(argv[8]);
        if ( no2Precr == -1 ) {
            cout << "Incorrent arg: no dbs to precreate" << endl;
            return BdbcError;
        }
        return BdbcSuccess != cc.initGroup(descr, no2Precr);
    } else if ( 0 == strcmp(argv[2], "-shutdownGroup") ) {
        if ( 9 != argc ) {
            cout << "-shutdownGroup: incorrect number of arguments" << endl;
            help();
            return 2;
        }
        BdbClustSrvModule::GroupDescr descr;
        descr.clusterName = CORBA::string_dup(argv[3]);
        descr.sdName      = CORBA::string_dup("evs");
        descr.authLevel   = argv[4][0];
        descr.authName    = CORBA::string_dup(argv[5]);
        descr.compName    = CORBA::string_dup(argv[6]);
        descr.streamName  = CORBA::string_dup(argv[7]);
        CORBA::Boolean try2Recover = 0;
        if ( argv[8][0] == '1' ) {
            try2Recover = 1;
        }
        return BdbcSuccess != cc.shutdownGroup(descr, try2Recover);
    } else if ( 0 == strcmp(argv[2], "-deleteGroup") ) {
        if ( 8 != argc ) {
            cout << "-deleteGroup: incorrect number of arguments" << endl;
            return 2;
        }
        BdbClustSrvModule::GroupDescr descr;
        descr.clusterName = CORBA::string_dup(argv[3]);
        descr.sdName      = CORBA::string_dup("evs");
        descr.authLevel   = argv[4][0];
        descr.authName    = CORBA::string_dup(argv[5]);
        descr.compName    = CORBA::string_dup(argv[6]);
        descr.streamName  = CORBA::string_dup(argv[7]);
        return BdbcSuccess != cc.deleteGroup(descr);
    } else if ( 0 == strcmp(argv[2], "-precrDbs") ) {
        if ( 9 != argc ) {
            cout << "-precrDbs: incorrect number of arguments" << endl;
            return 2;
        }
        BdbClustSrvModule::GroupDescr descr;
        descr.clusterName = CORBA::string_dup(argv[3]);
        descr.sdName      = CORBA::string_dup("evs");
        descr.authLevel   = argv[4][0];
        descr.authName    = CORBA::string_dup(argv[5]);
        descr.compName    = CORBA::string_dup(argv[6]);
        descr.streamName  = CORBA::string_dup(argv[7]);
        int nr2Precr = atoi(argv[8]);
        if ( nr2Precr < 1 ) {
            cerr << "nr2Precr = " << nr2Precr << endl;
            return 1;
        }
        return BdbcSuccess != cc.precreateDbs(descr, nr2Precr);
    } else if ( 0 == strcmp(argv[2], "-closeActiveDbs") ) {
        if ( 10 != argc ) {
            cout << "-closeActiveDbs: incorrect number of arguments" << endl;
            return 2;
        }
        BdbClustSrvModule::GroupDescr descr;
        descr.clusterName = CORBA::string_dup(argv[3]);
        descr.sdName      = CORBA::string_dup("evs");
        descr.authLevel   = argv[4][0];
        descr.authName    = CORBA::string_dup(argv[5]);
        descr.compName    = CORBA::string_dup(argv[6]);
        descr.streamName  = CORBA::string_dup(argv[7]);
        CORBA::Boolean force = 0;
        if ( '1' == argv[8][0] ) {
            force = 1;
        }
        CORBA::ULong onlyThisDbId = atoi(argv[9]);
        return BdbcSuccess != cc.closeActiveDbs(descr, force, onlyThisDbId);
    } else if ( 0 == strcmp(argv[2], "-closeAllActiveDbs") ) {
        return BdbcSuccess != cc.closeAllActiveDbs();
    } else if ( 0 == strcmp(argv[2], "-getConts") ) { 
        if ( 13 != argc ) {
            cout << "-getConts: incorrect number of arguments" << endl;
            return 2;
        }
        BdbClustSrvModule::GroupDescr descr;
        descr.clusterName = CORBA::string_dup(argv[3]);
        descr.sdName      = CORBA::string_dup("evs");
        descr.authLevel   = argv[4][0];
        descr.authName    = CORBA::string_dup(argv[5]);
        descr.compName    = CORBA::string_dup(argv[6]);
        descr.streamName  = CORBA::string_dup(argv[7]);
        int nrConts = atoi(argv[8]);
        if ( 0 >= nrConts ) {
            cerr << "error: nrConts = " << nrConts << endl;
            return 1;
        }
        int sleepBetween = atoi(argv[9]);
        if ( sleepBetween < 0 || sleepBetween > 1000 ) {
            cerr << "error: sleepBetween = " << sleepBetween << endl;
            return 1;
        }
        int nrObjects = atoi(argv[10]);
        
        CORBA::Boolean returnConts = 0;
        if ( argv[11][0] == '1' ) {
            returnConts = 1;
        }
        CORBA::Boolean setNPage = 0;
        if ( argv[12][0] == '1' ) {
            setNPage = 1;
        }

        set<BdbClSrvCRef*,babar::Collection::PtrLess> s; // of BdbClSrvCRef
        for(int i=0 ; i<nrConts ; i++) {
            BdbClustSrvModule::OID oid;
            if ( BdbcSuccess != cc.getOneContainer(descr, oid) ) {
                cerr << "getOneContainer failed, i=" << i << endl;
                return 2;
            }
            cout << "Got: [" << oid.db << "-" << oid.oc << "-"
                 << oid.pg << "-" << oid.sl << "], noPg=" << oid.noPg << endl;

            BdbRef(ooObj) r;
            r.set_DB(oid.db);
            r.set_OC(oid.oc);
            r.set_page(oid.pg);
            r.set_slot(oid.sl);
            s.insert(new BdbClSrvCRef(r));

            if ( nrObjects > 0 ) {
                if ( BdbcSuccess != cc.storeObjects(nrObjects, oid) ) {
                    cerr << "storeObjects failed" << endl;
                }
            }
            if ( sleepBetween > 0 ) {
                sleep(sleepBetween);
            }
        }
        if ( returnConts ) {
            if ( BdbcSuccess != cc.returnContainers(s, setNPage) ) {
                cerr << "returnAllContainers failed" << endl;
                return 3;
            }
        }
        BdbClSrvCRef* cr;
        set<BdbClSrvCRef*,babar::Collection::PtrLess>::iterator iter=s.begin();
        while ( iter!=s.end() ) {
            delete *iter;
            iter++;
        }        
        return 0;
    } else if ( 0 == strcmp(argv[2], "-write") ) { 
        if ( 10 != argc ) {
            cout << "-write: incorrect number of arguments" << endl;
            help();
            return 2;
        }
        BdbClustSrvModule::GroupDescr descr;
        descr.clusterName = CORBA::string_dup(argv[3]);
        descr.sdName      = CORBA::string_dup("evs");
        descr.authLevel   = argv[4][0];
        descr.authName    = CORBA::string_dup(argv[5]);
        descr.compName    = CORBA::string_dup(argv[6]);
        descr.streamName  = CORBA::string_dup(argv[7]);
        int nrObjects = atoi(argv[8]);
        if ( 0 >= nrObjects ) {
            cerr << "error: nrObjects = " << nrObjects << endl;
            return 1;
        }
        int checkEvery = atoi(argv[9]);
        if ( 0 >= checkEvery ) {
            cerr << "checkEvery invalid" << endl;
            return 2;
        }
        int sleepBetween = atoi(argv[9]);
        if ( sleepBetween < 0 || sleepBetween > 1000 ) {
            cerr << "error: sleepBetween = " << sleepBetween << endl;
            return 1;
        }

        BdbClustSrvModule::OID oid;
        if ( BdbcSuccess != cc.getOneContainer(descr, oid) ) {
            cerr << "getOneContainer failed" << endl;
            return 2;
        }
        cout << "Got: [" << oid.db << "-" << oid.oc << "-"
             << oid.pg << "-" << oid.sl << "], noPg=" << oid.noPg << endl;


        int doNow = 1, done = 0;
        while ( 0 < (doNow=(checkEvery<nrObjects?checkEvery:nrObjects)) ) {
            int nPage = 0;
            if ( BdbcSuccess != cc.storeObjects(doNow, oid, nPage) ) {
                cerr << "storeObjects failed" << endl;
            }
            nrObjects -= doNow;
            done += doNow;
            cout << "Wrote " << doNow << " objects, total done = " << done 
                 << ", nPage = " << nPage << endl;
            if ( nPage >= oid.noPg ) {
                cout << "Container is full, asking for a new container" << endl;
                if ( BdbcSuccess != cc.getOneContainer(descr, oid) ) {
                    cerr << "getOneContainer failed" << endl;
                    return 2;
                }
                cout << "Got: [" << oid.db << "-" << oid.oc << "-"
                     << oid.pg << "-" << oid.sl << "], noPg=" << oid.noPg << endl;
            }
        }

        if ( BdbcSuccess != cc.returnAllContainers() ) {
            cerr << "returnAllContainers failed" << endl;
            return 3;
        }
        return 0;
    } else if ( 0 == strcmp(argv[2], "-returnConts") ) {
        if ( 8 != argc && 10 != argc ) {
            cout << "-returnConts: incorrect number of arguments" << endl;
            help();
            return 2;
        }
        BdbClustSrvModule::GroupDescr descr;
        descr.clusterName = CORBA::string_dup(argv[3]);
        descr.sdName      = CORBA::string_dup("evs");
        descr.authLevel   = argv[4][0];
        descr.authName    = CORBA::string_dup(argv[5]);
        descr.compName    = CORBA::string_dup(argv[6]);
        descr.streamName  = CORBA::string_dup(argv[7]);
        char* hostName = 0;
        int pid        = 0;
        if ( 10 == argc ) {
            hostName = new char[strlen(argv[8])+1];
            strcpy(hostName, argv[8]);
            pid = atoi(argv[9]);
            if ( 0 > pid ) {
                cerr << "Pid negative" << endl;
                return 3;
            }
        }
        if ( BdbcSuccess != cc.returnAllContainers(hostName, pid) ) {
            cerr << "return containers failed" << endl;
            return 4;
        }
        return 0;
    } else if ( 0 == strcmp(argv[2], "-loadSrv") ) {
        if ( 9 != argc ) {
            help();
            return 2;
        }
        BdbClustSrvModule::GroupDescr descr;
        descr.clusterName = CORBA::string_dup(argv[3]);
        descr.sdName      = CORBA::string_dup("evs");
        descr.authLevel   = argv[4][0];
        descr.authName    = CORBA::string_dup(argv[5]);
        descr.compName    = CORBA::string_dup(argv[6]);
        descr.streamName  = CORBA::string_dup(argv[7]);
        CORBA::Boolean randomize = 1;
        if ( argv[8][0] == '1' ) {
            randomize = 1;
        }
        
        return BdbcSuccess != cc.loadSrv(descr, randomize);
    } else if ( 0 == strcmp(argv[2], "-test1") ) {
        if ( 4 != argc ) {
            cerr << "Expected more args" << endl;
            return 2;
        }
        int nr = atoi(argv[3]);
        if ( nr < 1 ) {
            cerr << "nr < 1 " << endl;
            return 3;
        }
        cc.test1(nr);
        return 0;
    } else if ( 0 == strcmp(argv[2], "-test2") ) {
        int nr = atoi(argv[3]);
        if ( nr < 1 ) {
            cerr << "nr < 1 " << endl;
            return 3;
        }
        cc.test2(nr);
        return 0;
    } else if ( 0 == strcmp(argv[2], "-waitUntilItIsReady") ) {
        CORBA::Boolean w = 0;
        if ( 4 != argc ) {
            cerr << "Expected more args" << endl;
            return 2;
        }
        if ( argv[3][0] == '1' ) {
            w = 1;
        }
        cc.waitUntilItIsReady(w);
        return 0;
    }
    
    cout << "Unsupported: \"" << argv[2] << "\"" << endl;
    help();
    return 2;
}



void help()
{
    cout << "Expected arguments:\n"
         << "   <IOR> -automaticPrecr          1/0 [enable/disable]\n"
         << "   <IOR> -closeActiveDbs    <GRD> 1/0 [force] <dbid or 0 (all dbs)>\n"
         << "   <IOR> -closeAllActiveDbs \n"
         << "   <IOR> -deleteGroup       <GRD>\n"
         << "   <IOR> -getConts          <GRD> nrConts sleepBetween[in sec] nrObjs [storedInCont]\n" 
            "                                  1/0 [returnConts/no] 1/0 [set nPage/no]\n"
         << "   <IOR> -initGroup         <GRD> nr [dbs2Precr]\n"
         << "   <IOR> -listDbs                 1/0 [all/inUseNow]\n"
         << "   <IOR> -listGroups              1/0 [all/inUseNow] 1/0 [withDbs/without]\n"
         << "   <IOR> -ping\n"
         << "   <IOR> -print                   1/0 [allGroups/inUseNow]\n"
         << "   <IOR> -printConts              1/0 [allGroups/inUseNow] whichConts\n"
         << "   <IOR> -precrDbs          <GRD> nr\n"
         << "   <IOR> -recoverNow\n"
         << "   <IOR> -resynchronize\n"
         << "   <IOR> -returnConts       <GRD> [hostName pid]\n"
         << "   <IOR> -shutdown                1/0 [try2ReleaseConts/no] 1/0 [force/no]\n"
         << "   <IOR> -shutdownGroup     <GRD> 1/0 [try2Recover/no] 1/0 [force/no]\n"
         << "   <IOR> -waitUntilItIsReady      1/0 [checkPrecr]\n"
         // << "   <IOR> -loadSrv           <GRD> 1/0 [=randomize/no]\n"
         // << "   <IOR> -test1 #repetitions\n"
         // << "   <IOR> -test2 #repetitions\n"
         // << "   <IOR> -write             <GRD> nrObjs checkeSizeEvery\n"
         << "\n"
         << "      where: <IOR> - location of the IOR file\n"
         << "             <GRD> - clusterName s/g/u authName compName streamName\n"
         << "             force in closeActiveDbs - ignore fact that dbs are in use\n"
         << "             whichCont:\n"
         << "                0x01 bit - turns on printing 'in use'        containers\n"
         << "                0x02 bit - turns on printing 'locked'        containers\n"
         << "                0x04 bit - turns on printing 'full'          containers\n"
         << "                0x08 bit - turns on printing 'empty'         containers\n"
         << "                0x10 bit - turns on printing 'partly filled' containers\n"
         << "                example: 11 - will print in use, locked and empty, will not show full\n"
         << "                          5 - will show in use and full\n"
         // << "             loadSrv - in the loop:\n"
         // << "                    randomize: \n"
         // << "                          1) ask for one cont\n"
         // << "                          2) writes objects (between 0 and 8)\n"
         // << "                          3) returns container\n"
         // << "                          4) sleeps (between 0 and 3 sec)\n"
         // << "                          5) stops when file /u/sf/becla/temp/stopCSLoad is touched\n"
         // << "                    do not randomize: \n"
         // << "                          1) ask for one cont\n"
         // << "                          2) writes one object\n"
         // << "                          3) return container\n"
         // << "                          4) stops when file /u/sf/becla/temp/stopCSLoad is touched\n"
         << endl;
}

 

---

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

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