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

                 

---

/BdbAccess/BdbFSMgr.cc

Go to the documentation of this file.

//------------------------------------------------------------------------------
// File:
//      BdbFSMgr.cc
//
// Description:
//      Class BdbFSMgr implementation. The class provides an API to all
//      the file system operations
//
// 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
//
//------------------------------------------------------------------------------

//-----------------------
// This Class's Header --
//-----------------------
#ifndef BDBFSMGR_HH
#include "BdbAccess/BdbFSMgr.hh"
#endif


//-------------------------------
// Collaborating Class Headers --
//-------------------------------
#include "BdbApplication/BdbDebug.hh"
#include "BdbAccess/BdbClusterConfigMgr.hh"
#include "BdbAccess/BdbFileConfigSpec.hh"
#include "BdbAccess/BdbDomainSpec.hh"
#include "BdbAccess/BdbCatalogFSHandler.hh"
#include "BdbPud/BdbPud.hh"
#include "BdbAccess/BdbAccessErrors.hh"
#include "BdbAccess/BdbFileSystem.hh"
#include "BdbAccess/BdbClustHintSetupMgr.hh"


//-------------
// C Headers --
//-------------
extern "C" {
#include <unistd.h>       /* symlink, geteuid, access */
#include <stdlib.h>       /* system                  */
#include <sys/types.h>    /* before stat and statvfs */
#include <sys/stat.h>     /* umask, mkdir            */
#include <grp.h>          /* getgrnam                */
#include <sys/statvfs.h>  /* statvfs                 */
#include <assert.h>
int statvfs(const char *, struct statvfs *) ; /* This line is required by DEC C++ but does no harm for other platforms */
}

//---------------
// C++ Headers --
//---------------
#include <fstream.h>


d_Boolean BdbFSMgr::_neverUseDaemon  = d_True ;   // by default daemons are disabled. If rebuildFSInfo() 
                                                         // and finish with success daemons are enabled

// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
//
//   C O N S T R U C T O R    /    D E S T R U C T O R
//
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%


BdbFSMgr::BdbFSMgr()
{
    _fsGroup       = 0;
    _currentFSNr   = 0;

}



BdbFSMgr::~BdbFSMgr()
{}



// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
//
//     F I L E   S Y S T E M   O P E R A T I O N S
//
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%


BdbStatus BdbFSMgr::copyFile(const char* source, const char* target, d_Boolean anyDaemon)
{
    if ( daemonDisabled() ) {
        ooVString cmd = "cp " ;
        cmd += source ; cmd += " " ; cmd += target ;
        // COUT1 << "No daemon, cmd: " << cmd.head() << endl ;

        if ( system(cmd.head()) != 0 )
            return BdbSignal(BdbcUserError, BdbAccessErrFunctionFailed, 
                   0, "BdbFSMgr::copyFile()-noDaemon", cmd.head()) ;

        return BdbcSuccess ;
    }
        
        return selectDaemon(anyDaemon)->copyFile(source, target) ;
}


BdbStatus BdbFSMgr::moveFile(const char* source, const char* target, d_Boolean anyDaemon)
{
    if ( daemonDisabled() ) {
        ooVString cmd = "mv " ;
        cmd += source ; cmd += " " ; cmd += target ;
        // COUT1 << "No daemon, cmd: " << cmd.head() << endl ;

        if ( system(cmd.head()) != 0 )
            return BdbSignal(BdbcUserError, BdbAccessErrFunctionFailed, 
                             0, "BdbFSMgr::moveFile()-noDaemon", cmd.head()) ;

        return BdbcSuccess ;
    }
        
        return selectDaemon(anyDaemon)->moveFile(source, target) ;
}


BdbStatus BdbFSMgr::checkAvailSpace(const char* path, d_ULong minSpaceNeeded, 
                                    d_Boolean* isAvailable, d_Boolean anyDaemon)
{
    *isAvailable = d_False ;
        
    if ( daemonDisabled() )
        {  struct statvfs buf ;
        if ( statvfs(path, &buf) != 0 )
            return BdbSignal(BdbcUserError, BdbAccessErrFunctionFailed, 0, 
                             "BdbFSMgr::checkAvailSpace", "in statvfs") ;
        // COUT1 << "No daemon, disk: " << path << " has available: " 
        //       << ((buf.f_bsize / 1024) * buf.f_bfree) 
        //               << " KB, min: " << minSpaceNeeded << " KB" << endl ;

        if ( ((buf.f_bsize / 1024) * buf.f_bfree) >= minSpaceNeeded ) {
            *isAvailable = d_True;
        }

        return BdbcSuccess ;
   }

        
        return selectDaemon(anyDaemon)->checkAvailSpace(path, minSpaceNeeded, isAvailable) ;
}


