---

CdbBdbSUtils.cc

Go to the documentation of this file.

// File and Version Information:
//      $Id: CdbBdbSUtils.cc,v 1.10 2004/08/06 05:54:25 bartoldu Exp $

/// Implementation file for the CdbBdbSUtils lass
/**
  * @see CdbBdbSCell
  */

#include "BaBar/BaBar.hh"

#include "CdbBdbShared/CdbBdbSUtils.hh"

#include "BdbApplication/BdbDomain.hh"
#include "BdbApplication/BdbCondFSNamesStr.hh"

#include "BdbAccess/BdbDbAccessMgr.hh"
#include "BdbAccess/BdbContAccessMgr.hh"
#include "BdbAccess/BdbAccessErrors.hh"

#include "BdbDistribution/BdbStandardDbIdMgr.hh"
#include "BdbDistribution/BdbDbIdAlloc.hh"
#include "BdbDistribution/BdbFdName.hh"

#include "BdbCond/BdbConditions.hh"

#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <assert.h>
using std::cout;
using std::endl;

namespace {

  /// Build the database name from specified components
  /**
    */
    std::string buildDatabaseName( bool               isPartitionableFlag,
                                   d_UShort           thePartitionId,
                                   d_UShort           theClusterId,
                                   d_UShort           theIncrementNumber,
                                   const std::string& theDbIdRange )
    {
        std::string databaseName( "con_cdb" );

        if( isPartitionableFlag ) {

            char numberStr[12];
            sprintf( numberStr, "%u", thePartitionId );

            databaseName = databaseName +
                           std::string( "_p" ) +
                           std::string( numberStr );
        }
        {
            char numberStr[12];
            sprintf( numberStr, "%u", theClusterId );

            databaseName = databaseName +
                           std::string( "_c" ) +
                           std::string( numberStr );
        }
        {
            char numberStr[12];
            sprintf( numberStr, "%u", theIncrementNumber );

            databaseName = databaseName +
                           std::string( "_i" ) +
                           std::string( numberStr );
        }
        databaseName = databaseName +
                       std::string( "_" ) +
                       theDbIdRange;

        return databaseName;
    }
};

std::string
CdbBdbSUtils::_localDbIdRange = "";

CdbStatus
CdbBdbSUtils::getLocalDbIdRange( std::string& theName )
{
  // WARNING: The method is using the cached value of the range, which might not
  //          work if there is more than one Objectivity context for the Condition/DB.

    CdbStatus result = CdbStatus::NotFound;
    do {

      // Still need to load the cache?

        if ( _localDbIdRange == "" ) {

          // The following operations are executed withing a separate context
          // in order not to leave locks 

            BdbStatus status;

            status = BdbApplicationOrDomain::activeInstance( )->startNestedRead( );
            if( status != BdbcSuccess ) {
                assert( 0 );
                result = CdbStatus::Error;
                break;
            }
            {
                BdbHandle(BdbFdName) theFdNameH;
                theFdNameH = BdbFdName::localInstance( BdbApplicationOrDomain::activeInstance()->fd( ));

                const char* rangeName = BdbStandardDbIdMgr::findKey( theFdNameH, "con" );
                if ( 0 != rangeName ) _localDbIdRange = rangeName;
            }
            status = BdbApplicationOrDomain::activeInstance( )->commitNested( );
            if( status != BdbcSuccess ) {
                assert( 0 );
                result = CdbStatus::Error;
                break;
            }
        }
        if ( _localDbIdRange != "" ) {
            theName = _localDbIdRange;
            result = CdbStatus::Success;
        }

    } while( false );

    return result;
}

