//
|
// Created by ps on 18-11-29.
|
//
|
|
#include "ErlangDbTool.h"
|
|
#include <QtSql/QSql>
|
#include <QtSql/QSqlDatabase>
|
#include <QtSql/QSqlError>
|
#include <QtSql/QSqlQuery>
|
#include <QtCore/QString>
|
#include <QtCore/QDebug>
|
#include <QtCore/QVariantList>
|
|
using ErlangTool::map_DevDataCache;
|
using ErlangTool::map_TabDataCache;
|
using ErlangTool::map_BwDataCache;
|
using ErlangTool::map_FaceDataCache;
|
|
|
static QSqlDatabase g_syncDbFile = QSqlDatabase::addDatabase("QSQLITE", "SyncDBSqliteFile");
|
|
|
static bool ErlangTool::dir_file_exists(std::string dir, bool mkdir_flag) {
|
int state = access(dir.c_str(), R_OK | W_OK); // 头文件 #include <unistd.h>
|
if (state == 0) {
|
//#todo
|
INFO("file exist");
|
return true;
|
} else if (mkdir_flag) {
|
dir = "mkdir -p " + dir;
|
system(dir.c_str()); // 调用linux系统命令创建文件
|
//#todo
|
return true;
|
} else {
|
return false;
|
}
|
}
|
|
static bool ErlangTool::pingNode(const std::string &nodeName, const std::string &cookie) {
|
int fd = -1;
|
int ret = -1;
|
// erl_init(NULL, 0);
|
// struct in_addr addr;
|
// addr.s_addr = inet_addr("127.0.0.1");
|
|
// std::string str_node("cnode");
|
// str_node.append(to_string((int) getpid()));
|
|
// std::string t_nodeName(str_node);
|
// t_nodeName.append("@127.0.0.1");
|
|
// INFO("str_node << " << str_node << " ;t_nodeName " << t_nodeName);
|
|
// if (erl_connect_xinit(str_node.c_str(), str_node.c_str(), t_nodeName.c_str(), &addr, cookie.c_str(), 0) == -1) {
|
// ERR("erl_connect_xinit error");
|
// erl_err_quit("erl_connect_xinit");
|
// return false;
|
// }
|
|
fd = erl_connect(const_cast<char *>(nodeName.c_str()));
|
if (0 > fd) {
|
erl_close_connection(fd);
|
ERR("erl_connect error " << nodeName);
|
// erl_err_quit("erl_connect");
|
return false;
|
}
|
erl_close_connection(fd);
|
return true;
|
}
|
|
static int ErlangTool::checkETERMType(ETERM *elemen) {
|
if (elemen == NULL) {
|
return -1;
|
}
|
switch (ERL_TYPE(elemen)) {
|
case ERL_UNDEF:
|
return ERL_UNDEF;
|
case ERL_INTEGER:
|
INFO("value is a int: " << ERL_INT_VALUE(elemen));
|
return ERL_INTEGER;
|
case ERL_U_INTEGER:
|
break;
|
case ERL_ATOM: {
|
// int atomSize = ERL_ATOM_SIZE(elemen);
|
// char *atomValue = ERL_ATOM_PTR(elemen);
|
// printf("value is a atom: atomSize:%d, atomValue:%s \n\r", atomSize, atomValue);
|
return ERL_ATOM;
|
}
|
case ERL_PID:
|
break;
|
case ERL_PORT:
|
break;
|
case ERL_REF:
|
break;
|
case ERL_LIST:
|
// printf("value is a list:%s\n", erl_iolist_to_string(elemen));
|
return ERL_LIST;
|
case ERL_NIL:
|
return ERL_EMPTY_LIST;
|
case ERL_TUPLE:
|
INFO("value is a tupe: " << ERL_ATOM_PTR(erl_element(1, elemen)));
|
return ERL_TUPLE;
|
case ERL_BINARY:
|
break;
|
case ERL_FLOAT:
|
break;
|
case ERL_VARIABLE:
|
break;
|
case ERL_SMALL_BIG:
|
break;
|
case ERL_U_SMALL_BIG:
|
break;
|
case ERL_FUNCTION:
|
break;
|
case ERL_BIG:
|
break;
|
case ERL_LONGLONG:
|
break;
|
case ERL_U_LONGLONG:
|
break;
|
default:
|
ERR("[Client] got a value but now checked\n\r");
|
//#todo morechuli
|
}
|
return -1;
|
}
|
|
static void ErlangTool::erlangFreeEterm(int count, ...) {
|
va_list args;
|
va_start(args, count);
|
for (int i = 0; i < count; ++i) {
|
auto test = va_arg(args, ETERM*);
|
erl_free_compound(test);
|
// if (test != NULL)
|
// erl_free_compound(test);
|
// else{
|
//
|
// }
|
}
|
}
|
|
|
ErlangTool::ErlangDbTool::ErlangDbTool() : m_fd(-1) {
|
|
}
|
|
ErlangTool::ErlangDbTool::ErlangDbTool(const std::string &nodeName, const std::string &cookie, const std::string &pName)
|
: m_fd(-1), m_path(""), m_nodeName(nodeName), m_cookie(cookie), m_pName(pName) {
|
initCNode();
|
}
|
|
ErlangTool::ErlangDbTool::ErlangDbTool(const std::string &path, const std::string &nodeName, const std::string &cookie,
|
const std::string &pName)
|
: m_fd(-1), m_path(path), m_nodeName(nodeName), m_cookie(cookie), m_pName(pName) {
|
initCNode();
|
}
|
|
|
ErlangTool::ErlangDbTool::ErlangDbTool(const std::string &path, const std::string &nodeName, const std::string &cookie,
|
const std::string &clusterID, const std::string &clusterName) :
|
m_fd(-1), m_path(path), m_nodeName(nodeName), m_cookie(cookie), m_clusterID(clusterID), m_clusterName(clusterName) {
|
|
}
|
|
|
ErlangTool::ErlangDbTool::ErlangDbTool(const std::string &path, const std::string &nodeName, const std::string &cookie,
|
const std::string &clusterID, const std::string &clusterName,
|
const std::string &pName) :
|
m_fd(-1), m_path(path), m_nodeName(nodeName), m_cookie(cookie), m_clusterID(clusterID), m_clusterName(clusterName),
|
m_pName(pName) {
|
initCNode();
|
}
|
|
ErlangTool::ErlangDbTool::~ErlangDbTool() {
|
g_syncDbFile.close();
|
erl_close_connection(m_fd);
|
}
|
|
|
void ErlangTool::ErlangDbTool::initCNode() {
|
//--------------init db-------------------
|
std::string str_SyncDbFile = "/opt/erlang/";
|
str_SyncDbFile.append(m_nodeName.substr(0, m_nodeName.find("@"))).append(".db");
|
g_syncDbFile.setDatabaseName(str_SyncDbFile.c_str());
|
g_syncDbFile.open();
|
|
erl_init(NULL, 0);
|
struct in_addr addr;
|
//#todo
|
addr.s_addr = inet_addr("127.0.0.1");
|
|
m_pName.append(to_string((int) getpid()));
|
|
std::string t_cNodeName(m_pName);
|
t_cNodeName.append("@127.0.0.1");
|
m_cNodeName.swap(t_cNodeName);
|
//m_pName
|
if (erl_connect_xinit(const_cast<char *>(m_pName.c_str()), const_cast<char *>(m_pName.c_str()),
|
const_cast<char *>(m_cNodeName.c_str()), &addr,
|
const_cast<char *>(m_cookie.c_str()), 0) == -1) {
|
ERR("erl_connect_xinit error" << m_pName << " " << m_cNodeName << " " << m_cookie);
|
erl_err_quit("erl_connect_xinit");
|
} else {
|
INFO("erl_connect_xinit ok " << m_pName << " " << m_cNodeName << " " << m_cookie);
|
}
|
}
|
|
|
int ErlangTool::ErlangDbTool::initErlang() {
|
if (m_nodeName == "") {
|
ERR("m_nodeName is null ");
|
return 3;
|
}
|
m_ret = pingNode(m_nodeName, m_cookie);
|
if (!m_ret) {
|
if (dir_file_exists(m_path, true)) {
|
std::string cmd = std::string("cd " + m_path + " && erl -name " + m_nodeName + " -setcookie "
|
+ m_cookie + " -mnesia dir '\"" + m_path +
|
"\"' -detached -noshell");// >>log
|
std::cout << cmd << std::endl;
|
system(cmd.c_str());
|
std::cout << m_ret << std::endl;
|
m_ret = waitNode();
|
resetConn();
|
return m_ret;
|
} else {
|
ERR("create file faile ");
|
return 0;
|
}
|
} else {
|
INFO("node is running");
|
return 2;
|
}
|
}
|
|
std::string ErlangTool::ErlangDbTool::getConfigJsonString() {
|
Json::Value t_json;
|
Json::FastWriter writer;
|
|
t_json["\"path\""] = "\"" + m_path + "\"";
|
t_json["\"nodeName\""] = "\"" + m_nodeName + "\"";
|
t_json["\"cookie\""] = "\"" + m_cookie + "\"";
|
t_json["\"clusterID\""] = "\"" + m_clusterID + "\"";
|
t_json["\"clusterName\""] = "\"" + m_clusterName + "\"";
|
|
std::string str_json = writer.write(t_json);
|
|
return str_json.substr(0, str_json.length() - 1);
|
}
|
|
bool ErlangTool::ErlangDbTool::startNodeDb(std::string FatherNodeName, std::string DeviceId, std::string DevAdd) {
|
LockG lock(m_mutex);
|
// m_mutex.lock();
|
m_ret = resetConn();
|
if (m_ret) {
|
// DeviceName = DeviceName.empty() ? m_nodeName : DeviceName;
|
} else {
|
//#todo error message
|
ERR(" error " << m_ret << " " << m_fd);
|
return false;
|
}
|
|
ErlMessage emsg; /* Incoming message */
|
//hanshu canshu
|
ETERM *arrlist[5];
|
arrlist[0] = erl_mk_atom(m_nodeName.c_str());
|
arrlist[1] = erl_mk_atom(FatherNodeName.c_str());
|
arrlist[2] = erl_mk_atom(DeviceId.c_str());
|
arrlist[3] = erl_mk_atom(m_clusterID.c_str());
|
arrlist[4] = erl_mk_string(m_clusterName.c_str());
|
ETERM *list = erl_mk_list(arrlist, 5);
|
|
// std::cout << __FILE__ << __FUNCTION__ <<__LINE__ << " " << m_fd << std::endl;
|
// erl_rpc(m_fd, "syncDB", "startNode", list);
|
int ret = -1;
|
ret = erl_rpc_to(m_fd, "syncDB", "startNode", list);
|
if (ret == ERL_TICK) {
|
ret = erl_rpc_from(m_fd, 9000000000, &emsg);
|
//erl_close_connection(m_fd);
|
// m_mutex.unlock();
|
if (ret == ERL_MSG) {
|
std::map<std::string, std::string> t_results;
|
ETERM *key, *value;
|
ETERM *tuplep[6];
|
|
tuplep[0] = erl_element(2, emsg.msg);
|
key = erl_element(1, tuplep[0]);
|
value = erl_element(2, tuplep[0]);
|
// printf("key:%s\n", ERL_ATOM_PTR(key));
|
switch (checkETERMType(value)) {
|
case ERL_ATOM: {
|
int atomSize = ERL_ATOM_SIZE(value);
|
char *atomValue = ERL_ATOM_PTR(value);
|
t_results.insert(std::make_pair(ERL_ATOM_PTR(key), atomValue));
|
// printf("value is a atom: atomSize:%d, atomValue:%s \n\r", atomSize, atomValue);
|
break;
|
}
|
default:
|
ERR("error add case todo \n\r");
|
}
|
auto it = t_results.find("atomic");
|
if (t_results.size() > 0 && t_results.end() != it && it->second == "ok") {
|
// erlangFreeEterm(7, emsg.to, emsg.msg, emsg.from, list, key, value, tuplep[0]);
|
// erl_eterm_release();
|
return true;
|
} //if end
|
else {
|
INFO(" t_results size is " << t_results.size());
|
for (auto &item : t_results) {
|
INFO("item is " << item.first << " " << item.second);
|
}
|
}
|
}//ret == ERL_MSG end
|
else {
|
ERR(" ret is " << ret);
|
|
}
|
} //ret == ERL_TICK
|
|
// erlangFreeEterm(4, emsg.to, emsg.msg, emsg.from, list);
|
return false;
|
}
|
|
bool ErlangTool::ErlangDbTool::removeNode() {
|
LockG lock(m_mutex);
|
// m_mutex.lock();
|
m_ret = resetConn();
|
if (!m_ret) {
|
//#todo error message
|
std::cout << __FILE__ << __FUNCTION__ << __LINE__ << " error " << m_ret << " " << m_fd << std::endl;
|
return false;
|
}
|
int ret = -1;
|
ErlMessage emsg; /* Incoming message */
|
//hanshu canshu
|
// ETERM *arrlist[1];
|
// arrlist[0] = erl_mk_atom(m_nodeName.c_str());
|
ETERM *list = erl_mk_empty_list();// (arrlist, 0);
|
|
// std::cout << __FILE__ << __FUNCTION__ <<__LINE__ << " " << m_fd << std::endl;
|
ret = erl_rpc_to(m_fd, "syncDB", "removeNode", list);
|
if (ret == ERL_TICK) {
|
ret = erl_rpc_from(m_fd, TIMEOUT, &emsg);
|
//erl_close_connection(m_fd);
|
// m_mutex.unlock();
|
if (ret == ERL_MSG) {
|
std::map<std::string, std::string> t_results;
|
ETERM *key, *value;
|
ETERM *tuplep[6];
|
|
tuplep[0] = erl_element(2, emsg.msg);
|
key = erl_element(1, tuplep[0]);
|
value = erl_element(2, tuplep[0]);
|
// printf("key:%s\n", ERL_ATOM_PTR(key));
|
switch (checkETERMType(value)) {
|
case ERL_ATOM: {
|
int atomSize = ERL_ATOM_SIZE(value);
|
char *atomValue = ERL_ATOM_PTR(value);
|
t_results.insert(std::make_pair(ERL_ATOM_PTR(key), atomValue));
|
// printf("value is a atom: atomSize:%d, atomValue:%s \n\r", atomSize, atomValue);
|
break;
|
}
|
default:
|
printf("error add case todo \n\r");
|
}
|
auto it = t_results.find("atomic");
|
if (t_results.size() > 0 && t_results.end() != it && it->second == "ok") {
|
//删除本地文件
|
if (!m_path.empty()) {
|
std::string cmd = std::string("rm -rf ").append(m_path);
|
//#todo
|
system(cmd.c_str());
|
}
|
erlangFreeEterm(7, emsg.to, emsg.msg, emsg.from, list, key, value, tuplep[0]);
|
erl_eterm_release();
|
return true;
|
} //if end
|
} //ret == ERL_MSG end
|
} //ret == ERL_TICK
|
|
erlangFreeEterm(4, emsg.to, emsg.msg, emsg.from, list);
|
return false;
|
}
|
|
bool ErlangTool::ErlangDbTool::modifyCluName(std::string CluId, std::string CluName) {
|
LockG lock(m_mutex);
|
// m_mutex.lock();
|
m_ret = resetConn();
|
if (!m_ret) {
|
//#todo error message
|
std::cout << __FILE__ << __FUNCTION__ << __LINE__ << " error " << m_ret << " " << m_fd << std::endl;
|
return false;
|
}
|
ErlMessage emsg; /* Incoming message */
|
int ret = -1;
|
ETERM *arrlist[2];
|
arrlist[0] = erl_mk_atom(CluId.c_str());
|
arrlist[1] = erl_mk_string(CluName.c_str());
|
ETERM *list = erl_mk_list(arrlist, 2);
|
|
ret = erl_rpc_to(m_fd, "syncDB", "modifyCluName", list);
|
if (ret == ERL_TICK) {
|
ret = erl_rpc_from(m_fd, TIMEOUT, &emsg);
|
//erl_close_connection(m_fd);
|
// m_mutex.unlock();
|
if (ret == ERL_MSG) {
|
std::map<std::string, std::string> t_results;
|
|
ETERM *tail_list;
|
ETERM *list_ret[1000], *arr_ret[2];
|
ETERM *key, *value;
|
ETERM *tuplep[6];
|
|
arr_ret[0] = erl_element(2, emsg.msg);
|
int erlLength = erl_length(arr_ret[0]);
|
printf("arr_ret[0]:%d\n", erlLength);
|
list_ret[0] = erl_hd(arr_ret[0]);
|
tail_list = erl_tl(arr_ret[0]);
|
for (int i = 0; i < erlLength; i++) {
|
if (i > 0) {
|
list_ret[i] = erl_hd(tail_list);
|
tail_list = erl_tl(tail_list);
|
}
|
// printf("list_ret[%d]:%d\n", i, erl_length(list_ret[i]));
|
tuplep[0] = erl_hd(list_ret[i]);
|
key = erl_element(1, list_ret[i]);
|
value = erl_element(2, list_ret[i]);
|
// printf("key:%s\n", ERL_ATOM_PTR(key));
|
|
switch (checkETERMType(value)) {
|
case ERL_ATOM: {
|
int atomSize = ERL_ATOM_SIZE(value);
|
char *atomValue = ERL_ATOM_PTR(value);
|
printf("value is a atom: atomSize:%d, atomValue:%s \n\r", atomSize, atomValue);
|
t_results.insert(std::make_pair(ERL_ATOM_PTR(key), atomValue));
|
break;
|
}
|
default:
|
printf("error add case todo \n\r");
|
}
|
erlangFreeEterm(4, key, value, tuplep[0], list_ret[i]);
|
|
}
|
erlangFreeEterm(2, tail_list, arr_ret[0]);
|
erl_eterm_release();
|
auto it = t_results.find("atomic");
|
if (t_results.size() > 0 && t_results.end() != it && it->second == "ok") {
|
return true;
|
}
|
}
|
}
|
erl_free_array(arrlist, 2);
|
// erlangFreeEterm(4, emsg.to, emsg.msg, emsg.from, list);
|
erl_eterm_release();
|
return false;
|
}
|
|
|
ErlangTool::map_DevDataCache ErlangTool::ErlangDbTool::findAllNode() {
|
LockG lock(m_mutex);
|
// m_mutex.lock();
|
m_ret = resetConn();
|
if (!m_ret) {
|
//#todo error message
|
ERR(" error " << m_ret << " " << m_fd);
|
return map_DevDataCache();
|
}
|
map_DevDataCache devDataCache;
|
int ret = -1;
|
ErlMessage emsg; /* Incoming message */
|
//hanshu canshu
|
// ETERM *arrlist[0];
|
// arrlist[0] = erl_mk_atom(m_nodeName.c_str());
|
ETERM *list = erl_mk_empty_list();//erl_mk_list(arrlist, 0);
|
|
ret = erl_rpc_to(m_fd, "syncDB", "findAllNode", list);
|
if (ret == ERL_TICK) {
|
ret = erl_rpc_from(m_fd, TIMEOUT, &emsg);
|
//erl_close_connection(m_fd);
|
// m_mutex.unlock();
|
if (ret == ERL_MSG) {
|
ETERM *key, *value;
|
ETERM *tuplep[20];
|
ETERM *arr_ret[2], *list_ret[1000];
|
ETERM *tail_list, *tail_tuple;
|
arr_ret[0] = erl_element(2, emsg.msg);
|
if (checkETERMType(arr_ret[0]) == ERL_LIST) {
|
int erlLength = erl_length(arr_ret[0]);
|
// printf("arr_ret[0]:%d\n", erlLength);
|
list_ret[0] = erl_hd(arr_ret[0]);
|
tail_list = erl_tl(arr_ret[0]);
|
for (int i = 0; i < erlLength; i++) {
|
if (i > 0) {
|
list_ret[i] = erl_hd(tail_list);
|
tail_list = erl_tl(tail_list);
|
}
|
if (checkETERMType(list_ret[i]) == ERL_LIST) {
|
SyncDB::Device_Info device_info;
|
int erlLength1 = erl_length(list_ret[i]);
|
// printf("list_ret[%d]:%d\n", i, erlLength1);
|
tuplep[0] = erl_hd(list_ret[i]);
|
tail_tuple = erl_tl(list_ret[i]);
|
|
for (int j = 0; j < erlLength1; j++) {
|
if (j > 0) {
|
tuplep[j] = erl_hd(tail_tuple);
|
tail_tuple = erl_tl(tail_tuple);
|
}
|
key = erl_element(1, tuplep[j]);
|
value = erl_element(2, tuplep[j]);
|
// printf("key:%s\n", erl_iolist_to_string(key));
|
switch (checkETERMType(value)) {
|
case ERL_ATOM: {
|
device_info.setValue(erl_iolist_to_string(key), ERL_ATOM_PTR(value));
|
break;
|
}
|
case ERL_INTEGER: {
|
device_info.setValue(erl_iolist_to_string(key),
|
std::to_string(ERL_INT_VALUE(value)));
|
break;
|
}
|
case ERL_LIST: {
|
device_info.setValue(erl_iolist_to_string(key),
|
erl_iolist_to_string(value));
|
break;
|
}
|
default:
|
ERR("error add case todo" << checkETERMType(value) << " key is "
|
<< checkETERMType(key));
|
}
|
erlangFreeEterm(3, key, value, tuplep[j]);
|
}
|
// printf("\none list end\n\n\n\n");
|
// #todo this is have a bug
|
// device_info.create_by = "";
|
devDataCache.insert(std::make_pair(device_info.uuid, device_info));
|
erlangFreeEterm(1, tail_tuple);
|
} else {
|
ERR("type error " << checkETERMType(list_ret[i]));
|
}
|
erlangFreeEterm(1, list_ret[i]);
|
}
|
|
erlangFreeEterm(5, emsg.to, emsg.msg, emsg.from, tail_list, arr_ret[0]);
|
erl_eterm_release();
|
return devDataCache;
|
} else {
|
ERR(" error " << checkETERMType(arr_ret[0]));
|
}
|
}
|
} else {
|
ERR("ret != ERL_TICK");
|
} //ret == ERL_TICK end
|
erlangFreeEterm(3, emsg.to, emsg.msg, emsg.from);
|
erl_eterm_release();
|
return map_DevDataCache();
|
}
|
|
bool ErlangTool::ErlangDbTool::createDatabase(std::string TableType, std::string TableName, bool SyncType,
|
std::string BwType, std::string StartTime, std::string EndTime) {
|
LockG lock(m_mutex);
|
// m_mutex.lock();
|
m_ret = resetConn();
|
if (!m_ret) {
|
//#todo error message
|
std::cout << __FILE__ << __FUNCTION__ << __LINE__ << " error " << m_ret << " " << m_fd << std::endl;
|
return false;
|
}
|
std::string NewTableName = ((!SyncType) && TableName.find("lt_")) ? std::string("lt_").append(TableName)
|
: TableName;
|
|
ErlMessage emsg; /* Incoming message */
|
int ret = -1;
|
ETERM *arrlist[6];
|
arrlist[0] = erl_mk_atom(TableType.c_str());
|
arrlist[1] = erl_mk_string(NewTableName.c_str());
|
auto str = std::to_string(SyncType);
|
arrlist[2] = erl_mk_atom(str.c_str());
|
arrlist[3] = erl_mk_atom(BwType.c_str());
|
arrlist[4] = erl_mk_atom(StartTime.c_str());
|
arrlist[5] = erl_mk_atom(EndTime.c_str());
|
ETERM *list = erl_mk_list(arrlist, 6);
|
|
ret = erl_rpc_to(m_fd, "syncDB", "createDatabase", list);
|
if (ret == ERL_TICK) {
|
ret = erl_rpc_from(m_fd, TIMEOUT, &emsg);
|
//erl_close_connection(m_fd);
|
// m_mutex.unlock();
|
if (ret == ERL_MSG) {
|
std::map<std::string, std::string> t_results;
|
|
ETERM *tail_list;
|
ETERM *list_ret[1000], *arr_ret[2];
|
ETERM *key, *value;
|
ETERM *tuplep[6];
|
|
arr_ret[0] = erl_element(2, emsg.msg);
|
int erlLength = erl_length(arr_ret[0]);
|
printf("arr_ret[0]:%d\n", erlLength);
|
list_ret[0] = erl_hd(arr_ret[0]);
|
tail_list = erl_tl(arr_ret[0]);
|
for (int i = 0; i < erlLength; i++) {
|
if (i > 0) {
|
list_ret[i] = erl_hd(tail_list);
|
tail_list = erl_tl(tail_list);
|
}
|
// printf("list_ret[%d]:%d\n", i, erl_length(list_ret[i]));
|
tuplep[0] = erl_hd(list_ret[i]);
|
key = erl_element(1, list_ret[i]);
|
value = erl_element(2, list_ret[i]);
|
// printf("key:%s\n", ERL_ATOM_PTR(key));
|
|
switch (checkETERMType(value)) {
|
case ERL_ATOM: {
|
// int atomSize = ERL_ATOM_SIZE(value);
|
char *atomValue = ERL_ATOM_PTR(value);
|
// printf("value is a atom: atomSize:%d, atomValue:%s \n\r", atomSize, atomValue);
|
t_results.insert(std::make_pair(ERL_ATOM_PTR(key), atomValue));
|
break;
|
}
|
default:
|
printf("error add case todo \n\r");
|
}
|
erlangFreeEterm(4, key, value, tuplep[0], list_ret[i]);
|
|
}
|
erlangFreeEterm(2, tail_list, arr_ret[0]);
|
erl_eterm_release();
|
auto it = t_results.find("atomic");
|
if (t_results.size() > 0 && t_results.end() != it && it->second == "ok") {
|
return true;
|
}
|
}
|
}
|
erl_free_array(arrlist, 6);
|
// erlangFreeEterm(4, emsg.to, emsg.msg, emsg.from, list);
|
erl_eterm_release();
|
return false;
|
}
|
|
bool ErlangTool::ErlangDbTool::updateDatabase(std::string UUID, std::string TableType, std::string TableName,
|
bool SyncType, std::string BwType, std::string StartTime,
|
std::string EndTime) {
|
LockG lock(m_mutex);
|
// m_mutex.lock();
|
m_ret = resetConn();
|
if (!m_ret) {
|
//#todo error message
|
std::cout << __FILE__ << __FUNCTION__ << __LINE__ << " error " << m_ret << " " << m_fd << std::endl;
|
return false;
|
}
|
std::string NewTableName = ((!SyncType) && TableName.find("lt_")) ? std::string("lt_").append(TableName)
|
: TableName;
|
|
ErlMessage emsg; /* Incoming message */
|
int ret = -1;
|
ETERM *arrlist[7];
|
arrlist[0] = erl_mk_atom(UUID.c_str());
|
arrlist[1] = erl_mk_atom(TableType.c_str());
|
arrlist[2] = erl_mk_string(NewTableName.c_str());
|
auto str = std::to_string(SyncType);
|
arrlist[3] = erl_mk_atom(str.c_str());
|
arrlist[4] = erl_mk_atom(BwType.c_str());
|
arrlist[5] = erl_mk_atom(StartTime.c_str());
|
arrlist[6] = erl_mk_atom(EndTime.c_str());
|
ETERM *list = erl_mk_list(arrlist, 7);
|
|
ret = erl_rpc_to(m_fd, "syncDB", "updateDatabase", list);
|
if (ret == ERL_TICK) {
|
ret = erl_rpc_from(m_fd, TIMEOUT, &emsg);
|
//erl_close_connection(m_fd);
|
// m_mutex.unlock();
|
if (ret == ERL_MSG) {
|
std::map<std::string, std::string> t_results;
|
|
ETERM *tail_list;
|
ETERM *list_ret[1000], *arr_ret[2];
|
ETERM *key, *value;
|
ETERM *tuplep[6];
|
|
arr_ret[0] = erl_element(2, emsg.msg);
|
int erlLength = erl_length(arr_ret[0]);
|
printf("arr_ret[0]:%d\n", erlLength);
|
list_ret[0] = erl_hd(arr_ret[0]);
|
tail_list = erl_tl(arr_ret[0]);
|
for (int i = 0; i < erlLength; i++) {
|
if (i > 0) {
|
list_ret[i] = erl_hd(tail_list);
|
tail_list = erl_tl(tail_list);
|
}
|
// printf("list_ret[%d]:%d\n", i, erl_length(list_ret[i]));
|
tuplep[0] = erl_hd(list_ret[i]);
|
key = erl_element(1, list_ret[i]);
|
value = erl_element(2, list_ret[i]);
|
// printf("key:%s\n", ERL_ATOM_PTR(key));
|
|
switch (checkETERMType(value)) {
|
case ERL_ATOM: {
|
// int atomSize = ERL_ATOM_SIZE(value);
|
char *atomValue = ERL_ATOM_PTR(value);
|
// printf("value is a atom: atomSize:%d, atomValue:%s \n\r", atomSize, atomValue);
|
t_results.insert(std::make_pair(ERL_ATOM_PTR(key), atomValue));
|
break;
|
}
|
default:
|
printf("error add case todo \n\r");
|
}
|
erlangFreeEterm(4, key, value, tuplep[0], list_ret[i]);
|
}
|
erlangFreeEterm(2, tail_list, arr_ret[0]);
|
erl_eterm_release();
|
auto it = t_results.find("atomic");
|
if (t_results.size() > 0 && t_results.end() != it && it->second == "ok") {
|
return true;
|
}
|
}
|
}
|
erl_free_array(arrlist, 7);
|
// erlangFreeEterm(4, emsg.to, emsg.msg, emsg.from, list);
|
erl_eterm_release();
|
return false;
|
}
|
|
bool ErlangTool::ErlangDbTool::deleteDatabase(std::string TableType, std::string TableName, bool SyncType) {
|
LockG lock(m_mutex);
|
// m_mutex.lock();
|
m_ret = resetConn();
|
if (!m_ret) {
|
//#todo error message
|
ERR(" error " << m_ret << " " << m_fd);
|
return false;
|
}
|
std::string NewTableName = ((!SyncType) && TableName.find("lt_")) ? std::string("lt_").append(TableName)
|
: TableName;
|
|
ErlMessage emsg; /* Incoming message */
|
int ret = -1;
|
|
ETERM *arrlist[2];
|
arrlist[0] = erl_mk_atom(TableType.c_str());
|
arrlist[1] = erl_mk_string(NewTableName.c_str());
|
ETERM *list = erl_mk_list(arrlist, 2);
|
|
ret = erl_rpc_to(m_fd, "syncDB", "deleteDatabase", list);
|
if (ret == ERL_TICK) {
|
ret = erl_rpc_from(m_fd, TIMEOUT, &emsg);
|
//erl_close_connection(m_fd);
|
// m_mutex.unlock();
|
if (ret == ERL_MSG) {
|
std::map<std::string, std::string> t_results;
|
ETERM *tail_list;
|
ETERM *list_ret[10], *arr_ret[2];
|
ETERM *key, *value;
|
ETERM *tuplep[6];
|
arr_ret[0] = erl_element(2, emsg.msg);
|
int erlLength = erl_length(arr_ret[0]);
|
printf("arr_ret[0]:%d\n", erlLength);
|
list_ret[0] = erl_hd(arr_ret[0]);
|
tail_list = erl_tl(arr_ret[0]);
|
for (int i = 0; i < erlLength; i++) {
|
if (i > 0) {
|
list_ret[i] = erl_hd(tail_list);
|
tail_list = erl_tl(tail_list);
|
}
|
// printf("list_ret[%d]:%d\n", i, erl_length(list_ret[i]));
|
tuplep[0] = erl_hd(list_ret[i]);
|
key = erl_element(1, list_ret[i]);
|
value = erl_element(2, list_ret[i]);
|
// printf("key:%s\n", ERL_ATOM_PTR(key));
|
switch (checkETERMType(value)) {
|
case ERL_ATOM: {
|
int atomSize = ERL_ATOM_SIZE(value);
|
char *atomValue = ERL_ATOM_PTR(value);
|
t_results.insert(std::make_pair(ERL_ATOM_PTR(key), atomValue));
|
printf("value is a atom: atomSize:%d, atomValue:%s \n\r", atomSize, atomValue);
|
break;
|
}
|
default:
|
printf("error add case todo \n\r");
|
}
|
erlangFreeEterm(4, key, value, tuplep[0], list_ret[i]);
|
}
|
erlangFreeEterm(2, tail_list, arr_ret[0]);
|
auto it = t_results.find("atomic");
|
if (t_results.size() > 0 && t_results.end() != it && it->second == "ok") {
|
return true;
|
}
|
}
|
}
|
erl_free_array(arrlist, 2);
|
erlangFreeEterm(4, emsg.to, emsg.msg, emsg.from, list);
|
return false;
|
}
|
|
// 和erlang交互
|
//ErlangTool::map_TabDataCache ErlangTool::ErlangDbTool::findAllDatabase() {
|
// LockG lock(m_mutex);
|
//// m_mutex.lock();
|
// m_ret = resetConn();
|
// map_TabDataCache tabDataCache;
|
// if (!m_ret) {
|
// //#todo error message
|
// std::cout << __FILE__ << __FUNCTION__ << __LINE__ << " error " << m_ret << " " << m_fd << std::endl;
|
// return tabDataCache;
|
// }
|
// int ret = -1;
|
// ErlMessage emsg; /* Incoming message */
|
// //hanshu canshu
|
//// ETERM *arrlist[0];
|
//// arrlist[0] = erl_mk_atom(m_nodeName.c_str());
|
// ETERM *list = erl_mk_empty_list();//erl_mk_list(arrlist, 0);
|
//
|
// std::cout << __FILE__ << __FUNCTION__ << __LINE__ << " " << m_fd << std::endl;
|
// ret = erl_rpc_to(m_fd, "syncDB", "findAllDatabase", list);
|
// if (ret == ERL_TICK) {
|
// ret = erl_rpc_from(m_fd, TIMEOUT, &emsg);
|
// //erl_close_connection(m_fd);
|
//// m_mutex.unlock();
|
// if (ret == ERL_MSG) {
|
// ETERM *key, *value;
|
// ETERM *tuplep[20];
|
// ETERM *arr_ret[2], *list_ret[1000];
|
// ETERM *tail_list, *tail_tuple;
|
// arr_ret[0] = erl_element(2, emsg.msg);
|
// if (checkETERMType(arr_ret[0]) == ERL_LIST) {
|
// int erlLength = erl_length(arr_ret[0]);
|
// list_ret[0] = erl_hd(arr_ret[0]);
|
// tail_list = erl_tl(arr_ret[0]);
|
// for (int i = 0; i < erlLength; i++) {
|
// if (i > 0) {
|
// list_ret[i] = erl_hd(tail_list);
|
// tail_list = erl_tl(tail_list);
|
// }
|
// if (checkETERMType(list_ret[i]) == ERL_LIST) {
|
// SyncDB::Table_Info table_info;
|
// int erlLength1 = erl_length(list_ret[i]);
|
// tuplep[0] = erl_hd(list_ret[i]);
|
// tail_tuple = erl_tl(list_ret[i]);
|
//
|
// for (int j = 0; j < erlLength1; j++) {
|
// if (j > 0) {
|
// tuplep[j] = erl_hd(tail_tuple);
|
// tail_tuple = erl_tl(tail_tuple);
|
// }
|
// key = erl_element(1, tuplep[j]);
|
// value = erl_element(2, tuplep[j]);
|
// switch (checkETERMType(value)) {
|
// case ERL_ATOM: {
|
// table_info.setValue(erl_iolist_to_string(key), ERL_ATOM_PTR(value));
|
// break;
|
// }
|
// case ERL_INTEGER: {
|
// table_info.setValue(erl_iolist_to_string(key),
|
// std::to_string(ERL_INT_VALUE(value)));
|
// break;
|
// }
|
// case ERL_LIST: {
|
// table_info.setValue(erl_iolist_to_string(key),
|
// erl_iolist_to_string(value));
|
// break;
|
// }
|
// default:
|
// printf("error add case todo %d\n\r", checkETERMType(value));
|
// }
|
//// erlangFreeEterm(3, key, value, tuplep[j]);
|
// }
|
//// erlangFreeEterm(2, tail_tuple, list_ret[i]);
|
//
|
// // #todo this is have a bug
|
//// table_info.create_by = "";
|
// tabDataCache.insert(std::make_pair(table_info.tableName, table_info));
|
// } else {
|
// std::cout << __FILE__ << __FUNCTION__ << __LINE__ << " type error "
|
// << checkETERMType(arr_ret[0])
|
// << " "
|
// << std::endl;
|
// }
|
// }
|
//// erlangFreeEterm(2, tail_list, arr_ret[0]);
|
// return tabDataCache; //ok
|
// } else {
|
// ERR(" error " << checkETERMType(arr_ret[0]));
|
// }
|
// }
|
// }
|
//// erlangFreeEterm(4, emsg.to, emsg.msg, emsg.from, list);
|
// return tabDataCache; //not ok
|
//}
|
|
//#todo
|
//直接和sqlite3 交互
|
ErlangTool::map_TabDataCache ErlangTool::ErlangDbTool::findAllDatabase() {
|
map_TabDataCache tabDataCache;
|
|
QString sql = QString::fromStdString(
|
"SELECT uuid,tableName,tableType,bwType,startTime,endTime FROM sys_o_tables where del_flag=0;");
|
QSqlQuery query(g_syncDbFile);
|
query.prepare(sql);
|
if (!query.exec()) {
|
qDebug() << "getTableNameList" << __FILE__ << __LINE__ << query.lastError();
|
} else {
|
while (query.next()) {
|
SyncDB::Table_Info t_table_info;
|
t_table_info.uuid = query.value(0).toString().toStdString();
|
t_table_info.tableName = query.value(1).toString().toStdString();
|
t_table_info.tableType = query.value(2).toString().toStdString();
|
t_table_info.bwType = query.value(3).toString().toStdString();
|
t_table_info.startTime = query.value(4).toString().toStdString();
|
t_table_info.endTime = query.value(5).toString().toStdString();
|
|
tabDataCache.insert(std::make_pair(t_table_info.uuid, t_table_info));
|
}
|
}
|
return tabDataCache; //not ok
|
}
|
|
/***
|
* @deprecated
|
* @return
|
*/
|
ErlangTool::map_BwDataCache ErlangTool::ErlangDbTool::findAllTypeInfo() {
|
return map_BwDataCache();
|
LockG lock(m_mutex);
|
// m_mutex.lock();
|
m_ret = resetConn();
|
if (!m_ret) {
|
//#todo error message
|
std::cout << __FILE__ << __FUNCTION__ << __LINE__ << " error " << m_ret << " " << m_fd << std::endl;
|
return map_BwDataCache();
|
}
|
map_BwDataCache bwDataCache;
|
int ret = -1;
|
ErlMessage emsg; /* Incoming message */
|
ETERM *list = erl_mk_empty_list();//erl_mk_list(arrlist, 0);
|
|
// std::cout << __FILE__ << __FUNCTION__ <<__LINE__ << " " << m_fd << std::endl;
|
ret = erl_rpc_to(m_fd, "syncDB", "findAllTypeInfo", list);
|
if (ret == ERL_TICK) {
|
ret = erl_rpc_from(m_fd, TIMEOUT, &emsg);
|
//erl_close_connection(m_fd);
|
// m_mutex.unlock();
|
if (ret == ERL_MSG) {
|
ETERM *key, *value;
|
ETERM *tuplep[20];
|
ETERM *arr_ret[2], *list_ret[1000];
|
ETERM *tail_list, *tail_tuple;
|
arr_ret[0] = erl_element(2, emsg.msg);
|
if (checkETERMType(arr_ret[0]) == ERL_LIST) {
|
int erlLength = erl_length(arr_ret[0]);
|
// printf("arr_ret[0]:%d\n", erlLength);
|
list_ret[0] = erl_hd(arr_ret[0]);
|
tail_list = erl_tl(arr_ret[0]);
|
for (int i = 0; i < erlLength; i++) {
|
if (i > 0) {
|
list_ret[i] = erl_hd(tail_list);
|
tail_list = erl_tl(tail_list);
|
}
|
if (checkETERMType(list_ret[i]) == ERL_LIST) {
|
SyncDB::Bw_Info bw_info;
|
int erlLength1 = erl_length(list_ret[i]);
|
// printf("list_ret[%d]:%d\n", i, erlLength1);
|
tuplep[0] = erl_hd(list_ret[i]);
|
tail_tuple = erl_tl(list_ret[i]);
|
|
for (int j = 0; j < erlLength1; j++) {
|
if (j > 0) {
|
tuplep[j] = erl_hd(tail_tuple);
|
tail_tuple = erl_tl(tail_tuple);
|
}
|
key = erl_element(1, tuplep[j]);
|
value = erl_element(2, tuplep[j]);
|
// printf("key:%s\n", erl_iolist_to_string(key));
|
switch (checkETERMType(value)) {
|
case ERL_ATOM: {
|
bw_info.setValue(erl_iolist_to_string(key), ERL_ATOM_PTR(value));
|
break;
|
}
|
case ERL_INTEGER: {
|
bw_info.setValue(erl_iolist_to_string(key),
|
std::to_string(ERL_INT_VALUE(value)));
|
break;
|
}
|
case ERL_LIST: {
|
bw_info.setValue(erl_iolist_to_string(key),
|
erl_iolist_to_string(value));
|
break;
|
}
|
default:
|
printf("error add case todo %d\n\r", checkETERMType(value));
|
}
|
// erlangFreeEterm(3, key, value, tuplep[j]);
|
}
|
// erlangFreeEterm(2, tail_tuple, list_ret[i]);
|
// printf("\none list end\n\n\n\n");
|
// #todo this is have a bug
|
// bw_info.create_by = "";
|
bwDataCache.insert(std::make_pair(bw_info.tableName, bw_info));
|
} else {
|
std::cout << __FILE__ << __FUNCTION__ << __LINE__ << " type error "
|
<< checkETERMType(arr_ret[0])
|
<< " "
|
<< std::endl;
|
}
|
}
|
// erlangFreeEterm(2, tail_list, arr_ret[0]);
|
return bwDataCache;//ok
|
} else {
|
ERR(" error " << checkETERMType(arr_ret[0]));
|
}
|
}
|
}
|
// erlangFreeEterm(4, emsg.to, emsg.msg, emsg.from, list);
|
return map_BwDataCache();
|
}
|
|
bool ErlangTool::ErlangDbTool::addPerson(std::string &UUID, std::string TableName, std::string Feature,
|
std::string ImgUrl, std::string IdCard, std::string PersonName,
|
std::string Age, std::string Sex, std::string PhoneNum) {
|
LockG lock(m_mutex);
|
// m_mutex.lock();
|
m_ret = resetConn();
|
if (!m_ret) {
|
//#todo error message
|
ERR(" error " << m_ret << " " << m_fd << " ");
|
return false;
|
}
|
int ret;
|
ErlMessage emsg; /* Incoming message */
|
//hanshu canshu
|
ETERM *arrlist[9];
|
arrlist[0] = erl_mk_string(TableName.c_str());
|
arrlist[1] = erl_mk_string(PersonName.c_str());
|
arrlist[2] = erl_mk_string(Age.c_str());
|
arrlist[3] = erl_mk_string(Sex.c_str());
|
arrlist[4] = erl_mk_string(IdCard.c_str());
|
arrlist[5] = erl_mk_string(PhoneNum.c_str());
|
arrlist[6] = erl_mk_string(ImgUrl.c_str());
|
arrlist[7] = erl_mk_string(UUID.c_str());
|
arrlist[8] = erl_mk_string(Feature.c_str());
|
std::string TmpUUid;
|
|
ETERM *list = erl_mk_list(arrlist, 9);
|
ret = erl_rpc_to(m_fd, "syncDB", "addPersonData", list);
|
if (ret == ERL_TICK) {
|
|
ret = erl_rpc_from(m_fd, TIMEOUT, &emsg);
|
// UUID.clear();
|
//erl_close_connection(m_fd);
|
// m_mutex.unlock();
|
if (ret == ERL_MSG) {
|
ETERM *value;
|
value = erl_element(2, emsg.msg);
|
switch (checkETERMType(value)) {
|
case ERL_LIST: {
|
TmpUUid = std::string(erl_iolist_to_string(value));
|
break;
|
}
|
case ERL_ATOM: {
|
TmpUUid = std::string(ERL_ATOM_PTR(value));
|
break;
|
}
|
default:
|
printf("error add case todo \n\r");
|
}
|
erl_free_term(value);
|
if (TmpUUid.size() > 0) {
|
UUID = TmpUUid;
|
erlangFreeEterm(5, emsg.msg, emsg.from, emsg.to, list, arrlist[8]);
|
erl_free_array(arrlist, 8);
|
erl_eterm_release();
|
return true;
|
}
|
}
|
}
|
erlangFreeEterm(5, emsg.msg, emsg.from, emsg.to, list, arrlist[8]);
|
erl_free_array(arrlist, 8);
|
erl_eterm_release();
|
UUID = "";
|
return false;
|
}
|
|
|
ErlangTool::vec_AddDataCache
|
ErlangTool::ErlangDbTool::addPersons(std::string TableUuid, std::vector<SyncDB::AddPersonInfo> &tmpPer) {
|
LockG lock(m_mutex);
|
// m_mutex.lock();
|
m_ret = resetConn();
|
ErlangTool::vec_AddDataCache t_vec_addDataCache;
|
if (!m_ret) {
|
//#todo error message
|
ERR(" error " << m_ret << " " << m_fd << " ");
|
return t_vec_addDataCache;
|
}
|
int ret;
|
ErlMessage emsg; /* Incoming message */
|
ETERM *person_list[10];
|
int loop = 0;
|
for (auto &item :tmpPer) {
|
ETERM *arrlist[4];
|
arrlist[0] = erl_mk_atom(item.personid.c_str());
|
arrlist[1] = erl_mk_atom(item.idcard.c_str());
|
arrlist[2] = erl_mk_atom(item.personPic.c_str());
|
arrlist[3] = erl_mk_string(item.feature.c_str());
|
person_list[loop++] = erl_mk_tuple(arrlist, 4);
|
}
|
|
//hanshu canshu
|
ETERM *arrvaluelist[2];
|
arrvaluelist[0] = erl_mk_string(TableUuid.c_str());
|
arrvaluelist[1] = erl_mk_list(person_list, loop);
|
|
ETERM *list = erl_mk_list(arrvaluelist, 2);
|
ret = erl_rpc_to(m_fd, "syncDB", "addPersonDatas", list);
|
if (ret == ERL_TICK) {
|
ret = erl_rpc_from(m_fd, TIMEOUT, &emsg);
|
//erl_close_connection(m_fd);
|
// m_mutex.unlock();
|
if (ret == ERL_MSG) {
|
ETERM *key, *value;
|
ETERM *tuplep[20];
|
ETERM *arr_ret[2], *list_ret[5000];
|
ETERM *tail_list, *tail_tuple;
|
arr_ret[0] = erl_element(2, emsg.msg);
|
if (checkETERMType(arr_ret[0]) == ERL_LIST) {
|
int erlLength = erl_length(arr_ret[0]);
|
// printf("arr_ret[0]:%d\n", erlLength);
|
list_ret[0] = erl_hd(arr_ret[0]);
|
tail_list = erl_tl(arr_ret[0]);
|
for (int i = 0; i < erlLength; i++) {
|
// DBG(i);
|
if (i > 0) {
|
list_ret[i] = erl_hd(tail_list);
|
tail_list = erl_tl(tail_list);
|
}
|
if (tail_list == NULL)
|
break;
|
if (checkETERMType(list_ret[i]) == ERL_LIST) {
|
SyncDB::AddPersRet addPersRet;
|
int erlLength1 = erl_length(list_ret[i]);
|
// printf("list_ret[%d]:%d\n", i, erlLength1);
|
tuplep[0] = erl_hd(list_ret[i]);
|
tail_tuple = erl_tl(list_ret[i]);
|
|
for (int j = 0; j < erlLength1; j++) {
|
if (j > 0) {
|
tuplep[j] = erl_hd(tail_tuple);
|
tail_tuple = erl_tl(tail_tuple);
|
}
|
key = erl_element(1, tuplep[j]);
|
value = erl_element(2, tuplep[j]);
|
// printf("key:%s\n", erl_iolist_to_string(key));
|
|
switch (checkETERMType(value)) {
|
case ERL_ATOM: {
|
addPersRet.setValue(erl_iolist_to_string(key), ERL_ATOM_PTR(value));
|
break;
|
}
|
case ERL_LIST: {
|
addPersRet.setValue(erl_iolist_to_string(key),
|
erl_iolist_to_string(value));
|
break;
|
}
|
default:
|
printf("error add case todo %d\n\r", checkETERMType(value));
|
}
|
|
// erlangFreeEterm(2, key, value);
|
}
|
// printf("\none list end\n\n\n\n");
|
t_vec_addDataCache.push_back(addPersRet);
|
} else {
|
ERR(" type error " << checkETERMType(list_ret[i]));
|
}
|
}
|
erlangFreeEterm(4, emsg.msg, emsg.from, emsg.to, list);
|
erl_eterm_release();
|
// sleep()
|
return t_vec_addDataCache;
|
} else {
|
ERR(" error " << checkETERMType(arr_ret[0]));
|
}
|
} else {
|
ERR("send Message is error");
|
}
|
}
|
erlangFreeEterm(4, emsg.msg, emsg.from, emsg.to, list);
|
erl_free_array(arrvaluelist, 2);
|
erl_eterm_release();
|
return t_vec_addDataCache;
|
}
|
|
bool ErlangTool::ErlangDbTool::delPerson(std::string UUID, std::string TableName) {
|
LockG lock(m_mutex);
|
// m_mutex.lock();
|
m_ret = resetConn();
|
if (!m_ret) {
|
//#todo error message
|
ERR(" error " << m_ret << " " << m_fd << " ");
|
return false;
|
}
|
int ret;
|
ErlMessage emsg; /* Incoming message */
|
//hanshu canshu
|
ETERM *arrlist[2];
|
// arrlist[0] = erl_mk_atom(TableName.c_str());
|
// arrlist[1] = erl_mk_atom(UUID.c_str());
|
arrlist[0] = erl_mk_string(TableName.c_str());
|
arrlist[1] = erl_mk_string(UUID.c_str());
|
|
ETERM *list = erl_mk_list(arrlist, 2);
|
ret = erl_rpc_to(m_fd, "syncDB", "deletePersonData", list);
|
if (ret == ERL_TICK) {
|
ret = erl_rpc_from(m_fd, TIMEOUT, &emsg);
|
//erl_close_connection(m_fd);
|
// m_mutex.unlock();
|
if (ret == ERL_MSG) {
|
std::map<std::string, std::string> t_results;
|
ETERM *tail_list;
|
ETERM *list_ret[10], *arr_ret[2];
|
ETERM *key, *value;
|
ETERM *tuplep[6];
|
arr_ret[0] = erl_element(2, emsg.msg);
|
int erlLength = erl_length(arr_ret[0]);
|
printf("arr_ret[0]:%d\n", erlLength);
|
list_ret[0] = erl_hd(arr_ret[0]);
|
tail_list = erl_tl(arr_ret[0]);
|
for (int i = 0; i < erlLength; i++) {
|
if (i > 0) {
|
list_ret[i] = erl_hd(tail_list);
|
tail_list = erl_tl(tail_list);
|
}
|
// printf("list_ret[%d]:%d\n", i, erl_length(list_ret[i]));
|
tuplep[0] = erl_hd(list_ret[i]);
|
key = erl_element(1, list_ret[i]);
|
value = erl_element(2, list_ret[i]);
|
// printf("key:%s\n", ERL_ATOM_PTR(key));
|
switch (checkETERMType(value)) {
|
case ERL_ATOM: {
|
int atomSize = ERL_ATOM_SIZE(value);
|
char *atomValue = ERL_ATOM_PTR(value);
|
t_results.insert(std::make_pair(ERL_ATOM_PTR(key), atomValue));
|
// printf("value is a atom: atomSize:%d, atomValue:%s \n\r", atomSize, atomValue);
|
break;
|
}
|
default:
|
printf("error add case todo \n\r");
|
}
|
erlangFreeEterm(4, key, value, tuplep[0], list_ret[i]);
|
}
|
erlangFreeEterm(2, tail_list, arr_ret[0]);
|
auto it = t_results.find("atomic");
|
if (t_results.size() > 0 && t_results.end() != it && it->second == "ok") {
|
return true;
|
}
|
}
|
}
|
erlangFreeEterm(4, emsg.msg, emsg.from, emsg.to, list);
|
erl_free_array(arrlist, 2);
|
erl_eterm_release();
|
return false;
|
}
|
|
//ErlangTool::map_FaceDataCache ErlangTool::ErlangDbTool::loadFaceFeaData(std::string TableName) {
|
// std::lock_guard<std::mutex> lock(m_mutex);
|
//// m_mutex.lock();
|
// m_ret = resetConn();
|
// if (!m_ret) {
|
// //#todo error message
|
// std::cout << __FILE__ << __FUNCTION__ << __LINE__ << " error " << m_ret << " " << m_fd << std::endl;
|
// return map_FaceDataCache();
|
// }
|
// map_FaceDataCache dataCache;
|
// int ret;
|
// ErlMessage emsg; /* Incoming message */
|
// //hanshu canshu
|
// ETERM *arrlist[1];
|
// arrlist[0] = erl_mk_string(TableName.c_str());
|
//
|
// ETERM *list = erl_mk_list(arrlist, 1);
|
// ret = erl_rpc_to(m_fd, "syncDB", "loadFaceFeaData", list);
|
//
|
// if (ret == ERL_TICK) {
|
// ret = erl_rpc_from(m_fd, TIMEOUT * 100000, &emsg);
|
// //erl_close_connection(m_fd);
|
//// m_mutex.unlock();
|
// if (ret == ERL_MSG) {
|
// ETERM *key, *value;
|
// ETERM *tuplep[20];
|
// ETERM *arr_ret[2], *list_ret[5000];
|
// ETERM *tail_list, *tail_tuple;
|
// arr_ret[0] = erl_element(2, emsg.msg);
|
// if (checkETERMType(arr_ret[0]) == ERL_LIST) {
|
// int erlLength = erl_length(arr_ret[0]);
|
//// printf("arr_ret[0]:%d\n", erlLength);
|
// list_ret[0] = erl_hd(arr_ret[0]);
|
// tail_list = erl_tl(arr_ret[0]);
|
// for (int i = 0; i < erlLength; i++) {
|
//// DBG(i);
|
// if (i > 0) {
|
// list_ret[i] = erl_hd(tail_list);
|
// tail_list = erl_tl(tail_list);
|
// }
|
// if (tail_list == NULL)
|
// break;
|
// if (checkETERMType(list_ret[i]) == ERL_LIST) {
|
// SyncDB::Feature_Info feature_info;
|
// int erlLength1 = erl_length(list_ret[i]);
|
//// printf("list_ret[%d]:%d\n", i, erlLength1);
|
// tuplep[0] = erl_hd(list_ret[i]);
|
// tail_tuple = erl_tl(list_ret[i]);
|
// for (int j = 0; j < erlLength1; j++) {
|
// if (j > 0) {
|
// tuplep[j] = erl_hd(tail_tuple);
|
// tail_tuple = erl_tl(tail_tuple);
|
// }
|
// key = erl_element(1, tuplep[j]);
|
// value = erl_element(2, tuplep[j]);
|
//// printf("key:%s\n", erl_iolist_to_string(key));
|
//
|
// switch (checkETERMType(value)) {
|
// case ERL_ATOM: {
|
// feature_info.setValue(erl_iolist_to_string(key), ERL_ATOM_PTR(value));
|
// break;
|
// }
|
// case ERL_LIST: {
|
// feature_info.setValue(erl_iolist_to_string(key),
|
// erl_iolist_to_string(value));
|
// break;
|
// }
|
// default:
|
// printf("error add case todo %d\n\r", checkETERMType(value));
|
// }
|
//
|
//// erlangFreeEterm(2, key, value);
|
// }
|
//// printf("\none list end\n\n\n\n");
|
// dataCache.insert(std::move(std::make_pair(feature_info.id, feature_info)));
|
//// break;
|
//// erlangFreeEterm(1, list_ret[i]);
|
// } else {
|
// ERR(" type error " << checkETERMType(list_ret[i]));
|
// }
|
// }
|
// erlangFreeEterm(5, emsg.msg, emsg.from, emsg.to, list, arrlist[0]);
|
// erl_eterm_release();
|
//// sleep()
|
// return dataCache;
|
// } else {
|
// ERR(" error " << checkETERMType(arr_ret[0]));
|
// }
|
// } else {
|
// ERR(" error " << ret << " ");
|
// }
|
//
|
// }
|
// erlangFreeEterm(5, emsg.msg, emsg.from, emsg.to, list, arrlist[0]);
|
// erl_eterm_release();
|
// return map_FaceDataCache();
|
//};
|
|
//ErlangTool::map_FaceDataCache ErlangTool::ErlangDbTool::loadFaceFeaData2(std::string TableName) {
|
// std::lock_guard<std::mutex> lock(m_mutex);
|
//// m_mutex.lock();
|
// m_ret = resetConn();
|
// if (!m_ret) {
|
// //#todo error message
|
// ERR(" error " << m_ret << " " << m_fd);
|
// return map_FaceDataCache();
|
// }
|
// map_FaceDataCache dataCache;
|
// int ret;
|
// ErlMessage emsg; /* Incoming message */
|
// //hanshu canshu
|
// ETERM *arrlist[1];
|
//// arrlist[0] = erl_mk_atom(TableName.c_str());
|
// arrlist[0] = erl_mk_string(TableName.c_str());
|
//
|
// ETERM *list = erl_mk_list(arrlist, 1);
|
// ret = erl_rpc_to(m_fd, "syncDB", "loadFaceFeaData2", list);
|
//
|
// if (ret == ERL_TICK) {
|
// ret = erl_rpc_from(m_fd, TIMEOUT * 100000, &emsg);
|
// //erl_close_connection(m_fd);
|
//// m_mutex.unlock();
|
// if (ret == ERL_MSG) {
|
// ETERM *key, *value;
|
// ETERM *tuplep[20];
|
// ETERM *arr_ret[2], *list_ret[5000];
|
// ETERM *tail_list, *tail_tuple;
|
// arr_ret[0] = erl_element(2, emsg.msg);
|
// if (checkETERMType(arr_ret[0]) == ERL_LIST) {
|
// int erlLength = erl_length(arr_ret[0]);
|
//// printf("arr_ret[0]:%d\n", erlLength);
|
// list_ret[0] = erl_hd(arr_ret[0]);
|
// tail_list = erl_tl(arr_ret[0]);
|
// for (int i = 0; i < erlLength; i++) {
|
//// DBG(i);
|
// if (i > 0) {
|
// list_ret[i] = erl_hd(tail_list);
|
// tail_list = erl_tl(tail_list);
|
// }
|
// if (tail_list == NULL)
|
// break;
|
// if (checkETERMType(list_ret[i]) == ERL_LIST) {
|
// SyncDB::Feature_Info feature_info;
|
//// feature_info.id = "test";
|
//// feature_info.create_by = "";
|
//// feature_info.feature ="";
|
//// feature_info.update_time = "";
|
//// feature_info.create_time = "";
|
//
|
// int erlLength1 = erl_length(list_ret[i]);
|
//// printf("list_ret[%d]:%d\n", i, erlLength1);
|
// tuplep[0] = erl_hd(list_ret[i]);
|
// tail_tuple = erl_tl(list_ret[i]);
|
//
|
// for (int j = 0; j < erlLength1; j++) {
|
// if (j > 0) {
|
// tuplep[j] = erl_hd(tail_tuple);
|
// tail_tuple = erl_tl(tail_tuple);
|
// }
|
// key = erl_element(1, tuplep[j]);
|
// value = erl_element(2, tuplep[j]);
|
//// printf("key:%s\n", erl_iolist_to_string(key));
|
//
|
// switch (checkETERMType(value)) {
|
// case ERL_ATOM: {
|
// feature_info.setValue(erl_iolist_to_string(key), ERL_ATOM_PTR(value));
|
// break;
|
// }
|
// case ERL_LIST: {
|
// feature_info.setValue(erl_iolist_to_string(key),
|
// erl_iolist_to_string(value));
|
// break;
|
// }
|
// default:
|
// printf("error add case todo %d\n\r", checkETERMType(value));
|
// }
|
//
|
//// erlangFreeEterm(2, key, value);
|
// }
|
//// printf("\none list end\n\n\n\n");
|
// dataCache.insert(std::move(std::make_pair(feature_info.id, feature_info)));
|
//// break;
|
//// erlangFreeEterm(1, list_ret[i]);
|
// } else {
|
// ERR(" type error " << checkETERMType(list_ret[i]));
|
// }
|
// }
|
//// erlangFreeEterm(5, emsg.msg, emsg.from, emsg.to, list, arrlist[0]);
|
//// erl_eterm_release();
|
//// sleep()
|
// return dataCache;
|
// } else {
|
// ERR(" error " << checkETERMType(arr_ret[0]));
|
// }
|
// } else {
|
// ERR(" error " << ret << " ");
|
// }
|
//
|
// }
|
// erlangFreeEterm(5, emsg.msg, emsg.from, emsg.to, list, arrlist[0]);
|
// erl_eterm_release();
|
// return map_FaceDataCache();
|
//};
|
|
ErlangTool::map_FaceDataCache ErlangTool::ErlangDbTool::loadFaceFeaData(std::string TableName) {
|
map_FaceDataCache dataCache;
|
|
std::string str_tableUuid;
|
|
auto tableInfoMap = findAllDatabase();
|
|
for (auto &item : tableInfoMap) {
|
if (item.second.tableName == TableName) {
|
str_tableUuid = item.second.uuid;
|
break;
|
}
|
}
|
if (str_tableUuid.size() > 0) {
|
QString sql = QString::fromStdString(
|
"Select a.uuid as id ,a.faceUrl as img,a.feature,b.idCard as idcard from '" + str_tableUuid +
|
"_fea' as a ,'" + str_tableUuid + "' as b where a.uuid = b.uuid and ( a.del_flag=0 AND b.del_flag=0);");
|
QSqlQuery query(g_syncDbFile);
|
query.prepare(sql);
|
if (!query.exec()) {
|
qDebug() << "getTableNameList" << __FILE__ << __LINE__ << query.lastError();
|
} else {
|
while (query.next()) {
|
SyncDB::Feature_Info t_feature_info;
|
t_feature_info.id = query.value(0).toString().toStdString();
|
t_feature_info.img = query.value(1).toString().toStdString();
|
t_feature_info.feature = query.value(2).toString().toStdString();
|
t_feature_info.idcard = query.value(3).toString().toStdString();
|
|
dataCache.insert(std::make_pair(t_feature_info.id, t_feature_info));
|
}
|
return dataCache;
|
}
|
}
|
return map_FaceDataCache();
|
};
|
|
ErlangTool::map_FaceDataCache ErlangTool::ErlangDbTool::loadFaceFeaData2(std::string TableName) {
|
|
map_FaceDataCache dataCache;
|
|
std::string str_tableUuid;
|
|
auto tableInfoMap = findAllDatabase();
|
|
for (auto &item : tableInfoMap) {
|
if (item.second.tableName == TableName) {
|
str_tableUuid = item.second.uuid;
|
break;
|
}
|
}
|
if (str_tableUuid.size() > 0) {
|
QString sql = QString::fromStdString(
|
"Select b.uuid as id,b.faceUrl as img,a.idCard as idcard from '" + str_tableUuid + "' as a, '" +
|
str_tableUuid + "_fea' As b where a.uuid = b.uuid and ( a.del_flag=0 AND b.del_flag=0);");
|
QSqlQuery query(g_syncDbFile);
|
query.prepare(sql);
|
if (!query.exec()) {
|
qDebug() << "getTableNameList" << __FILE__ << __LINE__ << query.lastError();
|
} else {
|
while (query.next()) {
|
SyncDB::Feature_Info t_feature_info;
|
t_feature_info.id = query.value(0).toString().toStdString();
|
t_feature_info.img = query.value(1).toString().toStdString();
|
t_feature_info.idcard = query.value(2).toString().toStdString();
|
|
dataCache.insert(std::make_pair(t_feature_info.id, t_feature_info));
|
}
|
return dataCache;
|
}
|
}
|
return map_FaceDataCache();
|
};
|
|
bool ErlangTool::ErlangDbTool::resetConn() {
|
//#todo
|
if (m_pName.size() <= 0) {
|
srand(time(0));
|
m_loop = rand() % 1000;
|
|
int ret = -1;
|
erl_init(NULL, 0);
|
// m_loop %= 10;
|
// m_loop++;
|
ret = erl_connect_init(m_loop, const_cast<char *>(m_cookie.c_str()), 0);
|
DBG("node name is " << m_loop);
|
if (-1 == ret) {
|
// erl_err_quit("erl_connect_init");
|
return false;
|
}
|
|
// std::cout << __FILE__ << __FUNCTION__ <<__LINE__ << " " << m_fd << std::endl;
|
erl_close_connection(m_fd);
|
// std::cout << __FILE__ << __FUNCTION__ <<__LINE__ << " " << m_fd << std::endl;
|
m_fd = erl_connect(const_cast<char *>(m_nodeName.c_str()));
|
// std::cout << __FILE__ << __FUNCTION__ <<__LINE__ << " " << m_fd << std::endl;
|
if (0 > m_fd) {
|
// erl_err_quit("erl_connect");
|
return false;
|
}
|
return true;
|
} else {
|
erl_close_connection(m_fd);
|
m_fd = erl_connect(const_cast<char *>(m_nodeName.c_str()));
|
if (0 > m_fd) {
|
// erl_err_quit("erl_connect");
|
// std::cout << __FILE__ << __FUNCTION__ <<__LINE__ << " error " << fd << std::endl;
|
ERR("m_fd is " << m_fd << " m_nodeName is" << m_nodeName);
|
return false;
|
}
|
// std::cout << __FILE__ << __FUNCTION__ <<__LINE__ << " " << fd << std::endl;
|
INFO("m_fd is " << m_fd << " m_nodeName is" << m_nodeName);
|
return true;
|
}
|
}
|
|
bool ErlangTool::ErlangDbTool::waitNode() {
|
std::cout << "start waitNode" << std::endl;
|
int loop = 0;
|
while (!m_ret && loop <= 4000) {
|
m_ret = ErlangTool::pingNode(m_nodeName, m_cookie);
|
if (m_ret) {
|
// std::cout << "startNodeDb" << std::endl;
|
} else {
|
// std::cout << "init failer" << std::endl;
|
usleep(100000);
|
loop++;
|
}
|
}
|
std::cout << "start waitNode" << std::endl;
|
return m_ret;
|
}
|
|
void ErlangTool::ErlangDbTool::test(pthread_cond_t *t_pthcon, pthread_mutex_t *t_pthmut) {
|
bool ret = setCNodeName();
|
{
|
std::thread th1([&] {
|
int res;
|
pthread_cond_t *t_pthCon = t_pthcon;
|
pthread_mutex_t *t_pthMut = t_pthmut;
|
|
int listen; /* Listen socket */
|
int fd; /* fd to Erlang node */
|
ErlConnect conn; /* Connection data */
|
|
int loop = 1; /* Loop flag */
|
int got; /* Result of receive */
|
unsigned char buf[BUFSIZE]; /* Buffer for incoming message */
|
ErlMessage emsg; /* Incoming message */
|
|
ETERM *fromp, *tuplep, *fnp, *argp, *resp;
|
|
int port; /* Listen port number */
|
port = PORT;
|
/* Make a listen socket */
|
if ((listen = my_listen(port)) <= 0) {
|
ERR("my_listen is error");
|
erl_err_quit("my_listen");
|
}
|
if (erl_publish(port) == -1) {
|
ERR("erl_publish is error");
|
erl_err_quit("erl_publish");
|
}
|
if ((fd = erl_accept(listen, &conn)) == ERL_ERROR) {
|
ERR("erl_accept is error");
|
erl_err_quit("erl_accept");
|
}
|
INFO("Connected to " << conn.nodename);
|
|
while (loop) {
|
// std::cout << "hello world" << std::endl;
|
got = erl_receive_msg(fd, buf, BUFSIZE, &emsg);
|
if (got == ERL_TICK) {
|
/* ignore */
|
} else if (got == ERL_ERROR) {
|
if ((fd = erl_accept(listen, &conn)) == ERL_ERROR)
|
erl_err_quit("erl_accept");
|
INFO("Connected to " << conn.nodename);
|
} else {
|
|
if (emsg.type == ERL_REG_SEND) {
|
fromp = erl_element(2, emsg.msg);
|
tuplep = erl_element(3, emsg.msg);
|
fnp = erl_element(1, tuplep);
|
argp = erl_element(2, tuplep);
|
|
if (strncmp(ERL_ATOM_PTR(fnp), "update", 6) == 0) {
|
INFO("message is " << ERL_ATOM_PTR(fnp));
|
std::string str1(ERL_ATOM_PTR(fnp));
|
// CBF(str1);
|
DBG("erlangCallBackFunc");
|
pthread_cond_signal(t_pthCon);
|
pthread_mutex_unlock(t_pthMut);
|
//call back func
|
} else {
|
ERR("message not is update");
|
}
|
// resp = erl_format("{c1, {res,~i}}", res);
|
// erl_send(fd, fromp, resp);
|
|
erl_free_term(emsg.from);
|
erl_free_term(emsg.msg);
|
erl_free_term(fromp);
|
erl_free_term(tuplep);
|
erl_free_term(fnp);
|
erl_free_term(argp);
|
erl_free_term(resp);
|
erl_close_connection(fd);
|
if ((fd = erl_accept(listen, &conn)) == ERL_ERROR)
|
erl_err_quit("erl_accept");
|
INFO("Connected to " << conn.nodename);
|
}
|
}
|
|
}
|
});
|
th1.detach();
|
}
|
|
}
|
|
bool ErlangTool::ErlangDbTool::setCNodeName() {
|
LockG lock(m_mutex);
|
// m_mutex.lock();
|
m_ret = resetConn();
|
if (!m_ret) {
|
//#todo error message
|
ERR(" error " << m_ret << " " << m_fd);
|
return false;
|
}
|
ErlMessage emsg; /* Incoming message */
|
int ret = -1;
|
ETERM *arrlist[1];
|
arrlist[0] = erl_mk_atom(m_cNodeName.c_str());
|
// arrlist[0] = erl_mk_atom("c1@127.0.0.1");
|
ETERM *list = erl_mk_list(arrlist, 1);
|
ret = erl_rpc_to(m_fd, "syncDB", "setCNode", list);
|
if (ret == ERL_TICK) {
|
ret = erl_rpc_from(m_fd, TIMEOUT, &emsg);
|
//erl_close_connection(m_fd);
|
// m_mutex.unlock();
|
if (ret == ERL_MSG) {
|
std::map<std::string, std::string> t_results;
|
|
ETERM *tail_list;
|
ETERM *list_ret[1000], *arr_ret[2];
|
ETERM *key, *value;
|
ETERM *tuplep[6];
|
|
arr_ret[0] = erl_element(2, emsg.msg);
|
int erlLength = erl_length(arr_ret[0]);
|
INFO("arr_ret[0]: " << erlLength);
|
list_ret[0] = erl_hd(arr_ret[0]);
|
tail_list = erl_tl(arr_ret[0]);
|
for (int i = 0; i < erlLength; i++) {
|
if (i > 0) {
|
list_ret[i] = erl_hd(tail_list);
|
tail_list = erl_tl(tail_list);
|
}
|
// printf("list_ret[%d]:%d\n", i, erl_length(list_ret[i]));
|
tuplep[0] = erl_hd(list_ret[i]);
|
key = erl_element(1, list_ret[i]);
|
value = erl_element(2, list_ret[i]);
|
// printf("key:%s\n", ERL_ATOM_PTR(key));
|
switch (checkETERMType(value)) {
|
case ERL_ATOM: {
|
int atomSize = ERL_ATOM_SIZE(value);
|
char *atomValue = ERL_ATOM_PTR(value);
|
INFO("value is a atom: atomSize: " << atomSize << " , atomValue:" << atomValue << " \n\r");
|
t_results.insert(std::make_pair(ERL_ATOM_PTR(key), atomValue));
|
break;
|
}
|
default:
|
ERR("error add case todo \n\r");
|
}
|
erlangFreeEterm(4, key, value, tuplep[0], list_ret[i]);
|
}
|
erlangFreeEterm(2, tail_list, arr_ret[0]);
|
erl_eterm_release();
|
auto it = t_results.find("atomic");
|
if (t_results.size() > 0 && t_results.end() != it && it->second == "ok") {
|
return true;
|
} else {
|
ERR("res is err ");
|
}
|
} else {
|
ERR("recv mess error : ret != ERL_MSG");
|
}
|
} else {
|
ERR("send mess error : ret != ERL_TICK");
|
}
|
erl_free_array(arrlist, 1);
|
// erlangFreeEterm(4, emsg.to, emsg.msg, emsg.from, list);
|
erl_eterm_release();
|
return false;
|
}
|
|
bool ErlangTool::ErlangDbTool::sendMessage() {
|
LockG lock(m_mutex);
|
// m_mutex.lock();
|
m_ret = resetConn();
|
if (!m_ret) {
|
//#todo error message
|
ERR(" error " << m_ret << " " << m_fd);
|
return false;
|
}
|
ErlMessage emsg; /* Incoming message */
|
int ret = -1;
|
ETERM *list = erl_mk_empty_list();
|
ret = erl_rpc_to(m_fd, "syncDB", "sendMessage", list);
|
if (ret == ERL_TICK) {
|
ret = erl_rpc_from(m_fd, TIMEOUT, &emsg);
|
//erl_close_connection(m_fd);
|
// m_mutex.unlock();
|
if (ret == ERL_MSG) {
|
std::map<std::string, std::string> t_results;
|
|
ETERM *tail_list;
|
ETERM *list_ret[1000], *arr_ret[2];
|
ETERM *key, *value;
|
ETERM *tuplep[6];
|
|
arr_ret[0] = erl_element(2, emsg.msg);
|
int erlLength = erl_length(arr_ret[0]);
|
INFO("arr_ret[0]: " << erlLength);
|
list_ret[0] = erl_hd(arr_ret[0]);
|
tail_list = erl_tl(arr_ret[0]);
|
for (int i = 0; i < erlLength; i++) {
|
if (i > 0) {
|
list_ret[i] = erl_hd(tail_list);
|
tail_list = erl_tl(tail_list);
|
}
|
// printf("list_ret[%d]:%d\n", i, erl_length(list_ret[i]));
|
tuplep[0] = erl_hd(list_ret[i]);
|
key = erl_element(1, list_ret[i]);
|
value = erl_element(2, list_ret[i]);
|
// printf("key:%s\n", ERL_ATOM_PTR(key));
|
switch (checkETERMType(value)) {
|
case ERL_ATOM: {
|
int atomSize = ERL_ATOM_SIZE(value);
|
char *atomValue = ERL_ATOM_PTR(value);
|
INFO("value is a atom: atomSize: " << atomSize << " , atomValue:" << atomValue << " \n\r");
|
t_results.insert(std::make_pair(ERL_ATOM_PTR(key), atomValue));
|
break;
|
}
|
default:
|
ERR("error add case todo \n\r");
|
}
|
erlangFreeEterm(4, key, value, tuplep[0], list_ret[i]);
|
}
|
erlangFreeEterm(2, tail_list, arr_ret[0]);
|
erl_eterm_release();
|
auto it = t_results.find("atomic");
|
if (t_results.size() > 0 && t_results.end() != it && it->second == "ok") {
|
return true;
|
} else {
|
ERR("res is err ");
|
}
|
} else {
|
ERR("recv mess error : ret != ERL_MSG");
|
}
|
} else {
|
ERR("send mess error : ret != ERL_TICK");
|
}
|
// erl_free_array(arrlist, 1);
|
// erlangFreeEterm(4, emsg.to, emsg.msg, emsg.from, list);
|
erl_eterm_release();
|
return false;
|
}
|
|
ErlangTool::vec_PerExistRet ErlangTool::ErlangDbTool::personIsExistOnClu(std::string personUid) {
|
ErlangTool::vec_PerExistRet t_vec_perExistRet;
|
|
std::lock_guard<std::mutex> lock(m_mutex);
|
// m_mutex.lock();
|
m_ret = resetConn();
|
if (!m_ret) {
|
//#todo error message
|
ERR(" error " << m_ret << " " << m_fd);
|
return t_vec_perExistRet;
|
}
|
|
int ret;
|
ErlMessage emsg; /* Incoming message */
|
//hanshu canshu
|
ETERM *arrlist[1];
|
arrlist[0] = erl_mk_string(personUid.c_str());
|
|
ETERM *list = erl_mk_list(arrlist, 1);
|
ret = erl_rpc_to(m_fd, "syncDB", "singlePersonIsExists", list);
|
|
if (ret == ERL_TICK) {
|
ret = erl_rpc_from(m_fd, TIMEOUT * 100000, &emsg);
|
//erl_close_connection(m_fd);
|
// m_mutex.unlock();
|
if (ret == ERL_MSG) {
|
ETERM *key, *value;
|
ETERM *tuplep[20];
|
ETERM *arr_ret[2], *list_ret[5000];
|
ETERM *tail_list, *tail_tuple;
|
arr_ret[0] = erl_element(2, emsg.msg);
|
if (checkETERMType(arr_ret[0]) == ERL_LIST) {
|
int erlLength = erl_length(arr_ret[0]);
|
// printf("arr_ret[0]:%d\n", erlLength);
|
list_ret[0] = erl_hd(arr_ret[0]);
|
tail_list = erl_tl(arr_ret[0]);
|
for (int i = 0; i < erlLength; i++) {
|
// DBG(i);
|
if (i > 0) {
|
list_ret[i] = erl_hd(tail_list);
|
tail_list = erl_tl(tail_list);
|
}
|
if (tail_list == NULL)
|
break;
|
if (checkETERMType(list_ret[i]) == ERL_LIST) {
|
SyncDB::PerExistRet perExistRet;
|
|
int erlLength1 = erl_length(list_ret[i]);
|
// printf("list_ret[%d]:%d\n", i, erlLength1);
|
tuplep[0] = erl_hd(list_ret[i]);
|
tail_tuple = erl_tl(list_ret[i]);
|
|
for (int j = 0; j < erlLength1; j++) {
|
if (j > 0) {
|
tuplep[j] = erl_hd(tail_tuple);
|
tail_tuple = erl_tl(tail_tuple);
|
}
|
key = erl_element(1, tuplep[j]);
|
value = erl_element(2, tuplep[j]);
|
// printf("key:%s\n", erl_iolist_to_string(key));
|
|
switch (checkETERMType(value)) {
|
case ERL_ATOM: {
|
perExistRet.setValue(erl_iolist_to_string(key), ERL_ATOM_PTR(value));
|
break;
|
}
|
case ERL_LIST: {
|
perExistRet.setValue(erl_iolist_to_string(key),
|
erl_iolist_to_string(value));
|
break;
|
}
|
default:
|
printf("error add case todo %d\n\r", checkETERMType(value));
|
}
|
}
|
t_vec_perExistRet.push_back(perExistRet);
|
} else {
|
ERR(" type error " << checkETERMType(list_ret[i]));
|
}
|
}
|
erlangFreeEterm(5, emsg.msg, emsg.from, emsg.to, list, arrlist[0]);
|
erl_eterm_release();
|
return t_vec_perExistRet;
|
} else {
|
ERR(" error " << checkETERMType(arr_ret[0]));
|
}
|
} else {
|
ERR(" error " << ret << " ");
|
}
|
}
|
erlangFreeEterm(5, emsg.msg, emsg.from, emsg.to, list, arrlist[0]);
|
erl_eterm_release();
|
return t_vec_perExistRet;
|
}
|
|
ErlangTool::vec_UpdPersRet
|
ErlangTool::ErlangDbTool::singlePersonUpdate(std::string NewPerId, std::string OldId, std::string Idcard,
|
std::string PerPicUrl, std::string PerFea) {
|
ErlangTool::vec_UpdPersRet t_vec_UpdPersRet;
|
|
std::lock_guard<std::mutex> lock(m_mutex);
|
// m_mutex.lock();
|
m_ret = resetConn();
|
if (!m_ret) {
|
//#todo error message
|
ERR(" error " << m_ret << " " << m_fd);
|
return t_vec_UpdPersRet;
|
}
|
|
int ret;
|
ErlMessage emsg; /* Incoming message */
|
//hanshu canshu
|
ETERM *arrlist[5];
|
arrlist[0] = erl_mk_atom(NewPerId.c_str());
|
arrlist[1] = erl_mk_atom(OldId.c_str());
|
arrlist[2] = erl_mk_atom(Idcard.c_str());
|
arrlist[3] = erl_mk_atom(PerPicUrl.c_str());
|
arrlist[4] = erl_mk_string(PerFea.c_str());
|
|
ETERM *list = erl_mk_list(arrlist, 5);
|
ret = erl_rpc_to(m_fd, "syncDB", "singlePersonUpdate", list);
|
|
if (ret == ERL_TICK) {
|
ret = erl_rpc_from(m_fd, TIMEOUT * 100000, &emsg);
|
//erl_close_connection(m_fd);
|
// m_mutex.unlock();
|
if (ret == ERL_MSG) {
|
ETERM *key, *value;
|
ETERM *tuplep[20];
|
ETERM *arr_ret[2], *list_ret[5000];
|
ETERM *tail_list, *tail_tuple;
|
arr_ret[0] = erl_element(2, emsg.msg);
|
if (checkETERMType(arr_ret[0]) == ERL_LIST) {
|
int erlLength = erl_length(arr_ret[0]);
|
// printf("arr_ret[0]:%d\n", erlLength);
|
list_ret[0] = erl_hd(arr_ret[0]);
|
tail_list = erl_tl(arr_ret[0]);
|
for (int i = 0; i < erlLength; i++) {
|
// DBG(i);
|
if (i > 0) {
|
list_ret[i] = erl_hd(tail_list);
|
tail_list = erl_tl(tail_list);
|
}
|
if (tail_list == NULL)
|
break;
|
if (checkETERMType(list_ret[i]) == ERL_LIST) {
|
SyncDB::UpdPersRet updPersRet;
|
|
int erlLength1 = erl_length(list_ret[i]);
|
// printf("list_ret[%d]:%d\n", i, erlLength1);
|
tuplep[0] = erl_hd(list_ret[i]);
|
tail_tuple = erl_tl(list_ret[i]);
|
|
for (int j = 0; j < erlLength1; j++) {
|
if (j > 0) {
|
tuplep[j] = erl_hd(tail_tuple);
|
tail_tuple = erl_tl(tail_tuple);
|
}
|
key = erl_element(1, tuplep[j]);
|
value = erl_element(2, tuplep[j]);
|
// printf("key:%s\n", erl_iolist_to_string(key));
|
|
switch (checkETERMType(value)) {
|
case ERL_ATOM: {
|
updPersRet.setValue(erl_iolist_to_string(key), ERL_ATOM_PTR(value));
|
break;
|
}
|
case ERL_LIST: {
|
updPersRet.setValue(erl_iolist_to_string(key),
|
erl_iolist_to_string(value));
|
break;
|
}
|
default:
|
printf("error add case todo %d\n\r", checkETERMType(value));
|
}
|
}
|
t_vec_UpdPersRet.push_back(updPersRet);
|
} else {
|
ERR(" type error " << checkETERMType(list_ret[i]));
|
}
|
}
|
erlangFreeEterm(5, emsg.msg, emsg.from, emsg.to, list, arrlist[0]);
|
erl_eterm_release();
|
return t_vec_UpdPersRet;
|
} else {
|
ERR(" error " << checkETERMType(arr_ret[0]));
|
}
|
} else {
|
ERR(" error " << ret << " ");
|
}
|
}
|
erlangFreeEterm(5, emsg.msg, emsg.from, emsg.to, list, arrlist[0]);
|
erl_eterm_release();
|
return t_vec_UpdPersRet;
|
}
|
|
static int ErlangTool::my_listen(int port) {
|
int listen_fd;
|
struct sockaddr_in addr;
|
int on = 1;
|
|
if ((listen_fd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
|
return (-1);
|
|
setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
|
|
memset((void *) &addr, 0, (size_t) sizeof(addr));
|
addr.sin_family = AF_INET;
|
addr.sin_port = htons(port);
|
addr.sin_addr.s_addr = htonl(INADDR_ANY);
|
|
if (bind(listen_fd, (struct sockaddr *) &addr, sizeof(addr)) < 0)
|
return (-1);
|
|
listen(listen_fd, 5);
|
return listen_fd;
|
}
|