BdbStatus BdbFSMgr::chmodWrite(const char* fileName, d_Boolean anyDaemon)
{
   if ( daemonDisabled() )
      return changeFileMode(0664, fileName) ;

        return selectDaemon(anyDaemon)->chmodWrite(fileName) ;
}


BdbStatus BdbFSMgr::chmodRead(const char* fileName, d_Boolean anyDaemon)
{
   if ( daemonDisabled() )
                return changeFileMode(0444, fileName) ;
        
        return selectDaemon(anyDaemon)->chmodRead(fileName) ;
}


BdbStatus BdbFSMgr::checkExist(const char* fileName, d_Boolean anyDaemon)
{
   if ( daemonDisabled() )
   {  if ( access(fileName, F_OK) == 0 )
         return BdbcSuccess ;
      return BdbcError ;
   }

   return selectDaemon(anyDaemon)->checkExist(fileName) ;
}


BdbStatus BdbFSMgr::rmFile(const char* fileName, d_Boolean anyDaemon)
{
        if ( daemonDisabled() )
   {  if ( remove(fileName) == 0 )
                   return BdbcSuccess ;
           return BdbcError ;
   }

        return selectDaemon(anyDaemon)->rmFile(fileName) ;
}


BdbStatus 
BdbFSMgr::createFile(const char* fileName, d_Boolean anyDaemon)
{
    if ( daemonDisabled() ) {
        ofstream f(fileName);
        f.close();
        return BdbcSuccess;
    }

    return selectDaemon(anyDaemon)->createFile(fileName) ;
}


BdbStatus BdbFSMgr::mkDir(const char* dirName, d_Boolean anyDaemon)
{
    if ( checkExist(dirName, anyDaemon) ) {
        // COUT1 << "directory: " << dirName << " already existed" << endl ;
        return BdbcSuccess ;
        }

    char oneLevelUpDir[256], *tmp;

    strcpy( oneLevelUpDir, dirName );
    tmp = strrchr( oneLevelUpDir, '/' );

    if( tmp == oneLevelUpDir ) // doesn't want to create root directory
        return BdbSignal(BdbcUserError, BdbAccessErrFunctionFailed, 0, "BdbFSMgr::mkDir", dirName) ;                    

    *tmp = '\0'; // cut one level

    BdbStatus result = mkDir( oneLevelUpDir, anyDaemon );
    if( result != BdbcSuccess )
        return result;

        if ( daemonDisabled() ) {
        if ( checkExist(dirName) ) {
            // COUT1 << "directory: " << dirName << " already existed" << endl ;
            return BdbcSuccess ;
        }

        if ( mkdir(dirName, 0x3FD) != 0 )
            return BdbSignal(BdbcUserError, BdbAccessErrFunctionFailed, 0, "BdbFSMgr::mkDir", dirName) ;                        

        if ( chmod(dirName, 0775) != 0 )
            return BdbSignal(BdbcWarning, BdbAccessErrCommandFailed, 0, "BdbFSMgr::mkDir", "chmod", dirName) ;
                
        struct group* grStr = getgrnam(BdbDomain::groupName()) ;  // get the number of the group (bfactory at SLAC)

        if ( grStr != 0 ) {
            int owner = -1 ; // indicates that the owner is not changed
            chown(dirName, (uid_t)owner, grStr->gr_gid) ;
        }
        // do not check the returned status because on AFS it can fail.
        // At SLAC only authusers are allowed to run chgrp.
        // On AFS acl metters, not the group write permissions.

        // COUT1 << "new directory: " << dirName << endl ;
        return BdbcSuccess ;
    }

    return selectDaemon(anyDaemon)->mkDir(dirName) ;
}


BdbStatus BdbFSMgr::rmDir(const char* dirName, d_Boolean anyDaemon)
{
        if ( daemonDisabled() )
        {       if ( rmdir(dirName) == 0 )
                        return BdbcSuccess ;
                return BdbcError ;
        }

        return selectDaemon(anyDaemon)->rmDir(dirName) ;
}