CdbStatus
CdbBdbSUtils::verifyDbIdRange( const char* theName )
{
    CdbStatus result = CdbStatus::NotFound;
    do {

        if( 0 != theName ) {

          // The following operations are executed withing a separate context
          // in order not to leave locks 

            BdbStatus status;

            status = BdbApplicationOrDomain::activeInstance( )->startNestedRead( );
            if( status != BdbcSuccess ) {
                assert( 0 );
                result = CdbStatus::Error;
                break;
            }
            {
                BdbHandle(BdbDbIdAlloc) allocH;
                allocH = BdbDbIdAlloc::localInstance( BdbApplicationOrDomain::activeInstance()->fd( ));
                if( ! BdbIsNull(allocH)) {

                    char** aList = 0;
                    size_t aNum  = 0;
                    
                    aNum = allocH->keys( aList );
                    if(( 0 != aList ) && ( 0 != aNum )) {
                        for( size_t i = 0; i < aNum; ++i ) {
                            if( 0 == strcmp( theName, aList[i] )) result = CdbStatus::Success;
                            delete [] aList[i]; // Don't need this anymore
                        }
                        delete [] aList;    // Don't need the list anymore
                    }
                }
            }
            status = BdbApplicationOrDomain::activeInstance( )->commitNested( );
            if( status != BdbcSuccess ) {
                assert( 0 );
                result = CdbStatus::Error;
                break;
            }
        }

    } while( false );

    return result;
}

/*
 * BEGIN: This is an obsolete and inefficient implementation of these methods. It has been
 *        replaced with the one using a transient cache of databases and container handles.
 *

CdbStatus
CdbBdbSUtils::findContainer( BdbHandle(BdbContObj)& theContH,
                             const char*            theDatabaseName,
                             const char*            theContainerName,
                             const BdbMode          theOpenMode )
{
    const char* errorStr = "CdbBdbSUtils::findContainer() - ERROR.";

    CdbStatus result = CdbStatus::NotFound;
    do {

      // Find the database

        BdbHandle(BdbDBObj) dH;

        if( CdbStatus::Success != findDatabase( dH,
                                                theDatabaseName,
                                                BdbcRead )) {
            break;
        }

      // Find the container.

        BdbStatus status;

        BdbHandle(BdbContObj) cH;

        if( d_True != cH.exist( dH,
                                theContainerName,
                                BdbcNoOpen )) {
            break;
        }
        status = cH.open( dH,
                          theContainerName,
                          theOpenMode );
        if(( BdbcSuccess != status ) || BdbIsNull(cH)) {
            cout << errorStr << endl
                 << "    Failed to open the container: \"" << theContainerName << "\"" << endl
                 << "    at the database:              \"" << theDatabaseName << "\"" << endl;
            result = CdbStatus::Error;
            break;
        }

      // Done

        theContH = cH;

        result = CdbStatus::Success;

    } while( false );

    return result;
}

CdbStatus
CdbBdbSUtils::findDatabase( BdbHandle(BdbDBObj)& theDatabaseH,
                            const char*          theDatabaseName,
                            const BdbMode        theOpenMode )
{
    const char* errorStr = "CdbBdbSUtils::findDatabase() - ERROR.";

    CdbStatus result = CdbStatus::NotFound;
    do {

        BdbStatus status;

      // Find the database

        BdbHandle(BdbDBObj) dH;

        if( d_True != dH.exist( BdbApplicationOrDomain::activeInstance()->fd( ),
                                theDatabaseName,
                                BdbcNoOpen )) {
            break;
        }
        status = dH.open( BdbApplicationOrDomain::activeInstance()->fd( ),
                          theDatabaseName,
                          theOpenMode );
        if(( BdbcSuccess != status ) || BdbIsNull(dH)) {
            cout << errorStr << endl
                 << "    Failed to open the database: \"" << theDatabaseName << "\"" << endl;
            result = CdbStatus::Error;
            break;
        }

      // Done

        theDatabaseH = dH;

        result = CdbStatus::Success;

    } while( false );

    return result;
}

 *
 * END: See the efficient implementations of these methods below.
 */


