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

                 

---

/BdbClusteringServer/BdbSrvAbsBaseClustH.cc

Go to the documentation of this file.

//------------------------------------------------------------------------------
// File:
//      BdbSrvAbsBaseClustH.cc
//
// Description:
//
//      
//
// Environment:
//      Software developed for the BaBar Detector at the SLAC B-Factory
//
// Author List:
//      Jacek Becla                Original Author
//
// Copyright Information:
//      Copyright (C) 1997      Stanford Linear Accelerator Center
//
//------------------------------------------------------------------------------
#include "BaBar/BaBar.hh"

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

// ----------------------
// This Class's Header --
// ----------------------
#include "BdbClusteringServer/BdbSrvAbsBaseClustH.hh"

// ------------------------------
// Collaborating Class Headers --
// ------------------------------
#include "BdbApplication/BdbApplication.hh"
#include "BdbApplication/BdbDomain.hh"
#include "BdbApplication/BdbDebug.hh"
#include "BdbApplication/BdbErrorSignal.hh"
#include "BdbAccess/BdbClustHintSetupMgr.hh"
#include "BdbClusteringServer/BdbClSrvCRef.hh"
#include "BdbClusteringServer/BdbHintKernel.hh"
#include "BdbClusteringServer/BdbClusteringServerErrors.hh"

#include <set>
using std::set;
#include <vector>
using std::vector;
#include <string>
using std::string;
#include <algorithm>


extern "C" {
#include <sys/stat.h>     /* umask   */
#include <ctype.h>        /* isalnum, isupper, tolower */
}


// this is used, if we do not want a client to return 
// its containers when clustering hint destructor is called
// All containers will be returned in one goal.
set<BdbClSrvCRef*,babar::Collection::PtrLess>* BdbSrvAbsBaseClustH::_contsToBeReturned = 0;



BdbSrvAbsBaseClustH::BdbSrvAbsBaseClustH(const BdbDomain& domain, 
                                   d_ULong maxWaitTime, 
                                   d_Boolean quiet)
    : _domain(&domain),
      _authLevel(BdbDomain::IllegalAuth),
      _authName(0),
      _compName(0),
      _streamName(0),
      _compChanged(d_False),
      _streamChanged(d_False),
      _maxNoPages(0),
      _usedDbs(new vector<string>),
      _assignedConts(new set<BdbClSrvCRef*,babar::Collection::PtrLess>),
      _currentRef(0),
      _recentTransID(1),
      _maxWaitTime(maxWaitTime),
      _quietMode(quiet),
      _newDbFlag(d_False),
      _newContFlag(d_False),
      _changeAuthLevel(d_False)
{
    umask(0x002);              // rwxrwxr-x

    resetHint();
    _es = new BdbErrorSignal(quiet);
}


BdbSrvAbsBaseClustH::BdbSrvAbsBaseClustH(const BdbSrvAbsBaseClustH& obj)
    : BdbClusteringHint(obj),
      _domain(obj._domain),
      _authLevel(obj._authLevel),
      _authName(0),
      _compName(0),
      _streamName(0),
      _compChanged(obj._compChanged),
      _streamChanged(obj._streamChanged),
      _maxNoPages(obj._maxNoPages),
      _usedDbs(new vector<string>),
      _assignedConts(new set<BdbClSrvCRef*,babar::Collection::PtrLess>),
      _currentRef(obj._currentRef),
      _recentTransID(obj._recentTransID),
      _maxWaitTime(obj._maxWaitTime),
      _quietMode(obj._quietMode),
      _newDbFlag(obj._newDbFlag),
      _newContFlag(obj._newContFlag),
      _es(new BdbErrorSignal(_quietMode)),
      _changeAuthLevel(obj._changeAuthLevel)
{
    const char* n = obj._authName;
    if ( 0 != n ) {
        _authName = new char [strlen(n)+1];
        strcpy(_authName, n);
    }

    n = obj._compName;
    if ( 0 != n ) {
        _compName = new char [strlen(n)+1];
        strcpy(_compName, n);
    }
    
    n = obj._streamName;
    if ( 0 != n ) {
        _streamName = new char [strlen(n)+1];
        strcpy(_streamName, n);
    }
    
    *_usedDbs = *(obj._usedDbs);

    set<BdbClSrvCRef*,babar::Collection::PtrLess>::iterator iter=obj._assignedConts->begin();
    BdbClSrvCRef* cr;
    while ( iter!=obj._assignedConts->end() ) {
      cr=*iter;
      _assignedConts->insert(new BdbClSrvCRef(*cr));
      iter++;
    }
}



