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

                 

---

/BdbDistTools/BdbDbImport.cc

Go to the documentation of this file.

//--------------------------------------------------------------------------
// File and Version Information:
//      $Id: BdbDbImport.cc,v 1.32.2.2 2002/07/23 20:19:01 objysrv Exp $
//
// Description:
//      BdbDbImport copies and attaches to the federation databases
//      imported by one of the "bdbXxxZzzz" scripts.
//
// Usage
//      BdbDbImport [options]
//
// Options
//      -[no]checksize: enable/disable the file size checking (def: enabled)
//      -delay <mn>: delay to wait to attach the databases
//      -forced: force the attach of the database bypassing ooattachdb
//      -group <name>: move the databases to this group (def: not changed)
//      -ignore: ignore the errors and try to continue (def: stop)
//      -lftp: use FTP to locally copy the files
//      -lock: create HPSS lock file
//      -quiet: don't print anything
//      -[no]read: turn the files read-only
//      -replace: replace existing bases and collections
//      -verbose: print all the possible information
//      -[no]wait: try to lock the database before replacing it
//      -bdb{xfr,sfcp,scp,bbcp}: use bdb* family to locally copy the files
//      -xfr: use ooss_xfr to locally copy the files
//      -fget: use ooss_fget to locally copy files
//      -cmdpath : use this path to copy command
//      -remapdbid : assign a db new dbid from target's local range and change it's name accordingly. the argument is a source federation's FD_NUMBER.
//
// Commands
//      BdbDbImport reads commands to execute from the standard input
//      The supported commands are:
//              IMPORT <db-sysname> <dbid> <filename> <subdir> <fullsize>
//              COLLECTION <collection> <oid>
//
//      By default, the databases are turned in write mode for an import
//      and in read-only mode for a link
//
// Environment:
//      Software developed for the BaBar Detector at the SLAC B-Factory.
//
// Author List:
//      Jean-Noel Albert        First author
//
// Modification List:
//      Jna     July 1999       Remove the "LINK" command (not used)
//                              Attach the database using "BdbDistInstall"
//                              Support for the Large Files
//      DB      March 2000      Add option -lock to create HPSS lock files
//      Artem   July 2000       Add opt -printtdfline to print some more info
//
// Copyright Information
//      Copyright (C) 1999-2000
//
//------------------------------------------------------------------------

#define HAS_UNREGISTERDB 1

//-----------------------
// BaBar Headers --
//-----------------------
#include "BaBar/BaBar.hh"
#include "BdbUtil/Bdb.hh"
#include "BdbUtil/BdbTString.hh"
#include "BdbEventStore/BdbEventStore.hh"
#include "BdbAccess/BdbFSMgr.hh"
//  #include "BdbEventStore/BdbDbName.hh"
#include "BdbTrees/BdbDbRegistrator.hh"
#include "BdbTrees/BdbTreeNode.hh"
#include "BdbAccess/BdbDbTreeSingleton.hh"
#include "BdbAccess/BdbDbInfo.hh"
#include "BdbTrees/BdbTreeAccess.hh"
#include "BdbDistTools/BdbDistDatabase.hh"
#include "BdbDistTools/BdbDistFile.hh"
#include "BdbDistTools/BdbDistMessage.hh"
#include "BdbEvent/BdbEvent_001.hh"
#include "BdbEventStore/BdbAbsCollectionT.hh"
#include "BdbApplication/BdbDomain.hh"
#include "BdbDistribution/BdbDbIdManager.hh"
//---------------
// C++ Headers --
//---------------
#include <iostream.h>

//------------
// C Header --
//------------

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

//-----------------------------------------------------------------------
// Local Macros, Typedefs, Structures, Unions and Forward Declarations --
//-----------------------------------------------------------------------
#define SUCCESS 0
#define ERROR   1

