tech proxy

CondCore/DBCommon/interface/TechnologyProxy.h

@@ -17,11 +17,10 @@ namespace cond{
   class DbSession;
   class TechnologyProxy{
   public:
-    explicit TechnologyProxy( const  DbSession& isession ): m_session(isession) {}
+    explicit TechnologyProxy( ){}
     virtual ~TechnologyProxy(){}
+    virtual void initialize(const DbConnection& connection)=0;
     virtual std::string getRealConnectString() const=0;
-  protected:
-    DbSession m_session;
   private:
     TechnologyProxy( const TechnologyProxy& );
     const TechnologyProxy& operator=(const TechnologyProxy&); 

CondCore/DBCommon/interface/TechnologyProxyFactory.h

@@ -2,13 +2,14 @@
 #define CondCore_DBCommon_TechnologyProxyFactory_h
 #include "FWCore/PluginManager/interface/PluginFactory.h"
 #include "CondCore/DBCommon/interface/TechnologyProxy.h"
+#include "CondCore/DBCommon/interface/Exception.h"
+
 #include <memory>
 #include <string>
 namespace cond{
   typedef edmplugin::PluginFactory< cond::TechnologyProxy*(const std::string&) > TechnologyProxyFactory;
 
-  std::auto_ptr<cond::TechnologyProxy> buildTechnologyProxy (cond::DBSession& session){
-    const std::string & userconnect = session.connectionString(); 
+  std::auto_ptr<cond::TechnologyProxy> buildTechnologyProxy (const std::string&userconnect){
     std::string protocol;
     std::size_t pos=userconnect.find_first_of(':');
     if( pos!=std::string::npos ){
@@ -22,7 +23,7 @@ namespace cond{
     }
     //std::cout<<"userconnect "<<userconnect<<std::endl;
     //std::cout<<"protocol "<<protocol<<std::endl;  
-    std::auto_ptr<cond::TechnologyProxy> ptr(cond::TechnologyProxyFactory::get()->create(protocol,session));
+    std::auto_ptr<cond::TechnologyProxy> ptr(cond::TechnologyProxyFactory::get()->create(protocol));
     return ptr;
   }
 

CondCore/DBCommon/plugins/FrontierProxy.cc

@@ -16,9 +16,9 @@ namespace cond{
   public:
     explicit FrontierProxy(const DbSession& isession);
     ~FrontierProxy();
+    void initialize(const DbConnection& connection);
     std::string getRealConnectString() const;
   private:
-    void setupSession();
     static unsigned int countslash(const std::string& input);
   private:
     std::vector<std::string> m_refreshtablelist;
@@ -56,7 +56,7 @@ cond::FrontierProxy::getRealConnectString() const{
 }
 
 void 
-cond::FrontierProxy::setupSession(){
+cond::FrontierProxy::initialize(const DbConnection& connection){
   std::string refreshConnect;
   std::string realconnect=this->getRealConnectString();
   std::string::size_type startRefresh = realconnect.find("://");
@@ -77,7 +77,7 @@ cond::FrontierProxy::setupSession(){
   std::vector<std::string>::iterator ibeg=m_refreshtablelist.begin();
   std::vector<std::string>::iterator iend=m_refreshtablelist.end();
   for(std::vector<std::string>::iterator it=ibeg; it!=iend; ++it){
-    m_session.connection().webCacheControl().refreshTable(refreshConnect,*it );
+    connection.webCacheControl().refreshTable(refreshConnect,*it );
   }
 }
 unsigned int

CondCore/DBCommon/plugins/OracleProxy.cc

@@ -2,9 +2,9 @@
 namespace cond {
   class OracleProxy: public TechnologyProxy {
   public:
-    explicit OracleProxy(const  DbSession& isession):
-      cond::TechnologyProxy(isession){}
+    explicit OracleProxy(){}
     ~OracleProxy(){}
+    void initialize(const DbConnection&){}
     std::string getRealConnectString() const{ return m_session.connectionString();}
   };
 }//ns cond

CondCore/DBCommon/plugins/SQLiteProxy.cc

@@ -5,10 +5,9 @@
 namespace cond{
   class SQLiteProxy:public TechnologyProxy{
   public:
-    explicit SQLiteProxy(const  DbSession& isession):
-      cond::TechnologyProxy(isession){}
+    explicit SQLiteProxy({}
     ~SQLiteProxy(){}
-
+    void initialize(const DbConnection&){}
     std::string 
     getRealConnectString( ) const{
       std::string const & userconnect = m_session.connectionString();

CondCore/DBCommon/src/DbSession.cc

@@ -22,25 +22,31 @@
 #include "ObjectRelationalAccess/ObjectRelationalMappingSchema.h"
 //#include "ObjectRelationalAccess/ObjectRelationalMappingPersistency.h"
 
+#include "CondCore/DBCommon/interface/TechnologyProxy.h"
+
+
 namespace cond {
   class DbSession::SessionImpl {
-    public:
-      SessionImpl();
-      explicit SessionImpl( const DbConnection& connection );
-
-      virtual ~SessionImpl();
-
-      void open( const std::string& connectionString, bool readOnly );
-      void close();
-
-      DbConnection* m_connection;
-      std::string m_connectionString;
-      std::string m_blobStreamingService;
-      pool::IFileCatalog* m_catalogue;
-      pool::IDataSvc* m_dataSvc;
-      coral::ISessionProxy* m_session;
-      DbTransaction* m_transaction;
-      bool m_isOpen;
+  public:
+    SessionImpl();
+    explicit SessionImpl( const DbConnection& connection );
+
+    virtual ~SessionImpl();
+
+    void open( const std::string& connectionString, bool readOnly );
+    void close();
+
+    DbConnection* m_connection;
+
+    std::auto_ptr<cond::TechnologyProxy> technologyProxy;
+
+    std::string m_connectionString;
+    std::string m_blobStreamingService;
+    pool::IFileCatalog* m_catalogue;
+    pool::IDataSvc* m_dataSvc;
+    coral::ISessionProxy* m_session;
+    DbTransaction* m_transaction;
+    bool m_isOpen;
   };
 
 }
@@ -97,10 +103,11 @@ void cond::DbSession::SessionImpl::open( const std::string& connectionString, bo
     policy.setReadMode( pool::DatabaseConnectionPolicy::READ );
     m_dataSvc->session().setDefaultConnectionPolicy( policy );
     // open the db connection
-    m_connectionString = connectionString;
-    m_session = &m_dataSvc->configuration().sharedSession( connectionString, (readOnly)? coral::ReadOnly: coral::Update );
+    technologyProxy = buildTechnologyProxy(connectionString);
+    m_connectionString = (*technologyProxy).getRealConnectString();
+    m_session = &m_dataSvc->configuration().sharedSession(m_connectionString, (readOnly)? coral::ReadOnly: coral::Update );
     std::string catalogConnectionString("pfncatalog_memory://POOL_RDBMS?");
-    catalogConnectionString.append(connectionString);
+    catalogConnectionString.append(m_connectionString);
     m_catalogue->setWriteCatalog( catalogConnectionString );
     m_catalogue->connect();
     m_catalogue->start();
@@ -171,6 +178,11 @@ const std::string& cond::DbSession::connectionString() const {
   return m_implementation->m_connectionString;
 }
 
+const DbConnection& connection() const {
+  return *m_implementation->m_connection;
+}
+
+
 void cond::DbSession::setBlobStreamingService( const std::string& serviceName )
 {
   m_implementation->m_blobStreamingService = serviceName;

CondCore/DBCommon/test/testTechnologyPlugin.cc

@@ -1,42 +1,31 @@
-#include "CondCore/DBCommon/interface/TechnologyProxyFactory.h"
-#include "CondCore/DBCommon/interface/TechnologyProxy.h"
 #include "FWCore/PluginManager/interface/PluginManager.h"
 #include "FWCore/PluginManager/interface/standard.h"
-#include "CondCore/DBCommon/interface/DBSession.h"
-#include "CondCore/DBCommon/interface/ConnectionHandler.h"
-#include "FWCore/Catalog/interface/SiteLocalConfig.h"
-#include "FWCore/ServiceRegistry/interface/Service.h"
+#include "CondCore/DBCommon/interface/Exception.h"
+#include "CondCore/DBCommon/interface/DbSession.h"
 #include <iostream>
 int main(){
   edmplugin::PluginManager::Config config;
   edmplugin::PluginManager::configure(edmplugin::standard::config());
-  /*  const char* path = getenv("LD_LIBRARY_PATH");
-  std::string spath(path? path: "");
-  std::string::size_type last=0;
-  std::string::size_type i=0;
-  std::vector<std::string> paths;
-  while( (i=spath.find_first_of(':',last))!=std::string::npos) {
-    paths.push_back(spath.substr(last,i-last));
-    last = i+1;
-    std::cout <<paths.back()<<std::endl;
-  }
-  paths.push_back(spath.substr(last,std::string::npos));
-  config.searchPath(paths);
-  edmplugin::PluginManager::configure(config);
-  */
+
   std::cout<<"testing Connection Handler "<<std::endl;
-  cond::DBSession* session=new cond::DBSession;
-  static cond::ConnectionHandler& conHandler=cond::ConnectionHandler::Instance();
-  conHandler.registerConnection("sqlite_file:mydata.db",*session,0);
-  conHandler.registerConnection("sqlite_fip:CondCore/SQLiteData/data/mydata.db",*session,0);
-  session->open();
-  conHandler.connect(session);
-  conHandler.disconnectAll();
-  std::auto_ptr<cond::TechnologyProxy> ptr(cond::TechnologyProxyFactory::get()->create("sqlite","sqlite_file:pippo.db"));
-  std::cout<<ptr->getRealConnectString()<<std::endl;
-  static cond::ConnectionHandler& conHandler2=cond::ConnectionHandler::Instance();
-  conHandler.registerConnection("frontier://cmsfrontier.cern.ch:8000/FrontierDev/CMS_COND_PRESH",*session,0);
-  std::auto_ptr<cond::TechnologyProxy> ptr2(cond::TechnologyProxyFactory::get()->create("frontier","frontier://cmsfrontier.cern.ch:8000/FrontierDev/CMS_COND_PRESH"));
-  std::cout<<ptr2->getRealConnectString()<<std::endl;
-  delete session;
+  cond::DbConnection conn;
+  conn.configure( cond::CmsDefaults );
+  cond::DbSession session = conn.createSession();
+  const char * connects[] = {
+    "sqlite_file:mydata.db",
+    "sqlite_fip:CondCore/SQLiteData/data/mydata.db",
+    "frontier:FrontierDev/CMS_COND_PRESH",
+    "frontier://cmsfrontier.cern.ch:8000/FrontierDev/CMS_COND_PRESH"
+  };
+  for (int i=0; int<4; ++i) {
+    try {
+      session.open(connects[i]);
+      std::cout << connects[i] << " " <<  session.connectionString() << std::endl;
+    } catch ( const cond::Exception & er) {
+      std::cout << "error " << er.what();
+    }
+  }
+
+  return 0;
 }
+