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

                 

---

/BdbDistTools/BdbDistFile.cc

Go to the documentation of this file.

//--------------------------------------------------------------------------
// File and Version Information:
//   $Id: BdbDistFile.cc,v 1.11 2002/01/26 04:28:54 objysrv Exp $
//
// Description:
//   BdbDistFile is a parser for the name of the databases.
//
// Environment:
//   Software developed for the BaBar Detector at the SLAC B-Factory.
//
// Author List:
//   Jean-Noel Albert                   Original Author
//
// Copyright Information:
//   Copyright (C) 1999
//
//------------------------------------------------------------------------

//-----------------------
// This Class's Header --
//-----------------------
#include "BdbDistTools/BdbDistFile.hh"

//-------------
// C Headers --
//-------------
extern "C" {
#include <stdio.h>
#include <strings.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <assert.h>
}

//-------------------------------
// Collaborating Class Headers --
//-------------------------------
#include "BdbAccess/BdbFSMgr.hh"
#include "BdbAccess/BdbCatalogFSHandler.hh"
#include "BdbAccess/BdbFileConfigSpec.hh"
#include "BdbAccess/BdbFileConfig.hh"
#include "BdbAccess/BdbFSMgr.hh"
#include "BdbEventStore/BdbEventStore.hh"
//  #include "BdbDistTools/BdbDistributionErrors.hh"
#include "BdbAccess/BdbTFileSystem.hh"

//----------------
// Constructors --
//----------------
BdbDistFile::BdbDistFile ()
    : _daemon(0), _fsmgr(0)
{
    _useDaemon = d_True;
    BdbDistFile::reset();
}

BdbDistFile::BdbDistFile (const char* filepath, const char* host, int port)
    : _daemon(0), _fsmgr(0)
{
    _useDaemon = d_True;
    parse(filepath, host, port);
}

//--------------
// Destructor --
//--------------
BdbDistFile::~BdbDistFile ()
{
    BdbDistFile::reset();
}

void BdbDistFile::reset()
{
    _filepath = "";
    _host = "";
    _port = 0;

    _directory = "";
    _filename = "";
    _suffix = "";
    _fsRoot = "";
    _fsSubDir = "";
    _checkedPath= false;

    _fsLoaded = d_False;
    delete _daemon;
    _daemon = 0;
    delete _fsmgr;
    _fsmgr= 0;

    BdbDbNameParser::reset();
}

//////////////////////////////////////////////////////////////////////////////////////

//----------
// Parser --
//----------
BdbStatus BdbDistFile::parse (const char* filepath, const char* host, int port)
{
    BdbDistFile::reset();

    // Save the received parameters
    _filepath = filepath;
    _host = host;
    _port = port;

    // Work on a writeable copy of the string
    char* locstr = new char[strlen(filepath) + 1];
    char* topstr = locstr;              // Save the top of the string (-> delete[])
    strcpy(locstr, filepath);

    // Extract the name of the host (if any)
    // Note: if a host name is given using "host", 
    //       the parsed name is not saved
    char* sep = rindex(locstr, ':');
    if (0 != sep) {
        *sep++ = '\0';
        char* eoh = index(locstr, ':'); // Can have 2 ':'...
        if (0 != eoh)
            *eoh = 0;
        if (0 == host || '\0' == *host)
            _host = locstr;
        locstr = sep;
    }

    // Extract the name of the directory (if any)
    sep = rindex(locstr, '/');
    if (0 != sep) {
        *sep++ = '\0';
        _directory = locstr;
        locstr = sep;
    }

    // Save the name of the file without the directory part
    _filename = locstr;

    // Search the suffix and save it
    if (0 != (sep = index(locstr, '.'))) {
        _suffix = sep;
        *sep = '\0';
    }

    // The rest of "locstr" is the system name of the database
    BdbStatus stt = BdbDbNameParser::parse(locstr);
    delete[] topstr;
    return stt;
}

//////////////////////////////////////////////////////////////////////////////////////

//-------------
// Accessors --
//-------------

BdbTString BdbDistFile::fullPath()
{
    if ("" != _host)
        return _host + ":" + _filepath;

    return _filepath;
}

BdbTString BdbDistFile::filePath()
{
    return _filepath;
}

BdbTString BdbDistFile::directory()
{
    return _directory;
}

BdbTString BdbDistFile::fileName()
{
    return _filename;
}

BdbTString BdbDistFile::extension()
{
    return _suffix;
}

//////////////////////////////////////////////////////////////////////////////////////