//---------------
// Local flags --
//---------------
static d_Boolean checkonlyFlag = d_False;
static d_Boolean checkSizeFlag = d_True;
static d_Boolean forcedFlag = d_False;
static d_Boolean ignoreFlag = d_False;
static d_Boolean lftpFlag = d_False;
static d_Boolean bdbxfrFlag = d_False;
static d_Boolean bdbsfcpFlag = d_False;
static d_Boolean bdbbbcpFlag = d_False;
static d_Boolean bdbscpFlag = d_False;
static d_Boolean xfrFlag = d_False;
static d_Boolean fgetFlag = d_False;
static char* cmdpath = 0;
static char* remapDbid = 0;
static d_Boolean replaceFlag = d_False;
static d_Boolean quietFlag = d_False;
static enum {Default, ReadOnly, ReadWrite} readFlag = Default;
static d_Boolean verboseFlag = d_False;
static char* groupname = 0;
static int waitDelay = -1;              // No limit
static d_Boolean waitFlag = d_False;
static d_Boolean lockFlag = d_False;     // By default do not create HPSS lock file
static d_Boolean printtdflineFlag = d_False; // if true - print tdf line for each collections.

//-------------------
// Local variables --
//-------------------
static BdbEventStore* estore;

//--------------------
// Working routines --
//--------------------
static inline void printtdfline (const char* name, const char* collid,
                                 const int events, const int select)
{
  if (printtdflineFlag) {
    cout << "COLLECTION " << name << " COLLID " << collid+1 <<
      " EVENTS " << events << " SELECT " << select << endl;
  }
}

static inline void message (const char* s0=0, const char* s1=0,
                            const char* s2=0, const char* s3=0,
                            const char* s4=0, const char* s5=0,
                            const char* s6=0, const char* s7=0,
                            const char* s8=0, const char* s9=0)
{
  BdbDistMessage::message (s0, s1, s2, s3, s4, s5, s6, s7, s8, s9);
}

static inline void verbose (const char* s0=0, const char* s1=0,
                            const char* s2=0, const char* s3=0,
                            const char* s4=0, const char* s5=0,
                            const char* s6=0, const char* s7=0,
                            const char* s8=0, const char* s9=0,
                            const char* sa=0, const char* sb=0)
{
  BdbDistMessage::verbose (s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sa, sb);
}

static inline void warning (const char* s0=0, const char* s1=0,
                            const char* s2=0, const char* s3=0,
                            const char* s4=0, const char* s5=0,
                            const char* s6=0, const char* s7=0,
                            const char* s8=0, const char* s9=0,
                            const char* sa=0, const char* sb=0)
{
  BdbDistMessage::warning (s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sa, sb);
}

static inline void fail    (const char* s0=0, const char* s1=0,
                            const char* s2=0, const char* s3=0,
                            const char* s4=0, const char* s5=0,
                            const char* s6=0, const char* s7=0,
                            const char* s8=0, const char* s9=0,
                            const char* sa=0, const char* sb=0)
{
  BdbDistMessage::warning (s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sa, sb);
  exit (ERROR);
}

static inline const char* itoa (long i) {
  return BdbDistMessage::itoa (i);
}

// Define the wait mode for the following operations
static void setWaitMode()
{
    if (!waitFlag) {
        BdbDomain::activeInstance()->setLockWait(BdbcNoWait);
    }
    else if (waitDelay < 0) {
        BdbDomain::activeInstance()->setLockWait(BdbcWait);
    }
    else {
        BdbDomain::activeInstance()->setLockWait(waitDelay);
    }
}

// Send the command to execute to the shell
//      Signal the error and stop the application, 
//      if the "checkSucess" flag is set.
//
// Note: the current transaction is automatically commited
//      at the beginning of the operation and restarted after
//      to avoid to maintain long locks on the federation.
static int execute (const char* command,
                     const d_Boolean checkSuccess = d_True,
                     const int success = 0)
{
    verbose (command);

    estore->commit();

    // CAUTION: Don't use: int stt = WEXITSTATUS(system(command));
    //          On OSF, the command is executed twice
    int stt = system(command); stt = WEXITSTATUS(stt);
    if (checkSuccess && (success != stt)) {
        warning ("Command failed (", itoa(stt), "): ", command);
        exit(stt);
    }

    estore->startUpdate();
    setWaitMode();
    return stt;
}

