transactd 1.2.0 → 2.0.0

data/source/bzs/db/protocol/tdap/client/connMgr.cpp

@@ -16,13 +16,9 @@
    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
    02111-1307, USA.
 =================================================================*/
-#include <bzs/env/tstring.h>
-#pragma hdrstop
-
 #include "connMgr.h"
 #include "database.h"
 
-
 #pragma package(smart_init)
 
 namespace bzs
@@ -36,17 +32,18 @@ namespace tdap
 namespace client
 {
 
-
-connMgr::connMgr(database* db):nstable(db)
+connMgr::connMgr(database* db) : nstable(db)
 {
     m_db = db;
 }
 
 connMgr::~connMgr()
 {
-
 }
-database*  connMgr::db()const{return m_db;}
+database* connMgr::db() const
+{
+    return m_db;
+}
 
 void connMgr::connect(const _TCHAR* uri)
 {
@@ -67,11 +64,12 @@ void connMgr::disconnect()
     }
 }
 
-void  connMgr::allocBuffer()
+void connMgr::allocBuffer()
 {
-    m_records.resize(64000/sizeof(connMgr::record));
+    m_records.resize(64000 / sizeof(connMgr::record));
 
-    m_datalen = m_buflen = (uint_td)(m_records.size()*sizeof(connMgr::record));
+    m_datalen = m_buflen =
+        (uint_td)(m_records.size() * sizeof(connMgr::record));
     m_pdata = (void*)&m_records[0];
     memset(m_pdata, 0, m_datalen);
     setIsOpen(true);
@@ -87,7 +85,7 @@ const connMgr::records& connMgr::connections()
     m_keynum = TD_STSTCS_READ;
     tdap(TD_STASTISTICS);
     if (m_stat == 0)
-        m_records.resize(m_datalen/sizeof(connMgr::record));
+        m_records.resize(m_datalen / sizeof(connMgr::record));
     return m_records;
 }
 
@@ -99,7 +97,7 @@ const connMgr::records& connMgr::databases(__int64 connid)
     m_params[1] = -1;
     tdap(TD_STASTISTICS);
     if (m_stat == 0)
-        m_records.resize(m_datalen/sizeof(connMgr::record));
+        m_records.resize(m_datalen / sizeof(connMgr::record));
     return m_records;
 }
 
@@ -111,7 +109,7 @@ const connMgr::records& connMgr::tables(__int64 connid, int dbid)
     m_params[1] = dbid;
     tdap(TD_STASTISTICS);
     if (m_stat == 0)
-        m_records.resize(m_datalen/sizeof(connMgr::record));
+        m_records.resize(m_datalen / sizeof(connMgr::record));
     return m_records;
 }
 
@@ -127,7 +125,6 @@ void connMgr::disconnectAll()
 {
     m_keynum = TD_STSTCS_DISCONNECT_ALL;
     tdap(TD_STASTISTICS);
-
 }
 
 short_td connMgr::stat()
@@ -135,10 +132,8 @@ short_td connMgr::stat()
     return m_stat;
 }
 
-
-
-}//namespace client
-}//namespace tdap
-}//namespace protocol
-}//namespace db
-}//namespace bzs
+} // namespace client
+} // namespace tdap
+} // namespace protocol
+} // namespace db
+} // namespace bzs

data/source/bzs/db/protocol/tdap/client/connMgr.h

@@ -22,7 +22,6 @@
 #include <bzs/db/transactd/connectionRecord.h>
 #include <vector>
 
