DbConnectionString.cc

Go to the documentation of this file.

#include "CondCore/CondDB/interface/Exception.h"
#include "CondCore/CondDB/interface/Utils.h"
#include "DbConnectionString.h"
//
#include "FWCore/ParameterSet/interface/FileInPath.h"
#include "FWCore/Catalog/interface/SiteLocalConfig.h"
#include "FWCore/ServiceRegistry/interface/Service.h"

namespace cond {

  namespace persistency {

    unsigned int countslash( const std::string& input ) {
      unsigned int count = 0;
      std::string::size_type slashpos( 0 );
      while( slashpos != std::string::npos ) {
        slashpos = input.find('/', slashpos );
        if( slashpos != std::string::npos ) {
          ++count;
          // start next search after this word
          slashpos += 1;
        }
      }
      return count;
    }

    std::string parseFipConnectionString( const std::string& fipConnect ){
      std::string connect( "sqlite_file:" );
      std::string::size_type pos = fipConnect.find( ':' );
      std::string fipLocation = fipConnect.substr( pos+1 );
      edm::FileInPath fip( fipLocation );
      connect.append( fip.fullPath() );
      return connect;
    }

    //FIXME: sdg this function does not support frontier connections strings like
    //frontier://cmsfrontier.cern.ch:8000/FrontierPrep/CMS_CONDITIONS
    //as http://cmsfrontier.cern.ch:8000/FrontierPrep(freshkey=foo) is an invalid URI.
    std::pair<std::string,std::string> getConnectionParams( const std::string& connectionString, 
                                                            const std::string& transactionId,
                                                            const std::string& signature ) {
      if( connectionString.empty() ) cond::throwException( "The connection string is empty.", "getConnectionParams" ); 
      std::string protocol = getConnectionProtocol( connectionString );
      std::string finalConn = connectionString;
      std::string refreshConn( "" );
      if( protocol == "frontier" ) {
        std::string protocol( "frontier://" );
        std::string::size_type fpos = connectionString.find( protocol );
        unsigned int nslash = countslash( connectionString.substr( protocol.size(), connectionString.size() - fpos ) );
        if( nslash==1 ) {
          edm::Service<edm::SiteLocalConfig> localconfservice;
          if( !localconfservice.isAvailable() ) {
        cond::throwException( "edm::SiteLocalConfigService is not available", "getConnectionParams" );
          }
          finalConn = localconfservice->lookupCalibConnect( connectionString );
        }
        if( !transactionId.empty() ) {
          size_t l = finalConn.rfind('/');
          finalConn.insert( l, "(freshkey="+transactionId+')' );
          }

        //When the signature parameter is set to sig, FroNTier requests that the server sends digital signatures on every response.
        //We test here that the signature string, if defined, is actually set to sig, otherwise we throw an exception
        std::string signatureParameter( "sig" );
        if( !signature.empty() ) {
          if( signature.compare( signatureParameter ) == 0 ) {
            std::string::size_type s = finalConn.rfind('/');
            finalConn.insert( s, "(security="+signature+')' );
          } else {
        cond::throwException( "The FroNTier security option is invalid.", "getConnectionParams" );
          }
        }

        std::string::size_type startRefresh = finalConn.find( "://" );
          if( startRefresh != std::string::npos ) {
          startRefresh += 3;
        }
        std::string::size_type endRefresh=finalConn.rfind( "/", std::string::npos );
          if( endRefresh == std::string::npos ) {
          refreshConn = finalConn;
        } else {
          refreshConn = finalConn.substr( startRefresh, endRefresh - startRefresh );
          if( refreshConn.substr( 0, 1 ) != "(" ) {
            //if the connect string is not a complicated parenthesized string,
            // an http:// needs to be at the beginning of it
            refreshConn.insert( 0, "http://" );
          }
        }
      } else if( protocol == "sqlite_fip" ) {
        finalConn = parseFipConnectionString( connectionString ); 
      }
      return std::make_pair( finalConn, refreshConn ); 
    }

  }
}