BdbStatus BdbFSMgr::changeFileMode(int mode, const char* fileName) const
{
   struct stat buf ;
        if ( stat(fileName, &buf) == 0)          // check if owner of a file == owner of a current process
           if ( buf.st_uid != geteuid() )        // if yes, chmod without daemon
                   return BdbSignal(BdbcUserError, BdbAccessErrNotAnOwner, 0, "BdbFSMgr::changeFileMode", fileName) ;                      

        if ( chmod(fileName, mode) != 0 )
                return BdbSignal(BdbcWarning, BdbAccessErrCommandFailed, 0, "BdbFSMgr::changeFileMode", "chmod", fileName) ;
        
        // COUT2 << "standard chmod: " << mode << fileName << " suceeded" << endl ;

        return BdbcSuccess ;
}


BdbStatus BdbFSMgr::getFileSize(const char* fileName, 
                                off_t& theSize, 
                                d_Boolean anyDaemon)
{
 #if defined(BABAR_LARGEFILE) && defined(_FILE_OFFSET_BITS)
    /* Check if the includes are called in the correct order */
    assert((sizeof(off_t)*8) == _FILE_OFFSET_BITS);
#endif
    const char* fn = "BdbFSMgr::getFileSize";
    
    theSize = 0 ;
    
    if ( daemonDisabled() ) {
        struct stat statbuf;
        if (stat(fileName, &statbuf) == 0) {
            theSize = statbuf.st_size;
            return BdbcSuccess;
        }
        return BdbSignal(BdbcWarning, BdbAccessErrCommandFailed, 
                         0, fn, "getFileSize", fileName);
    }
    
    return selectDaemon(anyDaemon)->getFileSize(fileName, theSize);
}

BdbStatus BdbFSMgr::getModificationDate(const char* fileName, 
                                        time_t& stime, 
                                        d_Boolean anyDaemon)
{
    const char* fn = "BdbFSMgr::getModificationDate";
    
    stime = 0 ;
    
    if ( daemonDisabled() ) {
        struct stat statbuf;
        if (stat(fileName, &statbuf) == 0) {
            stime = statbuf.st_mtime;
            return BdbcSuccess;
        }
        return BdbSignal(BdbcWarning, BdbAccessErrCommandFailed, 
                         0, fn, "getModificationDate", fileName);
    }
    
    return selectDaemon(anyDaemon)->getModificationDate(fileName, stime);
}



BdbStatus
BdbFSMgr::purgeMigrateFile(const char* path, const char* params)
{
    if ( daemonDisabled() ) {
        COUT1 << "Daemon disabled, puring/migration not supported "
              << "for local file systems" << endl;
        return BdbcError;
    }

    return selectDaemon(d_True)->purgeMigrateFile(path, params);
}



// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
//
//       M A N A G I N G   M U L T I P L E   F S
//
//       The functions in this block should be never 
//       called if fs-info is not loaded
//
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%


// If this function has been called it means fs-related info has been 
// loaded to the configuration database. 
// If this function has never been called, daemons are not used and 
// all the data is placed on the catalog FS
BdbStatus 
BdbFSMgr::rebuildFSInfo(const char* domainName, 
                        const char* authLevelName,
                        const char* authName, 
                        const char* compName)
{
    const char* fn = "BdbFSMgr::rebuildFSInfo";

        // ----- initialize catalog daemon -----
        if ( BdbCatalogFSHandler::instance()->update() != BdbcSuccess ) {
        return BdbSignal(BdbcUserError, BdbAccessErrFunctionFailed, 0, fn, 
                         "in updatecatalogDaemon->update");
    }
   
   if ( compName == 0 ) {
       return BdbSignal(BdbcUserError, BdbAccessErrNameNotValid, 0, fn);
   }

   BdbClustHintSetupMgr* chsMgr = BdbClustHintSetupMgr::instance();
   if ( BdbcSuccess != chsMgr->initCHSetupObj() ) {
       return BdbcError;
   }
   if ( ! chsMgr->fcLoaded() ) {
       return BdbcError;
   }

   chsMgr->setStrings(BdbClusterConfigMgr::getClusterName(), 
                      domainName, authLevelName, authName, compName);

   _neverUseDaemon = d_False;

    // ----- initialize default dameon -----
    if ( ! firstAvailableDisk() ) {
        _neverUseDaemon = d_True;
        return BdbSignal(BdbcUserError, BdbAccessErrFunctionFailed, 0, fn, 
                         "in firstAvailableDisk");
    }

    return BdbcSuccess;
}