-
 namespace bzs
 {
 namespace db
@@ -35,28 +34,28 @@ namespace client
 {
 
 class database;
-#pragma warning(disable:4251)
+#pragma warning(disable : 4251)
 
-class AGRPACK connMgr : private nstable
+class DLLLIB connMgr : private nstable
 {
 public:
-    typedef  bzs::db::transactd::connection::record  record;
-    typedef  std::vector<record> records;
-protected:
-
+    typedef bzs::db::transactd::connection::record record;
+    typedef std::vector<record> records;
 
+protected:
 private:
     std::vector<record> m_records;
-	__int64 m_params[2];
+    __int64 m_params[2];
     database* m_db;
     std::_tstring m_uri;
     void allocBuffer();
     void writeRecordData(){};
     void onReadAfter(){};
 
-     ~connMgr();
+    ~connMgr();
+
 public:
-	explicit connMgr(database* db);
+    explicit connMgr(database* db);
 
     void connect(const _TCHAR* uri);
     void disconnect();
@@ -67,16 +66,15 @@ public:
     void disconnectAll();
     short_td stat();
 
-    database* db()const;
+    database* db() const;
     using nstable::tdapErr;
 };
 
-#pragma warning(default:4251)
-
+#pragma warning(default : 4251)
 
-}//namespace client
-}//namespace tdap
-}//namespace protocol
-}//namespace db
-}//namespace bzs
-#endif //BZS_DB_PROTOCOL_TDAP_CLIENT_CTDCONNMGR_H
+} // namespace client
+} // namespace tdap
+} // namespace protocol
+} // namespace db
+} // namespace bzs
+#endif // BZS_DB_PROTOCOL_TDAP_CLIENT_CTDCONNMGR_H

data/source/bzs/db/protocol/tdap/client/connectionPool.cpp