BdbSrvAbsBaseClustH::~BdbSrvAbsBaseClustH()
{
    if ( ! _assignedConts->empty() ) {
        set<BdbClSrvCRef*,babar::Collection::PtrLess>::iterator iter=_assignedConts->begin();
        BdbClSrvCRef* cr;
        if ( 0 == _contsToBeReturned ) {
            COUT1 << "returning containers: ";
            while ( iter!=_assignedConts->end() ) {
              cr=*iter;
              cr->print(COUT1n);
              iter++;
            }
            COUT1n << endl;
            BdbHintKernel::returnContainers(_assignedConts);
            iter=_assignedConts->begin();
            while ( iter!=_assignedConts->end() ) {
              delete *iter;
              iter++;
            }
            _assignedConts->clear();
        } else {
            COUT1 << "collecting returned containers: ";
            while ( iter!=_assignedConts->end() ) {
              cr=*iter;
              cr->print(COUT1n);
              _contsToBeReturned->insert(cr);
              iter++;
            }
            COUT1n << endl;
        }
    }
    
    if ( 0 != _authName ) {
        delete [] _authName;
    }
    if ( 0 != _compName ) {
        delete [] _compName;
    }
    if ( 0 != _streamName ) {
        delete [] _streamName;
    }
    printUsedDbs();
    _usedDbs->clear();
    delete _usedDbs;
    
    delete _es;
}


void
BdbSrvAbsBaseClustH::setHint(BdbHandleAny& theHint)
{
    _currentRef = new BdbClSrvCRef(theHint);
    BdbClusteringHint::setHint(theHint);
}


void 
BdbSrvAbsBaseClustH::setHint(BdbRefAny& theHint)
{
    _currentRef = new BdbClSrvCRef(theHint);
    BdbClusteringHint::setHint(theHint);
}


BdbRefAny
BdbSrvAbsBaseClustH::resetHint()
{
    if ( hintIsValid() ) {
        BdbClSrvCRef cr(getHint());
        std::set<BdbClSrvCRef*,babar::Collection::PtrLess>::iterator pos=_assignedConts->find(&cr);
        BdbClSrvCRef* item = 0;
        if (pos!=_assignedConts->end()) item=*pos;
        if ( 0 == item ) {
            COUT1 << "resetHint: " << BdbPrintOID(getHint()) << " not found in _assignedConts" << endl;
        } else if ( oocNoOpen != BdbApplicationOrDomain::activeInstance()->mode() ) {
            d_ULong np = item->setNPage();
            COUT1 << BdbPrintOID(getHint()) << " set to " << np << endl;
        }
    }

    _currentRef = 0;
    
    return BdbClusteringHint::resetHint();
}



BdbRefAny
BdbSrvAbsBaseClustH::hint()
{
    if ( ! hintIsValid() ) {
        updatedHint();
    }

    return getHint();
}


void 
BdbSrvAbsBaseClustH::prepareHint()
{
    if ( hintIsValid() ) {
        updatedHint();
    }
}



BdbStatus 
BdbSrvAbsBaseClustH::setComponent(const char* name)
{
    const char* fn = "BdbSrvAbsBaseClustH::setComponent";

    if ( name == 0 ) {
        return _es->BdbESig(BdbClusteringServerErrCompIsNul, fn);
    }

    if ( 0 != _compName ) {
        if ( 0 == strcmp(_compName, name) ) {
            return BdbcSuccess; // the same
        }
        delete [] _compName;
        _compName = 0;
    }

    d_Boolean applyRestr = d_True;
    if ( BdbcSuccess != internalSetComp(name, applyRestr) ) {
        return _es->BdbESig(BdbClusteringServerErrFunctionFailed, fn, name);
    }

    return BdbcSuccess;
}



BdbStatus 
BdbSrvAbsBaseClustH::setStream(const char* name)
{
    const char* fn = "BdbSrvAbsRegularClustH::setStream";
    if ( name == 0 ) {
        return _es->BdbESig(BdbClusteringServerErrCompIsNul, fn); 
    }

    if ( 0 != streamName() ) {
        if ( ! strcmp(name, streamName()) ) {
            return BdbcSuccess;
        }
    }

    delete [] _streamName;
    _streamName = new char [strlen(name)+1];
    strcpy(_streamName, name);

    _streamChanged = d_True;
    
    return BdbcSuccess;
}



