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

                 

---

/BdbClusteringServer/BdbHintKernel.cc

Go to the documentation of this file.

//------------------------------------------------------------------------------
// File and Version Information:
//      $Id: BdbHintKernel.cc,v 1.11 2002/08/30 01:13:31 ryd Exp $
//
// Description:
//      The class is responsible for kernel clustering hint operations, like
//          - distributing containers
//          - creation / deletion of databases and containers
//      It can do that using a server on in-process.
//
// Environment:
//      Software developed for the BaBar Detector at the SLAC B-Factory
//
// Author List:
//      Jacek Becla                Original Author
//
// Copyright Information:
//      Copyright (C) 2000      Stanford Linear Accelerator Center
//
//------------------------------------------------------------------------------
#include "BaBar/BaBar.hh"

// Work around a bug in ACE/TAO with DEC CXX6.3
#include <string.h>


#include "BdbClusteringServer/BdbHintKernel.hh"


#include "BdbApplication/BdbDebug.hh"
#include "BdbApplication/BdbDomain.hh"
#include "BdbAccess/BdbClusterConfigMgr.hh"
#include "BdbAccess/BdbClustHintSetupMgr.hh"
#include "BdbClusteringServer/BdbClSrvCRef.hh"
#include "BbrStdUtils/CollectionUtils.hh"

#include <unistd.h> // getpid

#include <set>
using std::set;

BdbClustSrvModule::BdbClusteringServer_var  BdbHintKernel::_clustServerRef;
BdbClustSrvModule::ClientDescr              BdbHintKernel::_myDescr;
char*      BdbHintKernel::_clusterName          = 0;
d_Boolean  BdbHintKernel::_orbIsInit            = d_False;
const int  BdbHintKernel::_maxNoFailuresAllowed = 5;
int        BdbHintKernel::_noFailures           = 0;
int        BdbHintKernel::_fdid                 = 0;


BdbHintKernel::BdbHintKernel()
{}



BdbHintKernel::~BdbHintKernel()
{
    returnAllContainers();
    _orbIsInit = d_False;
}

        

BdbStatus
BdbHintKernel::initORB(int argc, char** argv)
{
    if ( _orbIsInit ) {
        return BdbcSuccess;
    }

    BdbClustHintSetupMgr* chsMgr = BdbClustHintSetupMgr::instance();
    const char* iorFile = chsMgr->iorFilePath();
    if ( 0 == iorFile ) {
        cerr << "Invalid iorFile, check clustering config file" << endl;
        ::abort();
    }
    
    char hN[64];
    gethostname(hN, 64); // this does not contain domain name
    struct hostent* hent1 = gethostbyname(hN);
    if ( 0 == hent1 ) {
        cerr << "Unable to determine host name" << endl;
        return BdbcError;
    }
    
    CORBA::Environment theEnv;
    CORBA::ORB_ptr     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(iorFile);
    if ( ! theIORFile ) {
        cerr << "Fatal error: cannot open IOR file" << endl;
        ::abort();
    }
    
    theIORFile >> theStr;
    theIORFile.close();

    CORBA::Object_var theObject;
    theObject = theOrb->string_to_object(theStr);
    if( CORBA::is_nil(theObject) ) {
        COUT1 << "FATAL ERROR: Clustering server not responding" << endl;
        ::abort();
    }

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

    _myDescr.hostName = CORBA::string_dup(hent1->h_name);
    _myDescr.pid      = getpid() ;

    initFDID();
    int repeat = 60, serverFDID = 0;
    while(1) {        
        if ( _clustServerRef->ping(serverFDID, _myDescr) ) {
            break;
        }
        if ( repeat-- == 0 ) {
            COUT1 << "FATAL ERROR: clustering server cannot be reached" << endl;
            ::abort();
        }
        sleep(1);
        COUT1 << "ERROR: clustering server cannot be reached, retrying" << endl;
    }

    if ( serverFDID != _fdid ) {
        cerr << "FATAL ERROR: client fdid (" << _fdid << ") differs "
             << "from server fdid (" << serverFDID << ")" << endl;
        ::abort();
    }

    _orbIsInit = d_True;
    
    return BdbcSuccess;
}


BdbStatus
BdbHintKernel::initFDID()
{
    BdbApplicationOrDomain* app = BdbApplicationOrDomain::activeInstance();
    d_Boolean inTrans = ( BdbcNoOpen != app->mode() );
    if ( ! inTrans ) {
        if ( BdbcSuccess != app->startRead("getfdid") ) {
            return BdbcError;
        }
    }
    _fdid = app->fd().number();
    COUT1 << "_fdid init: " << _fdid << endl;
    if ( ! inTrans ) {
        app->commit("getfdid");
    }

    return BdbcSuccess;
}