// Import a given file as a database
//      The file is copied to the directory designated by FSMgr
//      (the directory is created if needed) and attached to the federation
//      using "BdbDistInstal". The file is registered in the BaBar book keeping.
//      If the PUD daemon is not used, the database group is changed to
//      <groupname> [by default "bfactory", then BaBar standard for the AMS server) 
//      and the group protection is set to "rw".
static void importDb(const char* original_dbname,
                     const char* original_oid,
                     const char* inpfile, 
                     const char* subdir,
                     const char* original_filename,
                     float fsize)
{
  // Load the state of a special environment variable which is used
  // to modify a way the Conditions databases are being imported.
  //
  // If this variable "BDBCOND_RENAME_LINK_DB" is set then the following
  // database names:
  //
  //    con_xxx_Link
  //
  // are renamed into:
  //
  //    con_xxx_Link_<OID>
  //
  // Where: <OID> is the number (Object Id) of the database in a federation.
  //
  // If the database already has the <OID> attached then its name does not change.
  // This rule allows to avoid the names like:
  //
  //    con_xxx_Link_<OID>_<OID>...

    char* oid;
    char* dbname;
    char* filename;

    verbose("Will import original database ", original_dbname, " dbid ", original_oid, " impfile ", inpfile, " filename ", original_filename,")");

    // Start a transaction
    estore->startUpdate();
    setWaitMode();

    if (0 != getenv( "BDBCOND_RENAME_LINK_DB" )){

      verbose("Will rename con link db");

      oid = new char[ strlen( original_oid ) + 1 ];
      strcpy( oid, original_oid );

        const char link_string[5] = "Link";
        const char *linkTestStr;
        const char *oidTestStr;

        linkTestStr = strstr(original_dbname,link_string);
        oidTestStr  = strstr(original_dbname,oid);

        if ((0 != linkTestStr) && (0 == oidTestStr)) {
          //           message (" now db is ", original_dbname);

           dbname = new char[ strlen( original_dbname )
                             + 1
                             + strlen( oid )
                             + 1 ];
           strcpy( dbname, original_dbname );
           strcat( dbname, "_" );
           strcat( dbname, oid );

           // Append "_<OID>" by the end of the file name if this name
           // does not have a file extention or
           // insert "_<OID>" before the file extention.

           filename = new char[ strlen( original_filename )
                               + 1
                               + strlen( oid )
                               + 1 ];
           strcpy( filename, original_filename );

           char* dot = rindex( filename, '.' );
           if( dot == (const char*) 0 ) {
               strcat( filename, "_" );
               strcat( filename, oid );
           } else {
              *dot = '\0';    // That would trancate the filename.
              strcat( filename, "_" );
              strcat( filename, oid );
              const char* original_dot = rindex( original_filename, '.' );
              strcat( filename, original_dot );
           } 
        } else {
           dbname = new char[ strlen( original_dbname ) + 1 ];
           strcpy( dbname, original_dbname );

           filename = new char[ strlen( original_filename ) + 1 ];
           strcpy( filename, original_filename );
        }
    }
    else if ( remapDbid != 0) {
      verbose("Will remap dbids");
      //convert old database name to new name.
      //just a hook by now - until decide upon a convention
      dbname = new char[ strlen( original_dbname )
                       + 1
                       + strlen( remapDbid )
                       + 1 ];
      strcpy( dbname, original_dbname );
      strcat( dbname, "_" );
      strcat( dbname,  remapDbid );

      filename = new char[ strlen( original_filename )
                         + 1
                         + strlen( remapDbid )
                         + 1 ];
      strcpy( filename, original_filename );
      
      char* dot = rindex( filename, '.' );
      if( dot == (const char*) 0 ) {
        strcat( filename, "_" );
        strcat( filename, remapDbid );
      } else {
        *dot = '\0';    // That would trancate the filename.
        strcat( filename, "_" );
        strcat( filename, remapDbid );
        const char* original_dot = rindex( original_filename, '.' );
        strcat( filename, original_dot );
      } 

      message ("New dbname is ", dbname);

      //check if it already exists in the federation
      BdbDistDatabase db(dbname);
      d_Boolean dbExist = db.isDbExist();
      if (dbExist) { 
        //get it's own dbid and filepath
        int dbid = db.dbid();
        oid = new char[ 5 + 1 ];
        //      strcpy( oid, 
        sprintf(oid,"%d",dbid); 

        const char* oldfilename = db.fileName().data();
        filename = new char[strlen(oldfilename)+1];
        strcpy(filename, oldfilename);

        verbose("Db exists, will keep old id ", oid, 
                " and filepath ", filename);
      }
      else {
        //if no - get new dbid
        BdbHandle( ooFDObj ) fdH ;
        ooTrans gTransaction ;
        
        // Start a federation transaction
        //      gTransaction.start() ;
        
        if( oocError == fdH.open( 0 , oocUpdate , oocFalse ) ) {
          cout << "Failed to open Federated Database." << endl ;
          return;
        }
        const char* domain( "evs" ) ;
        BdbHandle( BdbDbIdManager ) manager ;
        manager = BdbDbIdManager::localInstance( fdH , domain ) ;
        
        BdbDbId dbid = manager->issueNextDbId();

        //      gTransaction.commit() ;

        cout << "new dbid " << dbid <<endl;

        oid = new char[ 5 + 1 ];
        //      strcpy( oid, 
                sprintf(oid,"%d",dbid); 
                
        message (" now id is ", oid);

      }
    }
    else {
      
      verbose("Will import as is");
      
        oid = new char[ strlen( original_oid ) + 1 ];
        strcpy( oid, original_oid );

        dbname = new char[ strlen( original_dbname ) + 1 ];
        strcpy( dbname, original_dbname );

        filename = new char[ strlen( original_filename ) + 1 ];
        strcpy( filename, original_filename );

    }

#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
    BdbTString cmd;
    BdbStatus status;

    // Standard log
    message("Importing database ", dbname, " dbid ", oid, " impfile ", inpfile, " filename ", filename,")");

    // Check if the input inpfile exist
    if (0 != access(inpfile,  F_OK)) {
        warning ("File ", inpfile, " does not exist");
        delete dbname;
        delete filename;
        return;
    }

    // Convert the object id to a base number
    int dbid = atoi(oid);
    if (dbid == 0) {
        warning ("Invalid Database id (", oid, ")");
        delete dbname;
        delete filename;
        return;
    }

    // Start a transaction
    //    estore->startUpdate();
    //    setWaitMode();

    // Check if the database exists
    //  If yes, and if the "replace" flag is not set,
    //  this database can't be superseded...
    BdbDistDatabase db (dbname);
    d_Boolean dbExist = db.isDbExist();
    if (dbExist && !replaceFlag)
        fail("Database ", dbname, " already exists - not superseded");

    // Autorization level
    if (!db.isAuthorized())
        fail("Not autorized to manage the database ", dbname);

    // Create a FS Manager, to execute the import operations
    //  (Note: can't test return status: if no ASCII file loaded, return error)
    BdbFSMgr fsmgr;
    fsmgr.rebuildFSInfo(db.domainName(), db.authLevelName(), db.userGroupName(), 
                        db.componentName());

    // Name of the directory where the file will be copied
    BdbTString outdir = BdbTString(fsmgr.baseDir(), "/", subdir);

    // Name of the copied file
    BdbTString outfile = BdbTString(outdir, "/", filename);
    BdbTString outfile2 = outfile;

    // Check if the target directory exists
    //  Create it if needed
    if (BdbcSuccess != fsmgr.checkExist(outdir)) {
        verbose("Creating target directory ", outdir);
        if (BdbcSuccess != fsmgr.mkDir(outdir))
            fail("Error creating directory: ", outdir);

        // If the PUD daemon is not used, the group and protection
        //      of the directories must be changed to <groupname> (def: "bfactory) and "g:rw"
        if (fsmgr.daemonDisabled()) {
            // Change the protection of the directory
            cmd = "chmod -R g+rw " + outdir;
            execute(cmd);

            // Change the group of the directory
            if (groupname != 0) {
                cmd = BdbTString("chgrp ", groupname, " ", outdir);
                execute(cmd);
            }
        }
    }

    // Copy the inpfile
    //  If the database already exists, the imported file is copied as "bdbimp"
    //  then will be replaced by the BdbDistInstall tool to the correct one
    //  under a lock protection
    if (dbExist && db.isFileExist())
        outfile += "imp";

    cmd = "BdbDistCopy -replace";
    if (verboseFlag)
        cmd += " -verbose";
    if (lftpFlag)
        cmd += " -lftp";
    else if (bdbxfrFlag)
        cmd += " -bdbxfr";
    else if (bdbsfcpFlag)
        cmd += " -bdbsfcp";
    else if (bdbbbcpFlag)
        cmd += " -bdbbbcp";
    else if (bdbscpFlag)
        cmd += " -bdbscp";
    else if (xfrFlag)
        cmd += " -xfr";
    else if (fgetFlag)
      cmd += " -fget";

    cmd += " ";
    if (cmdpath) { cmd += "-cmdpath " ; cmd += cmdpath; }

    cmd += " "; cmd += inpfile;
    cmd += " "; cmd += fsmgr.host(); cmd += ":" + outfile;
    verbose("Copying ", inpfile, " to ", outfile);
    execute(cmd);

    // Create HPSS lock file

    if (!lftpFlag && lockFlag) {
      verbose("Creating lock file ",cmd);
      cmd = "/usr/etc/ooss/ooss_Xeq mk ";
      cmd += outfile2;
      execute(cmd); 
    }

    // Attach the file
    cmd = "BdbDistInstall";
    if (verboseFlag)
        cmd += " -verbose";
    if (!waitFlag)
        cmd += " -nowait";
    else if (waitDelay < 0)
        cmd += " -wait";
    else
        cmd += " -wait -delay " + BdbTString(waitDelay);
    if (ReadOnly == readFlag)
        cmd += " -read";
    if (0 != groupname) {
        cmd += " -group ";
        cmd += groupname;
    }
    if (forcedFlag)
        cmd += " -forced";              // Bypass "ooattachdb"

    cmd += BdbTString(" -db ", dbname, " -id ", oid, 
                      " -host ", fsmgr.host(),
                      " -filepath ", outfile);

    verbose("Attaching ", dbname);
    int stt = execute(cmd, d_False);
    if (0 != stt) {
        warning ("Command failed (", itoa(stt), "): ", cmd);
        estore->abort();
        exit(stt);
    }

    // Done
    estore->commit();

    delete dbname;
    delete filename;
}

