transactd 1.0.1

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

@@ -0,0 +1,724 @@
+/* =================================================================
+ Copyright (C) 2000-2013 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 <bzs/env/tstring.h>
+#pragma hdrstop
+
+//#define BOOST_THREAD_BUILD_LIB
+#if (__BCPLUSPLUS__  && _WIN64)
+#	define BOOST_ALL_NO_LIB
+#endif
+
+#include "nsDatabase.h"
+#include "nsTable.h"
+#include "stringConverter.h"
+#include <sys/stat.h>
+#include <stdio.h>
+#include <boost/thread/mutex.hpp>
+
+#ifdef LINUX
+#include <dlfcn.h>
+#include <cstddef>
+#include <bzs/env/crosscompile.h>
+typedef void* HANDLE;
+typedef void* HINSTANCE;
+#endif
+
+#pragma package(smart_init)
+
+
+#if (__BCPLUSPLUS__)
+#   ifdef _WIN64
+#	    pragma comment(lib, "boost_chrono-bcb64-mt-1_50.a")
+#	    pragma comment(lib, "boost_thread-bcb64-mt-1_50.a")
+#   else
+#	    pragma comment(lib, "libboost_system-bcb-mt-s-1_39.lib")
+#	    pragma comment(lib, "libboost_filesystem-bcb-mt-s-1_39.lib")
+#	    pragma comment(lib, "libboost_thread-bcb-mt-s-1_39.lib")
+#   endif
+#endif
+
+
+
+namespace bzs
+{
+namespace db
+{
+namespace protocol
+{
+namespace tdap
+{
+namespace client
+{
+extern EnginsFunc engins;
+unsigned int g_lastTrnTime = 0;
+unsigned int nsdatabase::m_execCodepage = GetACP();
+
+
+void registEnginsPtr(EnginsFunc func) {engins = func;}
+
+BTRCALLID_PTR BTRCALLIDX = NULL;
+BTRCALLID_PTR MYTICALLID = NULL;
+
+HANDLE hBtrvDLL = NULL;
+HANDLE hTrsdDLL = NULL;
+
+#ifdef LINUX
+#define LIB_PREFIX "lib"
+#else
+#define LIB_PREFIX
+#endif
+
+BTRCALLID_PTR getTrnsctdEntryPoint()
+{
+    if (MYTICALLID)
+        return MYTICALLID;
+	
+
+    if (hTrsdDLL == NULL)
+        hTrsdDLL = LoadLibraryA(LIB_PREFIX TDCLC_LIBNAME);
+
+    if (hTrsdDLL)
+        MYTICALLID = (BTRCALLID_PTR)GetProcAddress((HINSTANCE)hTrsdDLL, "BTRCALLID");
+    return MYTICALLID;
+}
+
+BTRCALLID_PTR getBtrvEntryPoint() {return BTRCALLIDX;}
+
+int smartLoadLibrary()
+{
+	int ret = 0;
+	if (hBtrvDLL == NULL)
+        hBtrvDLL = LoadLibrary(_T("W3Btrv7"));
+
+    if (hBtrvDLL == NULL)
+        hBtrvDLL = LoadLibrary(_T("WBtrv32"));
+
+    if (hBtrvDLL)
+        BTRCALLIDX = (BTRCALLID_PTR)GetProcAddress((HINSTANCE)hBtrvDLL, "BTRCALLID");
+    if (BTRCALLIDX)
+		ret = 1;
+    MYTICALLID = getTrnsctdEntryPoint();
+	if (MYTICALLID)
+		ret = 2;
+	return ret;
+}
+
+void smartFreeLibrary()
+{
+    if (hBtrvDLL)
+        FreeLibrary((HINSTANCE)hBtrvDLL);
+
+    if (hTrsdDLL)
+        FreeLibrary((HINSTANCE)hTrsdDLL);
+    hBtrvDLL = NULL;
+    hTrsdDLL = NULL;
+    BTRCALLIDX = NULL;
+    MYTICALLID = NULL;
+}
+
+struct nsdbimpl
+{
+    int refCount;
+    int tranCount;
+    unsigned short id;
+    short snapShotCount;
+    nstable* tables[nsdatabase::maxtables];
+    uchar_td clientID[16];
+    uchar_td* cid() {return clientID;}
+    _TCHAR bdfPath[MAX_PATH];
+    short tableCount;
+    short lockWaitCount;
+    short lockWaitTime;
+    bool uriMode;
+    bool uselongFilename;
+    bool localSharing;
+
+	nsdbimpl() : refCount(1), snapShotCount(0), tranCount(0), uselongFilename(false), tableCount(0),
+        lockWaitCount(10), lockWaitTime(100), localSharing(false), uriMode(false)
+    {
+
+    }
+
+    void setId(unsigned short id_)
+    {
+        id = id_;
+
+        // make client id
+        memset(clientID, 0, 12);
+        clientID[12] = 'G';
+        clientID[13] = 'X';
+        memcpy(&clientID[14], &id, 2);
+        bdfPath[0] = 0x00;
+    }
+
+	nsdbimpl& operator= (const nsdbimpl & rt)
+	{
+		if (&rt != this)
+		{
+			lockWaitCount = rt.lockWaitCount;
+			lockWaitTime = rt.lockWaitCount;
+			uselongFilename = rt.uselongFilename;
+			uriMode = rt.uriMode;
+		}
+		return *this;
+	}
+   
+};
+
+boost::mutex g_mutex;
+
+nsdatabase::nsdatabase() : m_stat(0)
+{
+    m_nsimpl = new nsdbimpl();
+    int type = 0;
+    if (hBtrvDLL == 0x00)
+        type = smartLoadLibrary();
+
+    m_btrcallid = getBtrvEntryPoint();
+    if (m_btrcallid == NULL)
+        m_btrcallid = getTrnsctdEntryPoint();
+
+    if ((type == 2) || MYTICALLID)
+        setUseLongFilename(true);
+    else
+    {
+        btrVersions v;
+        memset(&v, 0, sizeof(btrVersions));
+        uchar_td posblk[POS_BLOCK_SIZE] = {0x00};
+        getBtrVersion(&v, posblk);
+        if ((v.versions[1].majorVersion >= 9) || (v.versions[0].majorVersion >= 9))
+            setUseLongFilename(true);
+    }
+
+    for (int i = 0; i < maxtables; i++)
+        m_nsimpl->tables[i] = NULL;
+
+    boost::mutex::scoped_lock lck(g_mutex);
+    // serach empty
+    int i;
+    for (i = 0; i < MAX_BTRENGIN; i++)
+        if (engins()[i] == NULL)
+            break;
+
+    engins()[i] = this;
+
+    // no empty
+    if (MAX_BTRENGIN == i)
+    {
+        m_stat = -1;
+        return;
+    }
+    m_nsimpl->setId((unsigned short)i);
+
+}
+
+int nsdatabase::refCount()const {return m_nsimpl->refCount;}
+
+void nsdatabase::addref()
+{
+	++m_nsimpl->refCount;
+}
+
+void nsdatabase::release()
+{
+	if (--m_nsimpl->refCount == 0)
+		delete this;
+}
+
+nsdatabase::~nsdatabase()
+{
+    reset();
+
+    boost::mutex::scoped_lock lck(g_mutex);
+    if (m_nsimpl->id != 0)
+        engins()[m_nsimpl->id] = NULL;
+	delete m_nsimpl;
+#ifdef _WIN32
+	OutputDebugString(_T("delete database\n"));
+#endif
+}
+
+nsdatabase* nsdatabase::clone() const
+{
+    nsdatabase* p = new nsdatabase();
+    *p = *this;
+    return p;
+}
+
+nsdatabase& nsdatabase:: operator = (const nsdatabase & rt)
+{
+    if (&rt != this)
+    {
+        *m_nsimpl = *rt.m_nsimpl;
+		setUri(rt.uri());
+        m_btrcallid = rt.m_btrcallid;
+    }
+    return *this;
+}
+
+int nsdatabase::enableTrn() const {return m_nsimpl->tranCount;}
+
+short nsdatabase::stat() const {return m_stat;}
+
+uchar_td* nsdatabase::clientID() const {return m_nsimpl->clientID;}
+
+short nsdatabase::openTableCount() const {return m_nsimpl->tableCount;}
+
+_TCHAR* nsdatabase::uri() const {return m_nsimpl->bdfPath;}
+
+bool nsdatabase::uriMode() const {return m_nsimpl->uriMode;}
+
+nstable** nsdatabase::tables() {return m_nsimpl->tables;}
+
+short nsdatabase::lockWaitCount() const {return m_nsimpl->lockWaitCount;}
+
+void nsdatabase::setLockWaitCount(short v) {m_nsimpl->lockWaitCount = v;}
+
+short nsdatabase::lockWaitTime() const {return m_nsimpl->lockWaitTime;}
+
+void nsdatabase::setLockWaitTime(short v) {m_nsimpl->lockWaitTime = v;}
+
+bool nsdatabase::localSharing() const {return m_nsimpl->localSharing;}
+
+void nsdatabase::setLocalSharing(bool v) {m_nsimpl->localSharing = v;}
+
+
+
+bool nsdatabase::setUri(const _TCHAR* Path)
+{
+    _TCHAR buf[MAX_PATH];
+
+#ifdef _WIN32
+    _TCHAR* lpFilePart;
+    if (useLongFilename() == false)
+    {
+        GetFullPathName(Path, MAX_PATH, buf, &lpFilePart);
+        GetShortPathName(buf, m_nsimpl->bdfPath, MAX_PATH);
+        _tcsmupr((_TUCHAR*)m_nsimpl->bdfPath);
+    }
+    else
+#endif
+        _tcscpy(m_nsimpl->bdfPath, Path);
+
+    m_nsimpl->uriMode = false;
+    if (_tcsstr(m_nsimpl->bdfPath, _T("btrv://")) || _tcsstr(m_nsimpl->bdfPath, _T("tdap://")))
+        m_nsimpl->uriMode = true;
+#ifdef _WIN32
+    else
+    {
+        struct _stat statbuf;
+        if (_tstat(m_nsimpl->bdfPath, &statbuf) == -1)
+            return false;
+    }
+#endif
+    return true;
+}
+
+void nsdatabase::createTable(fileSpec *pfs, uint_td len, const _TCHAR *pFullPath, short_td mode)
+{
+    _TCHAR buf[MAX_PATH];
+    _TCHAR posblk[128] = {0x00};
+#ifdef _WIN32
+    if ((useLongFilename() == false) && _tcsstr(pFullPath, _T(" ")))
+    {
+        GetShortPathName(pFullPath, buf, MAX_PATH);
+    }
+    else
+#endif
+    {
+        _tcscpy(buf, pFullPath);
+    }
+    // tdap
+    if (isTransactdUri(buf))
+    {
+        if (setUseTransactd() == false)
+            return;
+    }
+
+    char buf2[MAX_PATH]={0x00};;
+    const char* p = toServerUri(buf2, MAX_PATH, buf, isUseTransactd());
+
+    m_stat = m_btrcallid(TD_CREATETABLE, posblk, pfs, &len, (void*)p, (uchar_td)strlen(p),
+            (char_td)mode, m_nsimpl->clientID);
+}
+
+void nsdatabase::dropTable(const _TCHAR* pFullPath)
+{
+    _TCHAR buf[MAX_PATH];
+    _TCHAR posblk[128] = {0x00};
+#ifdef _WIN32
+    if ((useLongFilename() == false) && _tcsstr(pFullPath, _T(" ")))
+    {
+        GetShortPathName(pFullPath, buf, MAX_PATH);
+    }
+    else
+#endif
+    {
+        _tcscpy(buf, pFullPath);
+    }
+    // tdap
+    if (isTransactdUri(buf))
+    {
+        if (setUseTransactd() == false)
+            return;
+    }
+
+    char buf2[MAX_PATH]={0x00};
+    const char* p = toServerUri(buf2, MAX_PATH, buf, isUseTransactd());
+
+
+    m_stat = m_btrcallid(TD_CREATETABLE, posblk, NULL, NULL, (void*)p, (uchar_td)strlen(p)+1, CR_SUBOP_DROP,
+        m_nsimpl->clientID);
+}
+
+void nsdatabase::swapTablename(const _TCHAR* Name1, const _TCHAR* Name2)
+{
+    _TCHAR posblk[128] = {0x00};
+
+    char buf1[MAX_PATH]={0x00};
+    char buf2[MAX_PATH]={0x00};
+    const char* p = toServerUri(buf1, MAX_PATH, Name1, isUseTransactd());
+    const char* p2 = toServerUri(buf2, MAX_PATH, Name2, isUseTransactd());
+    uint_td len = (uint_td)strlen(p);
+
+    m_stat = m_btrcallid(TD_CREATETABLE, posblk, (void*)p, &len, (void*)p2, (uchar_td)strlen(p2),
+        CR_SUBOP_SWAPNAME, m_nsimpl->clientID);
+}
+
+void nsdatabase::rename(const _TCHAR* pFullPath, const _TCHAR* newName)
+{
+    _TCHAR buf[MAX_PATH];
+    _TCHAR posblk[128] = {0x00};
+#ifdef _WIN32
+    if ((useLongFilename() == false) && _tcsstr(pFullPath, _T(" ")))
+    {
+        GetShortPathName(pFullPath, buf, MAX_PATH);
+    }
+    else
+#endif
+    {
+        _tcscpy(buf, pFullPath);
+    }
+    if (isTransactdUri(buf))
+    {
+        if (setUseTransactd() == false)
+            return;
+    }
+
+    char buf2[MAX_PATH]={0x00};
+    const char* p = toServerUri(buf2, MAX_PATH, buf, isUseTransactd());
+    uint_td len = (uint_td)strlen(p);
+
+
+
+    char bufNew[MAX_PATH]={0x00};
+#ifdef _WIN32
+    if ((useLongFilename() == false) && _tcsstr(newName, _T(" ")))
+        GetShortPathName(newName, buf, MAX_PATH);
+    else
+#endif
+        _tcscpy(buf, newName);
+    toServerUri(bufNew, MAX_PATH, newName, isUseTransactd());
+
+
+
+    m_stat = m_btrcallid(TD_CREATETABLE, posblk, (void*)p, &len, (void*)bufNew, (uchar_td)strlen(bufNew),
+        CR_SUBOP_RENAME, m_nsimpl->clientID);
+}
+
+void nsdatabase::registerTable(nstable* tb)
+{
+    int i;
+    for (i = 0; i < maxtables; i++)
+    {
+        if (m_nsimpl->tables[i] == NULL)
+        {
+            m_nsimpl->tables[i] = tb;
+            m_nsimpl->tableCount++;
+            break;
+        }
+    }
+}
+
+void nsdatabase::unregisterTable(nstable* table)
+{
+    int i;
+    for (i = 0; i < maxtables; i++)
+    {
+        if (m_nsimpl->tables[i] == table)
+        {
+            m_nsimpl->tables[i] = NULL;
+            m_nsimpl->tableCount--;
+			break;
+        }
+    }
+}
+
+
+void nsdatabase::reset()
+{
+    int i;
+
+    if (m_nsimpl->tranCount)
+    {
+#ifdef _WIN32
+    #ifdef ARBTREGN_PKG
+            int ret = MessageBox(NULL, _T("Is an uncompleted transaction aborted?"), NULL, 33);
+    #else
+            int ret = 2;
+    #endif
+#else
+        int ret = 2;
+#endif
+
+        m_nsimpl->tranCount = 1;
+        if (ret == 1)
+            abortTrn();
+        else
+            endTrn();
+    }
+
+    for (i = 0; i < maxtables; i++)
+    {
+        if (m_nsimpl->tables[i] != NULL)
+        {
+			m_nsimpl->tables[i]->destroy();
+            m_nsimpl->tables[i] = NULL;
+        }
+    }
+    m_nsimpl->lockWaitCount = 10;
+    m_nsimpl->lockWaitTime = 200;
+    m_nsimpl->tableCount = 0;
+    m_nsimpl->bdfPath[0] = 0x00;
+    if (m_btrcallid)
+    {
+        m_stat = m_btrcallid(TD_RESET_CLIENT, NULL, NULL, NULL, NULL, 0, 0, m_nsimpl->clientID);
+        m_stat = m_btrcallid(TD_STOP_ENGINE, NULL, NULL, NULL, NULL, 0, 0, m_nsimpl->clientID);
+        if (m_stat == ERROR_TD_NOT_CONNECTED)
+            m_stat = STATUS_SUCCESS;
+    }
+    if (getBtrvEntryPoint())
+        m_btrcallid = getBtrvEntryPoint();
+
+}
+
+void nsdatabase::beginSnapshot()
+{
+    if (m_nsimpl->snapShotCount == 0)
+        m_stat = m_btrcallid(TD_BEGIN_SHAPSHOT, NULL, NULL, NULL, NULL, 0, 0, m_nsimpl->clientID);
+    m_nsimpl->snapShotCount++;
+}
+
+void nsdatabase::endSnapshot()
+{
+    m_nsimpl->snapShotCount--;
+    if (m_nsimpl->snapShotCount == 0)
+        m_stat = m_btrcallid(TD_END_SNAPSHOT, NULL, NULL, NULL, NULL, 0, 0, m_nsimpl->clientID);
+
+}
+
+void nsdatabase::beginTrn(short BIAS)
+{
+    if (m_nsimpl->tranCount == 0)
+    {
+        m_stat = m_btrcallid((ushort_td)(BIAS + TD_BEGIN_TRANSACTION), NULL, NULL, NULL, NULL, 0, 0,
+            m_nsimpl->clientID);
+        if (m_stat == 0)
+            m_nsimpl->tranCount++;
+    }else
+        m_nsimpl->tranCount++;
+}
+
+void nsdatabase::endTrn()
+{
+
+    m_nsimpl->tranCount--;
+    if (m_nsimpl->tranCount == 0)
+    {
+        m_stat = m_btrcallid(TD_END_TRANSACTION, NULL, NULL, NULL, NULL, 0, 0, m_nsimpl->clientID);
+
+#ifdef _WIN32
+        g_lastTrnTime = GetTickCount();
+#endif
+    }
+    if (m_nsimpl->tranCount < 0)
+        m_nsimpl->tranCount = 0;
+}
+
+void nsdatabase::abortTrn()
+{
+    m_stat = m_btrcallid(TD_ABORT_TRANSACTION, NULL, NULL, NULL, NULL, 0, 0, m_nsimpl->clientID);
+
+    m_nsimpl->tranCount = 0;
+#ifdef _WIN32
+    g_lastTrnTime = GetTickCount();
+#endif
+}
+
+short_td nsdatabase::tdapErr(HWND hWnd, _TCHAR* retbuf) {
+    return nstable::tdapErr(hWnd, m_stat, _T("Engin"), retbuf);}
+
+void nsdatabase::getBtrVersion(btrVersions* Vers, uchar_td* posblk)
+{
+
+    uchar_td posblkTmp[128] = {0x00};
+    if (posblk == NULL)
+        posblk = posblkTmp;
+
+    uint_td datalen = sizeof(btrVersions);
+
+    m_stat = m_btrcallid(TD_VERSION, posblk, Vers, &datalen, NULL, 0, 0, m_nsimpl->clientID);
+    {
+        bool remote = false;
+        if (uriMode())
+            remote = true;
+#ifdef _WIN32
+        else if (_tcsstr(m_nsimpl->bdfPath, PSEPARATOR PSEPARATOR) == m_nsimpl->bdfPath)
+            remote = true;
+        else
+        {
+            _TCHAR drive[3] = {0x00};
+            _tcsncpy(drive, m_nsimpl->bdfPath, 2);
+            if (DRIVE_REMOTE == GetDriveType(drive))
+                remote = true;
+        }
+#endif
+        if (remote)
+        {
+            //faile shareing
+            if (datalen / 5 == 2)
+            {
+                Vers->versions[2] = Vers->versions[1];
+                Vers->versions[2].type = 'F';
+            }
+        }
+        else
+            memset(&Vers->versions[2], 0, sizeof(btrVersion));
+    }
+
+}
+
+bool nsdatabase::useLongFilename() {return m_nsimpl->uselongFilename;}
+
+void nsdatabase::setUseLongFilename(bool value) {m_nsimpl->uselongFilename = value;}
+
+bool nsdatabase::setUseTransactd()
+{
+    m_btrcallid = getTrnsctdEntryPoint();
+    if (m_btrcallid == NULL)
+        m_stat = STATUS_REQUESTER_DEACTIVE; // can not load db engin;
+    else
+    {
+        m_nsimpl->uriMode = true;
+        setLockWaitCount(0);
+        setLockWaitTime(0);
+
+    }
+    return (m_btrcallid != NULL);
+}
+
+bool nsdatabase::isTransactdUri(const _TCHAR* uri) {return (_tcsstr(uri, _T("tdap://")) != NULL);
+
+}
+
+bool nsdatabase::isUseTransactd() {return (m_btrcallid == getTrnsctdEntryPoint());}
+
+void nsdatabase::readDatabaseDirectory(_TCHAR* retBuf, uchar_td buflen)
+{
+    // keynum is drive name A=1 B=2 C=3 0=default
+    char tmp[128];
+    m_stat = m_btrcallid(TD_GETDIRECTORY, NULL, NULL, NULL, tmp, 128, 0, m_nsimpl->clientID);
+    toTChar(retBuf, tmp, buflen);
+}
+
+bool nsdatabase::connect(const _TCHAR* URI, bool newConnection)
+{
+    if (isTransactdUri(URI))
+        if (!setUseTransactd())
+            return false;
+
+    uint_td datalen = 0;
+
+    char uri_a[MAX_PATH]={0x00};
+    const char* p = toServerUri(uri_a, MAX_PATH, URI, isUseTransactd());
+    char_td keyNum = newConnection ? 3 : 0;
+    m_stat = m_btrcallid(TD_CONNECT, NULL, NULL, &datalen, (void*)p, (keylen_td)(strlen(p) + 1),
+        keyNum, clientID());
+    if (m_stat)
+        return false;
+    return true;
+}
+
+bool nsdatabase::disconnect(const _TCHAR* URI)
+{
+    if (isTransactdUri(URI))
+        if (!setUseTransactd())
+            return false;
+    uint_td datalen = 0;
+    char uri_a[MAX_PATH];
+    const char* p = toServerUri(uri_a, MAX_PATH, URI, isUseTransactd());
+    m_stat = m_btrcallid(TD_CONNECT, NULL, NULL, &datalen, (void*)p, (keylen_td)(strlen(p) + 1), 1,
+        clientID());
+    if (m_stat)
+        return false;
+    return true;
+
+}
+
+bool nsdatabase::trnsactionFlushWaitStatus()
+{
+    bool ret = false;
+#ifdef  _WIN32
+    if (g_lastTrnTime)
+        ret = ((GetTickCount() - g_lastTrnTime) < 8000);
+    else
+#endif
+        g_lastTrnTime = 0;
+    return ret;
+}
+
+void nsdatabase::setExecCodePage(unsigned int codepage)
+{
+    m_execCodepage = codepage;
+}
+
+unsigned int nsdatabase::execCodePage()
+{
+    return m_execCodepage;
+}
+
+const char* nsdatabase::toServerUri(char* buf, int buflen, const _TCHAR* src, bool trd)
+{
+    #ifdef _UNICODE
+    if (trd)
+    {
+        stringConverter cv(CP_UTF8, GetACP());
+        cv.convert(buf, buflen, src, strlen_t(src));
+        return buf;
+    }
+    #endif
+    return toChar(buf, src, buflen);
+
+}
+
+}// namespace client
+}// namespace tdap
+}// namespace protocol
+}// namespace db
+}// namespace bzs