transactd 3.4.1 → 3.5.0

data/source/global/replication/replCommand.h

@@ -0,0 +1,161 @@
+
+#ifndef GLOBAL_REPLICATION_REPLCOMMANDH
+#define GLOBAL_REPLICATION_REPLCOMMANDH
+/*=================================================================
+   Copyright (C) 2016 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/db/protocol/tdap/client/fields.h>
+#include <bzs/db/protocol/tdap/client/trdboostapi.h>
+#include <bzs/db/protocol/tdap/client/connMgr.h>
+
+namespace bz = bzs::db::protocol::tdap;
+namespace bzc = bzs::db::protocol::tdap::client;
+
+// Copy mode
+#define CP_NO_SCHEMA              1
+#define CP_NO_DB                  2
+
+// Node options
+#define OPT_UNTIL_WAIT            1
+#define OPT_CREATE_BY_SCHEM_IF    2
+#define OPT_DISABLE_LOGBIN        4
+#define OPT_RESET_MASTER          8
+
+
+// Replication mode
+#define REP_TYPE_REGACY           0
+#define REP_TYPE_GTID_MA          1
+#define REP_TYPE_GTID_MY          2
+
+
+// Replication error
+#define ERROR_IO_THREAD               1
+#define ERROR_SQL_THREAD              2
+#define ERROR_LOG_BROKN               3
+#define ERROR_FAILED                  4
+
+// Replication error resolve results
+#define RESOLV_RESULT_CANCEL          2
+#define RESOLV_RESULT_YES             6
+#define RESOLV_RESULT_NO              7
+
+// Replication params
+struct node
+{
+private:
+    int options;
+public:
+    std::_tstring host;
+    std::_tstring port;
+    std::_tstring db;
+    std::_tstring schema;
+    std::_tstring user;
+    std::_tstring passwd;
+
+    node() : options(OPT_UNTIL_WAIT) {};
+    bzc::connectParams cp(int opt=0);
+    bool option(int op) const { return (options & op) != 0 ;}
+    void setOption(int op, bool enable=true);
+};
+
+struct masterNode : public node
+{
+    masterNode() : node(){}
+    std::string repPort;
+    std::string repUser;
+    std::string repPasswd;
+    std::string repOption;
+    std::string channel;
+};
+
+
+struct replicationParam
+{
+    masterNode master;
+    node slave;
+    std::vector<std::_tstring> skipTables;
+    int type;
+    bool needSlaveWait() { return slave.option(OPT_UNTIL_WAIT);}
+    void setSlaveWait(bool v){ slave.setOption(OPT_UNTIL_WAIT, v);}
+    bool isCreateBySchemIf() { return slave.option(OPT_CREATE_BY_SCHEM_IF);}
+    void setCreateBySchemIf(bool v){ slave.setOption(OPT_CREATE_BY_SCHEM_IF, v);}
+    bool isDisableLogbin() { return slave.option(OPT_DISABLE_LOGBIN);}
+    void setDisableLogbin(bool v){ slave.setOption(OPT_DISABLE_LOGBIN, v);}
+    replicationParam() : type(REP_TYPE_REGACY) {}
+};
+
+#define REP_NF_WAIT                   1000
+
+class replicationNotify
+{
+public:
+    virtual ~replicationNotify() {};
+    virtual void onUpdateStaus(int status) = 0;
+    virtual int onResolvError(int type, const bzc::connMgr::records& recs) = 0;
+};
+
+
+// replication manegemnet operations
+class replSlave
+{
+    struct replImpl* m_impl;
+    bzc::database_ptr m_db;
+    bzc::connMgr* m_mgr;
+    bool m_mysqlGtid;
+    void validateError(const _TCHAR* msg);
+    bool isSlaveSync(bzc::binlogPos& bpos, replicationNotify* nf);
+    bool resolvBroknError(const bzc::connMgr::records& recs, replicationNotify* nf);
+    bool resolvIOError(const bzc::connMgr::records& recs, replicationNotify* nf);
+    bool resolvSqlError(const bzc::connMgr::records& recs, bzc::binlogPos& bpos, replicationNotify* nf);
+
+public:
+    enum autoPosType{slave_pos, current_pos};
+
+    replSlave(bzc::database_ptr db, replicationParam& pm, bzc::connMgr* mgr);
+    ~replSlave();
+    void setSkipError(const char* gtid);
+    void stop(bool all=true);
+    void start(bool all=true);
+    void startNoThrow();
+    void reset();
+    void resetAll();
+    bool startUntil(bzc::binlogPos& bpos);
+    void waitForSlaveSync(bzc::binlogPos& bpos, int waitTime, replicationNotify* nf);
+    void changeMaster(const bzc::binlogPos* bpos);
+    void switchMaster(autoPosType v);
+    void skipLogEvent(const char* gtid);
+    void stopAndReset();
+    void resetMaster();
+    bool isMysqlGtidMode() const {return m_mysqlGtid;}
+    const replicationParam& params() const;
+};
+
+std::string toUtf8(const std::_tstring& s);
+bool isGtidAutoPos(const bzc::connMgr::records& recs);
+bool isPosBrokn(const bzc::connMgr::records& recs);
+std::string getSkipGtid(const bzc::connMgr::records& recs);
+bool isSlaveSqlRunning(const bzc::connMgr::records& recs);
+bool isSlaveIoRunning(const bzc::connMgr::records& recs);
+void notyfy(replicationNotify* nf, int v);
+int resolv(replicationNotify* nf, int type, const bzc::connMgr::records& recs, int defValue);
+
+static const bool all=true;
+static const bool one=false;
+
+
+#endif // GLOBAL_REPLICATION_REPLCOMMANDH

data/source/global/tdclatl/BinlogPos.cpp

@@ -59,6 +59,16 @@ STDMETHODIMP CBinlogPos::get_Gtid(BSTR* retVal)
     return S_OK;
 }
 
+STDMETHODIMP CBinlogPos::put_Gtid(BSTR Value)
+{
+    int size = WideCharToMultiByte(CP_ACP, WC_COMPOSITECHECK, Value, -1, NULL, 0, NULL, NULL);
+    char* p = new char[size + 1];
+    WideCharToMultiByte(CP_ACP, WC_COMPOSITECHECK, Value, -1, p, size + 1, NULL, NULL);
+    m_pos.setGtid(p);
+    delete [] p;
+    return S_OK;
+}
+
 
 
     

data/source/global/tdclatl/BinlogPos.h

@@ -79,6 +79,7 @@ public:
     STDMETHOD(get_Type)(short* retVal);
     STDMETHOD(get_Filename)(BSTR* retVal);
     STDMETHOD(get_Gtid)(BSTR* retVal);
+    STDMETHOD(put_Gtid)(BSTR Value);
 };
 
 //OBJECT_ENTRY_AUTO(__uuidof(Bitset), CBitset)

data/source/global/tdclatl/ConnMgr.cpp

@@ -159,14 +159,14 @@ STDMETHODIMP CConnMgr::Statusvars(IConnRecords** retVal)
     return S_OK;
 }
 
-STDMETHODIMP CConnMgr::SlaveStatus(IConnRecords** retVal)
+STDMETHODIMP CConnMgr::SlaveStatus(BSTR channel, IConnRecords** retVal)
 {
     if (m_mgr == NULL) Error(_T("No database error"), IID_IConnMgr);
     CComObject<CConnRecords>* obj;
     CComObject<CConnRecords>::CreateInstance(&obj);
     if (!obj)
         return Error("CreateInstance ConnRecords", IID_IConnMgr);
-    obj->m_recs = m_mgr->slaveStatus();
+    obj->m_recs = m_mgr->slaveStatus(channel);
     setResult(obj, retVal);
     return S_OK;
 }
@@ -303,4 +303,91 @@ STDMETHODIMP CConnMgr::StatusvarName(int index, BSTR* retVal)
 }
 
 
+STDMETHODIMP CConnMgr::Extendedvars(IConnRecords** retVal)
+{
+    if (m_mgr == NULL) Error(_T("No database error"), IID_IConnMgr);
+    CComObject<CConnRecords>* obj;
+    CComObject<CConnRecords>::CreateInstance(&obj);
+    if (!obj)
+        return Error("CreateInstance ConnRecords", IID_IConnMgr);
+    obj->m_recs = m_mgr->extendedvars();
+    setResult(obj, retVal);
+    return S_OK;
+}
+
+STDMETHODIMP CConnMgr::SlaveHosts(IConnRecords** retVal)
+{
+    if (m_mgr == NULL) Error(_T("No database error"), IID_IConnMgr);
+    CComObject<CConnRecords>* obj;
+    CComObject<CConnRecords>::CreateInstance(&obj);
+    if (!obj)
+        return Error("CreateInstance ConnRecords", IID_IConnMgr);
+    obj->m_recs = m_mgr->slaveHosts();
+    setResult(obj, retVal);
+    return S_OK;
+}
+
+STDMETHODIMP CConnMgr::Channels(IConnRecords** retVal)
+{
+    if (m_mgr == NULL) Error(_T("No database error"), IID_IConnMgr);
+    CComObject<CConnRecords>* obj;
+    CComObject<CConnRecords>::CreateInstance(&obj);
+    if (!obj)
+        return Error("CreateInstance ConnRecords", IID_IConnMgr);
+    obj->m_recs = m_mgr->channels();
+    setResult(obj, retVal);
+    return S_OK;
+}
+
+STDMETHODIMP CConnMgr::ExtendedVarName(int index, BSTR* retVal)
+{
+    CComBSTR ret= connMgr::extendedVarName(index);
+    *retVal = ret.Copy();
+    return S_OK;
+}
+
+STDMETHODIMP CConnMgr::HaLock(VARIANT_BOOL* retVal)
+{
+    if (m_mgr == NULL) Error(_T("No database error"), IID_IConnMgr);
+    *retVal = m_mgr->haLock();
+    return S_OK;
+}
+
+STDMETHODIMP CConnMgr::HaUnlock()
+{
+    if (m_mgr == NULL) Error(_T("No database error"), IID_IConnMgr);
+    m_mgr->haUnlock();
+    return S_OK;
+}
+
+STDMETHODIMP CConnMgr::SetRole(int v, VARIANT_BOOL* retVal)
+{
+    if (m_mgr == NULL) Error(_T("No database error"), IID_IConnMgr);
+    *retVal = m_mgr->setRole(v);
+    return S_OK;
+}
+
+STDMETHODIMP CConnMgr::SetTrxBlock(VARIANT_BOOL v, VARIANT_BOOL* retVal)
+{
+    if (m_mgr == NULL) Error(_T("No database error"), IID_IConnMgr);
+    *retVal = m_mgr->setTrxBlock(v!=0);
+    return S_OK;
+}
+
+STDMETHODIMP CConnMgr::SetEnableFailover(VARIANT_BOOL v, VARIANT_BOOL* retVal)
+{
+    if (m_mgr == NULL) Error(_T("No database error"), IID_IConnMgr);
+    *retVal = m_mgr->setEnableFailover(v!=0);
+    return S_OK;
+}
+
+STDMETHODIMP CConnMgr::get_IsOpen(VARIANT_BOOL* retVal)
+{
+    if (m_mgr == NULL) Error(_T("No database error"), IID_IConnMgr);
+    *retVal = m_mgr->isOpen();
+    return S_OK;
+}
+
+
+
 

data/source/global/tdclatl/ConnMgr.h

@@ -59,7 +59,7 @@ public:
     STDMETHOD(Views)(BSTR dbname, IConnRecords** retVal);
     STDMETHOD(SchemaTables)(BSTR dbname, IConnRecords** retVal);
     STDMETHOD(Sysvars)(IConnRecords** retVal);
-    STDMETHOD(SlaveStatus)(IConnRecords** retVal);
+    STDMETHOD(SlaveStatus)(BSTR channel, IConnRecords** retVal);
     STDMETHOD(Connections)(IConnRecords** retVal);
 #ifdef _WIN64
     STDMETHOD(InUseDatabases)(__int64 connid, IConnRecords** retVal);
@@ -80,6 +80,18 @@ public:
     STDMETHOD(Statusvars)(IConnRecords** retVal);
     STDMETHOD(StatusvarName)(int index, BSTR* retVal);
 
+    STDMETHOD(Extendedvars)(IConnRecords** retVal);
+    STDMETHOD(SlaveHosts)(IConnRecords** retVal);
+    STDMETHOD(Channels)(IConnRecords** retVal);
+    STDMETHOD(ExtendedVarName)(int index, BSTR* retVal);
+
+    STDMETHOD(HaLock)(VARIANT_BOOL* retVal);
+    STDMETHOD(HaUnlock)();
+    STDMETHOD(SetRole)(int v, VARIANT_BOOL* retVal);
+    STDMETHOD(SetTrxBlock)(VARIANT_BOOL v, VARIANT_BOOL* retVal);
+    STDMETHOD(SetEnableFailover)(VARIANT_BOOL v, VARIANT_BOOL* retVal);
+    STDMETHOD(get_IsOpen)(VARIANT_BOOL* retVal);
+
 };
 
 OBJECT_ENTRY_AUTO(__uuidof(ConnMgr), CConnMgr)

data/source/global/tdclatl/ConnRecord.cpp

@@ -58,13 +58,13 @@ STDMETHODIMP CConnRecord::get_Id(int* retVal)
     return S_OK;
 }
 
-STDMETHODIMP CConnRecord::get_Db(short* retVal)
+STDMETHODIMP CConnRecord::get_Db(int* retVal)
 {
     *retVal = m_rec.db;
     return S_OK;
 }
 
-STDMETHODIMP CConnRecord::get_Type(short* retVal)
+STDMETHODIMP CConnRecord::get_Type(int* retVal)
 {
     *retVal = m_rec.type;
     return S_OK;
@@ -128,4 +128,10 @@ STDMETHODIMP CConnRecord::get_InsCount(int* retVal)
 {
     *retVal = m_rec.insCount;
     return S_OK;
+}
+
+STDMETHODIMP CConnRecord::get_Port(int* retVal)
+{
+    *retVal = m_rec.port;
+    return S_OK;
 }

data/source/global/tdclatl/ConnRecord.h

@@ -55,9 +55,9 @@ public:
 #else
     STDMETHOD (get_ConId)(BSTR* retVal);
 #endif
-    STDMETHOD (get_Id)(int* retVal); //unsigned int value_id;
-    STDMETHOD (get_Db)(short* retVal);
-    STDMETHOD (get_Type)(short* retVal); //trnType
+    STDMETHOD (get_Id)(int* retVal); 
+    STDMETHOD (get_Db)(int* retVal);
+    STDMETHOD (get_Type)(int* retVal); 
     STDMETHOD (get_Name)(BSTR* retVal); 
     STDMETHOD (get_Value)(BSTR* retVal); 
     STDMETHOD (get_Status)(short* retVal); 
@@ -66,5 +66,6 @@ public:
     STDMETHOD (get_DelCount)(int* retVal); 
     STDMETHOD (get_InsCount)(int* retVal); 
     STDMETHOD (get_LongValue)(BSTR* retVal); 
+    STDMETHOD (get_Port)(int* retVal);
 };
 

data/source/global/tdclatl/Database.cpp

@@ -635,6 +635,19 @@ STDMETHODIMP CDatabase::GetCreateViewSql(BSTR name, BSTR* retVal)
     return S_OK;
 }
 
+STDMETHODIMP CDatabase::get_EnableAutoReconnect(VARIANT_BOOL* retVal)
+{
+    *retVal = m_db->enableAutoReconnect();   
+    return S_OK;
+}
+
+STDMETHODIMP CDatabase::put_EnableAutoReconnect(VARIANT_BOOL val)
+{
+    m_db->setEnableAutoReconnect(val != 0);   
+    return S_OK;
+}    
+
+
 void __stdcall onCopyData(database* db, table* tb, int recordCount, int count,
                           bool& cancel)
 {

data/source/global/tdclatl/Database.h

@@ -165,6 +165,8 @@ public:
     STDMETHOD(get_IsAssociate)(VARIANT_BOOL* retVal);
     STDMETHOD(GetCreateViewSql)(BSTR name, BSTR* retVal);
     STDMETHOD(ExecSql)(BSTR Sql, VARIANT_BOOL* Value);
+    STDMETHOD(get_EnableAutoReconnect)(VARIANT_BOOL* retVal);
+    STDMETHOD(put_EnableAutoReconnect)(VARIANT_BOOL val);
 };
 
 OBJECT_ENTRY_AUTO(__uuidof(Database), CDatabase)

data/source/global/tdclatl/HaNameREsolver.cpp

@@ -0,0 +1,54 @@
+// HaNameREsolver.cpp : CHaNameREsolver �̎���
+
+#include "stdafx.h"
+#include "HaNameREsolver.h"
+#include <comutil.h>
+using namespace bzs::db::protocol::tdap::client;
+
+// CHaNameREsolver
+STDMETHODIMP CHaNameResolver::Start(BSTR master, BSTR slaves,
+                   BSTR slaveHostsWithPort, short slaveNum,
+                   BSTR userName,
+                   BSTR password,
+                   int option, int* retVal)
+{
+    *retVal = haNameResolver::start(_bstr_t(master), _bstr_t(slaves),
+                        _bstr_t(slaveHostsWithPort),slaveNum,
+                        _bstr_t(userName),_bstr_t(password), 
+                        option);
+    return S_OK;
+}
+
+STDMETHODIMP CHaNameResolver::AddPortMap(short mysqlPort, short transactdPort)
+{
+    haNameResolver::addPortMap(mysqlPort, transactdPort);
+    return S_OK;
+}
+
+STDMETHODIMP CHaNameResolver::ClearPortMap()
+{
+    haNameResolver::clearPortMap();
+    return S_OK;
+}
+
+STDMETHODIMP CHaNameResolver::Stop()
+{
+    haNameResolver::stop();
+    return S_OK;
+}
+
+STDMETHODIMP CHaNameResolver::get_Master(BSTR* retVal)
+{
+    CComBSTR ret= haNameResolver::master();
+    *retVal = ret.Copy();
+    return S_OK;
+}
+
+STDMETHODIMP CHaNameResolver::get_Slave(BSTR* retVal) 
+{
+    CComBSTR ret= haNameResolver::slave();
+    *retVal = ret.Copy();
+    return S_OK;
+}
+
+