---

CdbRooInit.cc

Go to the documentation of this file.

//--------------------------------------------------------------------------
// File and Version Information:
//      $Id: CdbRooInit.cc,v 1.1 2005/02/09 17:14:35 gapon Exp $
//
// Description:
//      Class CdbRooInit.  Initialize Cdb.
//
// Environment:
//      Software developed for the BaBar Detector at the SLAC B-Factory.
//
// Author List:
//     David Brown, Igor Gaponenko 4/26/02
//
// Copyright Information:
//      Copyright (C) 2002              Lawrence Berkeley Laboratory
//
//------------------------------------------------------------------------

#include "BaBar/BaBar.hh"

#include "CdbRooModules/CdbRooInit.hh"

#include "CdbBase/CdbEnvironment.hh"
#include "CdbBase/CdbDatabase.hh"
#include "CdbBase/CdbOrigin.hh"
#include "CdbBase/CdbTransaction.hh"
#include "CdbBase/CdbDebugStream.hh"

#include "CdbRooReadonly/CdbRooReadonly.hh"

#include "ErrLogger/ErrLog.hh"

#include "BbrStdUtils/Tokenize.hh" 
using namespace babar::String; 
#include "BbrStdUtils/String.hh"
#include <string>
using std::endl;
using std::string;

namespace {

  // These are the minimally allowed and the default interval (in seconds) between
  // restarted transactions if the corresponding option is choosen. 

  const double MINIMAL_INTERVAL_BETWEEN_RESTARTS = 1.0;
  const double DEFAULT_INTERVAL_BETWEEN_RESTARTS = 300.0;
};

CdbRooInit::CdbRooInit( const char* const theName,
                        const char* const theDescription ) :
  AppModule( theName, theDescription ),
  _implementation( "Implementation", this ),
  _view( "View", this, "<local>::<recent>" ),
  _truncateTime( "TruncateTime", this, "+Infinity" ),
  _mainTransactionPolicy( "MainTransactionPolicy", this ),
  _mainTransactionRestartInterval( "MainTransactionRestartInterval", this, DEFAULT_INTERVAL_BETWEEN_RESTARTS ),
  _numEvents(0),
  _previousTimestamp(BdbTime::minusInfinity),
  _allowedOrigins("AllowedOrigins", this, "*" ),
  _myTransactionPtr(0)
{
  commands( )->append( &_implementation );
  commands( )->append( &_view );
  commands( )->append( &_truncateTime );
  commands( )->append( &_mainTransactionPolicy );
  commands( )->append( &_mainTransactionRestartInterval );
  commands( )->append( &_allowedOrigins );

  // create the commands: first entry becomes default
  _implementation.addItem( "<autodetection>", CdbRooInit::AUTODETECTION );
  _implementation.addItem( "Readonly",        CdbRooInit::READONLY );

  _mainTransactionPolicy.addItem( "RestartedLongTransaction",  CdbRooInit::RESTARTED_LONG_MAIN_TRANSACTION );
  _mainTransactionPolicy.addItem( "LongTransaction",           CdbRooInit::LONG_MAIN_TRANSACTION );
  _mainTransactionPolicy.addItem( "ShortTransaction",          CdbRooInit::SHORT_MAIN_TRANSACTION );
  _mainTransactionPolicy.addItem( "NoTransaction",             CdbRooInit::NO_MAIN_TRANSACTION );

  // force linking of the CDB API implementation
  CdbRooReadonly::forceLoad();
}

CdbRooInit::~CdbRooInit( )
{
    commitTransaction( );
}