BdbStatus
BdbSrvAbsBaseClustH::internalSetComp(const char* name, d_Boolean applyRestr)
{
    const char* fn = "BdbSrvAbsBaseClustH::internalSetComp";
    
    // note that the same verification is done during loading data from ASCII file
    int length = strlen(name);
    if ( length > 6 && applyRestr ) {
        BdbSignal(BdbcUserError, BdbClusteringServerErrCompNameTooLong, 0, fn);
        length = 6;
    }

    _compName = new char [ length+1 ];

    d_Boolean issueWarning = d_False;
    for (int i=0 ; i<length ; i++) {
        char c = name[i];
        if ( ! isalnum(c) && applyRestr ) {
            issueWarning = d_True;
            _compName[i] = '_';
        }
        else if ( isupper(c) && applyRestr ) {
            issueWarning = d_True;
            _compName[i] = tolower(c);
        }
        else {
            _compName[i] = c;
        }
    }
    _compName[length] = '\0';

    if ( issueWarning ) {
        COUT1 << "Specified component name (" << name 
              << " ) was not valid and has been changed to "
              << _compName << endl;
    }

    _compChanged = d_True;

    return BdbcSuccess;
}




d_Boolean
BdbSrvAbsBaseClustH::currentContIsFull()
{
    if ( ! hintIsValid() ) {
        return d_False;
    }

    // this will call nPage on the container handle and remember it
    d_ULong curNPage = _currentRef->setNPage();

    if ( curNPage >= _maxNoPages ) {
        COUT1 << "Cont " << BdbPrintOID(getHint()) << " is full "
              << "(curNPage=" << curNPage << ", max = " << _maxNoPages << ")" << endl;
        return d_True;
    }
    return d_False;
}



d_Boolean
BdbSrvAbsBaseClustH::newDatabaseCreated() 
{
    cout << "BdbSrvAbsBaseClustH::newDatabaseCreated currently not functioning" << endl;
    return d_False;
}


d_Boolean 
BdbSrvAbsBaseClustH::newContainerCreated()
{
    cout << "BdbSrvAbsBaseClustH::newContainerCreated currently not functioning" << endl;
    return d_False;

}



BdbStatus 
BdbSrvAbsBaseClustH::changeAuthL(BdbDomain::AuthLevels authLevel, 
                              const char* name)
{
    const char* fn = "BdbSrvAbsBaseClustH::changeAuthL";

    BdbDomain* theDomain = (BdbDomain*) _domain;
    
    if ( theDomain->setAuthLevel(authLevel, name) != BdbcSuccess ) {
        return _es->BdbESig(BdbClusteringServerErrFunctionFailed, fn,
                            "in setAuthLevel");
    }

    _changeAuthLevel = d_False;

    return BdbcSuccess;
}



BdbStatus
BdbSrvAbsBaseClustH::setMaxWaitTime(d_ULong value)
{
    if ( value < 0 ) {
        return BdbcError;
    }
    _maxWaitTime = value;
    return BdbcSuccess;
}



BdbStatus 
BdbSrvAbsBaseClustH::requestContainer()
{
    const char* fn = "BdbSrvAbsBaseClustH::requestContainer";
    
    if ( ! BdbHintKernel::isInit() ) {
        if ( BdbcSuccess != BdbHintKernel::initORB(0, 0) ) {
            return _es->BdbFSig(BdbClusteringServerErrFunctionFailed, fn, 
                                "initORB");
        }
    }

    char authLevelChar = (BdbDomain::authLevelName(_authLevel))[0];
    
    ooRef(ooObj) ref;
    // this will also set _maxNoPages
    if ( BdbcSuccess != 
         BdbHintKernel::getOneContainer(_domain->shortDomainName(), 
                                        authLevelChar, _authName, 
                                        _compName, _streamName,
                                        ref, _maxNoPages) ) {
        return _es->BdbESig(BdbClusteringServerErrFunctionFailed, fn, 
                            "in BdbHintKernel::getOneContainer"); 
    }
    if ( BdbIsNull(ref) ) {
        return _es->BdbESig(BdbClusteringServerErrFunctionFailed, fn, 
                            "ref is not valid"); 
    }
    setHint(ref);
    _assignedConts->insert(_currentRef);
    
    return BdbcSuccess;
}



BdbStatus
BdbSrvAbsBaseClustH::lockTheHint()
{
    const char* fn = "BdbSrvAbsBaseClustH::lockTheHint";

    if ( ! hintIsValid() ) {
        return _es->BdbESig(BdbClusteringServerErrFunctionFailed, fn, 
                            "contHint not initialized");
    }
    COUT1 << "Attempting to lock hint: " << BdbPrintOID(getHint()) << endl;
    BdbStatus status = getHint().update();
    // refresh nPage, just in case this is a new container
    // and updatedHint will not be called anymore.
    if ( ! BdbIsNull(_currentRef) ) {
        _currentRef->setNPage();
    }
    
    return status;
}