BdbStatus 
BdbFSMgr::firstAvailableDisk(d_ULong currentGlobalFSNr)
{
    const char* fn = "BdbFSMgr::firstAvailableDisk" ;

    char* groupName = 0;
    vector<BdbTFileSystem*>* vector = 0;
    
    if ( BdbcSuccess != BdbClustHintSetupMgr::instance()->retrieveFileSystems(groupName, vector) ) {
        _fsGroup = 0;
        return BdbSignal(BdbcUserError, BdbAccessErrFunctionFailed, 
                         0, fn, "retrieveFileSystems");
    }
    
    d_ULong size = vector->size();

    d_Boolean FSFound = d_False;
    d_Boolean newLoop = d_False;
    
    do {
        for ( _currentFSNr = 0; _currentFSNr<size ; _currentFSNr++ ) {
            BdbTFileSystem tSys = *((*vector)[_currentFSNr]);

            // initialize any daemon
            if ( _anyFSHandler.update(&tSys) != BdbcSuccess ) {
                for ( int i=0 ; i<size ; i++) {
                    delete (*vector)[i];
                }
                delete vector;
                _fsGroup = 0;
                            return BdbSignal(BdbcUserError, BdbAccessErrFunctionFailed, 
                                 0, fn, "in default->update") ;
            }

                    if ( isAvailableSpace() ) {
                FSFound = d_True ;
                COUT1 << "Switching to " << tSys.hostName() 
                      << "::" << tSys.dirName() << endl ;
                for ( int i=0 ; i<size ; i++) {
                    delete (*vector)[i];
                }
                delete vector;
                _fsGroup = groupName;
                delete [] groupName;
                            return BdbcSuccess ; // the only successful exit 
            }
        }
        if ( ! newLoop ) {
            _currentFSNr = 0 ;
            newLoop = d_True ;
        } else {
            _fsGroup = 0;
            return BdbSignal(BdbcFatalError, BdbAccessErrNoMoreSpace, 0, fn) ;
        }
    } while ( ! FSFound ) ;

    for ( int i=0 ; i<size ; i++) {
        delete (*vector)[i];
    }
    delete vector;
    _fsGroup = 0;

    return BdbcError;  // should never reach this point
}





// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
//
//        M A N A G I N G   F R E E   S P A C E
//
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

BdbStatus BdbFSMgr::verifyDiskSpace(d_Boolean* diskChanged)
{
        if ( ! isAvailableSpace() )
        {       _currentFSNr ++ ;
      if ( ! firstAvailableDisk() )
                        return BdbSignal(BdbcUserError, BdbAccessErrFunctionFailed, 0, "BdbFSMgr::verifyDiskSpace", "in firstAvailableDisk") ;  
                *diskChanged = d_True ;
        }
        return BdbcSuccess ;
}



d_Boolean BdbFSMgr::isAvailableSpace()
{
   if ( daemonDisabled() )
        {       struct statvfs buf ;
                if ( statvfs(baseDir(), &buf) != 0 )
                {       BdbSignal(BdbcUserError, BdbAccessErrFunctionFailed, 0, "BdbFSMgr::isAvailableSpace() in statvfs", baseDir()) ;
                        return d_False ;
                }
      
                if ( getenv("BDBDEBUG2") != 0 )
                        COUT2 << "disk: " << baseDir() << " has available: " << ((buf.f_bsize / 1024) * buf.f_bfree) 
                  << " KB, min: " << minDiskSpace() << " KB" << endl ;

                return ((buf.f_bsize / 1024) * buf.f_bfree) >= minDiskSpace() ;
        }


        d_Boolean isAvailable = d_False ;

   if ( ! selectDaemon(d_True)->checkAvailSpace(baseDir(), minDiskSpace(), &isAvailable) )
        {       BdbSignal(BdbcUserError, BdbAccessErrFunctionFailed, 0, "BdbFSMgr::isAvailableSpace", "in daemon.checkAvailSpace") ;
                return d_False ;
        }

        return isAvailable ;
}


// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
//
//           S E L E C T    M E T H O D S
//
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%


BdbPud* 
BdbFSMgr::selectDaemon(d_Boolean anyDaemon)
{
        if ( anyDaemon && ! daemonDisabled() ) {
        if ( ! _anyFSHandler.isInitialized() ) {
            if ( ! firstAvailableDisk() ) { // this will make all the initialization
                BdbSignal(BdbcUserError, BdbAccessErrFunctionFailed, 
                          0, "BdbFSMgr::selectDaemon", "in firstAvailableDisk");
                                return 0;
            }
        }
        return _anyFSHandler.daemon();
    }
    return BdbCatalogFSHandler::instance()->daemon();
}



const char* 
BdbFSMgr::baseDir(d_Boolean anyFS)
{
    if ( ! anyFS || daemonDisabled() ) {
        return BdbCatalogFSHandler::instance()->baseDir();
    }
    

        if ( ! _anyFSHandler.isInitialized() ) {
        if ( ! firstAvailableDisk() ) { // this will make all the initialization
                        BdbSignal(BdbcUserError, BdbAccessErrFunctionFailed, 
                      0, "BdbFSMgr::baseDir", "in firstAvailableDisk");
                        return 0;
                }
    }
        
   return _anyFSHandler.baseDir();
}


