---

dbstreamerfactory.cpp

Go to the documentation of this file.

//============================================================================= 
//
// XDFLengine library
//
//----------------------------------------------------------------------------- 
//  DBStreamerFactory.CPP
//----------------------------------------------------------------------------- 
//_____________________________________________________________________________
//
//  Copyright (C) 2003 Guillaume Baurand. All Rights Reserved.
//
//  This file is part of the XDFLengine project.
//
//  The XDFLengine is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation; either version 2 of the License, or
//  (at your option) any later version.
//
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this program; if not, write to the Free Software
//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,
//  USA.
//
//  For more information, 
//      contact  : guillaume@baurand.net 
//      or visit : http://xdflengine.sourceforge.net
//
//=============================================================================

#include "dbstreamerfactory.hpp"
#include "processor/xmlprocessor.hpp"


BEGIN_XDFLENGINE_NS

//============================================================================= 
//  CLASS DBStreamerFactory
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~


    //_________________________________________________________________________
    //  SETCONNECTIONLIFETIME
    //-------------------------------------------------------------------------
    void DBStreamerFactory::setSQLSyntax(const char* p_pszSQLSyntax)
    {

        if(p_pszSQLSyntax)
        {
            if      ( strcmp(p_pszSQLSyntax,DB_ORA)==0)     g_uiSQLSyntax = SQL_SYNTAX_ORA;
            else if ( strcmp(p_pszSQLSyntax,DB_MSSQL)==0)   g_uiSQLSyntax = SQL_SYNTAX_MSSQL;
            else if ( strcmp(p_pszSQLSyntax,DB_DB2)==0)     g_uiSQLSyntax = SQL_SYNTAX_DB2;
        }
    }

    //_________________________________________________________________________
    //  GETCONNECTIONLIFETIME
    //-------------------------------------------------------------------------
    unsigned int DBStreamerFactory::getSQLSyntax()
    {
        return g_uiSQLSyntax;
    }

    //_________________________________________________________________________
    //  DBStreamerFactory
    //-------------------------------------------------------------------------
    DBStreamerFactory::DBStreamerFactory()
    {
        //---------------------------------------------------------------------
        unsigned int i;
        //---------------------------------------------------------------------

        logout.display_version( "OTL", "Oracle, ODBC and DB2/CLI Template Library", OTL_VERSION_NUMBER, "Copyright (C) Sergei Kuchin, 1996,2002");  
        
        // init connection pool
        if(! g_boolConnectionPoolsReady)
        {
            DEBUG_ECHO << "Init connection pool for " << XMLProcessor::getThreadCount() << " threads \n";

            // initialize OCI/ODBC environment
            otl_connect::otl_initialize(1); 

            // allocate pools pointers index
            g_ppConnectionPools=(DBConnectionPool**) malloc( sizeof(DBConnectionPool*) * XMLProcessor::getThreadCount());

            // fills connection pool map with one pool per thread
            for(i=0; i < XMLProcessor::getThreadCount(); i++)
            {
                DEBUG_ECHO << "init connection pool for thread #" << i << "\n";
                g_ppConnectionPools[i]=new DBConnectionPool();          
            }

            g_boolConnectionPoolsReady=true;

        }
        
        DEBUG_CREATE(DBStreamerFactory) 
    }

    //_________________________________________________________________________
    //  ~DBStreamerFactory
    //-------------------------------------------------------------------------
    DBStreamerFactory::~DBStreamerFactory()
    {
        //---------------------------------------------------------------------
        DBConnectionPool*   l_pDBConnectionPool;
        unsigned int        i;
        //---------------------------------------------------------------------

        DEBUG_DEL(DBStreamerFactory)

        if( g_boolConnectionPoolsReady)
        {
            // release connection pools
            for(i=0; i<XMLProcessor::getThreadCount(); i++)
            {
                l_pDBConnectionPool = g_ppConnectionPools[i];           
                delete( l_pDBConnectionPool);
            }

            // desallocate shared pool array
            free( g_ppConnectionPools);

            // terminate OCI environment
#ifndef OTL_ODBC
            otl_connect::otl_terminate(); 
#endif
            g_boolConnectionPoolsReady=false;
        }

    }

    //_____________________________________________________________________
    // GETCONNECTION
    //---------------------------------------------------------------------
    otl_connect* DBStreamerFactory::getConnection(const char* p_pszConnectionString,unsigned int p_uiThreadId  )
    {
        DEBUG_FUNC(DBStreamerFactory::getConnection)
        logout << "\t" << "DB POOL" << "   :   " << "Get connection '"<< p_pszConnectionString << "' for thread #" << p_uiThreadId   << "\n";
        return (g_ppConnectionPools[p_uiThreadId  ])->getConnection( p_pszConnectionString);
    }


    //_____________________________________________________________________
    // RELEASECONNECTION
    //---------------------------------------------------------------------
    void DBStreamerFactory::releaseConnection(const char* p_pszConnectionString,unsigned int p_uiThreadId  )
    {
        DEBUG_FUNC(DBStreamerFactory::releaseConnection) 
        logout << "\t" << "DB POOL" << "   :   " << "Release connection '"<< p_pszConnectionString << "' for thread #" << p_uiThreadId   << "\n";
        g_ppConnectionPools[p_uiThreadId  ]->releaseConnection( p_pszConnectionString);
    }


    //_____________________________________________________________________
    //  TICK
    //---------------------------------------------------------------------
    void DBStreamerFactory::tick(unsigned long  p_ulClock)
    {
        DEBUG_FUNC(DBStreamerFactory::tick)
        //---------------------------------------------------------------------
        unsigned int            i;
        static unsigned long    l_sulLastClock=0;
        //---------------------------------------------------------------------

        if( p_ulClock > l_sulLastClock)
        {
            l_sulLastClock = p_ulClock;
            for(i=0; i<XMLProcessor::getThreadCount(); i++)
            {
                logout << "\t" << "DB POOL" << "   :   " <<  " Ticking pool #" << i <<"\n";
                g_ppConnectionPools[i]->tick( p_ulClock);   
            }
        }
    }

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//=============================================================================




