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

                 

---

/BdbClustering/BdbFSSupportClustH.cc

Go to the documentation of this file.

//------------------------------------------------------------------------------
// File:
//      BdbFSSupportClustH.cc
//
// Description:
//
// Environment:
//      Software developed for the BaBar Detector at the SLAC B-Factory
//
// Author List:
//      Jacek Becla                 Original Author
//      Igor A. Gaponenko           Modified to use DBFS interace of BdbDomain class
//
// Copyright Information:
//      Copyright (C) 1997          Stanford Linear Accelerator Center
//
//------------------------------------------------------------------------------

// -------------------------
// -- This Class's Header --
// -------------------------
#include "BdbClustering/BdbFSSupportClustH.hh"

// ---------------------------------
// -- Collaborating Class Headers --
// ---------------------------------
#include "BdbApplication/BdbDebug.hh"
#include "BdbApplication/BdbErrorSignal.hh"
#include "BdbAccess/BdbFSMgr.hh"
#include "BdbAccess/BdbClusterConfigMgr.hh"
#include "BdbClustering/BdbClusteringErrors.hh"

// -------------------------------
// -- Constructors / Destructor --
// -------------------------------

BdbFSSupportClustH::BdbFSSupportClustH(d_Boolean quiet)
{
        _currentAuthLevel = BdbDomain::IllegalAuth ;
        _currentDomain    = BdbDomain::IllegalDomain ;
    _currentAuthName  = 0;
   _fsMgr = new BdbFSMgr ;
   _es = new BdbErrorSignal(quiet);
   _quietMode = quiet;
}


BdbFSSupportClustH::BdbFSSupportClustH(const BdbDomain& domain, 
                                       d_Boolean quiet)
{
    _domain           = &domain ;
    _currentAuthLevel = BdbDomain::IllegalAuth ;
    _currentDomain    = BdbDomain::IllegalDomain ;
    _currentAuthName  = 0;

   _fsMgr = new BdbFSMgr ;
   _es = new BdbErrorSignal(quiet);
   _quietMode = quiet;
}


BdbFSSupportClustH::BdbFSSupportClustH(const BdbFSSupportClustH& obj)
: _currentPath(obj._currentPath), 
  _currentDbName(obj._currentDbName)

{
   _domain           = obj._domain ;
   _fsMgr            = new BdbFSMgr ;
   _defFS            = obj._defFS ;
   _currentAuthLevel = obj._currentAuthLevel ;

    const char* n = obj._currentAuthName.head();
    if ( 0 == n ) {
        _currentAuthName = 0;
    } else {
        _currentAuthName.resize(strlen(n)+1);
        _currentAuthName = n;
    }

   _currentDomain    = obj._currentDomain ;
   _es               = new BdbErrorSignal(obj._es->mode());
   _quietMode        = obj._quietMode;
}

BdbFSSupportClustH::~BdbFSSupportClustH()
{
    if ( _fsMgr != 0 ) {
        delete _fsMgr ;
    }
    delete _es;
}




void 
BdbFSSupportClustH::setDbNameAndPath(const char* name, const char* path)
{
    _currentDbName.resize(strlen(name)+1);
    _currentDbName = name;
    
    _currentPath.resize(strlen(path)+1);
    _currentPath = path;
}



const BdbDomain* 
BdbFSSupportClustH::domain() const
{
    if ( _domain == 0 ) {
        _es->BdbFSig(BdbClusteringErrFunctionFailed,
                  "BdbFSSupportClustH::domain", "_domain not initialized") ;
    }
    return _domain ;
}

void 
BdbFSSupportClustH::refreshCurrentAuthLevel()
{
    _currentAuthLevel = domain()->authLevel() ; 
}

void 
BdbFSSupportClustH::refreshCurrentAuthName()
{
    const char* nnn = domain()->authName();
    const char* old = _currentAuthName.head();
    
    if ( 0 == nnn ) {
        if ( 0 != old ) {
            _currentAuthName.resize(0);
            _currentAuthName = 0;
        }
        return;
    }
    
    if ( 0 != old ) {
        if ( !strcmp(old, nnn) ) {
            return;
        }
    }
    
    _currentAuthName.resize(strlen(nnn)+1);
    _currentAuthName = nnn;
}


void 
BdbFSSupportClustH::refreshCurrentDomain()
{
    _currentDomain = domain()->domain() ;
}

d_Boolean 
BdbFSSupportClustH::authLevelChanged() const
{       
    return ( domain()->authLevel() != _currentAuthLevel ) ; 
}


d_Boolean 
BdbFSSupportClustH::authNameChanged() const
{
    const char* a = domain()->authName();
    const char* c = _currentAuthName.head();
    if ( a == 0 && c == 0 ) {
        return d_False;
    }
    if ( (a == 0 && c != 0) || (a != 0 && c == 0)  ) {
        return d_True;
    }
    
    return strcmp(a, c); 
}


d_Boolean 
BdbFSSupportClustH::domainChanged() const
{
    return ( domain()->domain() != _currentDomain ) ;
}

d_Boolean 
BdbFSSupportClustH::allowRemoteFS() const
{
    return ! _fsMgr->daemonDisabled() ; 
}

const char* 
BdbFSSupportClustH::currentHost()
{
    return fsMgr()->host(defFS()) ;
}

const char* 
BdbFSSupportClustH::baseDirectory()
{  
    return fsMgr()->baseDir(defFS()) ;  
}