/**
 **  BdbSrvAbsBaseClustH::transactionChanged()
 **
 **  The function returns d_True if current (main) transaction changed 
 **  since that function was called last time. It automatically changes 
 **  the "recent transaction ID", so it should not be called to often
 **/

d_Boolean
BdbSrvAbsBaseClustH::transactionChanged()
{
    d_ULong currentID = BdbApplicationOrDomain::activeInstance()->transId(); 
    if ( _recentTransID < currentID ) {
        _recentTransID = currentID;
        return d_True;
    }
    return d_False;
}



d_Boolean 
BdbSrvAbsBaseClustH::conditionsChanged()
{
    d_Boolean ret = d_False;
    // check / refresh auth level
    if ( _domain->authLevel() != _authLevel ) {
        _authLevel = _domain->authLevel();
        ret = d_True;
    }
    // check / refresh auth name
    if ( myStrcmp(_domain->authName(), _authName) ) {
        if ( 0 != _authName ) {
            delete [] _authName;
            _authName = 0;
        }
        const char* n = _domain->authName();
        if ( 0 != n ) {
            _authName = new char [strlen(n)+1];
            strcpy(_authName, n);
        }
        ret = d_True;
    }
    // check component
    if ( _compChanged ) {
        ret = d_True;
        _compChanged = d_False;
    }
    // check stream
    if ( _streamChanged ) {
        ret = d_True;
        _streamChanged = d_False;
    }
    
    return ret;
}



d_Boolean
BdbSrvAbsBaseClustH::myStrcmp(const char* s1, const char* s2)
{
    if ( 0 == s1 && 0 == s2 ) {
        return d_False;
    }
    if ( (0 == s1 && 0 != s2) || (0 != s1 && 0 == s2)  ) {
        return d_True;
    }
    
    return strcmp(s1, s2); 
}


/**
 **  The function assumes, that the _dbHint handle is
 **  valid, and the db is already opened
 **/
BdbStatus
BdbSrvAbsBaseClustH::registerCurrentDbAsUsed()
{
    if ( BdbClustHintSetupMgr::instance()->collectUsedDbsStats() ) {
        ooRef(ooObj) r = getHint();
        BdbRef(BdbDBObj) dbRef;
        dbRef.set_DB(r.get_DB());
        char str[16];
        sprintf(str, "%i", dbRef.get_DB());
        string theDb(str);

        

        if ( std::find(_usedDbs->begin(),_usedDbs->end(),theDb)==
                                                   _usedDbs->end() ) {
            _usedDbs->push_back(theDb);
            std::sort(_usedDbs->begin(),_usedDbs->end());
            COUT1 << "Db: \"" << dbRef.name() << "\" [" << str 
                  << "] registered on list of used dbs" << endl;
        }
    }
    return BdbcSuccess;
}



void
BdbSrvAbsBaseClustH::printUsedDbs() const
{
    if ( ! BdbClustHintSetupMgr::instance()->collectUsedDbsStats() ) {
        return;    
    }
   
    vector<string>::iterator it=_usedDbs->begin();
    while( it!=_usedDbs->end() ) {
        cout << "USEDDB: " << *it << endl;
        it++;
    }
}


/**
 **  The function will turn on collecting returned containers:
 **  each time the destructor is called, containers are collected
 **  in the special rwset. They will be all returned in one goal
 **  (tirggered by a dedicated function)
 **/
void
BdbSrvAbsBaseClustH::internalCollectReturnedConts()
{
    if ( 0 == _contsToBeReturned ) {
        _contsToBeReturned = new set<BdbClSrvCRef*,babar::Collection::PtrLess>;
        COUT1 << "collecting returned containers turned on" << endl;
    }
}



BdbStatus
BdbSrvAbsBaseClustH::internalReturnCollectedConts() const
{
    const char* fn = "BdbSrvAbsBaseClustH::internalReturnCollectedConts";
    
    if ( 0 == _contsToBeReturned ) {
        COUT1 << "ERR " << fn << " collecting returned conts turned off" << endl;
        return BdbcError;
    }
    
    COUT1 << "returning collected containers: ";
    set<BdbClSrvCRef*,babar::Collection::PtrLess>::iterator iter=_contsToBeReturned->begin();
    BdbClSrvCRef* cr;
    while ( iter!= _contsToBeReturned->end()) {
      cr=*iter;
      cr->print(COUT1n);
      delete *iter;
      iter++;
    }
    COUT1n << endl;
    BdbStatus stat = BdbHintKernel::returnContainers(_contsToBeReturned);
    
    _contsToBeReturned->clear();
    _contsToBeReturned = 0;

    return stat;
}

 

---

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

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