//============================================================================= 
//  CLASS DBCONNECTIONPOOL
//----------------------------------------------------------------------------- 



    //_________________________________________________________________________
    //  SETCONNECTIONLIFETIME
    //-------------------------------------------------------------------------
    void DBConnectionPool::setConnectionLifeTime(unsigned long  p_ulConnectionLifeTime)
    {
        DEBUG_FUNC(DBConnectionPool::setConnectionLifeTime)
        g_ulPooledConnectionLifeTime=p_ulConnectionLifeTime;
    }

    //_________________________________________________________________________
    //  DBStreamerFactory
    //-------------------------------------------------------------------------
    DBConnectionPool::DBConnectionPool()
    {
        DEBUG_CREATE(DBConnectionPool)
            m_ulLastTick=0;
    }

    //_________________________________________________________________________
    //  DBStreamerFactory
    //-------------------------------------------------------------------------
    DBConnectionPool::~DBConnectionPool()
    {

        // Empty handlers map;
        while( !m_vaActiveConnections.empty()) deletePooledConnection( m_vaActiveConnections.pop());

        DEBUG_DEL(DBConnectionPool)

    }


    //_________________________________________________________________________
    // GETCONNECTION
    //-------------------------------------------------------------------------
    otl_connect* DBConnectionPool::getConnection(const char* p_pszConnectionString)
    {
        //---------------------------------------------------------------------
        DBPooledConnection* l_DBPooledConnection=0;
        //---------------------------------------------------------------------

        DEBUG_FUNC(DBConnectionPool::getConnection)

        

        l_DBPooledConnection = m_vaActiveConnections.get( p_pszConnectionString);
        if(! l_DBPooledConnection)
        {
            // insert connection in pool
            l_DBPooledConnection = poolConnection( p_pszConnectionString);
            DEBUG_ECHO << "Connection not found : insert in pool" <<"\n";
                        logout << "Getting connection " << p_pszConnectionString << "(" << l_DBPooledConnection->m_uiUsage << ")\n";
        }

        // get connection from pool
        l_DBPooledConnection->m_uiUsage = l_DBPooledConnection->m_uiUsage+1;

        return l_DBPooledConnection->m_pOTLConnection;
    }



    //_________________________________________________________________________
    // RELEASECONNECTION
    //-------------------------------------------------------------------------
    void DBConnectionPool::releaseConnection(const char* p_pszConnectionString)
    {
        //---------------------------------------------------------------------
        DBPooledConnection* l_DBPooledConnection;
        //---------------------------------------------------------------------

        DEBUG_FUNC(DBConnectionPool::releaseConnection)


        

        l_DBPooledConnection = m_vaActiveConnections.get( p_pszConnectionString);
        if( l_DBPooledConnection)
        {
            l_DBPooledConnection->m_uiUsage=l_DBPooledConnection->m_uiUsage-1;
                        logout << "Releasing connection " << p_pszConnectionString << "(" << l_DBPooledConnection->m_uiUsage << ")\n";
            if( g_ulPooledConnectionLifeTime == 0) 
                        /*&& ( l_DBPooledConnection->m_uiUsage==0 ) &&
                (   ( g_ulPooledConnectionLifeTime == 0 ) || 
                    ( m_ulLastTick - l_DBPooledConnection->m_ulTimeCreated  > g_ulPooledConnectionLifeTime ) ||
                    ( m_ulLastTick < l_DBPooledConnection->m_ulTimeCreated )
              ) )*/
            {
                unPoolConnection( l_DBPooledConnection);
            }
        }
    }

    //_________________________________________________________________________
    //  tick
    //-------------------------------------------------------------------------
    void DBConnectionPool::tick(unsigned long p_ulClock)
    {       
        //---------------------------------------------------------------------
        unsigned int i;
        DBPooledConnection* l_DBPooledConnection=0;
        //---------------------------------------------------------------------

        DEBUG_FUNC(DBConnectionPool::tick)

        //logout << "\t" << "DB POOL" << "   :   " << "Pool cleanup..." << "\n";

        m_ulLastTick = p_ulClock;

        // check for outdated connections
        for(i=0 ; i<m_vaActiveConnections.size() ; i++)
        {
            l_DBPooledConnection=m_vaActiveConnections.get(i);
            logout << l_DBPooledConnection->m_uiUsage << "/";
            logout << l_DBPooledConnection->m_ulTimeCreated << "\n";

            if( (   ( g_ulPooledConnectionLifeTime!=-1 ) && 
                    ( l_DBPooledConnection->m_uiUsage == 0 )
                )
                &&
                (   
                    ( m_ulLastTick - l_DBPooledConnection->m_ulTimeCreated  > g_ulPooledConnectionLifeTime ) ||
                    ( m_ulLastTick < l_DBPooledConnection->m_ulTimeCreated )
              ) )
            {
                unPoolConnection( l_DBPooledConnection);    
            }

        }

    }