@@ -0,0 +1,243 @@
+/*=================================================================
+   Copyright (C) 2014 BizStation Corp All rights reserved.
+
+   This program 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.
+=================================================================*/
+#include "connectionPool.h"
+
+#ifdef __BCPLUSPLUS__
+#ifdef _WIN64
+#define BZS_LINK_BOOST_SYSTEM
+#define BZS_LINK_BOOST_THREAD
+#define BZS_LINK_BOOST_CHRONO
+namespace boost
+{
+void tss_cleanup_implemented()
+{
+}
+}
+#else
+#define BZS_LINK_BOOST_THREAD
+namespace boost
+{
+extern "C" void tss_cleanup_implemented()
+{
+}
+}
+#endif
+#include <bzs/env/boost_bcb_link.h>
+#endif
+
+namespace bzs
+{
+namespace db
+{
+namespace protocol
+{
+namespace tdap
+{
+namespace client
+{
+
+#ifdef TRANSACTD_RB_CALL_WITHOUT_GVL
+struct busyWaitArguments
+{
+    mutable boost::condition* m_busy;
+    mutable boost::mutex* m_mutex2;
+};
+
+void scopedLock(boost::mutex::scoped_lock* lck)
+{
+    lck->lock();
+}
+
+void busyWait(busyWaitArguments* args)
+{
+    boost::mutex::scoped_lock lck(*(args->m_mutex2));
+    args->m_busy->wait(lck);
+}
+#endif // TRANSACTD_RB_CALL_WITHOUT_GVL
+
+short __STDCALL dllUnloadCallbackFunc()
+{
+    cpool.reset(0);
+    cpool.m_regitfunc = NULL;
+    return 0;
+}
+
+void releaseConnection(stdDbmCconnectionPool* pool)
+{
+    pool->releaseOne();
+}
+
+template <class Database_Ptr>
+connectionPool<Database_Ptr>::connectionPool(int maxConnections)
+    : m_maxConnections(maxConnections)
+{
+#ifdef USE_DLLUNLOAD_CALLBACK
+    m_regitfunc = nsdatabase::getDllUnloadCallbackFunc();
+    if (m_regitfunc)
+        m_regitfunc(dllUnloadCallbackFunc);
+#else
+    m_regitfunc = NULL;
+#endif
+}
+
+template <class Database_Ptr> connectionPool<Database_Ptr>::~connectionPool()
+{
+    if (m_regitfunc)
+        m_regitfunc(NULL);
+}
+
+template <class Database_Ptr>
+Database_Ptr connectionPool<Database_Ptr>::addOne(const connectParams& param)
+{
+    Database_Ptr db;
+    db = createDatabaseForConnectionPool(db);
+    connectOpen(db, param, true /* new connection*/);
+    m_dbs.push_back(db);
+    return m_dbs[m_dbs.size() - 1];
+}
+
+/** Delivery database instance
+        If a connect error is occured then bzs::rtl::exception exception is
+   thrown.
+*/
+template <class Database_Ptr>
+Database_Ptr connectionPool<Database_Ptr>::get(const connectParams* param)
+{
+    boost::mutex::scoped_lock lck(m_mutex, boost::defer_lock);
+#ifdef TRANSACTD_RB_CALL_WITHOUT_GVL
+    TRANSACTD_RB_CALL_WITHOUT_GVL(scopedLock, lck);
+#else
+    lck.lock();
+#endif
+    assert((param && m_maxConnections) || m_dbs.size());
+
+    while (1)
+    {
+        for (size_t i = 0; i < m_dbs.size(); i++)
+        {
+            if (m_dbs[i].use_count() == 1)
+            {
+                if (param)
+                {
+                    Database_Ptr db = m_dbs[i];
+                    if (isSameUri(param, db))
+                        return db;
+                }
+                else
+                    return m_dbs[i];
+            }
+        }
+        // create a new database object if there is no free one.
+        if (param && (m_maxConnections > (int)m_dbs.size()))
+            return addOne(*param);
+// Wait until releaseOne() called
+#ifdef TRANSACTD_RB_CALL_WITHOUT_GVL
+        busyWaitArguments bwArgs;
+        bwArgs.m_busy = &m_busy;
+        bwArgs.m_mutex2 = &m_mutex2;
+        TRANSACTD_RB_CALL_WITHOUT_GVL(busyWait, bwArgs);
+#else
+        boost::mutex::scoped_lock lck(m_mutex2);
+        m_busy.wait(lck);
+#endif
+    }
+}
+
+/** Create database and login the server with each connection.
+        If a connect error is occured then bzs::rtl::exception exception is
+   thrown.
+*/
+template <class Database_Ptr>
+void connectionPool<Database_Ptr>::reserve(size_t size,
+                                           const connectParams& param)
+{
+    boost::mutex::scoped_lock lck(m_mutex, boost::defer_lock);
+#ifdef TRANSACTD_RB_CALL_WITHOUT_GVL
+    TRANSACTD_RB_CALL_WITHOUT_GVL(scopedLock, lck);
+#else
+    lck.lock();
+#endif
+    m_maxConnections = (int)size;
+    for (size_t i = 0; i < size; ++i)
+        addOne(param);
+}
+
+/** Set max connections.*/
+template <class Database_Ptr>
+void connectionPool<Database_Ptr>::setMaxConnections(int n)
+{
+    boost::mutex::scoped_lock lck(m_mutex, boost::defer_lock);
+#ifdef TRANSACTD_RB_CALL_WITHOUT_GVL
+    TRANSACTD_RB_CALL_WITHOUT_GVL(scopedLock, lck);
+#else
+    lck.lock();
+#endif
+    m_maxConnections = n;
+}
+
+/** Return max connections. */
+template <class Database_Ptr>
+int connectionPool<Database_Ptr>::maxConnections() const
+{
+    return m_maxConnections;
+}
+
+template <class Database_Ptr> void connectionPool<Database_Ptr>::releaseOne()
+{
+    m_busy.notify_one();
+}
+
+// max 5second
+template <class Database_Ptr>
+bool connectionPool<Database_Ptr>::reset(int waitSec)
+{
+    boost::mutex::scoped_lock lck(m_mutex, boost::defer_lock);
+#ifdef TRANSACTD_RB_CALL_WITHOUT_GVL
+    TRANSACTD_RB_CALL_WITHOUT_GVL(scopedLock, lck);
+#else
+    lck.lock();
+#endif
+    bool flag = true;
+    for (int j = 0; j < waitSec * 100; j++)
+    {
+        flag = false;
+        for (size_t i = 0; i < m_dbs.size(); i++)
+            if (m_dbs[i].use_count() != 1)
+                flag = true;
+        if (!flag)
+            break;
+        Sleep(100 * MCRTOMM);
+    }
+    m_dbs.clear();
+    return flag;
+}
+
+#ifdef USE_DBM_CONNECTION_POOL
+template class connectionPool<dbmanager_ptr>;
+#else
+template class connectionPool<database_ptr>;
+#endif
+
+stdCconnectionPool cpool;
+
+} // namespace client
+} // namespace tdap
+} // namespace protocol
+} // namespace db
+} // namespace bzs