void BdbDistFile::loadFSInfo()
{
    _fsLoaded = d_True;

    d_Boolean initialized = d_False;
    _fsSubDir = "";
    _checkedPath= false;

    // Try to load the File Configuration
    BdbFileConfigSpec fsspec;
    BdbRef(BdbFileConfig) fc;

    d_Boolean haveFSConfig = 
        (BdbcSuccess == fsspec.initFileConfigObject(fc));

    // Try to found a FS in the database
    if (haveFSConfig) {
        BdbTFileSystem fs;
        if (BdbcSuccess == fc->lookupFS(fs, _filepath, _host)) {
            if ("" == _host)
                _host = fs.hostName();
            if (_port <= 0)
                _port = fs.portNr();

            _fsRoot = fs.dirName();
            initialized = d_True;
        }
    }

    // Try to see if the file is in the catalog
    if (! initialized) {
        BdbCatalogFSHandler catFS;
        if (strncmp(_filepath, catFS.baseDir(), strlen(catFS.baseDir())) == 0 &&
            ("" == _host || BdbTFileSystem::hostEqual(_host, catFS.host())))
        {
            if ("" == _host)
                _host = catFS.host();
            if (_port <= 0)
                _port = catFS.portNr();

            _fsRoot = catFS.baseDir();
            initialized = d_True;
        }
    }

    // Else ...
    if (! initialized) {
        if ("" == _host)
            _host = BdbTFileSystem::localHostName();
        _fsRoot = "";
    }

    // If a port number is defined but no daemon is present,
    //  try to create one (the user calls the constructor with a port number)
    //  if the file is not locally visible
    if (0 != _port && "" != _host && 0 == _daemon) {
//      if (access(_filepath, F_OK) != 0) {
        if (!BdbTFileSystem::hostEqual(_host, BdbTFileSystem::localHostName())) {
            if (_port < 0)
                _port = 3333;
            _daemon = new BdbPud(_host, _port);
        }
    }
}


// Hopefully the root will have been loaded from the file config
// or catalogue. If these failed, checkPathInfo guesses.
// We only try to guess if we need this info to prevent spurious warning
// messages.

void BdbDistFile::checkPathInfo()
{
    if (_checkedPath) return;
    _checkedPath= true;

    // Extract the subdirectory path from the file path
    if ("" != _fsRoot) {
        int len = strlen(_fsRoot);
        if (strncmp(_filepath, _fsRoot, len) == 0) {
            const char* subdir = &(_directory.data())[len];
            if (*subdir == '/')
                subdir++;
            _fsSubDir = subdir;
        } else {
            cerr << "BdbDistFile::loadFSInfo warning: " << _filepath
                 << " is not in " << _fsRoot << endl;
        }
    }

    // Panic: there is no valid FS Info - try to imagine what can be the root...
    else {
        // Try to found the domain name in the directory path
        BdbTString domaindir("/",  domainName(), "/");

        // Copy the directory to a local writeable buffer
        char* dir = new char[strlen(directory()) + 1];
        strcpy(dir, directory());

        // Iterate to find the domain directory
        char* subdir = dir;
        char* tmp;
        while ((tmp = strstr(subdir, domaindir)) != 0) {
            subdir = tmp+1;
        }

        if (dir != subdir) {
            *(subdir - 1) = '\0';
            _fsSubDir = subdir;
            _fsRoot = dir;
            cerr << "BdbDistFile::loadFSInfo warning: had to guess root "
                 << dir << endl;
        } else {  // Really a problem...
            cerr << "BdbDistFile::loadFSInfo error: unable to guess root directory in "
                 << dir << endl;
        }
        delete[] dir;
    }
}

BdbFSMgr* BdbDistFile::getFSMgr()
{
    if (!_fsmgr) {
        _fsmgr= new BdbFSMgr;
        _fsmgr->rebuildFSInfo(domainName(), authLevelName(), userGroupName(),
                              componentName());
    }
    return _fsmgr;
}

//////////////////////////////////////////////////////////////////////////////////////

void BdbDistFile::useDaemon(d_Boolean mode)
{
    _useDaemon = mode;
}

BdbStatus  BdbDistFile::setDaemon (const char* host, int port)
{
    if ((0 == host || '\0' == *host) && "" == _host &&
        0 == port && 0 == _port)
        return BdbcError;               // Invalid host & port

    if (0 != host && '\0' != *host)
        _host = host;
    if (0 != port)
        _port = port;

    BdbPud* daemon = new BdbPud(_host, _port);
    if (0 == daemon)
        return BdbcError;

    if (0 != _daemon)
        delete _daemon;

    _daemon = daemon;
    return BdbcSuccess;
}

//////////////////////////////////////////////////////////////////////////////////////

d_Boolean BdbDistFile::hasDaemon()
{
    return (0 != _daemon);
}

BdbTString BdbDistFile::host()
{
    if ("" == _host && !_fsLoaded)
        loadFSInfo();
    return _host;
}

int BdbDistFile::pudPort ()
{
    if (0 == _port && !_fsLoaded)
        loadFSInfo();
    return _port;
}

BdbTString BdbDistFile::fsRoot()
{
    if ("" == _fsRoot && !_fsLoaded)
        loadFSInfo();
    checkPathInfo();

    return _fsRoot;
}

BdbTString BdbDistFile::fsSubDir()
{
    if ("" == _fsSubDir && !_fsLoaded)
        loadFSInfo();
    checkPathInfo();
    return _fsSubDir;
}