CdbStatus
CdbBdbSUtils::findContainer( BdbHandle(BdbContObj)& theContH,
                             const char*            theDatabaseName,
                             const char*            theContainerName,
                             const BdbMode          theOpenMode )
{
    const char* errorStr = "CdbBdbSUtils::findContainer() - ERROR.";

    CdbStatus result = CdbStatus::Error;
    do {

      // Find the container handle through the transient access manager. This manager
      // also manages the transient cach of handles (one per ooContext & ooTransaction)
      // to avoid FDB catalog operations if possible.

        d_Long    lockWait = -2;        // default value of this parameter
        d_Boolean useCache = d_True;    // default value of this parameter
        d_Boolean quiet    = d_True;    // ovverride the default value of this parameter

        BdbContAccessMgr      aMgr;
        BdbHandle(BdbContObj) cH;
        BdbStatus             status = aMgr.openDbAndCont( theDatabaseName,
                                                           cH,
                                                           theContainerName,
                                                           theOpenMode,
                                                           lockWait,
                                                           useCache,
                                                           quiet );

        if(( BdbAccessErrDbNotExist.errorN == status ) || ( BdbAccessErrContNotFound.errorN == status )) {

          // This might be a normal situation from the point of view of
          // a client of the current method.

            return CdbStatus::NotFound;

        } else if(( BdbcSuccess != status ) || BdbIsNull(cH)) {
            cout << errorStr << endl
                 << "    Failed to open the container: \"" << theContainerName << "\"" << endl
                 << "    at the database:              \"" << theDatabaseName << "\"" << endl;
            break;
        }

      // Done

        theContH = cH;

        result = CdbStatus::Success;

    } while( false );

    return result;
}

CdbStatus
CdbBdbSUtils::findDatabase( BdbHandle(BdbDBObj)& theDatabaseH,
                            const char*          theDatabaseName,
                            const BdbMode        theOpenMode )
{
    const char* errorStr = "CdbBdbSUtils::findDatabase() - ERROR.";

    CdbStatus result = CdbStatus::Error;
    do {

      // Find the database handle through the transient access manager. This manager
      // also manages the transient cach of handles (one per ooContext & ooTransaction)
      // to avoid FDB catalog operations if possible.

        BdbDbAccessMgr      aMgr;
        BdbHandle(BdbDBObj) dH;
        BdbStatus           status = aMgr.openDb( dH,
                                                  theDatabaseName,
                                                  theOpenMode );

        if( BdbAccessErrDbNotExist.errorN == status ) {

          // This might be a normal situation from the point of view of
          // a client of the current method.

            return CdbStatus::NotFound;

        } else if(( BdbcSuccess != status ) || BdbIsNull(dH)) {
            cout << errorStr << endl
                 << "    Failed to open the database: \"" << theDatabaseName << "\"" << endl;
            break;
        }

      // Done

        theDatabaseH = dH;

        result = CdbStatus::Success;

    } while( false );

    return result;
}