BdbStatus
BdbHintKernel::getOneContainer(const char* sdName,
                               char authLevel,
                               const char* authName,
                               const char* compName,
                               const char* streamName, 
                               ooRef(ooObj)& ref,
                               d_ULong& maxNoPages)
{
    if ( ! _orbIsInit ) {
        cerr << "ORB not initialize, in-process not supported" << endl;
        return BdbcError;
    }

    if ( 0 == _clusterName ) {
        const char* c = BdbClusterConfigMgr::getClusterName();
        if ( 0 == c ) {
            c = "default";
        }
        _clusterName = new char [strlen(c)+1];
        strcpy(_clusterName, c);
    }
    
    if ( authLevel != 'g' && authLevel != 's' && authLevel != 'u' ) {
        cerr << "Incorrect auth level: " << authLevel << endl;
        return BdbcError;
    }
    
    BdbClustSrvModule::GroupDescr descr;
    descr.clusterName = CORBA::string_dup(_clusterName);
    descr.sdName      = CORBA::string_dup(sdName);
    descr.authLevel   = authLevel;
    descr.authName    = CORBA::string_dup(authName);
    descr.compName    = CORBA::string_dup(compName);
    if ( 0 != streamName ) {
        descr.streamName  = CORBA::string_dup(streamName);
    } else {
        descr.streamName  = CORBA::string_dup("NULL");
    }
    
    BdbClustSrvModule::RetStatus* ret;
    BdbClustSrvModule::OID oid;
    oid.db = oid.oc = oid.pg = oid.sl = oid.noPg = 0;

    COUT1 << "Requesting a container for: ";
    if ( 0 == _clusterName ) COUT1n << "NULL-"; else   COUT1n << _clusterName << "-";
    if ( 0 == sdName      )  COUT1n << "NULL-"; else   COUT1n << sdName       << "-";
    COUT1n << authLevel << "-";
    if ( 0 == authName    )  COUT1n << "NULL-"; else   COUT1n << authName     << "-";
    if ( 0 == compName    )  COUT1n << "NULL-"; else   COUT1n << compName     << "-";
    if ( 0 == streamName  )  COUT1n << "NULL" ; else   COUT1n << streamName;
    COUT1n << endl;


    long startedAt = time(0);    
 retry:
    ret = _clustServerRef->getOneContainer(descr, _myDescr, oid);
    if ( 0 == ret ) {
        cerr << "Returned RetStatus object = 0" << endl;
        return BdbcError;
    }

    if ( ret->level != BdbClustSrvModule::Success ) {
        ooRef(ooContObj) nullRef;
        ref = nullRef;
        if ( ret->level == BdbClustSrvModule::Warning ) {
            COUT1 << "Warning: " << ret->msg << endl;
            if ( ! strcmp(ret->msg, "wait") ) {
                COUT1 << "Waiting " << oid.sl << " sec for precreation to finish" 
                      << ", precreation started " << oid.pg << " sec ago" << endl;
                sleep(oid.sl);
                
                COUT1 << "Attempting to get container again" << endl;
                delete ret;
                if ( time(0) - startedAt > 3600 ) {
                    COUT1 << "Waited ~1 hour, giving up" << endl;
                    return BdbcError;
                }
                goto retry;
            }
        } else {
            cout << "Error: " << ret->msg << endl;
            cout << "Error returned by getOneContainer" << endl;
            if ( ++ _noFailures >= _maxNoFailuresAllowed ) {
                cerr << "Fatal error: server keeps returning error" << endl;
                ::abort();
            }
            return BdbcError;
        }
    }
    
    _noFailures = 0;

    delete ret;
    ret = 0;
    
    ref.set_DB(oid.db);
    ref.set_OC(oid.oc);
    ref.set_page(oid.pg);
    ref.set_slot(oid.sl);
    maxNoPages = oid.noPg;
    COUT1 << "Got:" << BdbPrintOID(ref) << ", maxNoPages = " << maxNoPages << endl;
    
    return BdbcSuccess;
}



BdbStatus
BdbHintKernel::returnAllContainers()
{
    if ( ! _orbIsInit ) {
        cerr << "ORB not initialize, nothing to return" << endl;
        return BdbcSuccess;
    }


    BdbClustSrvModule::RetStatus* ret;
    COUT1 << "Returning all containers" << endl;
    
    ret = _clustServerRef->returnAllContainers(_myDescr);
    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;
            cout << "Error returned by returnAllContainers" << endl;
            return BdbcError;
        }
    }
    delete ret;
    ret = 0;
    
    return BdbcSuccess;
}




BdbStatus
BdbHintKernel::returnContainers(set<BdbClSrvCRef*,babar::Collection::PtrLess>* s)
{
    if ( ! _orbIsInit ) {
        cerr << "ORB not initialize, nothing to return" << endl;
        return BdbcSuccess;
    }

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

    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();
        oid.noPg = cr->get_nPage();
        array[i++] = oid;
        iter++;
    }

    BdbClustSrvModule::RetStatus* ret;
    COUT1 << "About to return some containers" << endl;
    
    ret = _clustServerRef->returnContainers(array, _myDescr);

    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;
            cout << "Error returned by returnAllContainers" << endl;
            return BdbcError;
        }
    }
    delete ret;
    ret = 0;
    
    return BdbcSuccess;
}


void
BdbHintKernel::overrideClusterName(const char* name)
{
    if ( 0 != _clusterName ) {
        delete [] _clusterName;
        _clusterName = 0;
    }
    if ( 0 != name ) {
        _clusterName = new char [strlen(name)+1];
        strcpy(_clusterName, name);
    }    
}

 

---

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

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