// PRIVATES 

    //_________________________________________________________________________
    // POOLCONNECTION
    //-------------------------------------------------------------------------
    DBPooledConnection* DBConnectionPool::poolConnection(const char* p_pszConnectionString)
    {
        //---------------------------------------------------------------------
        DBPooledConnection* l_DBPooledConnection=0;
        otl_connect*        l_pOTLConnection=0;
        //--------------------------------------------------------------------- 

        DEBUG_FUNC(DBConnectionPool::poolConnection)

        logout << "\t" << "DB POOL" << "   :   " << "Pool connection " << p_pszConnectionString << "\n";

        PREP_CATCH_XML_FLOW_ERROR;
        
        l_pOTLConnection= new otl_connect;

        // Connect !
        try { l_pOTLConnection->rlogon(  p_pszConnectionString); }
        catch(otl_exception& p)
        { 
            MAKE_XMLFLOW_EXCEPTION ( ERRCODE_LOC_DBCONNPOOL + ERRCODE_CAUSE_DATAACCESS , "Unable to connect to DB." , (char*)(&(p.msg)), "DBConnectionPool::poolConnection", "", false);
            p.~otl_tmpl_exception();
            goto RELEASE_AND_RETURN;
        }

        l_DBPooledConnection=new DBPooledConnection;
        l_DBPooledConnection->m_ulTimeCreated = m_ulLastTick;
        l_DBPooledConnection->m_pOTLConnection = l_pOTLConnection;
        l_DBPooledConnection->m_uiUsage=0;
        l_DBPooledConnection->m_pszConnectionString =importCharBuffer( 0, p_pszConnectionString);

        m_vaActiveConnections.add( l_DBPooledConnection, p_pszConnectionString);

        DEBUG_ECHO << "Pooled connection '" << p_pszConnectionString << "'\n";

    RELEASE_AND_RETURN:
    
        // release 
        ON_XML_FLOW_ERROR_DO
        {
            if( l_DBPooledConnection)
            {
                releaseCharBuffer( l_DBPooledConnection->m_pszConnectionString);
                delete l_DBPooledConnection;
            }
            if( l_pOTLConnection)
            {
                l_pOTLConnection->logoff();
                delete l_pOTLConnection;
            }
        }
            
        ON_XML_FLOW_ERROR_THROW;    
        return l_DBPooledConnection;
    }

    //_________________________________________________________________________
    // UNPOOLCONNECTION
    //-------------------------------------------------------------------------
    void DBConnectionPool::unPoolConnection(DBPooledConnection* p_pDBPooledConnection)
    {
        //---------------------------------------------------------------------
        DBPooledConnection* l_DBPooledConnection=0;
        //---------------------------------------------------------------------

        DEBUG_FUNC(DBConnectionPool::unPoolConnection)

        // insert connection in pool
        deletePooledConnection( m_vaActiveConnections.remove( p_pDBPooledConnection->m_pszConnectionString));   
    }

    //_________________________________________________________________________
    // DELETEPOOLEDCONNECTION
    //-------------------------------------------------------------------------
    void DBConnectionPool::deletePooledConnection(DBPooledConnection*   p_pDBPooledConnection)
    {
        //---------------------------------------------------------------------
        otl_connect*        l_pOTLConnection;
        //---------------------------------------------------------------------

        DEBUG_FUNC(DBConnectionPool::deletePooledConnection)

        logout << "\t" << "DB POOL" << "   :   " << "Unpool connection " << p_pDBPooledConnection->m_pszConnectionString  << "(" << p_pDBPooledConnection->m_uiUsage << ")\n";

        releaseCharBuffer( p_pDBPooledConnection->m_pszConnectionString);

        l_pOTLConnection = p_pDBPooledConnection->m_pOTLConnection;

        // release connection
        l_pOTLConnection->logoff();
        delete l_pOTLConnection;

        // release pooled connection
        delete p_pDBPooledConnection;
    }



//=============================================================================

END_XDFLENGINE_NS

---