---

CdbRooRoCdb.cc

Go to the documentation of this file.

// File and Version Information:
//      $Id: CdbRooRoCdb.cc,v 1.5 2005/11/11 01:41:26 gapon Exp $

/// The implementation of the CdbRooRoCdb singleton.
/**
  * @see CdbRooRoCdb
  */

#include "BaBar/BaBar.hh"

#include "CdbRooReadonly/CdbRooRoCdb.hh"

#include "CdbBase/CdbView.hh"
#include "CdbBase/CdbDatabase.hh"
#include "CdbBase/CdbEnvironment.hh"
#include "CdbBase/CdbDebugStream.hh"
#include "CdbBase/CdbAnyTypeDict.hh"

#include "CdbRooReadonly/CdbRooReadonly.hh"
#include "CdbRooReadonly/CdbRooRoFileUtils.hh"
#include "CdbRooReadonly/CdbRooRoDatabase.hh"
#include "CdbRooReadonly/CdbRooRoDatabaseItr.hh"
#include "CdbRooReadonly/CdbRooRoBootRecordR.hh"

#include "ErrLogger/ErrLog.hh"

#include "BbrStdUtils/Tokenize.hh"
#include "BbrStdUtils/String.hh"
using namespace babar::String;

#include <stdlib.h>     // getenv()
#include <stdio.h>      // sscanf()

#include <string.h>
#include <assert.h>

#include <iostream>
#include <fstream>
#include <map>

using std::ifstream;
using std::cout;
using std::cerr;
using std::endl;

namespace {

  /// Dummy transaction manager
  /**
    * DESIGN NOTE:
    *
    *   At the moment, we don't have a concept of the "transaction" in the current
    *   implementation of the CDB API, However we must provide this manager to comply
    *   with specifications of the technology-neutral CDB API.
    */
    class CdbRooRoDummyTransaction : public CdbTransactionBase {

    public:

        CdbRooRoDummyTransaction( ) : CdbTransactionBase( ) { }

        virtual ~CdbRooRoDummyTransaction( ) { }

        virtual void commitAndHold( ) { }
    };
}

////////////////////////////////
// CdbRooRoCdb implementation //
////////////////////////////////

CdbRooRoCdb::CdbRooRoCdb( ) :
    Cdb( ),
    _isInitialized      (false),                    // For the sake of deffered initialization
    _defaultDatabaseName("<default>"),
    _defaultViewName    ("<local>::<recent>")
{
    CDB_DEBUG_STREAM
        << "Condition/DB API instantiated for"
        << " TECHNOLOGY=\""     << CdbRooReadonly::technology( )     << "\""
        << " IMPLEMENTATION=\"" << CdbRooReadonly::implementation( ) << "\""
        << endl;

  // Try to register itself in the API registry.
  //
  // NOTE: If the registration will fail then we may probably encounter a fatal
  //       unrecoverable problem with implementations of CDB API. One of the possible
  //       reasons of the falure would be if another implementation of the API has already
  //       registered itself in the dictionary under the same names.

    CdbPtr myPtr = this;

    CdbStatus status = set( myPtr );
    assert( CdbStatus::Success == status );
}

CdbRooRoCdb::~CdbRooRoCdb( )
{ }

const char*
CdbRooRoCdb::technologyName( ) const
{
    return CdbRooReadonly::technology( );
}

const char*
CdbRooRoCdb::implementationName( ) const
{
    return CdbRooReadonly::implementation( );
}

void
CdbRooRoCdb::initialize( )
{
    if( !_isInitialized ) {

      // IMPORTANT: This flag has to be set up first before doing any actual
      //            operations with the persistent store since we may have
      //            indirect recursion when setting default (the defaults setting
      //            algorithm may request initialization).

        _isInitialized = true;

      // Read the default "boot" file to configure the context of this CDB API implementation

        CdbStatus result = readBootFile( );
        if( CdbStatus::Success == result ) {

          // Okay, we have a consistent context

            ;

        } else if( CdbStatus::NotFound == result ) {

          // We have no context specific to the current implementation of the CDB API

            ;

        } else {

          // We had a failure when attempting to translate the context

            cerr << "CdbRooRoCdb::initialize() -- WARNING." << endl
                 << "    Failed to read and/or translate the contents of the boot file. See details above." << endl;
        }

      // Check the environment and see if there are optional parameters to rune-up this
      // implementation of the CDB API

        {
            const char* var = "CDB_ROO_MAX_TTREES";
            const char* ptr = getenv( var );
            if( ptr ) {
                unsigned num = 0;
                if( 1 == sscanf( ptr, "%u", &num )) {
                    const char* key = "Roo/Readonly/max_num_ttrees";
                    if( CdbStatus::Success != CdbEnvironment::extra( ).replace( key, num )) {
                        ErrMsg(fatal) << "CdbRooRoCdb::initialize( ) -- FATAL ERROR\n"
                                      << "    Failed to set the parameter '" << key << "' = " << num << " in CdbEnvironment.\n"
                                      << "    This is an unrecoverable error caused by an inconsistency in the CDB API Logic.\n"
                                      << "    Please, report the problem to CDB API developers." << endmsg;
                    }
                }
                CDB_DEBUG_STREAM
                    << "Condition/DB API for"
                    << " TECHNOLOGY=\""     << CdbRooReadonly::technology( )     << "\""
                    << " IMPLEMENTATION=\"" << CdbRooReadonly::implementation( ) << "\""
                    << " translated environment variable: " << var << " = " << num
                    << endl;
            }
        }
    }
}