// Fix the reference between a collection and its tree node parent.
// The collection must exist
//      This is to fix a problem in previous imports
static void fixTreeNode(char* name)
{
    message("Fixing tree node collection ", name);

    // Start a transaction
    estore->startUpdate();
    setWaitMode();

    // Check if the collection exists
    BdbAbsCollectionT<BdbEventT>* coll;
    BdbHandle(BdbCollectionP) collH;
    BdbRef(BdbCollectionP) collR;

    coll = estore->collection(name, (*(BdbEventT*)0));
    if (0 == coll) {
        estore->abort();
        fail("No such collection ", name);
    }

    // Get the collection handle
    collH = coll->persistent();

    // Check for the tree node root
    char* treepath = name;
    char* collnode = strrchr(treepath, '/');
    if (collnode == NULL) {
        warning ("Invalid collection path: ", name);
        return;
    }
    *collnode++ = '\0';

    BdbTreeNode node;
    if (BdbcSuccess != node.moveTo(treepath)) {
        estore->abort();
        fail("No such tree node path ", treepath);
    }

    // Replace the collection tree node,
    //  if it is different of the current one
    BdbHandle(BdbTreeNodeP) nodeP;
    if (BdbcSuccess != collH->treeNode(nodeP))
        fail("Internal error - can't get collection tree node");

    if (node.persistent() == nodeP)
        message("Collection tree node already fixed");
    else {
        message("Fixing collection tree node");
        nodeP = node.persistent();
        collH->setTreeNode(nodeP);
    }

    // Done
    estore->commit();
}