CdbStatus
CdbBdbSUtils::findMetaData( BdbRef(CdbBdbSMetaDataP)& theRef,
                            const d_UShort            theConditionId,
                            bool                      isPartitionableFlag,
                            d_UShort                  thePartitionId,
                            d_UShort                  theClusterId,
                            d_UShort                  theIncrementNumber,
                            const std::string&        theDbIdRange )
{
    const char* errorStr = "CdbBdbSUtils::findMetaData() -- ERROR";

    CdbStatus result = CdbStatus::Error;
    do {

      // Build the database name

        std::string databaseName = buildDatabaseName( isPartitionableFlag,
                                                      thePartitionId,
                                                      theClusterId,
                                                      theIncrementNumber,
                                                      theDbIdRange );

      // Build the container name

        char cIdStr[12];
        sprintf( cIdStr, "%u", theConditionId );

        std::string mdContainerName = std::string( "MetaData." ) +
                                      std::string( cIdStr );

      // Try to locate the container and the MetaData object in this
      // container.

        BdbHandle(BdbContObj) mdContH;
        if( CdbStatus::Success != CdbBdbSUtils::findContainer( mdContH,
                                                               databaseName.c_str( ),
                                                               mdContainerName.c_str( ))) {
            cout << errorStr << endl
                 << "    Failed to locate/open a persistent container with meta-data." << endl
                 << "    The database may not be properly initialized/loaded." << endl
                 << "        CONTAINER NAME:     \"" << mdContainerName.c_str( ) << "\"" << endl
                 << "        DATABASE FILE NAME: \"" << databaseName.c_str( ) << "\"" << endl;
            break;
        }

        BdbHandle(CdbBdbSMetaDataP) mdH;
        if( BdbcSuccess != mdH.lookupObj( mdContH,
                                          "MetaData" )) {
            cout << errorStr << endl
                 << "    Failed to locate the \"MetaData\" registry object in the container." << endl
                 << "    The database may not be properly initialized/loaded." << endl
                 << "        CONTAINER NAME:     \"" << mdContainerName.c_str( ) << "\"" << endl
                 << "        DATABASE FILE NAME: \"" << databaseName.c_str( ) << "\"" << endl;
            break;
        }
        assert( mdH->ooIsKindOf( ooTypeN( CdbBdbSMetaDataP )));

      // Done.

        theRef = mdH;

        result = CdbStatus::Success;

    } while( false );

    return result;
}

CdbStatus
CdbBdbSUtils::databaseSize( d_ULong&           theNumPages,
                            d_ULong&           thePageSize,
                            bool               isPartitionableFlag,
                            d_UShort           thePartitionId,
                            d_UShort           theClusterId,
                            d_UShort           theIncrementNumber,
                            const std::string& theDbIdRange )
{
    const char* errorStr = "CdbBdbSUtils::databaseSize(meta-data & objects) -- ERROR";

    CdbStatus result = CdbStatus::Error;
    do {

      // Build the database name

        std::string databaseName = buildDatabaseName( isPartitionableFlag,
                                                      thePartitionId,
                                                      theClusterId,
                                                      theIncrementNumber,
                                                      theDbIdRange );

      // Try to measure the database size

        if( CdbStatus::Success != measureDatabaseSize( theNumPages,
                                                       thePageSize,
                                                       databaseName.c_str( ))) {
            cout << errorStr << endl
                 << "    Failed to measure the size of a persistent database with meta-data and objects." << endl
                 << "    The database may not be properly initialized/loaded." << endl
                 << "        DATABASE FILE NAME: \"" << databaseName.c_str( ) << "\"" << endl;
            break;
        }

      // Done.

        result = CdbStatus::Success;

    } while( false );

    return result;
}

CdbStatus
CdbBdbSUtils::databaseSize( d_ULong& theNumPages,
                            d_ULong& thePageSize )
{
    const char* errorStr = "CdbBdbSUtils::databaseSize(master) -- ERROR";

    CdbStatus result = CdbStatus::Error;
    do {

      // Build the database name

        std::string databaseName = "con_cdb_database";

      // Try to measure the database size

        if( CdbStatus::Success != measureDatabaseSize( theNumPages,
                                                       thePageSize,
                                                       databaseName.c_str( ))) {
            cout << errorStr << endl
                 << "    Failed to measure the size of the MASTER registry database." << endl
                 << "    The database may not be properly initialized/loaded." << endl
                 << "        DATABASE FILE NAME: \"" << databaseName.c_str( ) << "\"" << endl;
            break;
        }

      // Done.

        result = CdbStatus::Success;

    } while( false );

    return result;
}