bool
CdbRooRoCdb::isInitialized( )
{
    return _isInitialized;
}

CdbStatus
CdbRooRoCdb::getDefaultDatabase( std::string& theDatabaseName )
{
    assert( isInitialized( ));

    theDatabaseName = _defaultDatabaseName;

    return CdbStatus::Success;
}

CdbStatus
CdbRooRoCdb::getDefaultView( std::string& theViewName,
                             const char*  theDatabaseName )
{
    assert( isInitialized( ));

    if( 0 == theDatabaseName ) return CdbStatus::IllegalParameters;

  // We only allow the following database names:
  //
  //   - "<default>"
  //   - the actual BOOT file stored in the current object

    if( 0 != strcmp( theDatabaseName, "<default>" )) {
        if( theDatabaseName != _defaultDatabaseName )
            return CdbStatus::NotFound;
    }

  // Return the current default.

    theViewName = _defaultViewName;

    return CdbStatus::Success; 
}

CdbStatus
CdbRooRoCdb::setDefaultDatabase( const char* theDatabaseName )
{
    assert( isInitialized( ));

    if( 0 == theDatabaseName ) return CdbStatus::IllegalParameters;

  // First let's see if the passed name corresponds to one of the following
  // options:
  //
  //   - "<default>"
  //   - the actual BOOT file which exists and has the correct format

    if( 0 == strcmp( theDatabaseName, "<default>" )) return CdbStatus::Success;
    if( theDatabaseName == _defaultDatabaseName )    return CdbStatus::Success;

  // If it's something new then try to see what's in the one passed by the parameter.

   return readBootFile( theDatabaseName );
}

CdbStatus
CdbRooRoCdb::setDefaultView( const char* theViewName,
                             const char* theDatabaseName )
{
    assert( isInitialized( ));

    if( 0 == theViewName     ) return CdbStatus::IllegalParameters;
    if( 0 == theDatabaseName ) return CdbStatus::IllegalParameters;

  // This method will checks for the correctness of the database and view names.
  //
  // IMPLEMENTATION NOTE: It will NOT check if specified view is present in the database.
  //                      The reason is that certain operations with CDB may be permitted
  //                      without having finally established database.

  // We only allow the following database names:
  //
  //   - "<default>"
  //   - the actual BOOT file stored in the current object

    if( 0 != strcmp( theDatabaseName, "<default>" )) {
        if( theDatabaseName != _defaultDatabaseName )
            return CdbStatus::NotFound;
    }

  // Try open the database and the view to check if they both exist.
  /**
   ** IMPLEMENTATION NOTE: The following code is disabled to allow operations with
   **                      incomplete CDB.
   **

    CdbDatabasePtr databasePtr;
    if( CdbStatus::Success != findDatabase( databasePtr )) return CdbStatus::Error;

    CdbViewPtr viewPtr;
    if( CdbStatus::Success != databasePtr->findView( viewPtr, theViewName  )) return CdbStatus::Error;

   **
   **/

  // Done

    _defaultViewName = theViewName;

    return CdbStatus::Success; 
}

CdbStatus
CdbRooRoCdb::findDatabase( CdbDatabasePtr& thePtr,
                           const char*     theName )
{
    assert( isInitialized( ));

    CdbStatus result = CdbStatus::Error;

    thePtr = 0;

    do {

      // Verify and correct parameters if 0 pointer is passed to indicate
      // that default database is needed. The "<default>" string is also allowed
      // since the current implementation maps it onto the boot file name.

        std::string defaultDatabaseName;
        if( CdbStatus::Success != getDefaultDatabase( defaultDatabaseName )) break;

        std::string databaseName = defaultDatabaseName;
        if( 0 != theName ) {
            if( 0 == strcmp( "<default>", theName )) {

              // This is a special keyword to be mapped onto whatever default
              // bootfile name we have.

                ;

            } else {
                databaseName = theName;
            }
        }

        if( databaseName != defaultDatabaseName ) {

            cout << "CdbRooRoCdb::findDatabase( ) -- ERROR" << endl
                 << "    No such database in this implementation:  \"" << databaseName        << "\"" << endl
                 << "    The only name allowed is the default one: \"" << defaultDatabaseName << "\"" << endl;

            break;
        }

      // NOTE: - the above corrected parameters object is used.
      //       - a smart pointer onto itself is found through the registry.

        CdbPtr selfPtr;
        if( CdbStatus::Success != get( selfPtr,
                                       technologyName( ),
                                       implementationName( ))) {

            cout << "CdbRooRoCdb::findDatabase( ) -- FATAL ERROR" << endl
                 << "    Failed to recover its own instance of the CDB API." << endl
                 << "        TECHNOLOGY     : \"" << technologyName( ) << "\"" << endl
                 << "        IMPLEMENTATION : \"" << implementationName( ) << "\"" << endl;

            assert( 0 );

            break;
        }
        thePtr = new CdbRooRoDatabase( selfPtr,
                                       databaseName.c_str( ));
        result = CdbStatus::Success;

    } while( false );

    return result;
}

