---

CdbBdbSUtils.hh

Go to the documentation of this file.

#ifndef CDBBDBSHARED_UTILS_HH
#define CDBBDBSHARED_UTILS_HH

// File and Version Information:
//      $Id: CdbBdbSUtils.hh,v 1.7 2003/08/18 22:21:57 gapon Exp $

#include "BdbUtil/Bdb.hh"

#include "CdbBase/CdbCommon.hh"

#include "CdbBdbShared/CdbBdbSMetaDataP.hh"

#include <string>

/// The utility cass
/**
  * This is an utility class provides various operations with persistent store.
  */
class CdbBdbSUtils {

public:

  /// Find out the name of the local BDID range

    static CdbStatus getLocalDbIdRange( std::string& theName );

  /// Check if specified BDID range is known
  /**
    * The result of this operation is returned via its completions status,
    * which is:
    *
    *   CdbStatus::NotFound - if there is no such DBID range found
    *   CdbStatus::Success  - if it's found, or
    *   CdbStatus::Error    - in case of any error.
    */
    static CdbStatus verifyDbIdRange( const char* theName );

  /// Find out a persistent container
  /**
    * The returned container will be open in the specified mode.
    */
    static CdbStatus findContainer( BdbHandle(BdbContObj)& theContH,
                                    const char*            theDatabaseName,
                                    const char*            theContainerName,
                                    const BdbMode          theOpenMode = BdbcRead );

  /// Find out a persistent database
  /**
    * The returned database will be open in the specified mode.
    */
    static CdbStatus findDatabase( BdbHandle(BdbDBObj)& theDatabaseH,
                                   const char*          theDatabaseName,
                                   const BdbMode        theOpenMode = BdbcRead );

  /// Find MetaData object at specified location
  /**
    * This method does the actual database/container mining work.
    */
    static CdbStatus findMetaData( BdbRef(CdbBdbSMetaDataP)& theRef,
                                   const d_UShort            theConditionId,
                                   bool                      isPartitionableFlag,
                                   d_UShort                  thePartitionId,
                                   d_UShort                  theClusterId,
                                   d_UShort                  theIncrementNumber,
                                   const std::string&        theDbIdRange );

  /// Find the actual size of a database file corresponding to specified parameters
  /**
    * This method will use the specified parameters to build the name of the database.
    * Then it will return (into specified variables) the total number of pages
    * in this database and the page size (BYTES).
    */
    static CdbStatus databaseSize( d_ULong&           theNumPages,
                                   d_ULong&           thePageSize,
                                   bool               isPartitionableFlag,
                                   d_UShort           thePartitionId,
                                   d_UShort           theClusterId,
                                   d_UShort           theIncrementNumber,
                                   const std::string& theDbIdRange );

  /// Find the actual size of the MASTER database file
  /**
    * This method will find the size of the main "bootstrap" file which is used
    * to startup the bootsrtap sequence and to store the global registries of
    * the distributed CDB. There must be just one file of this type originated
    * in the MASTER CDB.
    */
    static CdbStatus databaseSize( d_ULong& theNumPages,
                                   d_ULong& thePageSize );

  /// Find the actual size of the local bootstrap database file
  /**
    * This method will find the size of the local (to specified DBID range) "bootstrap"
    * file which is used to store local registries, etc.
    *
    * If the local database is the MASTER one then CdbSatus::NotFound value
    * will be returned.
    */
    static CdbStatus databaseSize( d_ULong&           theNumPages,
                                   d_ULong&           thePageSize,
                                   const std::string& theDbIdRange );

  /// Set the required File Placement Strategy at the Clustering Hint Service
  /**
    * Initialize desired File Placement Strategy. It can be either a default
    * value or some explicitly specified path if an optional switch passed
    * as a parameter is "false". If a non-default value of the path is required then
    * the second parameter will be used.
    *
    * IMPORTANT:
    *
    *   The current implementation of the File Placement & Clustering Hint Service
    *   requires to use this procedure at least once. Otherwise the application will
    *   crash issuing the following message:
    *
    *       "Call BdbCondFSNamesStr::setCustomRelativePath() first
    *       "Abort (core dumped)"
    *
    * This File Placement Strategy specifies the default directory for newely created
    * databases, which in the old implementation of the Clustering Hint was:
    *
    *   <base>/conditions/cdb
    *
    * The new implementation will have
    *
    *   <base>/conditions/<local-dbid-range>
    *
    * By default the new scheme is used. Overriding the default value of
    * the optional 'useDefaultStrategyFlag' parameter to "false" would switch
    * the path back to the non-default policiy. In this case the second parameter
    * with the explicit path name will be used. The default value of the second
    * parameter corresponds to the old Strategy Policy.
    */
    static CdbStatus setPlacementStrategy( bool        useDefaultStrategyFlag = true,
                                           const char* theExplicitPathName    = "conditions/cdb" );

private:

  /// Do the actual measurement on specified database
  /**
    * The database must exist. If it's not found then CdbStatus::NotFound will
    * be returned. Other status values are returned as usually.
    */
    static CdbStatus measureDatabaseSize( d_ULong&           theNumPages,
                                          d_ULong&           thePageSize,
                                          const std::string& theDatabaseName );

  // Cached DBID range "native" to the Condition/DB domain of the local federation.

    static std::string _localDbIdRange;
};

#endif  // CDBBDBSHARED_UTILS_HH

---