// Attach a collection
//      If the collection already exists with a different OID
//      this existin collection is deleted if the "replace" flag is set,
//      else, an error is signaled
static void attachCollection(char* name, char* oid)
{
    message("Attaching collection ", name);

    // Parse the OID, remove the separator ("-") and read the numbers
    char* sep;
    while ((sep = strchr(oid, '-')) != 0)
        *sep = ' ';

    int dbid, contid, pageid, slotid;
    if (sscanf(oid, "%d %d %d %d", &dbid, &contid, &pageid, &slotid) != 4) {
        warning ("Invalid collection id: ", oid);
        return;
    }

    // Start a transaction
    estore->startUpdate();
    setWaitMode();

    // Check if the collection reference is valid
    //  (ie: check if the corresponding database exists)
    BdbRef(BdbCollectionP) collR;
    collR.set_DB(dbid);         // Create a dummy reference for this
    collR.set_OC(contid);
    collR.set_page(pageid);
    collR.set_slot(slotid);
    if (!collR.isValid()) {
        warning ("Invalid collection reference: ",
                 itoa(dbid),   "-", itoa(contid), "-",
                 itoa(pageid), "-", itoa(slotid), " (", name, ")");
        return;
    }

    BdbHandle(BdbCollectionP) collH;
    collH = collR;

    // Check if the collection exists
    //  If yes, and if the collection has the same "oid", it's OK
    //  else, if the "replace" flag is not set, this is an error
    BdbAbsCollectionT<BdbEventT>* coll;
    char collid[100];
    int size;

    coll = estore->collection(name, (*(BdbEventT*)0));
    if (0 != coll) {
        collH = coll->persistent();
        collR = collH;

        coll->persistent().sprint(collid);
        size = coll->size();

        // Check the collection OID
        if (collR.get_DB() == dbid && collR.get_OC() == contid &&
            collR.get_page() == pageid && collR.get_slot() == slotid) {
            // Same id. nothing to do
            message("Collection ", name, " already exists with the same OID");
            printtdfline(name, collid, size, 0);
            estore->commit();

            // Fix the tree node reference
            if (! replaceFlag)
                fixTreeNode(name);

            return;
        }
        // Different id; "replace" not specified;
        //      It's an error
        if (! replaceFlag)
            fail("Collection ", name, " already exist with a diff. OID");

        // Delete the collection
        verbose("Removing obsolete collection ", name, " (diff. OID)");
        if (BdbcSuccess != estore->removeCollection(coll))
            fail("Failed to remove existing collection ", name);
    }

    // Check for the tree node root, or create it
    char* treepath = name;
    char* collnode = strrchr(treepath, '/');
    if (collnode == NULL) {
        warning ("Invalid collection path: ", name);
        return;
    }
    *collnode++ = '\0';

    BdbTreeNode node;
    if (BdbcSuccess != node.moveTo(treepath)) {
        verbose("Creating tree node path ", treepath);

        // Set up the autorization level
        if (BdbcSuccess != estore->BdbDomain::setAuthLevel(treepath))
            fail("No privilege");

        if (BdbcSuccess != node.makeTo(treepath))
            fail("Failed to create the tree node ", treepath);
    }

    // Attaching the collection to this tree node
    BdbTreeAccess< BdbCollectionP > accessor;
    verbose("Attaching collection ", collnode);
    if (BdbcSuccess != accessor.add(node, collH, collnode))
        fail("Failed to insert the collection ", collnode);
    BdbHandle(BdbTreeNodeP) nodeP = node.persistent();
    collH->setTreeNode(nodeP);

    // Done
    collH.sprint(collid);
    size = collH->size();

    printtdfline(name, collid, size, 1);

    estore->commit();
}