AppResult
CdbRooInit::beginJob(AbsEvent* anEvent)
{
    _previousTimestamp = BdbTime::now( );

    if( CdbRooInit::NO_MAIN_TRANSACTION != _mainTransactionPolicy.value( )) {

        CDB_DEBUG_STREAM << "Starting main CDB trans in CdbRooInit::beginJob" << endl;

        if( CdbRooInit::RESTARTED_LONG_MAIN_TRANSACTION == _mainTransactionPolicy.value( )) {

            if( _mainTransactionRestartInterval.value( ) < MINIMAL_INTERVAL_BETWEEN_RESTARTS ) {
                ErrMsg(fatal) << "An incorrect value of the \"MainTransactionRestartInterval\" = "
                              << _mainTransactionRestartInterval.value( ) << " detected by the module." << endl
                              << "    The parameter must be equal or greater than " << MINIMAL_INTERVAL_BETWEEN_RESTARTS << " seconds." << endl
                              << "    Note, that this is a fatal error. The application is considered misconfigured." << endmsg;
                return AppResult::ERROR;
            }
            CDB_DEBUG_STREAM << "The main CDB transaction will be restarted every " << _mainTransactionRestartInterval.value( ) << " seconds at CdbRooInit::event()." << endl;
        }
        startTransaction( );
    }

  // Set requested defaults
  switch( _implementation.value( )){

  case READONLY:

    CdbEnvironment::setDefault("Roo",
                               "Readonly",
                               "<default>",
                               _view.value( ));
    break;

  case AUTODETECTION:

  default:

    // Rely on the CDB API "autodetection" mechanizm for the CDB API implementation.
    // Explicitly set up a user specified view if the one specified by a user differs
    // from the current default. This extra check is done to avoid noisy diagnostics
    // produced by CDB API when modifying default.

    std::string t = CdbEnvironment::defaultTechnology    ( );
    std::string i = CdbEnvironment::defaultImplementation( t.c_str( ));
    std::string d = CdbEnvironment::defaultDatabase      ( t.c_str( ), i.c_str( ));
    std::string v = CdbEnvironment::defaultView          ( t.c_str( ), i.c_str( ), d.c_str( ));

    if( v != std::string( _view.value( ))) {
      CdbEnvironment::setDefault( t.c_str( ),
                                  i.c_str( ),
                                  d.c_str( ),
                                  _view.value( ));
    }
    break;
  }
  ErrMsg(warning) << "CdbRooInit: Using CDB view \"" << _view.value( ) << "\"." << endmsg;

  // set truncate time if changed from the default (+Infinity)
  if( 0 != strcmp( "+Infinity", _truncateTime.value( ))) {
    BdbTime truncateTime( 0 );
    if( !BdbTime::parseTime( std::string( _truncateTime.value( )),
                             BdbTime::Local,
                             truncateTime )) {
      ErrMsg(error) << "CdbRooInit: Failed to trunslate specified value of the truncate time \"" << _truncateTime.value( ) << "\"." << endmsg;
      return AppResult::ERROR;
    }
    CdbEnvironment::setTruncateTime( truncateTime );
    ErrMsg(warning) << "CdbRooInit: Using truncate time \"" << _truncateTime.value( ) << "\" \"Local Timezone\"." << endmsg;
  }

  // Make sure we're running on the right type of CDB installation (so called "origin")
  // See the description of the syntax of the corresponding parameter at the header file
  // of the current class.
  //
  // NOTE: That the diagnostics message will only be reported if a non-default
  //       value of the parameter is set up.

  if( 0 != strcmp( "*", _allowedOrigins.value( ))) {

    CdbTransaction readOnlyTransaction;  // the transaction will end at the end of the current block

    CdbDatabasePtr databasePtr;
    if( CdbStatus::Success != CdbDatabase::instance( databasePtr )) {
      ErrMsg(fatal) << "CdbRooInit: Failed to obtain an API object for the default database." << endmsg;
      return AppResult::ERROR;
    }
    CdbOriginPtr originPtr = databasePtr->localOrigin( );
    if( originPtr.isNull( )) {
      ErrMsg(fatal) << "CdbRooInit: Failed to obtain an API object for the current database origin." << endmsg;
      return AppResult::ERROR;
    }

    ErrMsg(warning) << "CdbRooInit: Using user defined filter of CDB origins AllowedOrigins=\"" << _allowedOrigins.value( ) << "\"." << endmsg;
    ErrMsg(warning) << "CdbRooInit: The current origin is \"" << originPtr->name( ) << "\"." << endmsg;

    // Now translate the filter and cross-check it with the current origin

    bool isAllowedOrigin = false;
    {
      Tokenize theTokenizer( _allowedOrigins.value( ));
      while( true ) {
        std::string origin = theTokenizer( "," );
        if( origin.empty( )) break;

        if( 0 == strcmp( originPtr->name( ), origin.c_str( ))) {
          isAllowedOrigin = true;
          break;
        }
      }
    }
    if( !isAllowedOrigin ) {
      ErrMsg(fatal) << "CdbRooInit: The current CDB database you're attempting to use is not"
                    << " explicitly allowed by the \"AllowedOrigins\" parameter of CdbRooInit module."
                    << " This parameter is here to prevent your application from running against a wrong CDB." << endmsg;
      return AppResult::ERROR;
    }
  }
  return AppResult::OK;
}

AppResult
CdbRooInit::event( AbsEvent* anEvent )
{
    ++_numEvents;

// Uncomment this debugging message if needed:
//
//  CDB_DEBUG_STREAM << "CdbRooInit::event() _numEvents = " << _numEvents << endl;

    switch( _mainTransactionPolicy.value( )) {

    case CdbRooInit::RESTARTED_LONG_MAIN_TRANSACTION:
        {
            BdbTime currentTimestamp( BdbTime::now( ));
            d_ULong nSecondsElapsed = currentTimestamp.getGmtSec( ) - _previousTimestamp.getGmtSec( );

            if( nSecondsElapsed >= _mainTransactionRestartInterval.value( )) {
                CDB_DEBUG_STREAM << "Restarting main CDB trans in CdbRooInit::event after " << _mainTransactionRestartInterval.value( ) << " seconds." << endl;
                commitTransaction( );
                startTransaction( );
               _previousTimestamp = currentTimestamp;
            }
        }
        break;

    case CdbRooInit::SHORT_MAIN_TRANSACTION:

        if( 2 == _numEvents ) {
            CDB_DEBUG_STREAM << "Commiting main CDB trans in CdbRooInit::event at event " << _numEvents << endl;
            commitTransaction( );
        }
        break;

    default:

        break;
    }
    return AppResult::OK;
}

AppResult
CdbRooInit::endJob( AbsEvent* anEvent )
{
    if( CdbRooInit::NO_MAIN_TRANSACTION != _mainTransactionPolicy.value( )) {
        CDB_DEBUG_STREAM << "Commiting main CDB trans in CdbRooInit::endJob" << endl;
        commitTransaction( );
    }
    return AppResult::OK;
}

void
CdbRooInit::startTransaction( )
{
    if( 0 == _myTransactionPtr ) _myTransactionPtr = new CdbTransaction( );
}

void
CdbRooInit::commitTransaction( )
{
    if( 0 != _myTransactionPtr ) {
        delete _myTransactionPtr;
        _myTransactionPtr = 0;
    }
}

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

---