CdbStatus
CdbRooRoCdb::databaseIterator( CdbDatabaseItr& theItr )
{
    assert( isInitialized( ));

  // Note, that we find its own smart pointer through the Registry

  // ATTENTION: This is not a memory leak - the created object
  //            will be destroyed by the iterator.

    CdbPtr selfPtr;
    if( CdbStatus::Success != get( selfPtr,
                                   technologyName( ),
                                   implementationName( ))) {

        cout << "CdbRooRoCdb::databaseIterator( ) -- FATAL ERROR" << endl
             << "    Failed to recover its own instance of the CDB API." << endl
             << "        TECHNOLOGY     : \"" << technologyName( ) << "\"" << endl
             << "        IMPLEMENTATION : \"" << implementationName( ) << "\"" << endl;

        assert( 0 );

        return CdbStatus::Error;
    }
    theItr = CdbDatabaseItr( new CdbRooRoDatabaseItr( selfPtr ));

    return CdbStatus::Success;
}

CdbTransactionBase*
CdbRooRoCdb::transaction( CdbTransaction::Mode theMode ) const
{
    return new CdbRooRoDummyTransaction( );
}

CdbStatus
CdbRooRoCdb::readBootFile( const char* theBootFileName )
{
    const char* errorStr = "CdbRooRoCdb::readBootFile() -- ERROR.";

  // Try to find the bootfile first. Here is how we do the check:
  //
  //   - a value explicitly passed through the current method's parameter
  //
  // or
  //
  //   - an explicitly specified location using a special environment variable
  //   - a default file in the local directory

    const char* bootFileName = theBootFileName;
    std::string location;

    if( 0 != bootFileName ) {
        location = "the bootfile explicitly passed to the method";
    } else {

        const char* variable = "CDB_ROO_BOOT";
        bootFileName = getenv( variable );

        if( 0 != bootFileName ) {
            location = "the bootfile specified in the environment variable ";
            location += variable;
        } else {
            bootFileName = "con_cdb_boot.root";
            location = "default bootfile";
        }
    }
    assert( bootFileName );
    assert( !location.empty( ));

    TFile bootFile( bootFileName, "read" );
    if( bootFile.IsZombie( )) {
        cerr << errorStr << endl
                << "    Failed to open " << location << ".\n"
                << "    File name: \"" << bootFileName << "\"" << endl;
        return CdbStatus::Error;
    }

  // Read the boot record

    CdbCPtr<CdbRooRoBootRecordR> bootRecordPtr;
    {
        CdbRooRoBootRecordR* ptr;
        bootFile.GetObject( CdbRooRoBootRecordR::PersistentObjectName( ), ptr );
        if( !ptr ) {
            cerr << errorStr << endl
                 << "    Failed to find/read the '" << CdbRooRoBootRecordR::PersistentObjectName( ) << "' object in the boot file\n"
                 << "    '" << bootFile.GetName( ) << "'" << endl;
            return CdbStatus::Error;
        }
        bootRecordPtr = ptr;
    }

  // Configure the File Utility singleton with found parameters. This information
  // will be used later by the rest of the CDP API implementation.
  //
  // IMPLEMENTATION NOTE:
  //
  //    These parameters are passed through the singleton rather than via the current
  //    API class to avoid dangerous and nasty downcasting in the rest of the API
  //    implementation.
  //
  // @see class CdbRooRoFileUtils

    CdbRooRoFileUtils::instance( ).reset( );
    CdbRooRoFileUtils::instance( ).setLocalOrigin( bootRecordPtr->localOriginName( ),
                                                   bootRecordPtr->localOriginId( ));
    CdbRooRoFileUtils::instance( ).setBootFileLocation( bootFileName );
    CdbRooRoFileUtils::instance( ).setDatabase2LocationMap( bootRecordPtr->database2LocationMap( ));
    CdbRooRoFileUtils::instance( ).setObject2DatabaseMap( bootRecordPtr->object2DatabaseMap( ));

  // Done

    _defaultDatabaseName = bootFileName;
    _defaultViewName     = bootRecordPtr->defaultViewName( );

    return CdbStatus::Success;
}

/////////////////
// End Of File //
/////////////////

---