//----------------------
// Small on-line help --
//----------------------
static void usage ()
{
    cerr << "BdbDbImport [options] " << endl << endl;

    cerr << " Options: " << endl;
//  cerr << "   -checkonly: print the status of the bases and collections" << endl;
    cerr << "   -[no]checksize: enable/disable the file size checking (def: enabled)" << endl;
    cerr << "   -delay <mn>: delay to wait to attach the databases" << endl;
    cerr << "   -forced: force the attach of the database bypassing ooattachdb" << endl;
    cerr << "   -group <name>: move the databases to this group (def: not changed)" << endl;
    cerr << "   -ignore: ignore the errors and try to continue (def: stop)" << endl;
    cerr << "   -lftp: use FTP to locally copy the files" << endl;
    cerr << "   -quiet: don't print anything" << endl;
    cerr << "   -[no]read: turn the files read-only" << endl;
    cerr << "   -replace: replace existing bases and collections" << endl;
    cerr << "   -verbose: print all the possible information" << endl;
    cerr << "   -[no]wait: try to lock the database before replacing it" << endl;
    cerr << "   -bdb{xfr,sfcp,scp,bbcp}: use bdb* to locally copy the files" << endl;
    cerr << "   -xfr: use ooss_xfr to locally copy the files" << endl;
    cerr << "   -fget: use ooss_fget to locally copy the files" << endl;
    cerr << "   -cmdpath path : use this path to copy command "<< endl;
    cerr << endl;

    cerr << " BdbDbImport reads commands to execute from the standard input" << endl;
    cerr << " The supported commands are:" << endl;
    cerr << "   IMPORT <db-sysname> <dbid> <filename> <subdir> <fullsize>" << endl;
    cerr << "   COLLECTION <collection> <oid>" << endl << endl;

    cerr << " By default, the databases are turned in write mode for an import" << endl;
    cerr << " and in read-only mode for a link" << endl;

    exit(0);
}