BdbStatus
BdbFSSupportClustH::makeMetadataDir()
{
    const char* fn = "BdbFSSupportClustH::makeMetadataDir";

    if ( prepareMetadataSpec() != BdbcSuccess ) {
        return _es->BdbESig(BdbClusteringErrFunctionFailed, 
                            fn, "in prepareMetadataSpec") ;
    }

    // this will return with success immediatelly if the directory exists
    if ( fsMgr()->mkDir(currentPath(), d_False) != BdbcSuccess ) {
        return _es->BdbESig(BdbClusteringErrFunctionFailed,
                            fn, "in mkDir") ;
    }

    return BdbcSuccess ;
}



BdbStatus 
BdbFSSupportClustH::buildBaseDirectories(d_Boolean defaultFS)
{
    const char* fn = "BdbFSSupportClustH::buildBaseDirectories";

    // maybe the whole structure already exist...
    if ( prepareNameSpec(defaultFS) != BdbcSuccess ) {
        return _es->BdbESig(BdbClusteringErrFunctionFailed, 
                            fn, "in prepareNameSpec") ;
    }
    if ( fsMgr()->checkExist( currentPath(), defaultFS )) {
        return BdbcSuccess ;
    }

    // Make the path in one step
    if ( fsMgr()->mkDir(currentPath(), defaultFS) != BdbcSuccess ) {
        return _es->BdbESig(BdbClusteringErrFunctionFailed, 
                            fn, "in mkDir") ;
    }

    return BdbcSuccess ;
}

BdbStatus 
BdbFSSupportClustH::prepareBaseDirSpec(d_Boolean defaultFS)
{
    setDefFS(defaultFS) ;
    strcpyPath(baseDirectory()) ;
      
    return BdbcSuccess ;
}



BdbStatus
BdbFSSupportClustH::prepareMetadataSpec()
{
    const char* fn = "BdbFSSupportClustH::prepareMetadataDir";

    if ( prepareBaseDirSpec(d_False) != BdbcSuccess ) {
        return _es->BdbESig(BdbClusteringErrFunctionFailed,
                            fn, "in prepareBaseDirSpec");
    }

    strcatPath("metadata");

    char* str = ((BdbDomain*) domain())->getDBFSDomainRelativePath();
    char buf[16]; 
    strcpy(buf, domain()->shortDomainName(str));
    buf[4] = '\0';
    strcpyDbName (buf);

    return BdbcSuccess;
}






BdbStatus 
BdbFSSupportClustH::prepareDomainSpec(d_Boolean defaultFS)
{
    if ( prepareBaseDirSpec(defaultFS) != BdbcSuccess ) {
        return _es->BdbESig(BdbClusteringErrFunctionFailed, 
                 "BdbFSSupportClustH::prepareDomainSpec", "in prepareBaseDirSpec") ;
    }
    
    char* str = ((BdbDomain*) domain())->getDBFSDomainRelativePath() ;
    strcatPath ( str ) ;
 
    char buf[16] ; strcpy(buf, domain()->shortDomainName(str)) ;  buf[4] = '\0' ;
    strcpyDbName ( buf ) ;

    delete [] str;    
    return BdbcSuccess ;
}


BdbStatus 
BdbFSSupportClustH::prepareNameSpec(d_Boolean defaultFS)
{
  // Get the relative directory path & prefix name
  // from the domain's translation table.

    char* relativePath = ((BdbDomain*) domain())->getDBFSRelativePath() ;
    char* namePrefix   = ((BdbDomain*) domain())->getDBFSNamePrefix() ;

    if (( relativePath == (char*) 0 )||( namePrefix == (char*) 0 )) {

        delete [] relativePath ;
        delete [] namePrefix ;

        resetBoth() ;

        return _es->BdbESig(BdbClusteringErrFunctionFailed, 
                 "BdbFSSupportClustH::prepareNameSpec", "in getDBFSRelativePath") ;
    }
    
  // Initialize base directory (beginning of the) path.
 
    if ( prepareBaseDirSpec(defaultFS) != BdbcSuccess ) {
    
        delete [] relativePath ;
        delete [] namePrefix ;

        resetBoth() ;

        return _es->BdbESig(BdbClusteringErrFunctionFailed, 
                    "BdbFSSupportClustH::prepareNameSpec", "in prepareBaseDirSpec") ;
    }

  // Complete the path by concatenating the elative path by the end of
  // the base one.
  // Initialize the database name.

    strcatPath(relativePath) ;
    strcpyDbName(namePrefix) ;
    
    delete [] relativePath ;
    delete [] namePrefix ;

    return BdbcSuccess ;
}

BdbStatus 
BdbFSSupportClustH::prepareConfigDBSpec()
{
    const char* fn = "BdbFSSupportClustH::prepareConfigDBSpec";

    if ( prepareMetadataSpec() != BdbcSuccess ) {
        return _es->BdbESig(BdbClusteringErrFunctionFailed, 
                            fn, "in prepareNameSpec");
    }
    strcatDbName( "clustHintConfig" ) ;

    const char *clN = BdbClusterConfigMgr::getClusterName();
    if ( 0 != clN ) {
        strcatDbName(clN);
    }    

    return BdbcSuccess ;
}


BdbStatus 
BdbFSSupportClustH::verifyDiskSpace(d_Boolean* rebuildDb)
{
    const char* fn = "BdbFSSupportClustH::verifyDiskSpace";

    if ( ! allowRemoteFS()) {
        return BdbcSuccess;   // do not check the space for catalogFS
    }
    if ( ! fsMgr()->verifyDiskSpace(rebuildDb) ) {
        return _es->BdbESig(BdbClusteringErrFunctionFailed,
                            fn, "in verifyDiskSpace") ;
    }

    return BdbcSuccess ;
}

 

---

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

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