const char* 
BdbFSMgr::host(d_Boolean anyFS)
{
    if ( ! anyFS || daemonDisabled() ) {
        return BdbCatalogFSHandler::instance()->host() ;
    }
    

        if ( ! _anyFSHandler.isInitialized() )
        if ( ! firstAvailableDisk() ) // this will make all the initialization
                {       BdbSignal(BdbcUserError, BdbAccessErrFunctionFailed, 0, "BdbFSMgr::host", "in firstAvailableDisk") ;
                        return 0 ;
                }
        
   return _anyFSHandler.host() ;
}


d_ULong  
BdbFSMgr::minDiskSpace(d_Boolean anyFS)
{
    if ( ! anyFS || daemonDisabled() ) {
        return BdbCatalogFSHandler::instance()->minDiskSpace() ;
    }
    
        if ( ! _anyFSHandler.isInitialized() )
        if ( ! firstAvailableDisk() ) // this will make all the initialization
                {       BdbSignal(BdbcUserError, BdbAccessErrFunctionFailed, 0, "BdbFSMgr::minDiskSpace", "in firstAvailableDisk") ;
                        return 0 ;
                }
        
   return _anyFSHandler.minDiskSpace() ;
}




// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
//
//      I N D E P E N D E N T      M E T H O D S
//
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%



// the methods below are independed, they create and 
// configure the BdbPud object on the fly

/**
 **    BdbFSMgr::getFDFilePath
 **    The first argument: bootFilePath must have the 
 **    following format: hostName::fullPath
 **
 **    The second argument is an address of the string, which
 **    will be set to the federated database path (taken from the 
 **    boot file. The function uses the pud daemon (it requires
 **    it to be running on the host specified in the bootFilePath.
 **    The function talks to port number 3333 (hardcoded!!!)
 **/

BdbStatus
BdbFSMgr::getFDFilePath(const char* bootFilePath, 
                        char*& theFDPath) const
{
    const char* fn = "BdbFSMgr::getFDFilePath";
    
    // find "::"        
    int pos = 0;
    while ( *(bootFilePath+pos) != '\0' && *(bootFilePath+pos) != ':') {
        pos++;
    }

    if ( *(bootFilePath+pos) == '\0' || *(bootFilePath+pos+1) != ':') {
        return BdbSignal(BdbcUserError, BdbAccessErrInvBootFile, 0, fn);
    }

    // set the hostName and thePath
    char* hostName = new char [pos+1] ;
    strncpy(hostName, bootFilePath, pos);
    hostName[pos] = '\0';

    char* thePath = new char [strlen(bootFilePath) - pos + 1];
    strcpy(thePath, bootFilePath+pos+2);
    
    // configure the daemon
    BdbPud theDaemon(hostName, getPortNr(hostName));
    
    // do the real job
    BdbStatus retV = theDaemon.getFDFilePath(thePath, theFDPath);
    
    delete [] hostName;
    delete [] thePath;

    return retV;
}



/**
 **  BdbFSMgr::getPortNr
 **
 **  The function determines the pud demon's port number on the 
 **  "host". The default value for all hosts is 3333. It can be 
 **  overwritten using the environment variable "PUD_PORT_NR_HOSTNAME"
 **  where HOSTNAME is the name of the host.
 **
 **  Example: PUD_PORT_NR_objyserv2.slac.stanford.edu 3334
 **  Note, that PUD_PORT_NR_objyserv2.slac.stanford.edu and 
 **  PUD_PORT_NR_objyserv2 are not the same.
 **/  
 
int
BdbFSMgr::getPortNr(const char* host) const
{
    // check if the default value of the port number 
    // has not been overwritten
    
        // build the name of the environment variable
    char* envVarName = new char [strlen(host)+16];
    strcpy(envVarName, "PUD_PORT_NR_");
    strcat(envVarName, host);

    char* portStr = getenv(envVarName);
    
    delete [] envVarName;
    
    if ( portStr != (char*) 0 ) {
        int portNr = atoi(portStr);
        if ( portNr > 0 ) {
            COUT2n << "BdbFSMgr::getPortNr: portNr = " << portNr << endl ;
            return portNr;
        }
    }
    COUT2n << "BdbFSMgr::getPortNr: portNr = 3333" << endl ;
 
    return 3333;  // default value
}
    

 

---

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

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