static void help ()
{
    cout << "Supported commands are:" << endl;
    cout << " COLLECTION <collection> <oid>" << endl;
    cout << " IMPORT <dbsysname> <dbid> <inpfile> <subdir> <filename> <fullsize>" << endl;
    cout << " TREENODE <collection>" << endl;
    cout << " EXIT" << endl;
    cout << " HELP" << endl;
}

//---------------------------------
// Starting point of the program --
//---------------------------------
int main (int argc, char* argv[])
{
    d_Boolean debugFlag = d_False;
    BdbDistMessage::verbosity (1);

    // Initialize the Event Store
    BdbEventStore::instance()->activate();

    // Check the user arguments
    for (int a = 1; a < argc; a++) {
        int alen = strlen(argv[a]);
        if ('-' == argv[a][0] && 'h' == argv[a][1] &&
            strncmp(argv[a], "-help", alen) == 0) {
            usage();
        }
//         else if ('-' == argv[a][0] && 'c' == argv[a][1] &&
//             strncmp(argv[a], "-checkonly", alen) == 0) {
//             checkonlyFlag = d_True;
//             warning ("Sorry - \"-checkonly\" not yet supported");
//             return ERROR;
//         }
        else if ('-' == argv[a][0] && 'c' == argv[a][1] &&
            strncmp(argv[a], "-checksize", alen) == 0) {
            checkSizeFlag = d_True;
        }
//          else if ('-' == argv[a][0] && 'd' == argv[a][1] &&
//              strncmp(argv[a], "-debug", alen) == 0) {
//              debugFlag = d_True;
//          }
        else if ('-' == argv[a][0] && 'd' == argv[a][1] &&
            strncmp(argv[a], "-delay", alen) == 0) {
            waitDelay = atoi(argv[++a]);
            if (waitDelay != 0)
                waitFlag = d_True;
        }
        else if ('-' == argv[a][0] && 'f' == argv[a][1] &&
            strncmp(argv[a], "-forced", alen) == 0) {
            forcedFlag = d_True;
        }
        else if ('-' == argv[a][0] && 'g' == argv[a][1] &&
            strncmp(argv[a], "-group", alen) == 0) {
            groupname = argv[++a];
        }
        else if ('-' == argv[a][0] && 'i' == argv[a][1] &&
            strncmp(argv[a], "-ignore", alen) == 0) {
            ignoreFlag = d_True;
        }
        else if ('-' == argv[a][0] && 'l' == argv[a][1] &&
            strncmp(argv[a], "-lftp", alen) == 0) {
            lftpFlag = d_True;
        }
        else if ('-' == argv[a][0] && 'x' == argv[a][1] &&
            strncmp(argv[a], "-xfr", alen) == 0) {
            xfrFlag = d_True;
        }
        else if ('-' == argv[a][0] && 'b' == argv[a][1] &&
            strncmp(argv[a], "-bdbxfr", alen) == 0) {
            bdbxfrFlag = d_True;
        }
        else if ('-' == argv[a][0] && 'f' == argv[a][1] &&
            strncmp(argv[a], "-fget", alen) == 0) {
            fgetFlag = d_True;
        }
        else if ('-' == argv[a][0] && 'c' == argv[a][1] &&
            strncmp(argv[a], "-cmdpath", alen) == 0) {
            cmdpath = argv[++a];
        }
        else if ('-' == argv[a][0] && 'r' == argv[a][1] &&
            strncmp(argv[a], "-remapdbid", alen) == 0) {
            remapDbid = argv[++a];
        }
        else if ('-' == argv[a][0] && 'n' == argv[a][1] && alen >= 4 &&
            strncmp(argv[a], "-noread", alen) == 0) {
            readFlag = ReadWrite;
        }
        else if ('-' == argv[a][0] && 'n' == argv[a][1] && alen >= 4 &&
            strncmp(argv[a], "-nochecksize", alen) == 0) {
            checkSizeFlag = d_False;
        }
        else if ('-' == argv[a][0] && 'n' == argv[a][1] && alen >= 4 &&
            strncmp(argv[a], "-nowait", alen) == 0) {
            waitFlag = d_False;
        }
        else if ('-' == argv[a][0] && 'q' == argv[a][1] &&
            strncmp(argv[a], "-quiet", alen) == 0) {
            quietFlag = d_True;
        }
        else if ('-' == argv[a][0] && 'p' == argv[a][1] &&
            strncmp(argv[a], "-printtdfline", alen) == 0) {
            printtdflineFlag = d_True;
        }
        else if ('-' == argv[a][0] && 'r' == argv[a][1] &&
            strncmp(argv[a], "-read", alen) == 0) {
            readFlag = ReadOnly;
        }
        else if ('-' == argv[a][0] && 'r' == argv[a][1] &&
            strncmp(argv[a], "-replace", alen) == 0) {
            replaceFlag = d_True;
        }
        else if ('-' == argv[a][0] && 'v' == argv[a][1] &&
            strncmp(argv[a], "-verbose", alen) == 0) {
            verboseFlag = d_True;
        }
        else if ('-' == argv[a][0] && 'w' == argv[a][1] &&
            strncmp(argv[a], "-wait", alen) == 0) {
            waitFlag = d_True;
        }
        else if ('-' == argv[a][0] && 'l' == argv[a][1] &&
            strncmp(argv[a], "-lock", alen) == 0) {
            lockFlag = d_True;
        }
        else if ('-' == argv[a][0])
            fail("Unsupported option \"", argv[a], "\"");
        else
            fail("Unexpected argument \"", argv[a], "\"");
    }
    if (quietFlag && verboseFlag) {
        warning ("Conflicting \"verbose\" and \"quiet\" options - using verbose");
        quietFlag = d_False;
    }
    if      (quietFlag)
      BdbDistMessage::verbosity (0);
    else if (verboseFlag)
      BdbDistMessage::verbosity (2);

    // Setup BdbDistMessage as default Objy message handler.
    BdbDistMessage::regMsgHandler();

    if (lftpFlag && xfrFlag && bdbxfrFlag && fgetFlag)
      fail("Cannot specify both -lftp -fget and/or -xfr -bdbxfr");
    // Get access to the event store
    estore = BdbEventStore::instance();

    // Start a read-only transaction
    estore->startUpdate();

    // Initialization
    BdbDbTreeSingleton::instance()->setRegistrator(new BdbDbRegistrator);
    estore->configureClustering();
    estore->commit();    


    // Read the names of the databases and collections from the standard input.
    //  (typically, this tool is called by the "bdbCollImport" script
    char line[1024];
    while (fgets(line, sizeof(line) - 1, stdin) != NULL) {
        if (debugFlag)
            continue;           // Dummy mode

        char key[32] = {0};
        sscanf(line, "%s", key);
        if (strcasecmp("IMPORT", key) == 0) {
            char dbname[128];
            char oid[64];
            char inpfile[512];
            char subdir[512];
            char filename[128];
            float fsize;
            sscanf(line, "%s %s %s %s %s %s %f", 
                   key, dbname, oid, inpfile, subdir, filename, &fsize);
            importDb(dbname, oid, inpfile, subdir, filename, fsize);
        }
        else if (strcasecmp("COLLECTION", key) == 0) {
            char name[128];
            char oid[64];
            sscanf(line, "%s %s %s", key, name, oid);
            attachCollection(name, oid);
        }
        else if (strcasecmp("TREENODE", key) == 0) {
            char name[128];
            sscanf(line, "%s %s", key, name);
            fixTreeNode(name);
        }
        else if (strcasecmp("HELP", key) == 0) {
            help();
        }
        else if (strcasecmp("EXIT", key) == 0) {
            break;
        }
        else
            warning ("Invalid line: ", line);
    }

    // Done
    return SUCCESS;
}

 

---

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

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