////
|
//// Created by ps on 8/6/18.
|
////
|
//
|
//#ifndef UNTITLED_ERLANGTOOL_HPP
|
//#define UNTITLED_ERLANGTOOL_HPP
|
//
|
//#include <iostream>
|
//#include <cstring>
|
//#include <unistd.h>
|
//
|
//#include <map>
|
//#include <vector>
|
//#include <mutex>
|
//
|
//#include <stdio.h>
|
//#include <stdarg.h>
|
//#include <jsoncpp/json/json.h>
|
//#include <arpa/inet.h>
|
//
|
//#include "erl_interface.h"
|
//#include "ei.h"
|
//
|
//#include "SyncDB.hpp"
|
//
|
//#define TIMEOUT (5000)
|
//
|
////#TODO 多线程优化
|
//namespace ErlangTool {
|
//
|
// static int m_loop = 0;
|
// //map<uuid，人脸特征信息>
|
// typedef std::map<std::string, SyncDB::Feature_Info> map_FaceDataCache;
|
// //map<uuid，设备信息>
|
// typedef std::map<std::string, SyncDB::Device_Info> map_DevDataCache;
|
// //map<表名，底库表信息>
|
// typedef std::map<std::string, SyncDB::Table_Info> map_TabDataCache;
|
// //map<表名，黑白名单类型>
|
// typedef std::map<std::string, SyncDB::Bw_Info> map_BwDataCache;
|
//
|
// //c++11 互斥锁
|
// // LockG(Parma);
|
// typedef std::lock_guard<std::mutex> LockG;
|
//
|
// /***
|
// * 判断文件夹路径是否存在，不存在则创建
|
// * @param dir 文件路径
|
// * @param mkdir_flag 是否创建创建文件夹
|
// * @return 是否成功
|
// */
|
// static bool dir_file_exists(std::string dir, bool mkdir_flag = true) {
|
// 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;
|
// }
|
// }
|
//
|
// /***
|
// * 测试节点是否启动
|
// * @param nodeName 节点名称
|
// * @param cookie 节点cookie
|
// * @return 启动状态
|
// */
|
// static bool 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");
|
// if (erl_connect_xinit("idril", "cnode", "cnode@127.0.0.1", &addr, cookie.c_str(), 0) == -1) {
|
// ERR("");
|
// erl_err_quit("erl_connect_xinit");
|
// return false;
|
// }
|
//
|
// fd = erl_connect(const_cast<char *>(nodeName.c_str()));
|
// if (0 > fd) {
|
//// erl_err_quit("erl_connect");
|
//// std::cout << __FILE__ << __FUNCTION__ <<__LINE__ << " error " << fd << std::endl;
|
// return false;
|
// }
|
//// std::cout << __FILE__ << __FUNCTION__ <<__LINE__ << " " << fd << std::endl;
|
// erl_close_connection(fd);
|
// return true;
|
// }
|
//
|
// /***
|
// * 检查ETERM的数据类型
|
// * @param elemen
|
// * @return 返回数据类型
|
// */
|
// static int 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 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{
|
////
|
//// }
|
// }
|
// }
|
//
|
//
|
// /***
|
// * Erlang交互工具
|
// * #todo map保存到内存？
|
// */
|
// class ErlangDbTool {
|
// public:
|
// ErlangDbTool() : m_fd(-1) {
|
//
|
// }
|
//
|
// /***
|
// * 初始化节点(zhizuo chaxun shiyong)
|
// * @param nodeName 节点名称
|
// * @param cookie 集群cookie
|
// */
|
// 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();
|
// }
|
//
|
// /***
|
// * 初始化节点
|
// * @param path 节点数据库保存路径
|
// * @param nodeName 节点名称
|
// * @param cookie 集群cookie
|
// */
|
// 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();
|
// }
|
//
|
// //clusterID clusterName
|
// /***
|
// * 初始化节点
|
// * @param path 节点数据库保存路径
|
// * @param nodeName 节点名称
|
// * @param cookie 集群cookie
|
// * @param clusterID 集群id
|
// * @param clusterName 集群名称
|
// */
|
// 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) {
|
//
|
// }
|
//
|
// //clusterID clusterName
|
// /***
|
// * 初始化节点
|
// * @param path 节点数据库保存路径
|
// * @param nodeName 节点名称
|
// * @param cookie 集群cookie
|
// * @param clusterID 集群id
|
// * @param clusterName 集群名称
|
// * @param pName c节点标识名
|
// */
|
// 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();
|
// }
|
//
|
// private:
|
//
|
// void initCNode() {
|
// erl_init(NULL, 0);
|
// struct in_addr addr;
|
// //#todo
|
// addr.s_addr = inet_addr("127.0.0.1");
|
// std::string t_cNodeName(m_pName);
|
// t_cNodeName.append("@127.0.0.1");
|
// //m_pName
|
// if (erl_connect_xinit("idril", const_cast<char *>(m_pName.c_str()), const_cast<char *>(t_cNodeName.c_str()),
|
// &addr, const_cast<char *>(m_cookie.c_str()), 0) == -1) {
|
// ERR("erl_connect_xinit error" << m_pName << " " << t_cNodeName << " " << m_cookie);
|
// erl_err_quit("erl_connect_xinit");
|
// } else {
|
// ERR("erl_connect_xinit ok" << m_pName << " " << t_cNodeName << " " << m_cookie);
|
// }
|
// }
|
//
|
// public:
|
//
|
// virtual ~ErlangDbTool() {
|
// erl_close_connection(m_fd);
|
// }
|
//
|
// //#todo setCNodeName
|
//
|
// //#todo sendMessage
|
//
|
// /***
|
// * 启动erlang节点
|
// * @return 启动状态
|
// */
|
// int 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();
|
// return m_ret;
|
// } else {
|
// ERR("create file faile ");
|
// return 0;
|
// }
|
// } else {
|
// INFO("node is running");
|
// return 2;
|
// }
|
// }
|
//
|
// std::string 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);
|
// }
|
//
|
// /***
|
// * 启动节点数据库
|
// * 新节点自动创建数据库
|
// * @param FatherNodeName 第一个节点无需传入此参数，其他节点需要传入引导节点的名称
|
// * @param DeviceName 设备名称
|
// * @param DevAdd 设备地址
|
// * @return
|
// */
|
// bool startNodeDb(std::string FatherNodeName, std::string DeviceId = "", std::string DevAdd = "DevAddress") {
|
// 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_atom(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);
|
//// 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;
|
// }
|
//
|
// /***
|
// * 删除节点数据库，同时删除本地文件
|
// * @return 返回状态
|
// */
|
// bool 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);
|
//// 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") {
|
// //删除本地文件
|
// 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 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_atom(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);
|
//// 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;
|
// }
|
//
|
//
|
// /***
|
// * 查找在线节点信息
|
// * #TODO 有一个小bug
|
// * device_info.create_by会被重置
|
// * @return 节点集合信息
|
// */
|
// map_DevDataCache findAllNode() {
|
// 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_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);
|
//// 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:
|
// printf("error add case todo %d\n\r", checkETERMType(value));
|
// }
|
// 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 {
|
// std::cout << __FILE__ << __FUNCTION__ << __LINE__ << " type error "
|
// << checkETERMType(arr_ret[0])
|
// << " "
|
// << std::endl;
|
// }
|
// erlangFreeEterm(1, list_ret[i]);
|
// }
|
//
|
// erlangFreeEterm(6, emsg.to, emsg.msg, emsg.from, list, tail_list, arr_ret[0]);
|
// erl_eterm_release();
|
// return devDataCache;
|
// } else {
|
// std::cout << __FILE__ << __FUNCTION__ << __LINE__ << " error " << checkETERMType(arr_ret[0])
|
// << " "
|
// << std::endl;
|
// }
|
// }
|
// } //ret == ERL_TICK end
|
// erlangFreeEterm(4, emsg.to, emsg.msg, emsg.from, list);
|
// erl_eterm_release();
|
// return map_DevDataCache();
|
// }
|
//
|
// /***
|
// * 创建底库表
|
// * @param TableType car||person
|
// * @param TableName
|
// * @param SyncType true 1||false 0
|
// * @param BwType "Black"1||"White"0
|
// * @return 创建状态
|
// */
|
// bool 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_atom(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);
|
//// 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;
|
// }
|
//
|
// /***
|
// * 更新底库表
|
// * @param TableType car||person
|
// * @param TableName
|
// * @param SyncType true 1||false 0
|
// * @param BwType "white"0||"black"1
|
// * @return 创建状态
|
// */
|
// bool 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_atom(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);
|
//// 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;
|
// }
|
//
|
// /***
|
// * 删除数据表
|
// * @param TableType car||person
|
// * @param TableName biaoming
|
// * @param SyncType true 1||false 0
|
// * @return
|
// */
|
// bool 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_atom(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);
|
//// 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;
|
// }
|
//
|
// /***
|
// * 查询所有数据表
|
// * @return
|
// */
|
// map_TabDataCache 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);
|
//// 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 {
|
// std::cout << __FILE__ << __FUNCTION__ << __LINE__ << " error " << checkETERMType(arr_ret[0])
|
// << " "
|
// << std::endl;
|
// }
|
// }
|
// }
|
//// erlangFreeEterm(4, emsg.to, emsg.msg, emsg.from, list);
|
// return tabDataCache; //not ok
|
// }
|
//
|
// /***
|
// * 查询所有表的黑白名单类型
|
// * @return
|
// */
|
// map_BwDataCache findAllTypeInfo() {
|
// 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);
|
//// 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 {
|
// std::cout << __FILE__ << __FUNCTION__ << __LINE__ << " error " << checkETERMType(arr_ret[0])
|
// << " "
|
// << std::endl;
|
// }
|
// }
|
// }
|
//// erlangFreeEterm(4, emsg.to, emsg.msg, emsg.from, list);
|
// return map_BwDataCache();
|
// }
|
//
|
// /***
|
// * 增加人员
|
// * @param UUID out
|
// * @param TableName
|
// * @param Feature
|
// * @param PersonName
|
// * @param Age
|
// * @param Sex
|
// * @param IdCard
|
// * @param PhoneNum
|
// * @return
|
// */
|
// bool 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
|
// std::cout << __FILE__ << __FUNCTION__ << __LINE__ << " error " << m_ret << " " << m_fd << " "
|
// << Feature << std::endl;
|
// return false;
|
// }
|
// int ret;
|
// ErlMessage emsg; /* Incoming message */
|
// //hanshu canshu
|
// ETERM *arrlist[9];
|
// arrlist[0] = erl_mk_atom(TableName.c_str());
|
// arrlist[1] = erl_mk_atom(PersonName.c_str());
|
// arrlist[2] = erl_mk_atom(Age.c_str());
|
// arrlist[3] = erl_mk_atom(Sex.c_str());
|
// arrlist[4] = erl_mk_atom(IdCard.c_str());
|
// arrlist[5] = erl_mk_atom(PhoneNum.c_str());
|
// arrlist[6] = erl_mk_atom(ImgUrl.c_str());
|
// arrlist[7] = erl_mk_atom(UUID.c_str());
|
// arrlist[8] = erl_mk_string(Feature.c_str());
|
//
|
// 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);
|
//// m_mutex.unlock();
|
// if (ret == ERL_MSG) {
|
// ETERM *value;
|
// value = erl_element(2, emsg.msg);
|
// switch (checkETERMType(value)) {
|
// case ERL_LIST: {
|
// UUID = std::string(erl_iolist_to_string(value));
|
// break;
|
// }
|
// case ERL_ATOM: {
|
// UUID = std::string(ERL_ATOM_PTR(value));
|
// break;
|
// }
|
// default:
|
// printf("error add case todo \n\r");
|
// }
|
// erl_free_term(value);
|
// if (UUID.size() > 0) {
|
// 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();
|
// return false;
|
// }
|
//
|
// /***
|
// * 删除人员
|
// * @param UUID
|
// * @param TableName
|
// * @return
|
// */
|
// bool delPerson(std::string UUID, std::string TableName) {
|
// 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;
|
// 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());
|
//
|
// 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);
|
//// 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;
|
// }
|
//
|
//
|
// /***
|
// * 根据表名加载人脸特征
|
// * @param TableName
|
// * @return
|
// */
|
// map_FaceDataCache 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_atom(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);
|
//// 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 {
|
// std::cout << __FILE__ << __FUNCTION__ << __LINE__ << " type error "
|
// << checkETERMType(list_ret[i])
|
// << " "
|
// << std::endl;
|
// }
|
// }
|
// erlangFreeEterm(5, emsg.msg, emsg.from, emsg.to, list, arrlist[0]);
|
// erl_eterm_release();
|
//// sleep()
|
// return dataCache;
|
// } else {
|
// std::cout << __FILE__ << __FUNCTION__ << __LINE__ << " error " << checkETERMType(arr_ret[0])
|
// << " "
|
// << std::endl;
|
// }
|
// } else {
|
// std::cout << __FILE__ << __FUNCTION__ << __LINE__ << " error " << ret << " " << std::endl;
|
// }
|
//
|
// }
|
// erlangFreeEterm(5, emsg.msg, emsg.from, emsg.to, list, arrlist[0]);
|
// erl_eterm_release();
|
// return map_FaceDataCache();
|
// };
|
//
|
//
|
// /***
|
// * 根据表名加载人脸特征2
|
// * @param TableName
|
// * @return
|
// */
|
// map_FaceDataCache loadFaceFeaData2(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_atom(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);
|
//// 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 {
|
// std::cout << __FILE__ << __FUNCTION__ << __LINE__ << " type error "
|
// << checkETERMType(list_ret[i])
|
// << " "
|
// << std::endl;
|
// }
|
// }
|
// erlangFreeEterm(5, emsg.msg, emsg.from, emsg.to, list, arrlist[0]);
|
// erl_eterm_release();
|
//// sleep()
|
// return dataCache;
|
// } else {
|
// std::cout << __FILE__ << __FUNCTION__ << __LINE__ << " error " << checkETERMType(arr_ret[0])
|
// << " "
|
// << std::endl;
|
// }
|
// } else {
|
// std::cout << __FILE__ << __FUNCTION__ << __LINE__ << " error " << ret << " " << std::endl;
|
// }
|
//
|
// }
|
// erlangFreeEterm(5, emsg.msg, emsg.from, emsg.to, list, arrlist[0]);
|
// erl_eterm_release();
|
// return map_FaceDataCache();
|
// };
|
//
|
//// private:
|
// /***
|
// * 重新连接节点
|
// * @return 连接状态
|
// */
|
// bool 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("node name is " << m_loop);
|
// return false;
|
// }
|
//// std::cout << __FILE__ << __FUNCTION__ <<__LINE__ << " " << fd << std::endl;
|
// return true;
|
// }
|
// }
|
//
|
// /***
|
// * 等待节点启动，阻塞
|
// * @return
|
// */
|
// bool 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(1000);
|
// loop++;
|
// }
|
// }
|
// std::cout << "start waitNode" << std::endl;
|
// return m_ret;
|
// }
|
//
|
// public:
|
//
|
// private:
|
// //存储路径
|
// std::string m_path;
|
// std::string m_nodeName;
|
// std::string m_pName;
|
// std::string m_cookie;
|
//
|
// std::string m_clusterID;
|
// std::string m_clusterName;
|
//
|
// bool m_ret;
|
// int m_fd;
|
//
|
// std::mutex m_mutex;
|
// };
|
//
|
//}
|
//
|
//#endif //UNTITLED_ERLANGTOOL_HPP
|