data/source/bzs/db/protocol/tdap/client/connectionPool.h

@@ -0,0 +1,109 @@
+#ifndef BZS_DB_PROTOCOL_TDAP_CLIENT_CONNECTIONPOOL_H
+#define BZS_DB_PROTOCOL_TDAP_CLIENT_CONNECTIONPOOL_H
+/*=================================================================
+   Copyright (C) 2014 BizStation Corp All rights reserved.
+
+   This program 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.
+=================================================================*/
+#if HAVE_RB_THREAD_CALL_WITHOUT_GVL || HAVE_RB_THREAD_BLOCKING_REGION
+#include <build/swig/ruby/threadBlockRegionWrapper.h>
+#endif
+
+#include <bzs/db/protocol/tdap/client/databaseManager.h>
+#define BOOST_THREAD_USE_LIB
+#include <boost/thread/thread.hpp>
+#include <boost/thread/condition.hpp>
+#include <vector>
+
+namespace bzs
+{
+namespace db
+{
+namespace protocol
+{
+namespace tdap
+{
+namespace client
+{
+
+/** connection pool class
+        Hold database or databaseManager instance and delivery.
+
+        If maxConnections = 0 then not create databases automaticaly at no free
+   a database.
+        This case need call reserve() function at start up the process.\n
+
+        Otherwise, create new database automaticaly by get() function with
+   connectParams.
+        This case need call setMaxConnections() function at start up the
+   process.
+*/
+
+template <class Database_Ptr> class connectionPool
+{
+    std::vector<Database_Ptr> m_dbs;
+    mutable boost::mutex m_mutex;
+    mutable boost::mutex m_mutex2;
+    mutable boost::condition m_busy;
+    int m_maxConnections;
+    Database_Ptr addOne(const connectParams& param);
+#if (__BCPLUSPLUS__)
+public:
+#endif
+    DLLUNLOADCALLBACK_PTR m_regitfunc;
+    friend short __STDCALL dllUnloadCallbackFunc();
+
+public:
+    connectionPool(int maxConnections = 0);
+    ~connectionPool();
+
+    Database_Ptr get(const connectParams* param = NULL);
+    void reserve(size_t size, const connectParams& param);
+    void setMaxConnections(int n);
+    int maxConnections() const;
+    void releaseOne();
+    bool reset(int waitSec = 5);
+};
+
+typedef connectionPool<database_ptr> stdDbCconnectionPool;
+typedef connectionPool<dbmanager_ptr> stdDbmCconnectionPool;
+
+/** stdDbmCconnectionPool is default for connetion pool.
+        pooling database and reuse tables.
+*/
+#ifdef USE_DBM_CONNECTION_POOL
+typedef stdDbmCconnectionPool stdCconnectionPool;
+#else
+#ifdef USE_DB_CONNECTION_POOL
+typedef stdDbCconnectionPool stdCconnectionPool;
+#else
+#error                                                                         \
+    "Please define the USE_DBM_CONNECTION_POOL when you need a connection pool";
+#endif
+#endif
+
+short __STDCALL dllUnloadCallbackFunc();
+void releaseConnection(stdDbmCconnectionPool* pool);
+
+extern stdCconnectionPool cpool;
+
+} // namespace client
+} // namespace tdap
+} // namespace protocol
+} // namespace db
+} // namespace bzs
+
+#endif // BZS_DB_PROTOCOL_TDAP_CLIENT_CONNECTIONPOOL_H