//////////////////////////////////////////////////////////////////////////////////////

d_Boolean BdbDistFile::isFileExist()
{
    if (!_fsLoaded)
        loadFSInfo();

    if (_useDaemon && 0 != _daemon)
        return _daemon->checkExist(_filepath);

    return getFSMgr()->checkExist(_filepath);
}

d_Boolean BdbDistFile::isHostEqual(BdbTString host)
{
    if (!_fsLoaded)
        loadFSInfo();

    return BdbTFileSystem::hostEqual(_host, host);
}

BdbStatus BdbDistFile::fileSize(off_t& size)
{
#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
    if (!_fsLoaded)
        loadFSInfo();

    if (_useDaemon && 0 != _daemon)
        return _daemon->getFileSize(_filepath, size);

    return getFSMgr()->getFileSize(_filepath, size);
}

BdbStatus BdbDistFile::modificationDate(time_t& mtime)
{
    if (!_fsLoaded)
        loadFSInfo();

    if (_useDaemon && 0 != _daemon)
        return _daemon->getModificationDate(_filepath, mtime);

    return getFSMgr()->getModificationDate(_filepath, mtime);
}

BdbStatus BdbDistFile::chmodRead()
{
    if (!_fsLoaded)
        loadFSInfo();

    if (_useDaemon && 0 != _daemon)
        return _daemon->chmodRead(_filepath);

    return getFSMgr()->chmodRead(_filepath);
}

BdbStatus BdbDistFile::chmodWrite()
{
    if (!_fsLoaded)
        loadFSInfo();

    if (_useDaemon && 0 != _daemon)
        return _daemon->chmodWrite(_filepath);

    return getFSMgr()->chmodWrite(_filepath);
}

BdbStatus BdbDistFile::mkDir()
{
    if (!_fsLoaded)
        loadFSInfo();

    if (_useDaemon && 0 != _daemon)
        return _daemon->mkDir(_directory);

    return getFSMgr()->mkDir(_directory);
}

BdbStatus BdbDistFile::rename (BdbDistFile& to)
{
    if (!_fsLoaded)
        loadFSInfo();

    if (!BdbTFileSystem::hostEqual(_host, to._host))
        return BdbcError;
//      return BdbSignal(BdbcUserError, BdbDistributionNoHostOp, 0,
//                       "BdbDistFile::rename");

    if (_useDaemon && 0 != _daemon)
        return _daemon->moveFile(_filepath, to._filepath);

    return getFSMgr()->moveFile(_filepath, to._filepath);
}

BdbStatus BdbDistFile::copy (BdbDistFile& to)
{
    if (!_fsLoaded)
        loadFSInfo();

    if (BdbTFileSystem::hostEqual(_host, to._host))
        return BdbcError;
//      return BdbSignal(BdbcUserError, BdbDistributionHostNotSup, 0,
//                       "BdbDistFile::copy");

    if (_useDaemon && 0 != _daemon)
        return _daemon->copyFile(_filepath, to._filepath);

    return getFSMgr()->copyFile(_filepath, to._filepath);
}

BdbStatus BdbDistFile::remove ()
{
    if (!_fsLoaded)
        loadFSInfo();

    if (_useDaemon && 0 != _daemon)
        return _daemon->rmFile(_filepath);

    return getFSMgr()->rmFile(_filepath);
}

//////////////////////////////////////////////////////////////////////////////////////

BdbStatus BdbDistFile::tdf(char* buffer, int count)
{
    // Check if the FS Info are valid
    if ("" == fsRoot().data() || "" == fsSubDir().data()) {
        cerr << "Invalid FS Info - can't found the FS Root or SubDir" << endl;
        abort();
    }

#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
    char internal[1024];
    BdbTString format;

    format = "FILE %s NUMBER %d FILE %s DIR %s HOST %s SIZE %f";

    if (sizeof(off_t) > sizeof(int)) {
        // DEC/OSF - stat.st_size is a 64-bits long int (no %lld defined)
        if (sizeof(off_t) == sizeof(long))
            format += " FULLSIZE %ld";

        // Sun/Solaris with Large File option - stat.st_size is a 64-bits long int
        //      %d & %ld are for 32-bits int & long
        //      %lld is for 64-bits long long int
        else
            format += " FULLSIZE %lld";
    }
    else {
        // 32-bits UNIX system
        format += " FULLSIZE %d";
    }

    format += " TIME %d ROOT %s SUBDIR %s";

    off_t size = 0;
    fileSize(size);

    time_t mtime = 0;
    modificationDate(mtime);

    int blen = sprintf(internal, format.data(), 
                       name().data(), number(), 
                       fileName().data(), directory().data(), host().data(),
                       size/1024./1024., size, mtime,
                       fsRoot().data(), fsSubDir().data());
    if (blen >= count)
        return BdbcError;       // Can save the TDF

    strcpy(buffer, internal);
    return BdbcSuccess;
}

 

---

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

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