CdbStatus
CdbBdbSUtils::databaseSize( d_ULong&           theNumPages,
                            d_ULong&           thePageSize,
                            const std::string& theDbIdRange )
{
    const char* errorStr = "CdbBdbSUtils::databaseSize(local) -- ERROR";

    CdbStatus result = CdbStatus::Error;
    do {

      // Build the database name

        std::string databaseName = "con_cdb_database_" + theDbIdRange;

      // Try to measure the database size. Don't warry about "NotFound" status - just
      // propagate it up to the caller because some local databases images may just not exist
      // either because they've not been imported yet or because the current database
      // is the MASTER one.

        result = measureDatabaseSize( theNumPages,
                                      thePageSize,
                                      databaseName.c_str( ));
        if( CdbStatus::Success == result ) {
            ;
        } else if( CdbStatus::NotFound == result ) {
            ;
        } else {
            cout << errorStr << endl
                 << "    Failed to measure the size of the local registry database." << endl
                 << "    The database may not be properly initialized/loaded." << endl
                 << "        DATABASE FILE NAME: \"" << databaseName.c_str( ) << "\"" << endl;
        }

    } while( false );

    return result;
}

CdbStatus
CdbBdbSUtils::measureDatabaseSize( d_ULong&           theNumPages,
                                   d_ULong&           thePageSize,
                                   const std::string& theDatabaseName )
{
    const char* errorStr = "CdbBdbSUtils::measureDatabaseSize() -- ERROR";

    CdbStatus result = CdbStatus::Error;
    do {

      // Find the database

        BdbHandle(BdbDBObj) dH;

        CdbStatus findDatabaseStatus = findDatabase( dH,
                                                     theDatabaseName.c_str( ),
                                                     BdbcRead );
        if( CdbStatus::Success != findDatabaseStatus ) {
            result = findDatabaseStatus;
            break;
        }

      // Count the number of pages in all containers
      // including the default one.

        d_ULong total = 0;
        {
          // Set up an iterator of contaniers to iterate over this database
          // 
          // NOTE: This method will not affect the internal state of this object.
          //       This is why we open the database here explicitly.
 
            BdbItr(BdbContObj) itr;
            dH.contains( itr );
  
            bool failed = false;

            while ( itr.next( )) {

                d_ULong num = itr.nPage( );
                if( 0 == num ) {
                    cout << errorStr << endl
                         << "    Failed to determine the size of a persistent container." << endl
                         << "    The container is not found or could not be open." << endl
                         << "        CONTAINER NAME:     \"" << itr.name( ) << "\"" << endl
                         << "        DATABASE FILE NAME: \"" << theDatabaseName.c_str( ) << "\"" << endl;
                    failed = true;
                    break;
                }
                total += num;
            }
            if( failed ) break;
        }
        theNumPages = total;

      // Get the page size.

        thePageSize = BdbApplicationOrDomain::activeInstance()->fd( ).pageSize( );

      // Done.

        result = CdbStatus::Success;

    } while( false );

    return result;
}

CdbStatus
CdbBdbSUtils::setPlacementStrategy( bool        useDefaultStrategyFlag,
                                    const char* theExplicitPathName )
{
    const char* errorStr = "CdbBdbSUtils::setPlacementStrategy() -- ERROR";

    CdbStatus result = CdbStatus::Error;
    do {

      // Get the value of 'FDB_LOCAL_NAME' used when creating
      // the current federation

        std::string localDbIdRange;
        if( CdbStatus::Success != getLocalDbIdRange( localDbIdRange )) {
            cout << errorStr << endl
                 << "    Failed to obtain the local DBID range name of the current federation." << endl;
            break;
        }

      // Check if the old path was required by a user

        std::string customClusteringPath;
        {
            if( useDefaultStrategyFlag ) customClusteringPath = "conditions/" + localDbIdRange ;
            else                         customClusteringPath = theExplicitPathName;
        }

      // Aplly whatever path is required

        BdbCondFSNamesStr* strategy = new BdbCondFSNamesStr;
        strategy->setCustomRelativePath( customClusteringPath.c_str( ));

        BdbConditions::instance( )->setStrategyObj( strategy );

      // Done.

        result = CdbStatus::Success;

    } while( false );

    return result;
}

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

---