3437 lines
107 KiB
C++
3437 lines
107 KiB
C++
/**
|
||
* @file: $RCSfile: save2json.cpp,v $
|
||
* @brief: $IEC 61850 Protocol
|
||
*
|
||
* @version: $Revision: 1.21 $
|
||
* @date: $Date: 2020/10/27 08:51:07 $
|
||
* @author: $Author: lizhongming $
|
||
* @state: $State: Exp $
|
||
*
|
||
* @latest: $Id: save2json.cpp,v 1.21 2020/10/27 08:51:07 lizhongming Exp $
|
||
*
|
||
*/
|
||
|
||
using namespace std;
|
||
#include <iostream>
|
||
#include <stdio.h>
|
||
#include <assert.h>
|
||
#include <fstream> // std::filebuf
|
||
#include <string.h>
|
||
|
||
#include <sstream>
|
||
|
||
#include "qdebug.h"
|
||
#include <QSettings>
|
||
#include <QDateTime>
|
||
#include <QDir>
|
||
#include <QMap>//CZY 2023-08-17 WW 2023年3月13日17:21:02 增加多ICD支持
|
||
#include <apr_uuid.h>
|
||
#include <apr_strings.h>
|
||
|
||
#include "../log4cplus/log4.h"//lnk添加log4
|
||
|
||
#include "../mms/db_interface.h"
|
||
#include "../json/save2json.h"
|
||
#include "../json/mms_json_inter.h"
|
||
#include "kafka_producer.h"
|
||
//#include "../rocketmq/CPushConsumer.h"
|
||
#include "../rocketmq/DefaultMQPushConsumer.h"
|
||
#include <vector>
|
||
#include "../json/cjson.h" //解json
|
||
#include <sstream> //创建xml
|
||
#include <fstream> //创建xml
|
||
bool createXmlFile(int devindex, int mpindex, bool realData, bool soeData, int limit,std::string type);
|
||
extern int recall_json_handle(const char* jstr);
|
||
extern std::string intToString(int number);
|
||
int StringToInt(const std::string& str);
|
||
extern pthread_mutex_t mtx;//lnk20250115
|
||
|
||
extern bool should_process_after_start(const rocketmq::MQMessageExt& msg);
|
||
extern int64_t G_APP_START_MS;
|
||
|
||
extern int RECALL_ONLY_FLAG; //lnk20260309添加一个全局变量，标志是否只运行补招程序
|
||
|
||
extern void SendFileWeb(const std::string& strUrl,
|
||
const char* localpath,
|
||
const char* cloudpath,
|
||
char* wavepath);
|
||
|
||
extern int DownloadFileWeb(const std::string& strUrl,
|
||
const char* remotePath,
|
||
const char* localpath);
|
||
|
||
|
||
|
||
#ifdef __cplusplus
|
||
extern "C" {
|
||
|
||
//解决编译lnk20250509
|
||
#define thisFileName __FILE__
|
||
|
||
#include "../mms/rdb_client.h"
|
||
#include "node.h"//lnk20241223
|
||
#include "mvl_defs.h"
|
||
#include "mms_vvar.h"
|
||
#endif /* __cplusplus */
|
||
extern unsigned int g_node_id;
|
||
extern int g_front_seg_index;
|
||
extern char subdir[128];
|
||
extern int comtrade_remain_file_num;
|
||
extern node_t* g_node; //lnk20241223
|
||
extern LD_info_t* find_LD_info_only_from_mp_id(char* mp_id);//lnk20241223
|
||
extern void print_terminal(const terminal* tmnl);
|
||
|
||
extern ST_RET mms_mvla_obtfile(MVL_NET_INFO *net_info,
|
||
ST_CHAR *srcfilename,
|
||
ST_CHAR *destfilename,
|
||
int iTimeout);
|
||
|
||
extern pt61850app_t *g_pt61850app;
|
||
#ifdef __cplusplus
|
||
}
|
||
#endif
|
||
#ifndef nullptr
|
||
#define nullptr NULL
|
||
#endif
|
||
|
||
extern uint32_t g_mqproducer_blocked_times;
|
||
|
||
extern int INITFLAG;
|
||
|
||
extern std::string FRONT_INST;
|
||
|
||
extern QMutex kafka_data_list_mutex;
|
||
extern QList<Ckafka_data_t> kafka_data_list;
|
||
|
||
extern QMutex oss_data_list_mutex;
|
||
extern QList<oss_data_t> oss_data_list;
|
||
extern int FILE_FLAG;
|
||
KafkaSendThread myThrd;
|
||
//WW 2023-08-22 增加数据库线程和WebSokcet线程
|
||
WebSocketThread socketThrd; //Web Socket线程类对象
|
||
|
||
WebhttpThread webhttpThrd; //Web http线程类对象 lnk202411
|
||
httpThread httpThrd; //Web http线程类对象 lnk202411
|
||
mqconsumerThread mqconsumerThrd;//mq消费者线程lnk20241213
|
||
|
||
OnTimerThread onTimerThrd;//定时线程
|
||
|
||
extern int FILE_FLAG;
|
||
extern int SEND_FLAG;
|
||
extern char* BROKER_LIST;
|
||
extern char* TOPIC_STAT;
|
||
extern char* TOPIC_PST;
|
||
extern char* TOPIC_PLT;
|
||
extern char* TOPIC_EVENT;
|
||
extern char* TOPIC_ALARM;
|
||
extern char* TOPIC_SNG;
|
||
extern char* TOPIC_RTDATA;//lnk20241220
|
||
extern char* UDS_UPLOAD_URL;
|
||
extern char g_onlyIP[255]; //直连某个IP，仅仅为方便测试
|
||
//WW 2023-08-22 end
|
||
|
||
//lnk20241216添加mq消费者
|
||
extern std::string G_MQCONSUMER_IPPORT;//rocketmq ip+port
|
||
extern std::string G_MQCONSUMER_TOPIC_RT;//topie_realtimedata
|
||
extern std::string G_MQCONSUMER_TAG_RT;//tag
|
||
extern std::string G_MQCONSUMER_KEY_RT;//key
|
||
extern std::string G_MQCONSUMER_TOPIC_UD;//topie_update
|
||
extern std::string G_MQCONSUMER_TAG_UD;//tag
|
||
extern std::string G_MQCONSUMER_KEY_UD;//key
|
||
extern std::string G_MQCONSUMER_TOPIC_RC;//topie_recall
|
||
extern std::string G_MQCONSUMER_TAG_RC;//tag
|
||
extern std::string G_MQCONSUMER_KEY_RC;//key
|
||
extern std::string G_MQCONSUMER_TOPIC_SET;//topie_recall
|
||
extern std::string G_MQCONSUMER_TAG_SET;//tag
|
||
extern std::string G_MQCONSUMER_KEY_SET;//key
|
||
extern std::string G_MQCONSUMER_TOPIC_LOG;//topie_log
|
||
extern std::string G_MQCONSUMER_TAG_LOG;//tag
|
||
extern std::string G_MQCONSUMER_KEY_LOG;//key
|
||
extern std::string G_LOG_TOPIC;//topie
|
||
extern std::string G_LOG_TAG;//tag
|
||
extern std::string G_LOG_KEY;//key
|
||
extern std::string G_MQCONSUMER_TOPIC_FILE;//topie_file
|
||
extern std::string G_MQCONSUMER_TAG_FILE;//tag
|
||
extern std::string G_MQCONSUMER_KEY_FILE;//key
|
||
extern std::string Topic_Reply_Topic;
|
||
extern std::string Topic_Reply_Tag;
|
||
extern std::string Topic_Reply_Key;
|
||
|
||
extern std::string WEB_FILEUPLOAD;
|
||
extern std::string WEB_FILEDOWNLOAD;
|
||
|
||
extern std::string G_ROCKETMQ_CONSUMER;
|
||
|
||
bool showinshellflag =false;
|
||
|
||
|
||
#define APRTIME_8H (28800000000ULL)
|
||
#define APRTIME_1H (3600000000ULL)
|
||
///////////////////////////////////////////////////////////////////////////////
|
||
|
||
const int MAX_LIST_SIZE = 16;
|
||
//static QMap<int, QList<long long> > real_data_report_map;
|
||
static QMap<int, QMap<int, QList<long long>>> real_data_report_map; //多个监测点的多个实时报告的时间列表lnk20250624
|
||
static QMap<QString, json_block_data*> json_data_map;//CZY 2023-08-17 ww 2023年3月13日17:23:17扩展Map，用于保存各条线路的数据
|
||
static QMap<QString, json_block_data*> json_flicker_data_map;//CZY 2023-09-11 展Map，用于保存各条线路的闪变数据
|
||
static QMap<QString, json_block_data*> json_pst_data_map;//CZY 2023-09-11 展Map，用于保存各条线路的闪变数据
|
||
|
||
//////////////////////////////////////////////////////////////////////////////lnk20260310文件控制
|
||
pthread_mutex_t g_file_req_mutex = PTHREAD_MUTEX_INITIALIZER;
|
||
std::list<file_dir_req_t*> g_file_dir_req_list;
|
||
|
||
bool is_blank(const std::string& str)
|
||
{
|
||
for (std::string::const_iterator it = str.begin(); it != str.end(); ++it)
|
||
{
|
||
if (!std::isspace(*it)) {
|
||
return false;
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
|
||
///////////////////////////////////////////////////////////////////////////////////
|
||
|
||
int urcbRealDataHasReceived(int dev_index, int rptNo, LD_info_t* LD_info, long long Time) //增加报告入参lnk20250624
|
||
{
|
||
QList<long long>& ts_list = real_data_report_map[LD_info->line_id][rptNo];
|
||
bool bFind = ts_list.contains(Time); //实时数据时间链表
|
||
if (bFind == false) {
|
||
ts_list.append(Time);
|
||
if (ts_list.size() > MAX_LIST_SIZE)
|
||
ts_list.removeFirst();
|
||
|
||
//lnk20241223每收到一次实时数据就检查一下数量
|
||
int real_report_count = 0;
|
||
//real_report_count = get_real_report_count(LD_info);
|
||
real_report_count = LD_info->rptinfo[rptNo]->count;//lnk20250624
|
||
|
||
//调试
|
||
std::cout << "real_report_count is" << real_report_count << std::endl;
|
||
std::cout << "mp limit is" << LD_info->limit << std::endl;
|
||
|
||
if(real_report_count >= LD_info->limit){
|
||
std::cout << "real_report_count reach limit!!!"<< std::endl;
|
||
//生成delete.xml
|
||
if (!createXmlFile(dev_index, LD_info->line_id, 0, 0, 0,"delete")) {
|
||
std::cerr << "Failed to create delete XML file!!!." << std::endl;
|
||
}
|
||
}
|
||
|
||
return 0; //没有重复数据
|
||
}
|
||
else
|
||
return 1; //有重复数据
|
||
}
|
||
|
||
//////////////////////////////////////////////////////////////////////////
|
||
|
||
void add_comm_log(char* log_str)
|
||
{
|
||
QDateTime now = QDateTime::currentDateTime();
|
||
QString level_str = QString("[info]");
|
||
QString head_str = QString("");
|
||
QString tail_str = QString("");
|
||
#ifdef __GNUC__
|
||
QString com_log_fn("/usr/local/saslog/");
|
||
#else
|
||
QString com_log_fn("../etc/log/");
|
||
#endif
|
||
|
||
if (g_node_id == STAT_DATA_BASE_NODE_ID)
|
||
com_log_fn += "comm_100_stat.txt";
|
||
else if (g_node_id == THREE_SECS_DATA_BASE_NODE_ID)
|
||
com_log_fn += "comm_200_3s.txt";
|
||
else if (g_node_id == SOE_COMTRADE_BASE_NODE_ID)
|
||
com_log_fn += "comm_300_comtrade.txt";
|
||
else if (g_node_id == HIS_DATA_BASE_NODE_ID)
|
||
com_log_fn += "comm_400_his.txt";
|
||
else if (g_node_id == NEW_HIS_DATA_BASE_NODE_ID) {
|
||
com_log_fn.append(QString("comm_400_his_%1.txt").arg(g_front_seg_index));
|
||
}
|
||
else if(g_node_id == RECALL_HIS_DATA_BASE_NODE_ID)
|
||
com_log_fn += "comm_600_recall.txt";
|
||
else if (g_node_id == RECALL_ALL_DATA_BASE_NODE_ID) {
|
||
com_log_fn.append(QString("comm_700_allrecall_%1.txt").arg(g_front_seg_index));
|
||
}
|
||
else
|
||
com_log_fn += "comm_x00_unknown.txt";
|
||
|
||
QFile file(com_log_fn);
|
||
if (!file.open(QIODevice::WriteOnly | QIODevice::Text | QIODevice::Append))
|
||
return;
|
||
QTextStream out(&file);
|
||
out << (now.toString("yyyy-MM-dd hh:mm:ss") + " " + level_str + " " + QString::fromAscii(log_str)) << endl;
|
||
}
|
||
|
||
void add_sng_log(char* log_str)
|
||
{
|
||
QDateTime now = QDateTime::currentDateTime();
|
||
QString level_str = QString("[info]");
|
||
QString head_str = QString("");
|
||
QString tail_str = QString("");
|
||
#ifdef __GNUC__
|
||
QString com_log_fn("/usr/local/saslog/");
|
||
#else
|
||
QString com_log_fn("../etc/log/");
|
||
#endif
|
||
|
||
com_log_fn += "sng_kafka_json.txt";
|
||
|
||
QFile file(com_log_fn);
|
||
if (!file.open(QIODevice::WriteOnly | QIODevice::Text | QIODevice::Append))
|
||
return;
|
||
QTextStream out(&file);
|
||
out << (now.toString("yyyy-MM-dd hh:mm:ss") + " " + level_str + " " + QString::fromAscii(log_str)) << endl;
|
||
}
|
||
|
||
void add_stat_kafka_json_log(char* log_str)
|
||
{
|
||
QDateTime now = QDateTime::currentDateTime();
|
||
QString level_str = QString("[info]");
|
||
QString head_str = QString("");
|
||
QString tail_str = QString("");
|
||
#ifdef __GNUC__
|
||
QString com_log_fn("/usr/local/saslog/");
|
||
#else
|
||
QString com_log_fn("../etc/log/");
|
||
#endif
|
||
|
||
com_log_fn += "stat_kafka_json.txt";
|
||
|
||
QFile file(com_log_fn);
|
||
if (!file.open(QIODevice::WriteOnly | QIODevice::Text | QIODevice::Append))
|
||
return;
|
||
QTextStream out(&file);
|
||
out << (now.toString("yyyy-MM-dd hh:mm:ss") + " " + level_str + " " + QString::fromAscii(log_str)) << endl;
|
||
}
|
||
|
||
//////////////////////////////////////////////////////////////////////////
|
||
/*新增rocketmq发送数据lnk10-10*/
|
||
void my_rocketmq_send(Ckafka_data_t& data)
|
||
{
|
||
static std::string topic;
|
||
static std::string cfg_His_tp;
|
||
static std::string cfg_PLT_tp;
|
||
static std::string cfg_PST_tp;
|
||
static std::string cfg_Evt_tp;
|
||
static std::string cfg_Alm_tp;
|
||
static std::string cfg_Rt_tp;
|
||
static bool init = false;
|
||
if (!init) {
|
||
|
||
cfg_His_tp = TOPIC_STAT;
|
||
cfg_PLT_tp = TOPIC_PLT;
|
||
cfg_PST_tp = TOPIC_PST;
|
||
cfg_Evt_tp = TOPIC_EVENT;
|
||
cfg_Alm_tp = TOPIC_ALARM;
|
||
cfg_Rt_tp = TOPIC_RTDATA;
|
||
|
||
init = true;
|
||
}
|
||
|
||
std::string key = data.mp_id.toStdString();
|
||
std::string senddata = data.strText.toStdString();
|
||
if (data.strTopic == "HISDATA")
|
||
{
|
||
topic = cfg_His_tp;
|
||
}
|
||
else if (data.strTopic == "PLT")
|
||
{
|
||
topic = cfg_PLT_tp;
|
||
}
|
||
else if (data.strTopic == "PST")
|
||
{
|
||
topic = cfg_PST_tp;
|
||
}
|
||
else if (data.strTopic == "Event")
|
||
{
|
||
topic = cfg_Evt_tp;
|
||
}
|
||
else if (data.strTopic == "Alm")
|
||
{
|
||
topic = cfg_Alm_tp;
|
||
}
|
||
else if (data.strTopic == "RTDATA")//lnk20241220
|
||
{
|
||
topic = cfg_Rt_tp;
|
||
}
|
||
else
|
||
{
|
||
topic = data.strTopic.toStdString();
|
||
|
||
}
|
||
if (g_onlyIP[0] != 0)
|
||
{
|
||
//单例模式
|
||
add_sng_log(data.strText.toAscii().data());
|
||
|
||
}
|
||
//rocketmq_producer_send(const_cast<char*>(senddata.c_str()),const_cast<char*>(topic.c_str()));
|
||
rocketmq_producer_send(senddata, topic,FRONT_INST,key);//lnk20250623修复偶发性doublefree
|
||
}
|
||
|
||
#if 0
|
||
void my_kafka_send(Ckafka_data_t& data)
|
||
{
|
||
#ifdef __GNUC__
|
||
static FeKafkaProducer kafkaProducer;
|
||
#endif
|
||
|
||
int retsize = -1;
|
||
static std::string topic;
|
||
static std::string cfg_His_tp;
|
||
static std::string cfg_PLT_tp;
|
||
static std::string cfg_PST_tp;
|
||
static std::string cfg_Evt_tp;
|
||
static std::string cfg_Alm_tp;
|
||
static std::string cfg_Sng_tp;
|
||
static bool init = false;
|
||
if (!init) {
|
||
|
||
cfg_His_tp = TOPIC_STAT;
|
||
cfg_PLT_tp = TOPIC_PLT;
|
||
cfg_PST_tp = TOPIC_PST;
|
||
cfg_Evt_tp = TOPIC_EVENT;
|
||
cfg_Alm_tp = TOPIC_ALARM;
|
||
cfg_Sng_tp = TOPIC_SNG;
|
||
|
||
cout << cfg_His_tp << endl;
|
||
|
||
std::string brokerlist = BROKER_LIST;
|
||
|
||
|
||
#ifdef __GNUC__
|
||
if (kafkaProducer.init(brokerlist)) {
|
||
printf("kafka producer init success(%s)\n", brokerlist.c_str());
|
||
/*bool ret = kafkaProducer.create_topic(topic);
|
||
if(ret)
|
||
printf("create topic OK \n");
|
||
else
|
||
printf("create topic Failed \n");*/
|
||
}
|
||
else
|
||
printf("kafka producer init Failed(%s)\n", brokerlist.c_str());
|
||
#endif
|
||
init = true;
|
||
}
|
||
|
||
char tmp_str[256];
|
||
apr_snprintf(tmp_str, sizeof(tmp_str), "%d", data.monitor_id);
|
||
std::string key = std::string(tmp_str);
|
||
|
||
std::string senddata = data.strText.toStdString();
|
||
if (data.strTopic == "HISDATA")
|
||
{
|
||
topic = cfg_His_tp;
|
||
}
|
||
else if (data.strTopic == "PLT")
|
||
{
|
||
topic = cfg_PLT_tp;
|
||
}
|
||
else if (data.strTopic == "PST")
|
||
{
|
||
topic = cfg_PST_tp;
|
||
}
|
||
else if (data.strTopic == "Event")
|
||
{
|
||
topic = cfg_Evt_tp;
|
||
add_stat_kafka_json_log(data.strText.toAscii().data());
|
||
}
|
||
else if (data.strTopic == "Alm")
|
||
{
|
||
topic = cfg_Alm_tp;
|
||
}
|
||
else
|
||
{
|
||
topic = data.strTopic.toStdString();
|
||
}
|
||
|
||
if (g_onlyIP[0] != 0)
|
||
{
|
||
add_sng_log(data.strText.toAscii().data());
|
||
}
|
||
#ifdef __GNUC__
|
||
retsize = kafkaProducer.send(senddata.c_str(), senddata.length(), topic, RdKafka::Topic::PARTITION_UA, &key);
|
||
#endif
|
||
|
||
if (retsize > 0) {
|
||
printf("\nkafka send, monitor_id:[%s] topic:[%s] Success,return length %d\n", key.c_str(), topic.c_str(), retsize);
|
||
}
|
||
else
|
||
printf("\nFailed kafka send, monitor_id:[%s] topic:[%s]\n", key.c_str(), topic.c_str());
|
||
|
||
}
|
||
#endif
|
||
|
||
void my_datahub_send(Ckafka_data_t& data)
|
||
{
|
||
static std::string topic;
|
||
static std::string cfg_His_tp;
|
||
static std::string cfg_PLT_tp;
|
||
static std::string cfg_PST_tp;
|
||
static std::string cfg_Evt_tp;
|
||
static std::string cfg_Alm_tp;
|
||
static bool init = false;
|
||
if (!init) {
|
||
|
||
cfg_His_tp = TOPIC_STAT;
|
||
cfg_PLT_tp = TOPIC_PLT;
|
||
cfg_PST_tp = TOPIC_PST;
|
||
cfg_Evt_tp = TOPIC_EVENT;
|
||
cfg_Alm_tp = TOPIC_ALARM;
|
||
|
||
init = true;
|
||
}
|
||
|
||
std::string key = data.mp_id.toStdString();
|
||
std::string senddata = data.strText.toStdString();
|
||
if (data.strTopic == "HISDATA")
|
||
{
|
||
topic = cfg_His_tp;
|
||
}
|
||
else if (data.strTopic == "PLT")
|
||
{
|
||
topic = cfg_PLT_tp;
|
||
}
|
||
else if (data.strTopic == "PST")
|
||
{
|
||
topic = cfg_PST_tp;
|
||
}
|
||
else if (data.strTopic == "Event")
|
||
{
|
||
topic = cfg_Evt_tp;
|
||
}
|
||
else if (data.strTopic == "Alm")
|
||
{
|
||
topic = cfg_Alm_tp;
|
||
}
|
||
else
|
||
{
|
||
topic = data.strTopic.toStdString();
|
||
}
|
||
if (g_onlyIP[0] != 0)
|
||
{
|
||
//单例模式
|
||
add_sng_log(data.strText.toAscii().data());
|
||
|
||
}
|
||
//DataHub_Send_Datahub(const_cast<char*>(topic.c_str()), const_cast<char*>(senddata.c_str()));
|
||
printf("\ndatahub send, monitor_id:[%s] topic:[%s] Success\n", key.c_str(), topic.c_str());
|
||
}
|
||
|
||
void concatenate_and_separate(char str1[], char str2[], QString* result) {
|
||
QString qstr1 = QString(str1);
|
||
QString qstr2 = QString(str2);
|
||
*result = qstr1 + "-" + qstr2;
|
||
}
|
||
|
||
void KafkaSendThread::run()
|
||
{
|
||
//线程开始创建生产者lnk20241211
|
||
InitializeProducer();
|
||
|
||
printf("\nKafkaSendThread::run() is called ...... \n\n");
|
||
while (1) {
|
||
Ckafka_data_t data;
|
||
bool data_gotten;
|
||
|
||
data_gotten = false;
|
||
kafka_data_list_mutex.lock();
|
||
if (!kafka_data_list.isEmpty()) {
|
||
data_gotten = true;
|
||
data = kafka_data_list.takeFirst();
|
||
}
|
||
kafka_data_list_mutex.unlock();
|
||
|
||
if (data_gotten) {
|
||
static uint32_t count = 0;
|
||
printf("BEGIN my_kafka_send no.%i -------->>>>>>>>>>>> %s \n", count,
|
||
QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss.zzz").toAscii().data());
|
||
if (SEND_FLAG == 1) //kafka推送
|
||
{
|
||
//my_kafka_send(data);
|
||
}
|
||
else if (SEND_FLAG == 2)//datahub推送
|
||
{
|
||
//my_datahub_send(data);
|
||
}
|
||
else if (SEND_FLAG == 3)//rocketmq推送lnk10-11
|
||
{
|
||
my_rocketmq_send(data);
|
||
}
|
||
else //未配置 默认mq推送
|
||
{
|
||
my_rocketmq_send(data);
|
||
}
|
||
|
||
printf("END my_kafka_send no.%i -------->>>>>>>>>>>> %s \n\n", count++,
|
||
QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss.zzz").toAscii().data());
|
||
}
|
||
|
||
//清空计数器
|
||
g_mqproducer_blocked_times =0;
|
||
|
||
QThread::msleep(10); // 避免 CPU 空转lnk20250326
|
||
|
||
}
|
||
|
||
|
||
//线程结束摧毁生产者
|
||
ShutdownAndDestroyProducer();//lnk20241211
|
||
}
|
||
|
||
//lnk20241213补招部分///////////////////////////////////////////////////////////////////////////////////////////////
|
||
// 提取 'data' 数组并返回为新的 JSON 字符串 (返回 std::string)
|
||
std::string extractDataJson(const char* inputJson) {
|
||
// 解析输入 JSON 字符串
|
||
cJSON* root = cJSON_Parse(inputJson);
|
||
if (root == NULL) {
|
||
std::cerr << "Error parsing JSON" << std::endl;
|
||
return "";
|
||
}
|
||
|
||
// 提取 "messageBody" 部分
|
||
cJSON* messageJson = cJSON_GetObjectItem(root, "messageBody");
|
||
if (messageJson == NULL || messageJson->type != cJSON_String) {
|
||
std::cerr << "'messageJson' is missing or is not an cJSON_String" << std::endl;
|
||
cJSON_Delete(root);
|
||
return "";
|
||
}
|
||
|
||
// 解析 messageBody 中的 JSON 字符串
|
||
const char* messageBodyStr = messageJson->valuestring;
|
||
if (messageBodyStr == nullptr || strlen(messageBodyStr) == 0) {
|
||
std::cerr << "Failed to parse 'messageBody' JSON or it's empty." << std::endl;
|
||
cJSON_Delete(root);
|
||
return "";
|
||
}
|
||
|
||
cJSON* messageBody = cJSON_Parse(messageBodyStr); // 解析 messageBody 字符串
|
||
if (messageBody == NULL) {
|
||
std::cerr << "Failed to parse 'messageBody' JSON." << std::endl;
|
||
cJSON_Delete(root);
|
||
return "";
|
||
}
|
||
|
||
//添加guid
|
||
// 提取 "guid" 部分
|
||
cJSON* guidstr = cJSON_GetObjectItem(messageBody, "guid");
|
||
if (guidstr == NULL || guidstr->type != cJSON_String) {
|
||
std::cerr << "'guid' is missing or is not an string" << std::endl;
|
||
cJSON_Delete(messageBody);
|
||
cJSON_Delete(root);
|
||
return "";
|
||
}
|
||
//guid回复
|
||
std::string guid = guidstr->valuestring;
|
||
send_reply_to_kafka(guid,"1","收到补招指令");
|
||
|
||
// 提取 "data" 部分
|
||
cJSON* data = cJSON_GetObjectItem(messageBody, "data");
|
||
if (data == NULL || data->type != cJSON_Array) {
|
||
std::cerr << "'data' is missing or is not an array" << std::endl;
|
||
cJSON_Delete(messageBody);
|
||
cJSON_Delete(root);
|
||
return "";
|
||
}
|
||
|
||
// 创建新的 JSON 数组对象，只包含 "data" 部分
|
||
cJSON* newJson = cJSON_CreateArray(); // 创建一个新的数组
|
||
if (newJson == NULL) {
|
||
std::cerr << "Failed to create new JSON array" << std::endl;
|
||
cJSON_Delete(messageBody);
|
||
cJSON_Delete(root);
|
||
return "";
|
||
}
|
||
|
||
// 将 "data" 数组中的元素逐个添加到新数组中
|
||
cJSON* dataItem = NULL;
|
||
cJSON_ArrayForEach(dataItem, data) {
|
||
cJSON_AddItemToArray(newJson, cJSON_Duplicate(dataItem, 1));
|
||
}
|
||
|
||
// 将新的 JSON 数组转换为字符串
|
||
char* newJsonString = cJSON_Print(newJson);
|
||
if (newJsonString == NULL) {
|
||
std::cerr << "Error printing new JSON" << std::endl;
|
||
cJSON_Delete(messageBody);
|
||
cJSON_Delete(root);
|
||
cJSON_Delete(newJson);
|
||
return "";
|
||
}
|
||
|
||
// 转换为 std::string 类型
|
||
std::string result(newJsonString);
|
||
|
||
// 清理内存
|
||
free(newJsonString);
|
||
cJSON_Delete(messageBody);
|
||
cJSON_Delete(root);
|
||
cJSON_Delete(newJson);
|
||
|
||
return result; // 返回 std::string 类型的结果
|
||
}
|
||
//实时数据部分//////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||
// 提取 JSON 消息中的相关字段
|
||
bool parseJsonMessageRT(const std::string& body, std::string& devSeries, std::string& line, bool& realData, bool& soeData, int& limit)
|
||
{
|
||
// 解析 JSON 数据
|
||
cJSON* root = cJSON_Parse(body.c_str());
|
||
if (root == NULL) {
|
||
std::cerr << "Failed to parse JSON message." << std::endl;
|
||
return false;
|
||
}
|
||
|
||
// 提取 "messageBody" 部分
|
||
cJSON* messageJson = cJSON_GetObjectItem(root, "messageBody");
|
||
if (messageJson == NULL || messageJson->type != cJSON_String) {
|
||
std::cerr << "'messageJson' is missing or is not an cJSON_String" << std::endl;
|
||
cJSON_Delete(root);
|
||
return false;
|
||
}
|
||
|
||
// 解析 messageBody 中的 JSON 字符串
|
||
const char* messageBodyStr = messageJson->valuestring;
|
||
if (messageBodyStr == nullptr || strlen(messageBodyStr) == 0) {
|
||
std::cerr << "Failed to parse 'messageBody' JSON or it's empty." << std::endl;
|
||
cJSON_Delete(root);
|
||
return false;
|
||
}
|
||
|
||
cJSON* messageBody = cJSON_Parse(messageBodyStr); // 解析 messageBody 字符串
|
||
if (messageBody == NULL) {
|
||
std::cerr << "Failed to parse 'messageBody' JSON." << std::endl;
|
||
cJSON_Delete(root);
|
||
return false;
|
||
}
|
||
|
||
// 提取字段
|
||
cJSON* devSeriesItem = cJSON_GetObjectItem(messageBody, "devSeries");
|
||
cJSON* lineItem = cJSON_GetObjectItem(messageBody, "line");
|
||
cJSON* realDataItem = cJSON_GetObjectItem(messageBody, "realData");
|
||
cJSON* soeDataItem = cJSON_GetObjectItem(messageBody, "soeData");
|
||
cJSON* limitItem = cJSON_GetObjectItem(messageBody, "limit");
|
||
|
||
//添加guid
|
||
std::string guid;
|
||
cJSON* guidstr = cJSON_GetObjectItem(messageBody, "guid");
|
||
if(guidstr)guid = guidstr->valuestring;
|
||
|
||
if (devSeriesItem && lineItem && realDataItem && soeDataItem && limitItem) {
|
||
devSeries = devSeriesItem->valuestring;
|
||
line = lineItem->valuestring;
|
||
realData = realDataItem->valueint;
|
||
soeData = soeDataItem->valueint;
|
||
limit = limitItem->valueint;
|
||
|
||
//回复消息
|
||
//执行结果直接看实时数据，不需要再回复，1是收到消息
|
||
send_reply_to_kafka("11111","1","收到三秒数据指令");//实时数据没有下发guid
|
||
|
||
} else {
|
||
std::cerr << "Missing expected fields in JSON message." << std::endl;
|
||
cJSON_Delete(messageBody);
|
||
cJSON_Delete(root);
|
||
return false;
|
||
}
|
||
|
||
cJSON_Delete(messageBody);
|
||
cJSON_Delete(root); // 清理 JSON 对象
|
||
return true;
|
||
}
|
||
|
||
// 构造 XML 内容的函数新建和删除
|
||
std::string createnewXmlContent(int devindex, int mpindex, bool realData, bool soeData, int limit)
|
||
{
|
||
std::ostringstream xmlContent;
|
||
xmlContent << "<?xml version=\"1.0\" encoding=\"gb2312\"?>\n"
|
||
<< "<Trigger3S>\n"
|
||
<< " <New>\n"
|
||
<< " <Trigger Line=\"" << mpindex << "\" "
|
||
<< "RealData=\"" << (realData ? "true" : "false") << "\" "
|
||
<< "DevSeries=\"" << devindex << "\" "
|
||
<< "Limit=\"" << limit << "\" "
|
||
<< "Count=\"0\" "
|
||
<< "SOEData=\"" << (soeData ? "true" : "false") << "\"/>\n"
|
||
<< " </New>\n"
|
||
<< "</Trigger3S>\n";
|
||
return xmlContent.str();
|
||
}
|
||
|
||
std::string createdeleteXmlContent(int devindex, int mpindex)
|
||
{
|
||
std::ostringstream xmlContent;
|
||
xmlContent << "<?xml version=\"1.0\" encoding=\"gb2312\"?>\n"
|
||
<< "<Trigger3S>\n"
|
||
<< " <Delete>\n"
|
||
<< " <Trigger Line=\"" << mpindex << "\" "
|
||
<< "RealData=\"false\" "
|
||
<< "DevSeries=\"" << devindex << "\" "
|
||
<< "Limit=\"0\" "
|
||
<< "Count=\"0\" "
|
||
<< "SOEData=\"false\"/>\n"
|
||
<< " </Delete>\n"
|
||
<< "</Trigger3S>\n";
|
||
return xmlContent.str();
|
||
}
|
||
|
||
// 写入 XML 内容到文件的函数
|
||
bool writeToFile(const std::string& filePath, const std::string& xmlContent)
|
||
{
|
||
// 打开文件流以写入 XML 内容
|
||
std::ofstream outFile(filePath.c_str()); // 使用 c_str() 转换为 const char*
|
||
if (outFile.is_open()) {
|
||
outFile << xmlContent; // 写入内容
|
||
outFile.close();
|
||
std::cout << "XML file created at: " << filePath << std::endl;
|
||
return true;
|
||
} else {
|
||
std::cerr << "Failed to open file for writing: " << filePath << std::endl;
|
||
return false;
|
||
}
|
||
}
|
||
|
||
// 创建并写入新的 XML 文件的主函数
|
||
bool createXmlFile(int devindex, int mpindex, bool realData, bool soeData, int limit,std::string type)
|
||
{
|
||
std::string xmlContent = "";
|
||
std::string directory = "";
|
||
std::string filePath = "";
|
||
|
||
if(type == "new"){
|
||
// 构造 XML 内容
|
||
xmlContent = createnewXmlContent(devindex, mpindex, realData, soeData, limit);
|
||
|
||
// 设置文件路径
|
||
directory = "../etc/trigger3s/";
|
||
filePath = directory + "newtrigger.xml";
|
||
}
|
||
else if(type == "delete"){
|
||
// 构造 XML 内容
|
||
xmlContent = createdeleteXmlContent(devindex, mpindex);
|
||
|
||
// 设置文件路径
|
||
directory = "../etc/trigger3s/";
|
||
filePath = directory + "deletetrigger.xml";
|
||
}
|
||
else{
|
||
std::cerr << "Failed to create xmlfile,type error: " << std::endl;
|
||
return false;
|
||
}
|
||
|
||
|
||
// 创建目录（如果不存在）
|
||
if (system(("mkdir -p " + directory).c_str()) != 0) {
|
||
std::cerr << "Failed to create directory: " << directory << std::endl;
|
||
return false;
|
||
}
|
||
|
||
// 将 XML 内容写入文件
|
||
return writeToFile(filePath, xmlContent);
|
||
}
|
||
////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||
//lnk20250108进程更新部分
|
||
|
||
// 用于关闭进程监听的端口
|
||
extern int server_socket; //Web Socket服务端实例
|
||
void close_listening_socket() {
|
||
if (server_socket != -1) {
|
||
// 关闭socket
|
||
close(server_socket);
|
||
std::cout << "Server socket closed successfully!" << std::endl;
|
||
server_socket = -1; // 重置 server_socket
|
||
} else {
|
||
std::cout << "No server socket to close!" << std::endl;
|
||
}
|
||
}
|
||
|
||
//用于校验ip格式
|
||
bool isValidIP(const std::string &ip) {
|
||
std::vector<std::string> parts;
|
||
std::stringstream ss(ip);
|
||
std::string part;
|
||
|
||
// 使用 "." 作为分隔符将 IP 地址分割成各部分
|
||
while (getline(ss, part, '.')) {
|
||
parts.push_back(part);
|
||
}
|
||
|
||
// IP 地址必须有 4 部分
|
||
if (parts.size() != 4) {
|
||
return false;
|
||
}
|
||
|
||
// 校验每一部分是否为合法的数字且在 0 到 255 之间
|
||
for (size_t i = 0; i < parts.size(); ++i) {
|
||
// 校验每部分是否为数字
|
||
for (size_t j = 0; j < parts[i].size(); ++j) {
|
||
if (!isdigit(parts[i][j])) {
|
||
return false;
|
||
}
|
||
}
|
||
|
||
// 转换为整数并检查是否在有效范围内
|
||
int num = atoi(parts[i].c_str());
|
||
if (num < 0 || num > 255) {
|
||
return false;
|
||
}
|
||
|
||
// 检查是否有前导零（如 01、001 等）
|
||
if (parts[i].length() > 1 && parts[i][0] == '0') {
|
||
return false;
|
||
}
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
//执行脚本控制进程
|
||
void execute_bash(string fun,int process_num,string type)
|
||
{
|
||
// 为 char 数组分配足够的空间
|
||
char p_num_str[20];
|
||
// 使用 sprintf 转换
|
||
std::sprintf(p_num_str, "%d", process_num);
|
||
const char* script = "/FeProject/bin/set_process.sh";//使用setsid防止端口占用
|
||
const char* param1 = fun.c_str();
|
||
const char* param2 = p_num_str;
|
||
const char* param3 = type.c_str();
|
||
|
||
// 构造完整的命令
|
||
char command[256];
|
||
snprintf(command, sizeof(command), "%s %s %s %s &", script, param1, param2, param3);
|
||
|
||
std::cout << "command:" << command <<std::endl;
|
||
|
||
// 执行命令
|
||
system(command);
|
||
}
|
||
|
||
//执行脚本控制进程
|
||
void execute_bash_debug(string fun,string ip,string type,int proindex)
|
||
{
|
||
|
||
const char* script = "/FeProject/bin/set_debug.sh";//使用setsid防止端口占用
|
||
const char* param1 = fun.c_str();
|
||
const char* param2 = ip.c_str();
|
||
const char* param3 = type.c_str();
|
||
|
||
// 将 proindex 转换为字符串
|
||
char param4[32];
|
||
snprintf(param4, sizeof(param4), "%d", proindex);
|
||
|
||
// 构造完整的命令
|
||
char command[256];
|
||
snprintf(command, sizeof(command), "%s %s %s %s %s &", script, param1, param2, param3,param4);
|
||
|
||
std::cout << "command:" << command <<std::endl;
|
||
|
||
// 执行命令
|
||
system(command);
|
||
}
|
||
|
||
int parse_set(const std::string& json_str) {
|
||
// 解析 JSON 字符串
|
||
cJSON* root = cJSON_Parse(json_str.c_str());
|
||
if (root == nullptr) {
|
||
std::cout << "Error parsing JSON." << std::endl;
|
||
return 1;
|
||
}
|
||
|
||
// 提取 "messageBody" 部分
|
||
cJSON* messageJson = cJSON_GetObjectItem(root, "messageBody");
|
||
if (messageJson == NULL || messageJson->type != cJSON_String) {
|
||
std::cerr << "'messageJson' is missing or is not an cJSON_String" << std::endl;
|
||
cJSON_Delete(root);
|
||
return 1;
|
||
}
|
||
|
||
// 解析 messageBody 中的 JSON 字符串
|
||
const char* messageBodyStr = messageJson->valuestring;
|
||
if (messageBodyStr == nullptr || strlen(messageBodyStr) == 0) {
|
||
std::cerr << "Failed to parse 'messageBody' JSON or it's empty." << std::endl;
|
||
cJSON_Delete(root);
|
||
return 1;
|
||
}
|
||
|
||
cJSON* messageBody = cJSON_Parse(messageBodyStr); // 解析 messageBody 字符串
|
||
if (messageBody == NULL) {
|
||
std::cerr << "Failed to parse 'messageBody' JSON." << std::endl;
|
||
cJSON_Delete(root);
|
||
return 1;
|
||
}
|
||
|
||
// 获取 guid 字段
|
||
cJSON* guidstr = cJSON_GetObjectItem(messageBody, "guid");
|
||
if (guidstr == nullptr) {
|
||
std::cout << "Missing 'guid' in JSON." << std::endl;
|
||
cJSON_Delete(messageBody);
|
||
cJSON_Delete(root);
|
||
return 1;
|
||
}
|
||
|
||
// 根据 guid 字段回复消息
|
||
std::string guid = guidstr->valuestring;
|
||
|
||
// 获取 code 字段
|
||
cJSON* code = cJSON_GetObjectItem(messageBody, "code");
|
||
if (code == nullptr) {
|
||
std::cout << "Missing 'code' in JSON." << std::endl;
|
||
cJSON_Delete(messageBody);
|
||
cJSON_Delete(root);
|
||
return 1;
|
||
}
|
||
|
||
// 根据 code 字段值执行不同的解析逻辑
|
||
std::string code_str = code->valuestring;
|
||
|
||
cJSON* processNo = cJSON_GetObjectItem(messageBody, "processNo");
|
||
if (processNo == nullptr) {
|
||
std::cout << "Missing 'processNo' in JSON." << std::endl;
|
||
cJSON_Delete(messageBody);
|
||
cJSON_Delete(root);
|
||
return 1;
|
||
}
|
||
|
||
//判断是不是自己进程号：
|
||
int index_value = processNo->valueint;
|
||
|
||
cJSON* funtion = cJSON_GetObjectItem(messageBody, "fun");
|
||
if (funtion == nullptr) {
|
||
std::cout << "Missing 'fun' in JSON." << std::endl;
|
||
cJSON_Delete(messageBody);
|
||
cJSON_Delete(root);
|
||
return 1;
|
||
}
|
||
|
||
std::string fun = funtion->valuestring;
|
||
|
||
cJSON* front = cJSON_GetObjectItem(messageBody, "frontType");
|
||
if (front == nullptr) {
|
||
std::cout << "Missing 'frontType' in JSON." << std::endl;
|
||
cJSON_Delete(messageBody);
|
||
cJSON_Delete(root);
|
||
return 1;
|
||
}
|
||
|
||
std::string frontType = front->valuestring;
|
||
|
||
if (index_value != g_front_seg_index && g_front_seg_index != 0) {
|
||
std::cout << "msg index:"<< index_value <<"doesnt match self index:" << g_front_seg_index << std::endl;
|
||
cJSON_Delete(messageBody);
|
||
cJSON_Delete(root);
|
||
return 0;
|
||
}
|
||
|
||
//进程号为0或者进程号匹配上
|
||
std::cout << "msg index:"<< index_value <<" self index:" << g_front_seg_index << std::endl;
|
||
|
||
DIY_INFOLOG_CODE("process",0,LOG_CODE_PROCESS_CONTROL,"【NORMAL】前置的%s%d号进程处理topic:%s_%s的进程控制消息",get_front_msg_from_subdir(), g_front_seg_index,FRONT_INST.c_str(),G_MQCONSUMER_TOPIC_SET.c_str());
|
||
|
||
if (code_str == "set_process") {
|
||
|
||
cJSON* num = cJSON_GetObjectItem(messageBody, "processNum");
|
||
if (num == nullptr) {
|
||
std::cout << "Missing 'processNum' in JSON." << std::endl;
|
||
cJSON_Delete(messageBody);
|
||
cJSON_Delete(root);
|
||
return 1;
|
||
}
|
||
|
||
int processNum = num->valueint;
|
||
|
||
//校验数据
|
||
if((fun == "reset" || fun == "add") &&
|
||
(processNum >=1 && processNum < 10) &&
|
||
(frontType == "stat" || frontType == "recall" || frontType == "all")){
|
||
|
||
if(g_node_id == STAT_DATA_BASE_NODE_ID && g_front_seg_index == 1){
|
||
|
||
// 调用执行脚本函数
|
||
if(fun == "reset"){
|
||
close_listening_socket();
|
||
}
|
||
execute_bash(fun, processNum, frontType);
|
||
|
||
DIY_WARNLOG_CODE("process",0,LOG_CODE_PROCESS_CONTROL,"【WARN】前置的%s%d号进程执行指令:%s,reset表示重启所有进程,add表示添加进程",get_front_msg_from_subdir(), g_front_seg_index,fun.c_str());
|
||
|
||
//脚本在3秒后执行
|
||
//回复消息
|
||
send_reply_to_kafka(guid,"1","收到重置进程指令,重启所有进程!");
|
||
|
||
//上送日志
|
||
|
||
std::cout << "this msg should only execute once" <<std::endl;
|
||
}
|
||
else{
|
||
std::cout << "only cfg_stat_data index 1 can control process,this process not handle this msg" << std::endl;
|
||
}
|
||
}
|
||
else if(fun == "delete"){
|
||
//等待一会后退出进程
|
||
MVL_LOG_ACSE0("MYLOG: recive delete msg, so exit to restart ");
|
||
|
||
//回复消息
|
||
send_reply_to_kafka(guid,"1","收到删除进程指令,这个进程将会重启 ");
|
||
|
||
//上送日志
|
||
DIY_WARNLOG_CODE("process",0,LOG_CODE_PROCESS_CONTROL,"【WARN】前置的%s%d号进程执行指令:%s,即将重启",get_front_msg_from_subdir(), g_front_seg_index,fun.c_str());
|
||
|
||
apr_sleep(apr_time_from_sec(10));
|
||
::_exit(-1039); //进程退出
|
||
}
|
||
else{
|
||
std::cout << "param is not executable" <<std::endl;
|
||
}
|
||
|
||
}
|
||
else if (code_str == "set_debug"){
|
||
if(g_node_id == STAT_DATA_BASE_NODE_ID && g_front_seg_index == 1){
|
||
std::cout << "cfg_stat_data process" << g_front_seg_index <<" handle this msg" << std::endl;
|
||
|
||
cJSON* onlyip = cJSON_GetObjectItem(messageBody, "ip");
|
||
if (onlyip == nullptr) {
|
||
std::cout << "Missing 'ip' in JSON." << std::endl;
|
||
cJSON_Delete(messageBody);
|
||
cJSON_Delete(root);
|
||
return 1;
|
||
}
|
||
|
||
std::string ip = onlyip->valuestring;
|
||
|
||
cJSON* index_item = cJSON_GetObjectItem(messageBody, "proindex");
|
||
if (index_item == nullptr) {
|
||
std::cout << "Missing 'proindex' in JSON." << std::endl;
|
||
cJSON_Delete(messageBody);
|
||
cJSON_Delete(root);
|
||
return 1;
|
||
}
|
||
|
||
int proindex = index_item->valueint;
|
||
|
||
std::cout << "proindex is :" << proindex <<std::endl;
|
||
|
||
//校验数据
|
||
if((fun == "start" || fun == "delete") &&
|
||
isValidIP(ip) &&
|
||
(frontType == "stat" || frontType == "recall" || frontType == "realTime" || frontType == "comtrade") &&
|
||
(proindex >= 10 && proindex < 100)){ //单连测试用的进程号应该大于10小于100
|
||
execute_bash_debug(fun, ip, frontType,proindex);
|
||
|
||
DIY_WARNLOG_CODE("process",0,LOG_CODE_PROCESS_CONTROL,"【WARN】前置的%s%d号进程执行指令:%s,start开启单连进程,delete杀死单连进程",get_front_msg_from_subdir(), g_front_seg_index,fun.c_str());
|
||
}
|
||
else{
|
||
std::cout << "param is not executable" <<std::endl;
|
||
}
|
||
|
||
std::cout << "this msg should only execute once" <<std::endl;
|
||
}
|
||
else{
|
||
std::cout << "only cfg_stat_data index 1 can control process,this process not handle this msg" << std::endl;
|
||
}
|
||
}
|
||
else{
|
||
std::cout << "set process code str error" <<std::endl;
|
||
}
|
||
|
||
// 释放 JSON 对象
|
||
cJSON_Delete(messageBody);
|
||
cJSON_Delete(root);
|
||
return 0;
|
||
}
|
||
|
||
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||
//lnk20250103台账更新部分
|
||
// 准备更新内容并生成 XML 字符串
|
||
// 添加缩进的函数
|
||
void add_indent(std::stringstream& stream, int level) {
|
||
for (int i = 0; i < level; ++i) {
|
||
stream << " "; // 每一级缩进 2 个空格
|
||
}
|
||
}
|
||
|
||
std::string prepare_update(const std::string& code_str, const terminal& json_data,const std::string& guid) //添加guid
|
||
{
|
||
std::cout << "prepare update" << std::endl;
|
||
|
||
std::stringstream xmlStream;
|
||
int indentLevel = 0; // 缩进级别
|
||
|
||
// 根节点
|
||
add_indent(xmlStream, indentLevel);
|
||
xmlStream << "<ledger_update>" << std::endl;
|
||
indentLevel++;
|
||
|
||
// 添加 guid 节点
|
||
add_indent(xmlStream, indentLevel);
|
||
xmlStream << "<guid>" << guid << "</guid>" << std::endl;
|
||
|
||
if (code_str == "ledger_modify" || code_str == "add_terminal") {
|
||
|
||
// 如果是 modify 类型
|
||
if (code_str == "ledger_modify") {
|
||
add_indent(xmlStream, indentLevel);
|
||
xmlStream << "<modify>" << std::endl;
|
||
indentLevel++;
|
||
}
|
||
else {
|
||
add_indent(xmlStream, indentLevel);
|
||
xmlStream << "<add>" << std::endl;
|
||
indentLevel++;
|
||
}
|
||
|
||
// 添加数据部分
|
||
add_indent(xmlStream, indentLevel);
|
||
xmlStream << "<terminalData>" << std::endl;
|
||
indentLevel++;
|
||
|
||
add_indent(xmlStream, indentLevel);
|
||
xmlStream << "<id>" << json_data.terminal_id << "</id>" << std::endl;
|
||
|
||
add_indent(xmlStream, indentLevel);
|
||
xmlStream << "<ip>" << json_data.addr_str << "</ip>" << std::endl; // Assuming `addr_str` for IP
|
||
|
||
add_indent(xmlStream, indentLevel);
|
||
xmlStream << "<devType>" << json_data.dev_type << "</devType>" << std::endl;
|
||
|
||
add_indent(xmlStream, indentLevel);
|
||
xmlStream << "<maintName>" << json_data.maint_name << "</maintName>" << std::endl;
|
||
|
||
add_indent(xmlStream, indentLevel);
|
||
xmlStream << "<orgName>" << json_data.org_name << "</orgName>" << std::endl;
|
||
|
||
add_indent(xmlStream, indentLevel);
|
||
xmlStream << "<port>" << json_data.port << "</port>" << std::endl;
|
||
|
||
add_indent(xmlStream, indentLevel);
|
||
xmlStream << "<stationName>" << json_data.station_name << "</stationName>" << std::endl;
|
||
|
||
add_indent(xmlStream, indentLevel);
|
||
xmlStream << "<terminalCode>" << json_data.terminal_code << "</terminalCode>" << std::endl;
|
||
|
||
add_indent(xmlStream, indentLevel);
|
||
xmlStream << "<updateTime>" << json_data.timestamp << "</updateTime>" << std::endl; // Assuming `timestamp`
|
||
|
||
add_indent(xmlStream, indentLevel);
|
||
xmlStream << "<manufacturer>" << json_data.tmnl_factory << "</manufacturer>" << std::endl;
|
||
|
||
add_indent(xmlStream, indentLevel);
|
||
xmlStream << "<status>" << json_data.tmnl_status << "</status>" << std::endl;
|
||
|
||
add_indent(xmlStream, indentLevel);
|
||
xmlStream << "<series>" << json_data.dev_series << "</series>" << std::endl;
|
||
|
||
//lnk20250210
|
||
add_indent(xmlStream, indentLevel);
|
||
xmlStream << "<processNo>" << json_data.processNo << "</processNo>" << std::endl;
|
||
|
||
//lnk20250305
|
||
add_indent(xmlStream, indentLevel);
|
||
xmlStream << "<devKey>" << json_data.dev_key << "</devKey>" << std::endl;
|
||
|
||
add_indent(xmlStream, indentLevel);
|
||
xmlStream << "<loglevel>" << json_data.log_level << "</loglevel>" << std::endl;
|
||
|
||
// monitorData 部分
|
||
for (int i = 0; json_data.line[i].monitor_id[0] != '\0'; i++) {
|
||
const monitor& monitor = json_data.line[i];
|
||
|
||
add_indent(xmlStream, indentLevel);
|
||
xmlStream << "<monitorData" << (i + 1) << ">" << std::endl;
|
||
indentLevel++;
|
||
|
||
add_indent(xmlStream, indentLevel);
|
||
xmlStream << "<id>" << monitor.monitor_id << "</id>" << std::endl;
|
||
|
||
add_indent(xmlStream, indentLevel);
|
||
xmlStream << "<name>" << monitor.monitor_name << "</name>" << std::endl;
|
||
|
||
add_indent(xmlStream, indentLevel);
|
||
xmlStream << "<lineNo>" << monitor.logical_device_seq << "</lineNo>" << std::endl;
|
||
|
||
add_indent(xmlStream, indentLevel);
|
||
xmlStream << "<voltageLevel>" << monitor.voltage_level << "</voltageLevel>" << std::endl;
|
||
|
||
add_indent(xmlStream, indentLevel);
|
||
xmlStream << "<ptType>" << monitor.terminal_connect << "</ptType>" << std::endl;
|
||
|
||
add_indent(xmlStream, indentLevel);
|
||
xmlStream << "<timestamp>" << monitor.timestamp << "</timestamp>" << std::endl;
|
||
|
||
add_indent(xmlStream, indentLevel);
|
||
xmlStream << "<terminal_code>" << monitor.terminal_code << "</terminal_code>" << std::endl;
|
||
|
||
add_indent(xmlStream, indentLevel);
|
||
xmlStream << "<status>" << monitor.status << "</status>" << std::endl;
|
||
|
||
add_indent(xmlStream, indentLevel);
|
||
xmlStream << "<loglevel>" << monitor.log_level << "</loglevel>" << std::endl;
|
||
|
||
indentLevel--;
|
||
add_indent(xmlStream, indentLevel);
|
||
xmlStream << "</monitorData>" << std::endl;
|
||
}
|
||
|
||
indentLevel--;
|
||
add_indent(xmlStream, indentLevel);
|
||
xmlStream << "</terminalData>" << std::endl;
|
||
|
||
// 结束 modify 或 add 标签
|
||
if (code_str == "ledger_modify") {
|
||
indentLevel--;
|
||
add_indent(xmlStream, indentLevel);
|
||
xmlStream << "</modify>" << std::endl;
|
||
|
||
}
|
||
else {
|
||
indentLevel--;
|
||
add_indent(xmlStream, indentLevel);
|
||
xmlStream << "</add>" << std::endl;
|
||
|
||
}
|
||
|
||
} else if (code_str == "delete_terminal") {
|
||
// 如果是 delete 类型
|
||
add_indent(xmlStream, indentLevel);
|
||
xmlStream << "<delete>" << std::endl;
|
||
indentLevel++;
|
||
|
||
add_indent(xmlStream, indentLevel);
|
||
xmlStream << "<terminalData>" << std::endl;
|
||
indentLevel++;
|
||
|
||
add_indent(xmlStream, indentLevel);
|
||
xmlStream << "<id>" << json_data.terminal_id << "</id>" << std::endl;
|
||
|
||
indentLevel--;
|
||
add_indent(xmlStream, indentLevel);
|
||
xmlStream << "</terminalData>" << std::endl;
|
||
|
||
indentLevel--;
|
||
add_indent(xmlStream, indentLevel);
|
||
xmlStream << "</delete>" << std::endl;
|
||
}
|
||
else {
|
||
std::cerr << "code_str error" << std::endl;
|
||
return "";
|
||
}
|
||
|
||
// 结束根节点
|
||
indentLevel--;
|
||
add_indent(xmlStream, indentLevel);
|
||
xmlStream << "</ledger_update>" << std::endl;
|
||
|
||
return xmlStream.str(); // 返回构造的 XML 字符串
|
||
}
|
||
|
||
// 函数：将string字符串转换为整数
|
||
int StringToInt(const std::string& str) {
|
||
std::stringstream ss(str);
|
||
int number;
|
||
ss >> number; // 从字符串流中读取整数
|
||
|
||
// 检查是否转换成功
|
||
if (ss.fail()) {
|
||
std::cerr << "Conversion failed!" << std::endl;
|
||
return 0; // 或者你可以选择返回一个标识失败的值，如-1
|
||
}
|
||
return number;
|
||
}
|
||
|
||
// 解析 JSON 字符串并执行相应操作
|
||
int parse_log(const std::string& json_str) {
|
||
// 解析 JSON 字符串
|
||
cJSON* root = cJSON_Parse(json_str.c_str());
|
||
if (root == nullptr) {
|
||
std::cout << "Error parsing JSON." << std::endl;
|
||
return 1;
|
||
}
|
||
|
||
// 提取 "messageBody" 部分
|
||
cJSON* messageJson = cJSON_GetObjectItem(root, "messageBody");
|
||
if (messageJson == NULL || messageJson->type != cJSON_String) {
|
||
std::cerr << "'messageJson' is missing or is not an cJSON_String" << std::endl;
|
||
cJSON_Delete(root);
|
||
return 1;
|
||
}
|
||
|
||
// 解析 messageBody 中的 JSON 字符串
|
||
const char* messageBodyStr = messageJson->valuestring;
|
||
if (messageBodyStr == nullptr || strlen(messageBodyStr) == 0) {
|
||
std::cerr << "Failed to parse 'messageBody' JSON or it's empty." << std::endl;
|
||
cJSON_Delete(root);
|
||
return 1;
|
||
}
|
||
|
||
cJSON* messageBody = cJSON_Parse(messageBodyStr); // 解析 messageBody 字符串
|
||
if (messageBody == NULL) {
|
||
std::cerr << "Failed to parse 'messageBody' JSON." << std::endl;
|
||
cJSON_Delete(root);
|
||
return 1;
|
||
}
|
||
|
||
// 获取 guid 字段
|
||
cJSON* guidstr = cJSON_GetObjectItem(messageBody, "guid");
|
||
if (guidstr == nullptr) {
|
||
std::cout << "Missing 'guid' in JSON." << std::endl;
|
||
cJSON_Delete(messageBody);
|
||
cJSON_Delete(root);
|
||
return 1;
|
||
}
|
||
|
||
// 根据 guid 字段回复消息
|
||
std::string guid = guidstr->valuestring;
|
||
|
||
// 获取 code 字段
|
||
cJSON* code = cJSON_GetObjectItem(messageBody, "code");
|
||
if (code == nullptr) {
|
||
std::cout << "Missing 'code' in JSON." << std::endl;
|
||
cJSON_Delete(messageBody);
|
||
cJSON_Delete(root);
|
||
return 1;
|
||
}
|
||
|
||
// 根据 code 字段值执行不同的解析逻辑
|
||
std::string code_str = code->valuestring;
|
||
|
||
//获取进程号
|
||
cJSON* process = cJSON_GetObjectItem(messageBody, "processNo");
|
||
if (process == nullptr) {
|
||
std::cout << "Missing 'processNo' in JSON." << std::endl;
|
||
cJSON_Delete(messageBody);
|
||
cJSON_Delete(root);
|
||
return 1;
|
||
}
|
||
|
||
//判断是不是自己进程号：
|
||
int processNo = process->valueint;
|
||
|
||
// 获取 id 字段
|
||
cJSON* idstr = cJSON_GetObjectItem(messageBody, "id");
|
||
if (idstr == nullptr) {
|
||
std::cout << "Missing 'id' in JSON." << std::endl;
|
||
cJSON_Delete(messageBody);
|
||
cJSON_Delete(root);
|
||
return 1;
|
||
}
|
||
|
||
std::string id = idstr->valuestring;
|
||
|
||
// 获取 level 字段
|
||
cJSON* levelstr = cJSON_GetObjectItem(messageBody, "level");
|
||
if (levelstr == nullptr) {
|
||
std::cout << "Missing 'level' in JSON." << std::endl;
|
||
cJSON_Delete(messageBody);
|
||
cJSON_Delete(root);
|
||
return 1;
|
||
}
|
||
|
||
std::string level = levelstr->valuestring;
|
||
|
||
// 获取 grade 字段
|
||
cJSON* gradestr = cJSON_GetObjectItem(messageBody, "grade");
|
||
if (gradestr == nullptr) {
|
||
std::cout << "Missing 'grade' in JSON." << std::endl;
|
||
cJSON_Delete(messageBody);
|
||
cJSON_Delete(root);
|
||
return 1;
|
||
}
|
||
|
||
std::string grade = gradestr->valuestring;
|
||
|
||
// 获取 logtype 字段
|
||
cJSON* logtypestr = cJSON_GetObjectItem(messageBody, "logtype");
|
||
if (logtypestr == nullptr) {
|
||
std::cout << "Missing 'logtype' in JSON." << std::endl;
|
||
cJSON_Delete(messageBody);
|
||
cJSON_Delete(root);
|
||
return 1;
|
||
}
|
||
|
||
int logtype = logtypestr->valueint;
|
||
|
||
// 获取 frontType 字段
|
||
cJSON* frontTypestr = cJSON_GetObjectItem(messageBody, "frontType");
|
||
if (frontTypestr == nullptr) {
|
||
std::cout << "Missing 'frontType' in JSON." << std::endl;
|
||
cJSON_Delete(messageBody);
|
||
cJSON_Delete(root);
|
||
return 1;
|
||
}
|
||
|
||
std::string frontType = frontTypestr->valuestring;
|
||
|
||
if (processNo != g_front_seg_index) {
|
||
std::cout << "msg index:"<< processNo <<"doesnt match self index:" << g_front_seg_index << std::endl;
|
||
cJSON_Delete(messageBody);
|
||
cJSON_Delete(root);
|
||
return 0;
|
||
}
|
||
|
||
if (frontType != subdir) {
|
||
std::cout << "msg frontType:"<< frontType <<"doesnt match self frontType:" << subdir << std::endl;
|
||
cJSON_Delete(messageBody);
|
||
cJSON_Delete(root);
|
||
return 0;
|
||
}
|
||
|
||
DIY_INFOLOG_CODE("process",0,LOG_CODE_LOG_REQUEST,"【NORMAL】前置的%s%d号进程处理日志控制消息",get_front_msg_from_subdir(), g_front_seg_index);
|
||
|
||
//进程号和匹配上
|
||
std::cout << "msg index:"<< processNo <<" self index:" << g_front_seg_index << std::endl;
|
||
std::cout << "msg frontType:"<< frontType <<" self frontType:" << subdir << std::endl;
|
||
|
||
//回复消息
|
||
send_reply_to_kafka(guid,"1","收到日志控制指令");
|
||
|
||
if (code_str == "set_log") {
|
||
//校验数据
|
||
if((level == "terminal" || level == "measurepoint") &&
|
||
(grade == "NORMAL" || grade == "DEBUG") &&
|
||
(!id.empty() && !is_blank(id))){
|
||
|
||
//开启日志临时开关
|
||
process_log_command(id, level, grade, logtype);
|
||
|
||
}
|
||
else if((level == "measurepoint") && (grade == "TRACE") && (!id.empty() && !is_blank(id))){ //数据追踪
|
||
//打开监测点数据追踪开关
|
||
process_trace_command(id,3); //3表示追踪次数
|
||
}
|
||
else{
|
||
std::cout << "type doesnt match" <<std::endl;
|
||
//记录warm
|
||
|
||
}
|
||
std::cout << "this msg should only execute once" <<std::endl;
|
||
}
|
||
|
||
// 释放 JSON 对象
|
||
cJSON_Delete(messageBody);
|
||
cJSON_Delete(root);
|
||
return 0;
|
||
}
|
||
|
||
// 台账更新不区分功能
|
||
int parse_control(const std::string& json_str, const std::string& output_dir) {
|
||
// 解析 JSON 字符串
|
||
cJSON* root = cJSON_Parse(json_str.c_str());
|
||
if (root == nullptr) {
|
||
std::cout << "Error parsing JSON." << std::endl;
|
||
return 1;
|
||
}
|
||
|
||
// 提取 "messageBody" 部分
|
||
cJSON* messageJson = cJSON_GetObjectItem(root, "messageBody");
|
||
if (messageJson == NULL || messageJson->type != cJSON_String) {
|
||
std::cerr << "'messageJson' is missing or is not an cJSON_String" << std::endl;
|
||
cJSON_Delete(root);
|
||
return 1;
|
||
}
|
||
|
||
// 解析 messageBody 中的 JSON 字符串
|
||
const char* messageBodyStr = messageJson->valuestring;
|
||
if (messageBodyStr == nullptr || strlen(messageBodyStr) == 0) {
|
||
std::cerr << "Failed to parse 'messageBody' JSON or it's empty." << std::endl;
|
||
cJSON_Delete(root);
|
||
return 1;
|
||
}
|
||
|
||
cJSON* messageBody = cJSON_Parse(messageBodyStr); // 解析 messageBody 字符串
|
||
if (messageBody == NULL) {
|
||
std::cerr << "Failed to parse 'messageBody' JSON." << std::endl;
|
||
cJSON_Delete(root);
|
||
return 1;
|
||
}
|
||
|
||
// 获取 code 字段
|
||
cJSON* code = cJSON_GetObjectItem(messageBody, "code");
|
||
if (code == nullptr) {
|
||
std::cout << "Missing 'code' in JSON." << std::endl;
|
||
cJSON_Delete(messageBody);
|
||
cJSON_Delete(root);
|
||
return 1;
|
||
}
|
||
|
||
// 根据 code 字段值执行不同的解析逻辑
|
||
std::string code_str = code->valuestring;
|
||
|
||
//获取进程号
|
||
cJSON* process = cJSON_GetObjectItem(messageBody, "processNo");
|
||
if (process == nullptr) {
|
||
std::cout << "Missing 'processNo' in JSON." << std::endl;
|
||
cJSON_Delete(messageBody);
|
||
cJSON_Delete(root);
|
||
return 1;
|
||
}
|
||
|
||
//判断是不是自己进程号：
|
||
int process_No = process->valueint;
|
||
|
||
// 获取 guid 字段
|
||
cJSON* guidstr = cJSON_GetObjectItem(messageBody, "guid");
|
||
if (guidstr == nullptr) {
|
||
std::cout << "Missing 'guid' in JSON." << std::endl;
|
||
cJSON_Delete(messageBody);
|
||
cJSON_Delete(root);
|
||
return 1;
|
||
}
|
||
|
||
// 根据 guid 字段回复消息
|
||
std::string guid = guidstr->valuestring;
|
||
|
||
//进程号为0的进程处理所有台账更新消息
|
||
if (process_No != g_front_seg_index && g_front_seg_index !=0) {
|
||
std::cout << "msg index:"<< process_No <<"doesnt match self index:" << g_front_seg_index << std::endl;
|
||
cJSON_Delete(messageBody);
|
||
cJSON_Delete(root);
|
||
return 0;
|
||
}
|
||
|
||
//进程号为0或者进程号匹配上
|
||
std::cout << "msg index:"<< process_No <<" self index:" << g_front_seg_index << std::endl;
|
||
|
||
//记录日志
|
||
DIY_INFOLOG_CODE("process",0,LOG_CODE_LEDGER_UPDATE,"【NORMAL】前置的%s%d号进程处理topic:%s_%s的台账更新消息",get_front_msg_from_subdir(), g_front_seg_index,FRONT_INST.c_str(),G_MQCONSUMER_TOPIC_UD.c_str());
|
||
|
||
//匹配后响应收到台账更新消息
|
||
//除了回复收到消息，执行结束后还要回复结果
|
||
send_reply_to_kafka(guid,"1","收到台账更新指令");
|
||
|
||
if (code_str == "add_terminal" || code_str == "ledger_modify") {
|
||
|
||
std::cout << "add or update ledger" << std::endl;
|
||
|
||
// 解析 add_terminal 或 ledger_modify
|
||
cJSON* data = cJSON_GetObjectItem(messageBody, "data");
|
||
if (data != nullptr && data->type == cJSON_Array) {
|
||
int data_size = cJSON_GetArraySize(data);
|
||
for (int i = 0; i < data_size; i++) {
|
||
cJSON* item = cJSON_GetArrayItem(data, i);
|
||
|
||
terminal json_data;
|
||
// 填充 terminal_dev 的数据
|
||
cJSON* id = cJSON_GetObjectItem(item, "id"); // terminal_id
|
||
if (id && id->type == cJSON_String)
|
||
std::strncpy(json_data.terminal_id, id->valuestring, sizeof(json_data.terminal_id) - 1);
|
||
else
|
||
std::strncpy(json_data.terminal_id, "N/A", sizeof(json_data.terminal_id) - 1);
|
||
|
||
cJSON* name = cJSON_GetObjectItem(item, "name"); // terminal_code
|
||
if (name && name->type == cJSON_String)
|
||
std::strncpy(json_data.terminal_code, name->valuestring, sizeof(json_data.terminal_code) - 1);
|
||
else
|
||
std::strncpy(json_data.terminal_code, "N/A", sizeof(json_data.terminal_code) - 1);
|
||
|
||
cJSON* org_name = cJSON_GetObjectItem(item, "org_name"); // org_name
|
||
if (org_name && org_name->type == cJSON_String)
|
||
std::strncpy(json_data.org_name, org_name->valuestring, sizeof(json_data.org_name) - 1);
|
||
else
|
||
std::strncpy(json_data.org_name, "N/A", sizeof(json_data.org_name) - 1);
|
||
|
||
cJSON* maint_name = cJSON_GetObjectItem(item, "maint_name"); // maint_name
|
||
if (maint_name && maint_name->type == cJSON_String)
|
||
std::strncpy(json_data.maint_name, maint_name->valuestring, sizeof(json_data.maint_name) - 1);
|
||
else
|
||
std::strncpy(json_data.maint_name, "N/A", sizeof(json_data.maint_name) - 1);
|
||
|
||
cJSON* station_name = cJSON_GetObjectItem(item, "stationName"); // station_name
|
||
if (station_name && station_name->type == cJSON_String)
|
||
std::strncpy(json_data.station_name, station_name->valuestring, sizeof(json_data.station_name) - 1);
|
||
else
|
||
std::strncpy(json_data.station_name, "N/A", sizeof(json_data.station_name) - 1);
|
||
|
||
cJSON* manufacturer = cJSON_GetObjectItem(item, "manufacturer"); // tmnl_factory
|
||
if (manufacturer && manufacturer->type == cJSON_String)
|
||
std::strncpy(json_data.tmnl_factory, manufacturer->valuestring, sizeof(json_data.tmnl_factory) - 1);
|
||
else
|
||
std::strncpy(json_data.tmnl_factory, "N/A", sizeof(json_data.tmnl_factory) - 1);
|
||
|
||
cJSON* status = cJSON_GetObjectItem(item, "status"); // tmnl_status
|
||
if (status && status->type == cJSON_String)
|
||
std::strncpy(json_data.tmnl_status, status->valuestring, sizeof(json_data.tmnl_status) - 1);
|
||
else
|
||
std::strncpy(json_data.tmnl_status, "N/A", sizeof(json_data.tmnl_status) - 1);
|
||
|
||
cJSON* dev_type = cJSON_GetObjectItem(item, "devType"); // dev_type
|
||
if (dev_type && dev_type->type == cJSON_String)
|
||
std::strncpy(json_data.dev_type, dev_type->valuestring, sizeof(json_data.dev_type) - 1);
|
||
else
|
||
std::strncpy(json_data.dev_type, "N/A", sizeof(json_data.dev_type) - 1);
|
||
|
||
cJSON* dev_key = cJSON_GetObjectItem(item, "devKey"); // dev_key
|
||
if (dev_key && dev_key->type == cJSON_String)
|
||
std::strncpy(json_data.dev_key, dev_key->valuestring, sizeof(json_data.dev_key) - 1);
|
||
else
|
||
std::strncpy(json_data.dev_key, "N/A", sizeof(json_data.dev_key) - 1);
|
||
|
||
cJSON* dev_series = cJSON_GetObjectItem(item, "series"); // dev_series
|
||
if (dev_series && dev_series->type == cJSON_String)
|
||
std::strncpy(json_data.dev_series, dev_series->valuestring, sizeof(json_data.dev_series) - 1);
|
||
else
|
||
std::strncpy(json_data.dev_series, "N/A", sizeof(json_data.dev_series) - 1);
|
||
|
||
//lnk20250210台账进程号
|
||
cJSON* processNo = cJSON_GetObjectItem(item, "processNo"); // processNo转为字符串
|
||
if (processNo && processNo->type == cJSON_Number) snprintf(json_data.processNo, sizeof(json_data.processNo), "%d", processNo->valueint);
|
||
else strncpy(json_data.processNo, "N/A", sizeof(json_data.processNo) - 1);
|
||
|
||
cJSON* ip = cJSON_GetObjectItem(item, "ip"); // addr_str
|
||
if (ip && ip->type == cJSON_String)
|
||
std::strncpy(json_data.addr_str, ip->valuestring, sizeof(json_data.addr_str) - 1);
|
||
else
|
||
std::strncpy(json_data.addr_str, "N/A", sizeof(json_data.addr_str) - 1);
|
||
|
||
cJSON* port = cJSON_GetObjectItem(item, "port"); // port
|
||
if (port && port->type == cJSON_String)
|
||
std::strncpy(json_data.port, port->valuestring, sizeof(json_data.port) - 1);
|
||
else
|
||
std::strncpy(json_data.port, "N/A", sizeof(json_data.port) - 1);
|
||
|
||
cJSON* updateTime = cJSON_GetObjectItem(item, "updateTime"); // timestamp
|
||
if (updateTime && updateTime->type == cJSON_String)
|
||
std::strncpy(json_data.timestamp, updateTime->valuestring, sizeof(json_data.timestamp) - 1);
|
||
else
|
||
std::strncpy(json_data.timestamp, "N/A", sizeof(json_data.timestamp) - 1);
|
||
|
||
|
||
//添加loglevel字段
|
||
cJSON* loglevel = cJSON_GetObjectItem(item, "loglevel"); // log_level
|
||
int tmp_level = -1;
|
||
// 先读取 loglevel
|
||
if (loglevel && loglevel->type == cJSON_Number) {
|
||
tmp_level = loglevel->valueint;
|
||
}
|
||
else if (loglevel && loglevel->type == cJSON_String) {
|
||
tmp_level = atoi(loglevel->valuestring);
|
||
}
|
||
// 判断是否合法 (0~3)
|
||
if (tmp_level >= 0 && tmp_level <= 3) {
|
||
json_data.log_level = tmp_level;
|
||
} else {
|
||
json_data.log_level = 1; // 默认日志级别
|
||
}
|
||
printf("terminal log_level: %d\n", json_data.log_level);
|
||
|
||
// monitorData 解析，填充到 line 数组中
|
||
cJSON* monitorData = cJSON_GetObjectItem(item, "monitorData");
|
||
if (monitorData != nullptr && monitorData->type == cJSON_Array) {
|
||
int monitorData_size = cJSON_GetArraySize(monitorData);
|
||
|
||
for (int j = 0; j < monitorData_size && j < 10; j++) { // 最多 10 个监测点
|
||
cJSON* monitor_item = cJSON_GetArrayItem(monitorData, j);
|
||
monitor monitor_data;
|
||
|
||
cJSON* monitor_id = cJSON_GetObjectItem(monitor_item, "id"); // monitor_id
|
||
if (monitor_id && monitor_id->type == cJSON_String)
|
||
std::strncpy(monitor_data.monitor_id, monitor_id->valuestring, sizeof(monitor_data.monitor_id) - 1);
|
||
else
|
||
std::strncpy(monitor_data.monitor_id, "N/A", sizeof(monitor_data.monitor_id) - 1);
|
||
|
||
//添加loglevel字段
|
||
cJSON* loglevel = cJSON_GetObjectItem(monitor_item, "loglevel"); // log_level
|
||
int tmp_level = -1;
|
||
// 先尝试读取 loglevel
|
||
if (loglevel && loglevel->type == cJSON_Number) {
|
||
tmp_level = loglevel->valueint;
|
||
}
|
||
else if (loglevel && loglevel->type == cJSON_String) {
|
||
tmp_level = atoi(loglevel->valuestring);
|
||
}
|
||
// 判断是否合法 (0~3)
|
||
if (tmp_level >= 0 && tmp_level <= 3) {
|
||
monitor_data.log_level = tmp_level;
|
||
}
|
||
else if (json_data.log_level >= 0 && json_data.log_level <= 3) { // 继承 terminal loglevel
|
||
monitor_data.log_level = json_data.log_level;
|
||
}
|
||
else {
|
||
monitor_data.log_level = 1; // 默认 warn
|
||
}
|
||
|
||
cJSON* monitor_name = cJSON_GetObjectItem(monitor_item, "name"); // monitor_name
|
||
if (monitor_name && monitor_name->type == cJSON_String)
|
||
std::strncpy(monitor_data.monitor_name, monitor_name->valuestring, sizeof(monitor_data.monitor_name) - 1);
|
||
else
|
||
std::strncpy(monitor_data.monitor_name, "N/A", sizeof(monitor_data.monitor_name) - 1);
|
||
|
||
cJSON* voltage_level = cJSON_GetObjectItem(monitor_item, "voltageLevel"); // voltage_level
|
||
if (voltage_level && voltage_level->type == cJSON_String)
|
||
std::strncpy(monitor_data.voltage_level, voltage_level->valuestring, sizeof(monitor_data.voltage_level) - 1);
|
||
else
|
||
std::strncpy(monitor_data.voltage_level, "N/A", sizeof(monitor_data.voltage_level) - 1);
|
||
|
||
cJSON* monitor_status = cJSON_GetObjectItem(monitor_item, "status"); // status
|
||
if (monitor_status && monitor_status->type == cJSON_String)
|
||
std::strncpy(monitor_data.status, monitor_status->valuestring, sizeof(monitor_data.status) - 1);
|
||
else
|
||
std::strncpy(monitor_data.status, "N/A", sizeof(monitor_data.status) - 1);
|
||
|
||
cJSON* lineNo = cJSON_GetObjectItem(monitor_item, "lineNo"); // logical_device_seq
|
||
if (lineNo && lineNo->type == cJSON_String)
|
||
|
||
std::strncpy(monitor_data.logical_device_seq, lineNo->valuestring, sizeof(monitor_data.logical_device_seq) - 1);
|
||
else
|
||
std::strncpy(monitor_data.logical_device_seq, "N/A", sizeof(monitor_data.logical_device_seq) - 1);
|
||
|
||
cJSON* ptType = cJSON_GetObjectItem(monitor_item, "ptType"); // terminal_connect
|
||
if (ptType && ptType->type == cJSON_String)
|
||
|
||
std::strncpy(monitor_data.terminal_connect, ptType->valuestring, sizeof(monitor_data.terminal_connect) - 1);
|
||
else
|
||
std::strncpy(monitor_data.terminal_connect, "N/A", sizeof(monitor_data.terminal_connect) - 1);
|
||
|
||
std::strncpy(monitor_data.timestamp, json_data.timestamp, sizeof(monitor_data.timestamp) - 1);
|
||
std::strncpy(monitor_data.terminal_code, json_data.terminal_code, sizeof(monitor_data.terminal_code) - 1);
|
||
// 填充到 line 数组
|
||
json_data.line[j] = monitor_data;
|
||
|
||
}
|
||
}
|
||
|
||
print_terminal(&json_data);
|
||
|
||
// 准备 XML 内容并写入文件
|
||
std::string xmlContent = prepare_update(code_str, json_data,guid);//添加guid20250506
|
||
if (xmlContent != "") {
|
||
|
||
std::cout << "write to xml in /FeProject/etc/ledger_update" <<std::endl;
|
||
|
||
char nodeid[20];
|
||
std::sprintf(nodeid, "%u", g_node_id); // "%u" 用于 unsigned int
|
||
std::string nodeid_str(nodeid);
|
||
|
||
std::string frontindex_str = intToString(g_front_seg_index);
|
||
|
||
std::string file_name = output_dir + "/" + nodeid_str + "_" + frontindex_str + "_" + json_data.terminal_id + "_" + code_str + ".xml";
|
||
writeToFile(file_name, xmlContent);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else if (code_str == "delete_terminal") {
|
||
|
||
std::cout << "delete ledger" <<std::endl;
|
||
|
||
// 解析 delete_terminal
|
||
cJSON* data = cJSON_GetObjectItem(messageBody, "data");
|
||
if (data != nullptr && data->type == cJSON_Array) {
|
||
int data_size = cJSON_GetArraySize(data);
|
||
for (int i = 0; i < data_size; i++) {
|
||
cJSON* item = cJSON_GetArrayItem(data, i);
|
||
|
||
// 只解析 id 字段
|
||
cJSON* id = cJSON_GetObjectItem(item, "id");
|
||
if (id != nullptr) {
|
||
terminal json_data;
|
||
std::strncpy(json_data.terminal_id, cJSON_GetObjectItem(item, "id")->valuestring, sizeof(json_data.terminal_id) - 1);
|
||
// 准备 XML 内容并写入文件
|
||
std::string xmlContent = prepare_update(code_str, json_data,guid);//添加guid20250506
|
||
if(xmlContent != ""){
|
||
char nodeid[20];
|
||
std::sprintf(nodeid, "%u", g_node_id); // "%u" 用于 unsigned int
|
||
std::string nodeid_str(nodeid);
|
||
|
||
std::string frontindex_str = intToString(g_front_seg_index);
|
||
|
||
std::string file_name = output_dir + "/" + nodeid_str + "_" + frontindex_str + "_" + json_data.terminal_id + "_delete_terminal.xml";
|
||
writeToFile(file_name, xmlContent); //写文件加上guid，读文件
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else{
|
||
std::cout << "code_str error" <<std::endl;
|
||
}
|
||
|
||
// 释放 JSON 对象
|
||
cJSON_Delete(messageBody);
|
||
cJSON_Delete(root);
|
||
|
||
return 0;
|
||
}
|
||
//////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||
//处理文件请求
|
||
static int ParseFileDirReq(const char *body, file_dir_req_t *req)
|
||
{
|
||
if (body == NULL || req == NULL)
|
||
return -1;
|
||
|
||
cJSON *root = cJSON_Parse(body);
|
||
if (root == NULL)
|
||
return -1;
|
||
|
||
cJSON *guid = cJSON_GetObjectItem(root, "guid");
|
||
cJSON *frontid = cJSON_GetObjectItem(root, "nodeId");
|
||
cJSON *processNo = cJSON_GetObjectItem(root, "processNo");
|
||
cJSON *devid = cJSON_GetObjectItem(root, "devId");
|
||
cJSON *type = cJSON_GetObjectItem(root, "type");
|
||
cJSON *path = cJSON_GetObjectItem(root, "path");
|
||
cJSON *remotepath = cJSON_GetObjectItem(root, "remotePath");
|
||
|
||
if (!guid || guid->type != cJSON_String ||
|
||
!frontid || frontid->type != cJSON_String ||
|
||
!processNo || processNo->type != cJSON_Number ||
|
||
!devid || devid->type != cJSON_String ||
|
||
!type || type->type != cJSON_Number ||
|
||
!path || path->type != cJSON_String ||
|
||
!remotepath || remotepath->type != cJSON_String)
|
||
{
|
||
cJSON_Delete(root);
|
||
return -1;
|
||
}
|
||
|
||
memset(req, 0, sizeof(file_dir_req_t));
|
||
snprintf(req->guid, sizeof(req->guid), "%s", guid->valuestring);
|
||
snprintf(req->frontid, sizeof(req->frontid), "%s", frontid->valuestring);
|
||
req->processNo = processNo->valueint;
|
||
snprintf(req->devid, sizeof(req->devid), "%s", devid->valuestring);
|
||
req->type = type->valueint;
|
||
snprintf(req->path, sizeof(req->path), "%s", path->valuestring);
|
||
snprintf(req->remote_path, sizeof(req->remote_path), "%s", remotepath->valuestring);
|
||
req->create_time = time(NULL);
|
||
|
||
cJSON_Delete(root);
|
||
return 0;
|
||
}
|
||
|
||
static void PushFileDirReq(const file_dir_req_t *req)
|
||
{
|
||
if (req == NULL)
|
||
return;
|
||
|
||
file_dir_req_t *node = new file_dir_req_t;
|
||
*node = *req;
|
||
|
||
pthread_mutex_lock(&g_file_req_mutex);
|
||
|
||
g_file_dir_req_list.push_back(node);
|
||
pthread_mutex_unlock(&g_file_req_mutex);
|
||
}
|
||
|
||
static file_dir_req_t* PopMatchedFileDirReq(const char *terminal_id)
|
||
{
|
||
if (terminal_id == NULL || terminal_id[0] == 0)
|
||
return NULL;
|
||
|
||
file_dir_req_t *match = NULL;
|
||
|
||
pthread_mutex_lock(&g_file_req_mutex);
|
||
|
||
for (std::list<file_dir_req_t*>::iterator it = g_file_dir_req_list.begin();
|
||
it != g_file_dir_req_list.end();
|
||
++it)
|
||
{
|
||
file_dir_req_t *node = *it;
|
||
if (node != NULL && strcmp(node->devid, terminal_id) == 0)
|
||
{
|
||
match = node;
|
||
g_file_dir_req_list.erase(it);
|
||
break;
|
||
}
|
||
}
|
||
|
||
pthread_mutex_unlock(&g_file_req_mutex);
|
||
return match;
|
||
}
|
||
|
||
static std::string BuildFileDirRespJsonEx(const file_dir_req_t *req,
|
||
char **names,
|
||
const char **itemTypes,
|
||
int *itemSizes,
|
||
int itemNum,
|
||
int result)
|
||
{
|
||
cJSON *root = cJSON_CreateObject();
|
||
cJSON *detail = cJSON_CreateObject();
|
||
cJSON *dirInfo = cJSON_CreateArray();
|
||
|
||
cJSON_AddStringToObject(root, "guid", req ? req->guid : "");
|
||
cJSON_AddStringToObject(root, "nodeId", req ? req->frontid : "");
|
||
cJSON_AddNumberToObject(root, "processNo", req ? req->processNo : 0);
|
||
cJSON_AddStringToObject(root, "devId", req ? req->devid : "");
|
||
cJSON_AddNumberToObject(root, "type", req ? req->type : 0);
|
||
cJSON_AddNumberToObject(root, "result", result);
|
||
|
||
for (int i = 0; i < itemNum; ++i)
|
||
{
|
||
cJSON *item = cJSON_CreateObject();
|
||
cJSON_AddStringToObject(item, "name", (names && names[i]) ? names[i] : "");
|
||
cJSON_AddStringToObject(item, "type", (itemTypes && itemTypes[i]) ? itemTypes[i] : "file");
|
||
cJSON_AddNumberToObject(item, "size", itemSizes ? itemSizes[i] : 1);
|
||
cJSON_AddItemToArray(dirInfo, item);
|
||
}
|
||
|
||
cJSON_AddItemToObject(detail, "dirInfo", dirInfo);
|
||
|
||
cJSON_AddItemToObject(root, "detail", detail);
|
||
|
||
char *json = cJSON_PrintUnformatted(root);
|
||
std::string jsonStr = json ? json : "";
|
||
|
||
if (json) free(json);
|
||
cJSON_Delete(root);
|
||
return jsonStr;
|
||
}
|
||
|
||
static std::string BuildFileDirRespJson(const file_dir_req_t *req,
|
||
char **filenames,
|
||
int filenum,
|
||
int result)
|
||
{
|
||
if (filenum <= 0)
|
||
return BuildFileDirRespJsonEx(req, NULL, NULL, NULL, 0, result);
|
||
|
||
const char **types = new const char*[filenum];
|
||
int *sizes = new int[filenum];
|
||
|
||
for (int i = 0; i < filenum; ++i)
|
||
{
|
||
types[i] = "dir";
|
||
sizes[i] = 1;
|
||
}
|
||
|
||
std::string jsonStr = BuildFileDirRespJsonEx(req, filenames, types, sizes, filenum, result);
|
||
|
||
delete [] types;
|
||
delete [] sizes;
|
||
return jsonStr;
|
||
}
|
||
|
||
static std::string BuildSingleFileRespJson(const file_dir_req_t *req,
|
||
const char *name,
|
||
const char *itemType,
|
||
int size,
|
||
int result)
|
||
{
|
||
char *names[1];
|
||
const char *types[1];
|
||
int sizes[1];
|
||
|
||
if (name == NULL || result != 0)
|
||
{
|
||
return BuildFileDirRespJsonEx(req, NULL, NULL, NULL, 0, result);
|
||
}
|
||
|
||
names[0] = (char *)name;
|
||
types[0] = (itemType ? itemType : "file");
|
||
sizes[0] = size;
|
||
|
||
return BuildFileDirRespJsonEx(req, names, types, sizes, 1, result);
|
||
}
|
||
|
||
////////////////////////下载
|
||
static const char* GetFileNameOnly(const char* fullpath)
|
||
{
|
||
if (fullpath == NULL)
|
||
return "";
|
||
|
||
const char* p1 = strrchr(fullpath, '/');
|
||
const char* p2 = strrchr(fullpath, '\\');
|
||
const char* p = p1 > p2 ? p1 : p2;
|
||
|
||
return (p ? p + 1 : fullpath);
|
||
}
|
||
|
||
static int MakeDirRecursive(const char* dirPath)
|
||
{
|
||
if (dirPath == NULL || dirPath[0] == '\0')
|
||
return -1;
|
||
|
||
char tmp[512] = {0};
|
||
snprintf(tmp, sizeof(tmp), "%s", dirPath);
|
||
|
||
int len = strlen(tmp);
|
||
if (len <= 0)
|
||
return -1;
|
||
|
||
/* 去掉末尾 '/' */
|
||
if (tmp[len - 1] == '/')
|
||
tmp[len - 1] = '\0';
|
||
|
||
for (char* p = tmp + 1; *p; ++p)
|
||
{
|
||
if (*p == '/')
|
||
{
|
||
*p = '\0';
|
||
if (access(tmp, F_OK) != 0)
|
||
{
|
||
if (mkdir(tmp, 0777) != 0 && errno != EEXIST)
|
||
{
|
||
printf("mkdir failed: %s, err=%s\n", tmp, strerror(errno));
|
||
return -1;
|
||
}
|
||
}
|
||
*p = '/';
|
||
}
|
||
}
|
||
|
||
if (access(tmp, F_OK) != 0)
|
||
{
|
||
if (mkdir(tmp, 0777) != 0 && errno != EEXIST)
|
||
{
|
||
printf("mkdir failed: %s, err=%s\n", tmp, strerror(errno));
|
||
return -1;
|
||
}
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
static void SafePathName(const char* src, char* dst, size_t dstSize)
|
||
{
|
||
if (dst == NULL || dstSize == 0)
|
||
return;
|
||
|
||
dst[0] = '\0';
|
||
|
||
if (src == NULL)
|
||
return;
|
||
|
||
size_t j = 0;
|
||
for (size_t i = 0; src[i] != '\0' && j + 1 < dstSize; ++i)
|
||
{
|
||
char c = src[i];
|
||
if ((c >= '0' && c <= '9') ||
|
||
(c >= 'a' && c <= 'z') ||
|
||
(c >= 'A' && c <= 'Z') ||
|
||
c == '.' || c == '_' || c == '-')
|
||
{
|
||
dst[j++] = c;
|
||
}
|
||
else
|
||
{
|
||
dst[j++] = '_';
|
||
}
|
||
}
|
||
dst[j] = '\0';
|
||
}
|
||
|
||
static int BuildTempLocalPath(char* outPath,
|
||
size_t outSize,
|
||
chnl_usr_t* chnl_usr,
|
||
const char* remotePath)
|
||
{
|
||
if (outPath == NULL || outSize == 0 || chnl_usr == NULL)
|
||
return -1;
|
||
|
||
const char* fileName = GetFileNameOnly(remotePath);
|
||
if (fileName == NULL || fileName[0] == '\0')
|
||
fileName = "tmp_file.dat";
|
||
|
||
const char* ipStr = chnl_usr->ip_str;
|
||
if (ipStr == NULL || ipStr[0] == '\0')
|
||
ipStr = "unknown_ip";
|
||
|
||
char safeIp[128] = {0};
|
||
SafePathName(ipStr, safeIp, sizeof(safeIp));
|
||
|
||
char dirPath[512] = {0};
|
||
snprintf(dirPath, sizeof(dirPath), "/tmp/%s", safeIp);
|
||
|
||
/* 目录不存在则创建 */
|
||
if (MakeDirRecursive(dirPath) != 0)
|
||
{
|
||
printf("BuildTempLocalPath mkdir failed: %s\n", dirPath);
|
||
return -1;
|
||
}
|
||
|
||
snprintf(outPath, outSize, "%s/%s", dirPath, fileName);
|
||
return 0;
|
||
}
|
||
|
||
static int HandleTypeDownloadAndUpload(chnl_usr_t* chnl_usr,
|
||
file_dir_req_t* req,
|
||
std::string& jsonString)
|
||
{
|
||
if (chnl_usr == NULL || req == NULL || chnl_usr->net_info == NULL)
|
||
return -1;
|
||
|
||
char localpath[512] = {0};
|
||
if (BuildTempLocalPath(localpath, sizeof(localpath), chnl_usr, req->path) != 0)
|
||
{
|
||
DIY_ERRORLOG_CODE("process",0, LOG_CODE_TRANSIENT_COMM,
|
||
"【ERROR】构造本地临时路径失败 devid=%s path=%s",
|
||
req->devid, req->path);
|
||
|
||
jsonString = BuildSingleFileRespJson(req, NULL, "file", 1, -1);
|
||
return -1;
|
||
}
|
||
|
||
ST_RET ret = mms_getFile(chnl_usr->net_info,
|
||
(ST_CHAR*)localpath,
|
||
(ST_CHAR*)req->path,
|
||
3 * g_pt61850app->mmsOpTimeout);
|
||
|
||
if (ret != SD_SUCCESS)
|
||
{
|
||
DIY_ERRORLOG_CODE("process",0, LOG_CODE_TRANSIENT_COMM,
|
||
"【ERROR】装置文件下载失败 devid=%s, rem=%s, ret=0x%X",
|
||
req->devid, req->path, ret);
|
||
|
||
jsonString = BuildSingleFileRespJson(req, NULL, "file", 1, ret);
|
||
return -1;
|
||
}
|
||
|
||
DIY_INFOLOG_CODE(req->devid,1, LOG_CODE_FILE_CONTROL,
|
||
"【NORMAL】装置文件下载成功 devid=%s, rem=%s, local=%s",
|
||
req->devid, req->path, localpath);
|
||
|
||
char wavepath[512] = {0};
|
||
SendFileWeb(WEB_FILEUPLOAD, localpath, req->path, wavepath);
|
||
|
||
jsonString = BuildSingleFileRespJson(req,
|
||
(wavepath[0] != 0 ? wavepath : req->path),
|
||
"file",
|
||
1,
|
||
0);
|
||
remove(localpath);
|
||
|
||
return 0;
|
||
}
|
||
|
||
///////////传输
|
||
static int HandleTypeTransferToDevice(chnl_usr_t* chnl_usr,
|
||
file_dir_req_t* req,
|
||
std::string& jsonString)
|
||
{
|
||
if (chnl_usr == NULL || req == NULL || chnl_usr->net_info == NULL)
|
||
return -1;
|
||
|
||
char localpath[512] = {0};
|
||
if (BuildTempLocalPath(localpath, sizeof(localpath), chnl_usr, req->remote_path) != 0)
|
||
{
|
||
DIY_ERRORLOG_CODE(req->devid,1, LOG_CODE_FILE_CONTROL,
|
||
"【ERROR】构造本地临时路径失败 devid=%s path=%s",
|
||
req->devid, req->remote_path);
|
||
|
||
jsonString = BuildSingleFileRespJson(req, NULL, "file", 1, -1);
|
||
return -1;
|
||
}
|
||
|
||
int dlRet = DownloadFileWeb(WEB_FILEDOWNLOAD, req->remote_path, localpath);
|
||
if (dlRet != 0)
|
||
{
|
||
DIY_ERRORLOG_CODE(req->devid,1, LOG_CODE_FILE_CONTROL,
|
||
"【ERROR】Web 文件下载失败 devid=%s, path=%s",
|
||
req->devid, req->remote_path);
|
||
|
||
jsonString = BuildSingleFileRespJson(req, NULL, "file", 1, -1);
|
||
return -1;
|
||
}
|
||
|
||
DIY_INFOLOG_CODE(req->devid,1, LOG_CODE_FILE_CONTROL,
|
||
"【NORMAL】Web 文件下载成功 devid=%s, webpath=%s, local=%s",
|
||
req->devid, req->remote_path, localpath);
|
||
|
||
ST_RET ret = mms_mvla_obtfile(chnl_usr->net_info,
|
||
(ST_CHAR*)localpath, //本地路径
|
||
(ST_CHAR*)req->path, //装置路径
|
||
3 * g_pt61850app->mmsOpTimeout);
|
||
|
||
if (ret != SD_SUCCESS)
|
||
{
|
||
DIY_ERRORLOG_CODE(req->devid,1, LOG_CODE_FILE_CONTROL,
|
||
"【ERROR】文件传送到装置失败 devid=%s, src=%s, dest=%s, ret=0x%X",
|
||
req->devid, localpath, req->path, ret);
|
||
|
||
jsonString = BuildSingleFileRespJson(req, NULL, "file", 1, ret);
|
||
return -1;
|
||
}
|
||
|
||
DIY_INFOLOG_CODE(req->devid,1, LOG_CODE_FILE_CONTROL,
|
||
"【NORMAL】文件传送到装置成功 devid=%s, src=%s, dest=%s",
|
||
req->devid, localpath, req->path);
|
||
|
||
jsonString = BuildSingleFileRespJson(req,
|
||
req->path,
|
||
"file",
|
||
1,
|
||
0);
|
||
|
||
remove(localpath);
|
||
return 0;
|
||
}
|
||
|
||
void HandleFileDirReqForChannel(chnl_usr_t *chnl_usr)
|
||
{
|
||
if (chnl_usr == NULL || chnl_usr->chnl == NULL || chnl_usr->chnl->ied == NULL)
|
||
return;
|
||
|
||
ied_t *ied = chnl_usr->chnl->ied;
|
||
ied_usr_t *ied_usr = GET_IEDEXT_ADDR(ied);
|
||
if (ied_usr == NULL)
|
||
return;
|
||
|
||
if (ied_usr->terminal_id[0] == 0)
|
||
return;
|
||
|
||
file_dir_req_t *req = PopMatchedFileDirReq(ied_usr->terminal_id);
|
||
if (req == NULL)
|
||
return; // 当前连接没有文件请求
|
||
|
||
DIY_INFOLOG_CODE(req->devid,1, LOG_CODE_FILE_CONTROL,
|
||
"【NORMAL】处理文件请求 terminal_id=%s type=%d path=%s",
|
||
req->devid, req->type, req->path);
|
||
|
||
std::string jsonString;
|
||
int handleRet = -1;
|
||
|
||
if (req->type == 0)
|
||
{
|
||
/* 目录查询 */
|
||
char **filenames = NULL;
|
||
int filenum = 0;
|
||
|
||
ST_RET ret = mms_mvla_fdir(chnl_usr->net_info,
|
||
(ST_CHAR*)req->path,
|
||
3 * g_pt61850app->mmsOpTimeout,
|
||
&filenames,
|
||
&filenum,
|
||
g_pt61850app->tmp_pool);
|
||
|
||
jsonString = BuildFileDirRespJson(req,
|
||
filenames,
|
||
filenum,
|
||
(ret == SD_SUCCESS) ? 0 : ret);
|
||
|
||
DIY_INFOLOG_CODE(req->devid,1, LOG_CODE_FILE_CONTROL,
|
||
"【NORMAL】目录请求处理完成 terminal_id=%s ret=0x%X filenum=%d",
|
||
req->devid, ret, filenum);
|
||
|
||
handleRet = (ret == SD_SUCCESS) ? 0 : -1;
|
||
}
|
||
else if (req->type == 1)
|
||
{
|
||
/* 装置下载到本地，再上传 Web */
|
||
handleRet = HandleTypeDownloadAndUpload(chnl_usr, req, jsonString);
|
||
}
|
||
else if (req->type == 2)
|
||
{
|
||
/* Web 下载到本地，再传送到装置 /etc */
|
||
handleRet = HandleTypeTransferToDevice(chnl_usr, req, jsonString);
|
||
}
|
||
else
|
||
{
|
||
DIY_WARNLOG_CODE(req->devid,1, LOG_CODE_FILE_CONTROL,
|
||
"【WARN】未知文件请求类型 type=%d devid=%s path=%s",
|
||
req->type, req->devid, req->path);
|
||
|
||
jsonString = BuildSingleFileRespJson(req, NULL, "file", 1, 1);//1是失败
|
||
handleRet = -1;
|
||
}
|
||
|
||
/* 统一回 Kafka */
|
||
Ckafka_data_t dir_info;
|
||
dir_info.strTopic = QString::fromStdString(Topic_Reply_Topic);
|
||
dir_info.mp_id = QString::fromLocal8Bit(req->guid);
|
||
dir_info.strText = QString::fromStdString(jsonString);
|
||
|
||
kafka_data_list_mutex.lock();
|
||
kafka_data_list.append(dir_info);
|
||
kafka_data_list_mutex.unlock();
|
||
|
||
delete req;
|
||
}
|
||
|
||
/////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
||
int find_dev_index_from_dev_id(std::string dev_id)
|
||
{
|
||
ied_t* ied = NULL;
|
||
int iedno;
|
||
ied_usr_t* ied_usr = NULL;
|
||
for (iedno = 0; iedno < g_node->n_clients; iedno++) {
|
||
ied = g_node->clients[iedno];
|
||
ied_usr = (ied_usr_t*)ied->usr_ext;
|
||
if (ied_usr && strcmp(ied_usr->terminal_id, dev_id.c_str()) == 0) {
|
||
return ied_usr->dev_idx;
|
||
}
|
||
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
int find_mp_index_from_mp_id(std::string line)
|
||
{
|
||
LD_info_t* LD_info = NULL;
|
||
LD_info = find_LD_info_only_from_mp_id((char*)line.c_str());
|
||
if(LD_info == NULL){
|
||
return 0;
|
||
}
|
||
else{
|
||
return LD_info->line_id;
|
||
}
|
||
|
||
}
|
||
|
||
char* find_mp_name_from_mp_id(const char* mp_id)
|
||
{
|
||
LD_info_t* LD_info = NULL;
|
||
LD_info = find_LD_info_only_from_mp_id((char*)mp_id);
|
||
if(LD_info == NULL){
|
||
return 0;
|
||
}
|
||
else{
|
||
return LD_info->name;
|
||
}
|
||
|
||
}
|
||
|
||
//int myMessageCallbackrtdata(CPushConsumer* consumer, CMessageExt* msg)
|
||
ConsumeStatus myMessageCallbackrtdata(
|
||
const rocketmq::MQMessageExt& msg)
|
||
{
|
||
if(INITFLAG != 1)return rocketmq::RECONSUME_LATER;//防止崩溃
|
||
|
||
if (!should_process_after_start(msg)) {
|
||
std::cout << "[MQ] skip old message: "
|
||
<< "topic=" << msg.getTopic()
|
||
<< ", queueId=" << msg.getQueueId()
|
||
<< ", offset=" << msg.getQueueOffset()
|
||
<< ", bornTs=" << msg.getBornTimestamp()
|
||
<< ", appStart=" << G_APP_START_MS
|
||
<< std::endl;
|
||
|
||
return rocketmq::CONSUME_SUCCESS;
|
||
}
|
||
|
||
/*if (msg == NULL) {
|
||
std::cerr << "Received null message." << std::endl;
|
||
//return E_RECONSUME_LATER;
|
||
return rocketmq::RECONSUME_LATER;
|
||
}*/
|
||
if (msg.getBody().empty()) {
|
||
std::cout << "empty msg body" << std::endl;
|
||
}
|
||
|
||
//const char* body = GetMessageBody(msg);
|
||
//const char* key = GetMessageKeys(msg);
|
||
std::string body = msg.getBody();
|
||
std::string key = msg.getKeys();
|
||
std::string tag = msg.getTags();
|
||
std::string topic = msg.getTopic();
|
||
|
||
//if (body == NULL) {
|
||
if (body.empty()) {
|
||
std::cerr << "Message body is NULL." << std::endl;
|
||
//return E_RECONSUME_LATER;
|
||
return rocketmq::RECONSUME_LATER;
|
||
}
|
||
else{
|
||
//记录日志
|
||
DIY_INFOLOG_CODE("process",0,LOG_CODE_RT_DATA,"【NORMAL】前置消费topic:%s_%s的实时触发消息",FRONT_INST.c_str(),G_MQCONSUMER_TOPIC_RT.c_str());
|
||
|
||
// 处理消息（例如，打印消息内容）
|
||
std::cout << "rt data Callback received message: " << body << std::endl;
|
||
//if (key) {
|
||
if (!key.empty()) {
|
||
std::cout << "Message Key: " << key << std::endl;
|
||
}
|
||
else {
|
||
std::cout << "Message Key: N/A" << std::endl;
|
||
}
|
||
|
||
//处理消费数据
|
||
std::string devid, line;
|
||
bool realData, soeData;
|
||
int limit;
|
||
// 解析 JSON 数据
|
||
if (!parseJsonMessageRT(body, devid, line, realData, soeData, limit)) {
|
||
std::cerr << "Failed to parse the JSON message." << std::endl;
|
||
//记录日志
|
||
DIY_ERRORLOG_CODE("process",0,LOG_CODE_RT_DATA,"【ERROR】前置消费topic:%s_%s的实时触发消息失败,消息的json格式不正确",FRONT_INST.c_str(),G_MQCONSUMER_TOPIC_RT.c_str());
|
||
//return E_RECONSUME_LATER;
|
||
return rocketmq::RECONSUME_LATER;
|
||
}
|
||
|
||
//mq处理实时数据指令查询台账时添加锁
|
||
pthread_mutex_lock(&mtx); std::cout << "rtdata hold lock !!!!!!!!!!!" << std::endl;
|
||
|
||
int dev_index = find_dev_index_from_dev_id(devid);
|
||
int mp_index = find_mp_index_from_mp_id(line);
|
||
|
||
pthread_mutex_unlock(&mtx); std::cout << "rtdata free lock !!!!!!!!!!!" << std::endl;
|
||
|
||
if(dev_index == 0 || mp_index == 0){
|
||
std::cerr << "dev index or mp index is 0" << std::endl;
|
||
//return E_RECONSUME_LATER;
|
||
return rocketmq::RECONSUME_LATER;
|
||
}
|
||
// 创建 XML 文件
|
||
if (!createXmlFile(dev_index, mp_index, realData, soeData, limit,"new")) {
|
||
DIY_ERRORLOG_CODE("process",0,LOG_CODE_RT_DATA,"【ERROR】前置无法创建实时数据触发文件");
|
||
std::cerr << "Failed to create the XML file." << std::endl;
|
||
//return E_RECONSUME_LATER;
|
||
return rocketmq::RECONSUME_LATER;
|
||
}
|
||
|
||
}
|
||
|
||
// 根据业务逻辑决定返回状态
|
||
//return E_CONSUME_SUCCESS;
|
||
return rocketmq::CONSUME_SUCCESS;
|
||
}
|
||
|
||
//int myMessageCallbackupdate(CPushConsumer* consumer, CMessageExt* msg)
|
||
ConsumeStatus myMessageCallbackupdate(
|
||
const rocketmq::MQMessageExt& msg)
|
||
{
|
||
if(INITFLAG != 1)return rocketmq::RECONSUME_LATER;//防止崩溃
|
||
|
||
if (!should_process_after_start(msg)) {
|
||
std::cout << "[MQ] skip old message: "
|
||
<< "topic=" << msg.getTopic()
|
||
<< ", queueId=" << msg.getQueueId()
|
||
<< ", offset=" << msg.getQueueOffset()
|
||
<< ", bornTs=" << msg.getBornTimestamp()
|
||
<< ", appStart=" << G_APP_START_MS
|
||
<< std::endl;
|
||
|
||
return rocketmq::CONSUME_SUCCESS;
|
||
}
|
||
|
||
/*if (msg == NULL) {
|
||
std::cerr << "Received null message." << std::endl;
|
||
//return E_RECONSUME_LATER;
|
||
return rocketmq::RECONSUME_LATER;
|
||
}*/
|
||
if (msg.getBody().empty()) {
|
||
std::cout << "empty msg body" << std::endl;
|
||
}
|
||
|
||
//const char* body = GetMessageBody(msg);
|
||
//const char* key = GetMessageKeys(msg);
|
||
std::string body = msg.getBody();
|
||
std::string key = msg.getKeys();
|
||
std::string tag = msg.getTags();
|
||
std::string topic = msg.getTopic();
|
||
|
||
//if (body == NULL) {
|
||
if (body.empty()) {
|
||
std::cerr << "Message body is empty." << std::endl;
|
||
//return E_RECONSUME_LATER;
|
||
return rocketmq::RECONSUME_LATER;
|
||
}
|
||
else{
|
||
|
||
//处理消费数据
|
||
std::cout << "ledger update Callback received message: " << body << std::endl;
|
||
//if (key) {
|
||
if (!key.empty()) {
|
||
std::cout << "Message Key: " << key << std::endl;
|
||
}
|
||
else {
|
||
std::cout << "Message Key: N/A" << std::endl;
|
||
}
|
||
|
||
//处理台账更新消息
|
||
if(RECALL_ONLY_FLAG != 1 || (g_node_id != STAT_DATA_BASE_NODE_ID)) {
|
||
std::string updatefilepath = "/FeProject/etc/ledgerupdate";
|
||
if(parse_control(body,updatefilepath)){
|
||
DIY_ERRORLOG_CODE("process",0,LOG_CODE_LEDGER_UPDATE,"【ERROR】前置的%s%d号进程处理topic:%s_%s的台账更新消息失败,消息的json结构不正确",get_front_msg_from_subdir(), g_front_seg_index,FRONT_INST.c_str(),G_MQCONSUMER_TOPIC_UD.c_str());
|
||
}
|
||
}
|
||
else{
|
||
printf("only process recall config, skip ledger update\n");
|
||
DIY_WARNLOG_CODE("process",0,LOG_CODE_SPACE_ALARM,"【WARN】当前配置为仅日志模式,统计数据进程跳过台账更新");
|
||
}
|
||
|
||
}
|
||
|
||
// 根据业务逻辑决定返回状态
|
||
//return E_CONSUME_SUCCESS;
|
||
return rocketmq::CONSUME_SUCCESS;
|
||
}
|
||
|
||
//int myMessageCallbackset(CPushConsumer* consumer, CMessageExt* msg)
|
||
ConsumeStatus myMessageCallbackset(
|
||
const rocketmq::MQMessageExt& msg)
|
||
{
|
||
if(INITFLAG != 1)return rocketmq::RECONSUME_LATER;//防止崩溃
|
||
|
||
if (!should_process_after_start(msg)) {
|
||
std::cout << "[MQ] skip old message: "
|
||
<< "topic=" << msg.getTopic()
|
||
<< ", queueId=" << msg.getQueueId()
|
||
<< ", offset=" << msg.getQueueOffset()
|
||
<< ", bornTs=" << msg.getBornTimestamp()
|
||
<< ", appStart=" << G_APP_START_MS
|
||
<< std::endl;
|
||
|
||
return rocketmq::CONSUME_SUCCESS;
|
||
}
|
||
|
||
/*if (msg == NULL) {
|
||
std::cerr << "Received null message." << std::endl;
|
||
//return E_RECONSUME_LATER;
|
||
return rocketmq::RECONSUME_LATER;
|
||
}*/
|
||
if (msg.getBody().empty()) {
|
||
std::cout << "empty msg body" << std::endl;
|
||
}
|
||
|
||
//const char* body = GetMessageBody(msg);
|
||
//const char* key = GetMessageKeys(msg);
|
||
std::string body = msg.getBody();
|
||
std::string key = msg.getKeys();
|
||
std::string tag = msg.getTags();
|
||
std::string topic = msg.getTopic();
|
||
|
||
//if (body == NULL) {
|
||
if (body.empty()) {
|
||
std::cerr << "Message body is NULL." << std::endl;
|
||
//return E_RECONSUME_LATER;
|
||
return rocketmq::RECONSUME_LATER;
|
||
}
|
||
else{
|
||
//处理消费数据
|
||
std::cout << "process Callback received message: " << body << std::endl;
|
||
//if (key) {
|
||
if (!key.empty()) {
|
||
std::cout << "Message Key: " << key << std::endl;
|
||
}
|
||
else {
|
||
std::cout << "Message Key: N/A" << std::endl;
|
||
}
|
||
|
||
//处理进程更新消息
|
||
if(parse_set(body)){
|
||
DIY_ERRORLOG_CODE("process",0,LOG_CODE_PROCESS_CONTROL,"【ERROR】前置的%s%d号进程处理topic:%s_%s的进程控制消息失败,消息的json结构不正确",get_front_msg_from_subdir(), g_front_seg_index,FRONT_INST.c_str(),G_MQCONSUMER_TOPIC_SET.c_str());
|
||
}
|
||
|
||
}
|
||
|
||
// 根据业务逻辑决定返回状态
|
||
//return E_CONSUME_SUCCESS;
|
||
return rocketmq::CONSUME_SUCCESS;
|
||
}
|
||
|
||
//int myMessageCallbacklog(CPushConsumer* consumer, CMessageExt* msg)
|
||
ConsumeStatus myMessageCallbacklog(
|
||
const rocketmq::MQMessageExt& msg)
|
||
{
|
||
if(INITFLAG != 1)return rocketmq::RECONSUME_LATER;//防止崩溃
|
||
|
||
if (!should_process_after_start(msg)) {
|
||
std::cout << "[MQ] skip old message: "
|
||
<< "topic=" << msg.getTopic()
|
||
<< ", queueId=" << msg.getQueueId()
|
||
<< ", offset=" << msg.getQueueOffset()
|
||
<< ", bornTs=" << msg.getBornTimestamp()
|
||
<< ", appStart=" << G_APP_START_MS
|
||
<< std::endl;
|
||
|
||
return rocketmq::CONSUME_SUCCESS;
|
||
}
|
||
|
||
/*if (msg == NULL) {
|
||
std::cerr << "Received null message." << std::endl;
|
||
//return E_RECONSUME_LATER;
|
||
return rocketmq::RECONSUME_LATER;
|
||
}*/
|
||
if (msg.getBody().empty()) {
|
||
std::cout << "empty msg body" << std::endl;
|
||
}
|
||
|
||
//const char* body = GetMessageBody(msg);
|
||
//const char* key = GetMessageKeys(msg);
|
||
std::string body = msg.getBody();
|
||
std::string key = msg.getKeys();
|
||
std::string tag = msg.getTags();
|
||
std::string topic = msg.getTopic();
|
||
|
||
//if (body == NULL) {
|
||
if (body.empty()) {
|
||
std::cerr << "Message body is NULL." << std::endl;
|
||
//return E_RECONSUME_LATER;
|
||
return rocketmq::RECONSUME_LATER;
|
||
}
|
||
else{
|
||
//处理消费数据
|
||
std::cout << "process Callback received message: " << body << std::endl;
|
||
//if (key) {
|
||
if (!key.empty()) {
|
||
std::cout << "Message Key: " << key << std::endl;
|
||
}
|
||
else {
|
||
std::cout << "Message Key: N/A" << std::endl;
|
||
}
|
||
|
||
//处理进程更新消息
|
||
if(parse_log(body)){
|
||
DIY_ERRORLOG_CODE("process",0,LOG_CODE_LOG_REQUEST,"【ERROR】前置的%s%d号进程处理topic:%s_%s的日志上送消息失败,消息的json结构不正确",get_front_msg_from_subdir(), g_front_seg_index,FRONT_INST.c_str(),G_MQCONSUMER_TOPIC_LOG.c_str());
|
||
}
|
||
|
||
}
|
||
|
||
// 根据业务逻辑决定返回状态
|
||
//return E_CONSUME_SUCCESS;
|
||
return rocketmq::CONSUME_SUCCESS;
|
||
}
|
||
|
||
//int myMessageCallbackrecall(CPushConsumer* consumer, CMessageExt* msg)
|
||
ConsumeStatus myMessageCallbackrecall(
|
||
const rocketmq::MQMessageExt& msg)
|
||
{
|
||
if(INITFLAG != 1)return rocketmq::RECONSUME_LATER;//防止崩溃
|
||
|
||
if (!should_process_after_start(msg)) {
|
||
std::cout << "[MQ] skip old message: "
|
||
<< "topic=" << msg.getTopic()
|
||
<< ", queueId=" << msg.getQueueId()
|
||
<< ", offset=" << msg.getQueueOffset()
|
||
<< ", bornTs=" << msg.getBornTimestamp()
|
||
<< ", appStart=" << G_APP_START_MS
|
||
<< std::endl;
|
||
|
||
return rocketmq::CONSUME_SUCCESS;
|
||
}
|
||
|
||
//调试
|
||
std::cout << "myMessageCallbackrecall"<< std::endl;
|
||
|
||
/*if (msg == NULL) {
|
||
std::cerr << "Received null message." << std::endl;
|
||
//return E_RECONSUME_LATER;
|
||
return rocketmq::RECONSUME_LATER;
|
||
}*/
|
||
if (msg.getBody().empty()) {
|
||
std::cout << "empty msg body" << std::endl;
|
||
}
|
||
|
||
//const char* body = GetMessageBody(msg);
|
||
//const char* key = GetMessageKeys(msg);
|
||
std::string body = msg.getBody();
|
||
std::string key = msg.getKeys();
|
||
std::string tag = msg.getTags();
|
||
std::string topic = msg.getTopic();
|
||
|
||
//if (body == NULL) {
|
||
if (body.empty()) {
|
||
std::cerr << "Message body is NULL." << std::endl;
|
||
//return E_RECONSUME_LATER;
|
||
return rocketmq::RECONSUME_LATER;
|
||
}
|
||
else{
|
||
// 处理消息（例如，打印消息内容）
|
||
std::cout << "recall Callback received message: " << body << std::endl;
|
||
//if (key) {
|
||
if (!key.empty()) {
|
||
std::cout << "Message Key: " << key << std::endl;
|
||
}
|
||
else {
|
||
std::cout << "Message Key: N/A" << std::endl;
|
||
}
|
||
//处理消费数据
|
||
std::string result = extractDataJson(body.c_str()); // 使用 std::string 代替 malloc
|
||
|
||
//调试
|
||
std::cout << "extractDataJson:"<< result.c_str() <<std::endl;
|
||
|
||
if (!result.empty()) {
|
||
pthread_mutex_lock(&mtx); std::cout << "recall mq hold lock !!!!!!!!!!!" << std::endl;
|
||
recall_json_handle(result.c_str()); // 使用 c_str() 获取 const char* 类型
|
||
pthread_mutex_unlock(&mtx); std::cout << "recall mq free lock !!!!!!!!!!!" << std::endl;
|
||
}
|
||
else{
|
||
std::cerr << "recall data is NULL." << std::endl;
|
||
DIY_ERRORLOG_CODE("process",0,LOG_CODE_RECALL,"【ERROR】前置的%s%d号进程处理topic:%s_%s的补招触发消息失败,消息的json结构不正确",get_front_msg_from_subdir(), g_front_seg_index,FRONT_INST.c_str(),G_MQCONSUMER_TOPIC_RC.c_str());
|
||
}
|
||
|
||
}
|
||
|
||
// 根据业务逻辑决定返回状态
|
||
//return E_CONSUME_SUCCESS;
|
||
return rocketmq::CONSUME_SUCCESS;
|
||
}
|
||
|
||
//int myMessageCallbackfile(CPushConsumer* consumer, CMessageExt* msg)
|
||
ConsumeStatus myMessageCallbackfile(
|
||
const rocketmq::MQMessageExt& msg)
|
||
{
|
||
if (INITFLAG != 1)return rocketmq::RECONSUME_LATER;
|
||
|
||
if (!should_process_after_start(msg)) {
|
||
std::cout << "[MQ] skip old message: "
|
||
<< "topic=" << msg.getTopic()
|
||
<< ", queueId=" << msg.getQueueId()
|
||
<< ", offset=" << msg.getQueueOffset()
|
||
<< ", bornTs=" << msg.getBornTimestamp()
|
||
<< ", appStart=" << G_APP_START_MS
|
||
<< std::endl;
|
||
|
||
return rocketmq::CONSUME_SUCCESS;
|
||
}
|
||
|
||
/*if (msg == NULL) {
|
||
std::cerr << "Received null message." << std::endl;
|
||
//return E_RECONSUME_LATER;
|
||
return rocketmq::RECONSUME_LATER;
|
||
}*/
|
||
if (msg.getBody().empty()) {
|
||
std::cout << "empty msg body" << std::endl;
|
||
}
|
||
|
||
//const char* body = GetMessageBody(msg);
|
||
//const char* key = GetMessageKeys(msg);
|
||
std::string body = msg.getBody();
|
||
std::string key = msg.getKeys();
|
||
std::string tag = msg.getTags();
|
||
std::string topic = msg.getTopic();
|
||
|
||
//if (body == NULL) {
|
||
if (body.empty()) {
|
||
std::cerr << "Message body is NULL." << std::endl;
|
||
//return E_RECONSUME_LATER;
|
||
return rocketmq::RECONSUME_LATER;
|
||
}
|
||
|
||
DIY_INFOLOG_CODE("process",0,LOG_CODE_FILE_CONTROL,"【NORMAL】前置消费topic:%s_%s的文件控制消息",
|
||
FRONT_INST.c_str(), G_MQCONSUMER_TOPIC_FILE.c_str());
|
||
|
||
std::cout << "file Callback received message: " << body << std::endl;
|
||
std::cout << "Message Key: " << (key.empty() ? "N/A" : key) << std::endl;
|
||
|
||
file_dir_req_t req;
|
||
if (ParseFileDirReq(body.c_str(), &req) != 0)
|
||
{
|
||
DIY_WARNLOG_CODE(req.devid,1,LOG_CODE_FILE_CONTROL,"【WARN】文件控制消息解析失败: %s", body);
|
||
//return E_RECONSUME_LATER;
|
||
return rocketmq::RECONSUME_LATER;
|
||
}
|
||
|
||
PushFileDirReq(&req);
|
||
|
||
DIY_INFOLOG_CODE(req.devid,1, LOG_CODE_FILE_CONTROL,
|
||
"【NORMAL】文件目录请求已入队 guid=%s devid=%s path=%s",
|
||
req.guid, req.devid, req.path);
|
||
|
||
//return E_CONSUME_SUCCESS;
|
||
return rocketmq::CONSUME_SUCCESS;
|
||
}
|
||
|
||
//lnk20260424修改消费者topic去除id，id在配置文件中放入每个topic的tag
|
||
void mqconsumerThread::run()
|
||
{
|
||
// 配置消费者参数
|
||
std::string consumerName = G_ROCKETMQ_CONSUMER;//配置文件的消费者名称
|
||
std::string nameServer = G_MQCONSUMER_IPPORT; // NameServer地址
|
||
|
||
|
||
// 定义多个主题、标签及其对应的回调函数
|
||
std::vector<Subscription> subscriptions;
|
||
// 初始化消费者1 //lnk20241230只有实时进程会订阅实时topic，不订阅实时topic的进程无法触发实时数据
|
||
if(g_node_id == THREE_SECS_DATA_BASE_NODE_ID){
|
||
|
||
//lnk20260310添加文件管理
|
||
subscriptions.push_back(Subscription(G_MQCONSUMER_TOPIC_FILE, G_MQCONSUMER_TAG_FILE, myMessageCallbackfile));
|
||
subscriptions.push_back(Subscription(G_MQCONSUMER_TOPIC_RT, G_MQCONSUMER_TAG_RT, myMessageCallbackrtdata));
|
||
}
|
||
|
||
// 初始化消费者2 //所有进程都会订阅台账更新topic，不同功能进程的台账不能互相影响
|
||
subscriptions.push_back(Subscription(G_MQCONSUMER_TOPIC_UD, G_MQCONSUMER_TAG_UD, myMessageCallbackupdate));
|
||
|
||
// 初始化消费者3 //lnk20241230只有补招进程会订阅补招topic，不订阅补招topic的进程无法触发补招数据
|
||
if(g_node_id == RECALL_HIS_DATA_BASE_NODE_ID){
|
||
subscriptions.push_back(Subscription(G_MQCONSUMER_TOPIC_RC, G_MQCONSUMER_TAG_RC, myMessageCallbackrecall));
|
||
}
|
||
|
||
// 初始化消费者4 //lnk20250108只有稳态进程1会控制reset，
|
||
subscriptions.push_back(Subscription(G_MQCONSUMER_TOPIC_SET, G_MQCONSUMER_TAG_SET, myMessageCallbackset));
|
||
|
||
// 初始化消费者5 //所有进程都会订阅日志上送topic，不同功能进程的日志上送不能互相影响
|
||
subscriptions.push_back(Subscription(G_MQCONSUMER_TOPIC_LOG, G_MQCONSUMER_TAG_LOG, myMessageCallbacklog));
|
||
|
||
try {
|
||
rocketmq_consumer_receive(consumerName, nameServer, subscriptions);
|
||
}
|
||
catch (const std::exception& e) {
|
||
std::cerr << "Exception during consumerUD setup: " << e.what() << std::endl;
|
||
}
|
||
|
||
// 程序运行中，消费者会通过回调处理消息
|
||
std::cout << "Consumer is running. " << std::endl;
|
||
|
||
}
|
||
|
||
//CZY 2023-08-23 get double class voltage level, if false will return 0;
|
||
double get_voltage_level(char voltage_level_char[]) {
|
||
try
|
||
{
|
||
int n = atoi(voltage_level_char);
|
||
|
||
switch (n)
|
||
{
|
||
case 1://交流6V
|
||
return 0.006;
|
||
case 2://交流12V
|
||
return 0.012;
|
||
case 3://交流24V
|
||
return 0.024;
|
||
case 4://交流36V
|
||
return 0.036;
|
||
case 5://交流48V
|
||
return 0.048;
|
||
case 6://交流110V
|
||
return 0.11;
|
||
case 7://交流220V
|
||
return 0.22;
|
||
case 8://交流380V（含400V）
|
||
return 0.38;
|
||
case 9://交流660V
|
||
return 0.66;
|
||
case 10://交流1000V（含1140V）
|
||
return 1;
|
||
case 11://交流600V
|
||
return 0.6;
|
||
case 12://交流750V
|
||
return 0.75;
|
||
case 13://交流1500V
|
||
return 1.5;
|
||
case 14://交流2000V
|
||
return 2.0;
|
||
case 15://交流2500V
|
||
return 2.5;
|
||
case 20://交流3kV
|
||
return 3;
|
||
case 21://交流6kV
|
||
return 6;
|
||
case 22://交流10kV
|
||
return 10;
|
||
case 23://交流15.75kV
|
||
return 15.75;
|
||
case 24://交流20kV
|
||
return 20;
|
||
case 25://交流35kV
|
||
return 35;
|
||
case 30://交流66kV
|
||
return 66;
|
||
case 31://交流72.5kV
|
||
return 72.5;
|
||
case 32://交流110kV
|
||
return 110;
|
||
case 33://交流220kV
|
||
return 220;
|
||
case 34://交流330kV
|
||
return 330;
|
||
case 35://交流500kV
|
||
return 500;
|
||
case 36://交流750kV
|
||
return 750;
|
||
case 37://交流1000kV
|
||
return 1000;
|
||
case 51://直流6V
|
||
return 0.006;
|
||
case 52://直流12V
|
||
return 0.012;
|
||
case 53://直流24V
|
||
return 0.024;
|
||
case 54://直流36V
|
||
return 0.036;
|
||
case 55://直流48V
|
||
return 0.048;
|
||
case 56://直流110V
|
||
return 0.11;
|
||
case 60://直流220V
|
||
return 0.22;
|
||
case 70://直流600V
|
||
return 0.6;
|
||
case 71://直流750V
|
||
return 0.75;
|
||
case 72://直流1500V
|
||
return 1.5;
|
||
case 73://直流3000V
|
||
return 3.0;
|
||
case 76://直流35kV
|
||
return 35;
|
||
case 77://直流30kV
|
||
return 30;
|
||
case 78://直流50kV
|
||
return 50;
|
||
case 80://直流120kV
|
||
return 120;
|
||
case 81://直流125kV
|
||
return 125;
|
||
case 82://直流400kV
|
||
return 400;
|
||
case 83://直流500kV
|
||
return 500;
|
||
case 84://直流660kV
|
||
return 660;
|
||
case 85://直流800kV
|
||
return 800;
|
||
case 86://直流1000kV
|
||
return 1000;
|
||
case 87://直流200kV
|
||
return 200;
|
||
case 88://直流320kV。
|
||
return 320;
|
||
default:
|
||
return 0;
|
||
break;
|
||
}
|
||
|
||
}
|
||
catch (const std::exception&)
|
||
{
|
||
//error
|
||
return 0;
|
||
}
|
||
}
|
||
|
||
void try_start_kafka_thread()
|
||
{
|
||
static int kafka_thread_created = 0;
|
||
if (!kafka_thread_created) {
|
||
myThrd.start();
|
||
kafka_thread_created = 1;
|
||
}
|
||
}
|
||
|
||
//lnk20241213
|
||
void try_start_mqconsumer_thread()
|
||
{
|
||
static int mqconsumer_thread_created = 0;
|
||
if (!mqconsumer_thread_created) {
|
||
mqconsumerThrd.start();
|
||
mqconsumer_thread_created = 1;
|
||
}
|
||
}
|
||
|
||
/////////////////////////////////////////////////////////////////////////
|
||
json_block_data json_blkd;
|
||
|
||
//CZY 2023-08-17 WW 2022年12月6日14:09:08 增加多个ICD支持
|
||
//json_block_data json_blkd; //json拼接参数类对象,原有的一个数据对象，在多ICD下会出现数据错位问题
|
||
//解决方案是将此数据放入LDInfo结构中存储，保证一条线路一个json拼接参数类对象
|
||
void init_json_block_data(char mp_id[], char voltage_level[], int flicker_flag)//WW 2023年3月13日16:38:41 多ICD修改
|
||
{
|
||
|
||
json_block_data* pdata;
|
||
if (flicker_flag == 1) {
|
||
if (!json_flicker_data_map.contains(mp_id))
|
||
{
|
||
pdata = new json_block_data();
|
||
json_flicker_data_map.insert(mp_id, pdata);
|
||
}
|
||
pdata = json_flicker_data_map.value(mp_id);
|
||
}
|
||
else if (flicker_flag == 0) {
|
||
if (!json_data_map.contains(mp_id))
|
||
{
|
||
pdata = new json_block_data();
|
||
json_data_map.insert(mp_id, pdata);
|
||
}
|
||
pdata = json_data_map.value(mp_id);
|
||
}
|
||
else if (flicker_flag == 2) {
|
||
if (!json_pst_data_map.contains(mp_id))
|
||
{
|
||
pdata = new json_block_data();
|
||
json_pst_data_map.insert(mp_id, pdata);
|
||
}
|
||
pdata = json_pst_data_map.value(mp_id);
|
||
}
|
||
|
||
if (pdata == NULL)
|
||
return;
|
||
pdata->monitorId = -1;
|
||
QString tmp;
|
||
tmp.append(mp_id);
|
||
pdata->mp_id = tmp;
|
||
pdata->func_type = g_node_id;
|
||
//flag 是品质， 异常送1， 正常送0
|
||
pdata->flag = 0; // //剔除标记，1不剔除，0剔除，默认剔除
|
||
pdata->mms_str_map.clear();
|
||
pdata->voltage_level = get_voltage_level(voltage_level); //CZY 2023-08-23 add voltage_level
|
||
}
|
||
|
||
|
||
|
||
int json_block_create_start(char voltage_level[], char monid_char[], int flicker_flag, char temcode[], int line_id)//WW 2023年3月13日16:38 : 41 多ICD修改
|
||
{
|
||
try_start_kafka_thread();
|
||
|
||
init_json_block_data(monid_char, voltage_level, flicker_flag);
|
||
json_block_data* pdata;
|
||
if (flicker_flag == 1) {
|
||
if (!json_flicker_data_map.contains(monid_char))//未查到数据
|
||
return 0;
|
||
pdata = json_flicker_data_map.value(monid_char);
|
||
}
|
||
else if (flicker_flag == 0)
|
||
{
|
||
if (!json_data_map.contains(monid_char))//未查到数据
|
||
return 0;
|
||
pdata = json_data_map.value(monid_char);
|
||
}
|
||
else if (flicker_flag == 2)
|
||
{
|
||
if (!json_pst_data_map.contains(monid_char))//未查到数据
|
||
return 0;
|
||
pdata = json_pst_data_map.value(monid_char);
|
||
}
|
||
|
||
if (pdata != NULL)
|
||
{
|
||
pdata->dev_type.append(temcode);
|
||
pdata->monitorId = line_id;
|
||
if (strlen(monid_char) != 0) {
|
||
QString tmp;
|
||
tmp.append(monid_char);
|
||
pdata->mp_id = tmp;
|
||
}
|
||
else {
|
||
monid_char = "not define";
|
||
QString tmp;
|
||
tmp.append(monid_char);
|
||
pdata->mp_id = tmp;
|
||
}
|
||
}
|
||
|
||
printf("\n\n---------- json_block_create_start: mp_id=%s,voltage_level=%s,line_id=%d \n", monid_char, voltage_level, line_id);
|
||
return TRUE;
|
||
}
|
||
|
||
|
||
int json_block_create_time(char monid_char[], long long Time, int flicker_flag)//WW 2023年3月13日16:38:41 多ICD修改
|
||
{
|
||
json_block_data* pdata;
|
||
if (flicker_flag == 1) {
|
||
if (!json_flicker_data_map.contains(monid_char))//未查到数据
|
||
return 0;
|
||
pdata = json_flicker_data_map.value(monid_char);
|
||
}
|
||
else if (flicker_flag == 0)
|
||
{
|
||
if (!json_data_map.contains(monid_char))//未查到数据
|
||
return 0;
|
||
pdata = json_data_map.value(monid_char);
|
||
}
|
||
else if (flicker_flag == 2)
|
||
{
|
||
if (!json_pst_data_map.contains(monid_char))//未查到数据
|
||
return 0;
|
||
pdata = json_pst_data_map.value(monid_char);
|
||
}
|
||
|
||
if (pdata != NULL)
|
||
pdata->time = Time;
|
||
printf("\njson_block_create_time: mp_id=%s,Time=%lld \n", monid_char, Time);
|
||
return TRUE;
|
||
}
|
||
|
||
|
||
int json_block_create_flag(char monid_char[], int flag, int flicker_flag)//WW 2023年3月13日16:38:41 多ICD修改
|
||
{
|
||
json_block_data* pdata;
|
||
if (flicker_flag == 1) {
|
||
if (!json_flicker_data_map.contains(monid_char))//未查到数据
|
||
return 0;
|
||
pdata = json_flicker_data_map.value(monid_char);
|
||
}
|
||
else if (flicker_flag == 0)
|
||
{
|
||
if (!json_data_map.contains(monid_char))//未查到数据
|
||
return 0;
|
||
pdata = json_data_map.value(monid_char);
|
||
}
|
||
else if (flicker_flag == 2)
|
||
{
|
||
if (!json_pst_data_map.contains(monid_char))//未查到数据
|
||
return 0;
|
||
pdata = json_pst_data_map.value(monid_char);
|
||
}
|
||
|
||
if (pdata != NULL)
|
||
pdata->flag = flag;
|
||
printf("\njson_block_create_flag: mp_id=%s,flag=%d \n", monid_char, flag);
|
||
return TRUE;
|
||
}
|
||
|
||
|
||
|
||
int json_block_create_data(char monid_char[], char* mms_str, double v, int flicker_flag)//WW 2023年3月13日16:38:41 多ICD修改
|
||
{
|
||
json_block_data* pdata;
|
||
if (flicker_flag == 1) {
|
||
if (!json_flicker_data_map.contains(monid_char))//未查到数据
|
||
return 0;
|
||
pdata = json_flicker_data_map.value(monid_char);
|
||
}
|
||
else if (flicker_flag == 0)
|
||
{
|
||
if (!json_data_map.contains(monid_char))//未查到数据
|
||
return 0;
|
||
pdata = json_data_map.value(monid_char);
|
||
}
|
||
else if (flicker_flag == 2)
|
||
{
|
||
if (!json_pst_data_map.contains(monid_char))//未查到数据
|
||
return 0;
|
||
pdata = json_pst_data_map.value(monid_char);
|
||
}
|
||
|
||
static int count = 0;
|
||
if (pdata != NULL)
|
||
{
|
||
pdata->mms_str_map.insert(QString::fromAscii(mms_str), v);
|
||
if (strstr(mms_str, "MMXU2$MX$PhV")){
|
||
pdata->data_have_statistic = 1;
|
||
printf("---------- json_block_create_data: mp_id= %s ,mms_str=%s value=%fkV----------\n", monid_char, mms_str, v);
|
||
}
|
||
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
|
||
//lnk2024-8-16添加接线参数
|
||
int json_block_create_end(char v_wiring_type[], char monid_char[], int flicker_flag)//WW 2023年3月13日16:38:41 多ICD修改
|
||
{
|
||
json_block_data* pdata;
|
||
if (flicker_flag == 1) {
|
||
if (!json_flicker_data_map.contains(monid_char))//未查到数据
|
||
{
|
||
printf("---------- json_block_create_end: mp_id= %s json_flicker_data_map can't find MonitorId----------\n", monid_char);
|
||
return 1;
|
||
}
|
||
pdata = json_flicker_data_map.value(monid_char);
|
||
}
|
||
else if (flicker_flag == 0)
|
||
{
|
||
if (!json_data_map.contains(monid_char))//未查到数据
|
||
{
|
||
printf("---------- json_block_create_end: mp_id= %s json_data_map can't find MonitorId----------\n", monid_char);
|
||
return 1;
|
||
}
|
||
pdata = json_data_map.value(monid_char);
|
||
}
|
||
else if (flicker_flag == 2)
|
||
{
|
||
if (!json_pst_data_map.contains(monid_char))//未查到数据
|
||
{
|
||
printf("---------- json_block_create_end: mp_id= %s json_pst_data_map can't find MonitorId----------\n", monid_char);
|
||
return 1;
|
||
}
|
||
pdata = json_pst_data_map.value(monid_char);
|
||
}
|
||
|
||
//调试用
|
||
/*if (pdata != nullptr) {
|
||
printf("monitorId: %d\n", pdata->monitorId);
|
||
printf("func_type: %d\n", pdata->func_type);
|
||
printf("flag: %d\n", pdata->flag);
|
||
printf("time: %lld\n", pdata->time);
|
||
printf("voltage_level: %f\n", pdata->voltage_level);
|
||
printf("mp_id: %s\n", pdata->mp_id.toStdString().c_str());
|
||
printf("dev_type: %s\n", pdata->dev_type.toStdString().c_str());
|
||
printf("mms_str_map count: %d\n", pdata->mms_str_map.size());
|
||
} else {
|
||
printf("pdata is NULL\n");
|
||
}*/
|
||
|
||
if (pdata->mms_str_map.count() == 0) {
|
||
if (flicker_flag == 1) {
|
||
json_flicker_data_map.remove(monid_char);
|
||
}
|
||
else if (flicker_flag == 0)
|
||
{
|
||
json_data_map.remove(monid_char);
|
||
|
||
}
|
||
else if (flicker_flag == 2)
|
||
{
|
||
json_pst_data_map.remove(monid_char);
|
||
|
||
}
|
||
printf("---------- json_block_create_end: pdata->mms_str_map.count() == 0 ----------\n");
|
||
return 1;
|
||
}
|
||
//lnk2024-8-16添加接线参数
|
||
int ret = transfer_json_block_data(v_wiring_type, pdata);
|
||
|
||
if (pdata != NULL)
|
||
delete pdata;
|
||
if (flicker_flag == 1) {
|
||
json_flicker_data_map.remove(monid_char);
|
||
}
|
||
else if (flicker_flag == 0)
|
||
{
|
||
json_data_map.remove(monid_char);
|
||
|
||
}
|
||
else if (flicker_flag == 2)
|
||
{
|
||
json_pst_data_map.remove(monid_char);
|
||
|
||
}
|
||
printf("---------- json_block_create_end: MonitorId= %s ----------\n", monid_char);
|
||
return ret;
|
||
}
|
||
|
||
//////////////////////////////////////////////////////////////////////////////
|
||
|
||
void clear_old_comtrade_files()
|
||
{
|
||
if (g_node_id != SOE_COMTRADE_BASE_NODE_ID)
|
||
return;
|
||
|
||
QString full_fn_str;
|
||
QString dir_name("../comtrade/");
|
||
QDir directory_comtrade(dir_name);
|
||
QStringList fileNames = directory_comtrade.entryList(QDir::Files | QDir::NoDotAndDotDot, QDir::Time);
|
||
|
||
if (fileNames.size() <= comtrade_remain_file_num)
|
||
return;
|
||
|
||
for (QStringList::size_type i = comtrade_remain_file_num; i != fileNames.size(); ++i) {
|
||
full_fn_str = dir_name + fileNames.at(i);
|
||
QFile::remove(full_fn_str);
|
||
}
|
||
}
|
||
|
||
/////////////////////////////////////////////
|
||
|
||
int process_login_verify()
|
||
{
|
||
int length = 64;
|
||
char password[64 + 1];
|
||
char* p = NULL;
|
||
int count = 0;
|
||
char encode_password[256];
|
||
const char* passwordConfirm = "1c0e4e104de596846648ba495bd32601";
|
||
|
||
memset(password, 0, sizeof(password));
|
||
printf("Please input password : \n");
|
||
p = password;
|
||
count = 0;
|
||
|
||
system("stty -echo");
|
||
std::cin.getline(password, 64);
|
||
system("stty echo");
|
||
|
||
password[length] = '\0';
|
||
|
||
MyGetSM4Code(password, (unsigned char*)"epri.sgcc.com.cn", encode_password);
|
||
|
||
return (strcmp(encode_password, passwordConfirm));
|
||
|
||
|
||
}
|
||
|
||
|
||
///////////////////////////////////////////
|
||
|
||
void try_start_socket_thread()
|
||
{
|
||
static int socket_thread_created = 0;
|
||
if (!socket_thread_created) {
|
||
socketThrd.start();
|
||
socket_thread_created = 1;
|
||
}
|
||
}
|
||
|
||
//lnk20241029
|
||
void try_start_web_http_thread()
|
||
{
|
||
static int webhttp_thread_created = 0;
|
||
if (!webhttp_thread_created) {
|
||
webhttpThrd.start();
|
||
webhttp_thread_created = 1;
|
||
}
|
||
}
|
||
void try_start_http_thread()
|
||
{
|
||
static int http_thread_created = 0;
|
||
if (!http_thread_created) {
|
||
httpThrd.start();
|
||
http_thread_created = 1;
|
||
}
|
||
}
|
||
//lnk20241202
|
||
int try_start_mqtest_thread(int argc, char *argv[])
|
||
{
|
||
//不使用简单的循环线程，而是启动一个app，不仅执行循环线程，而且可以连接输入
|
||
//安装qt打印
|
||
qInstallMsgHandler(myQtMsgHandler);
|
||
|
||
QCoreApplication a(argc, argv);
|
||
|
||
// 创建 QThread 和 Worker 对象
|
||
QThread *thread = new QThread();
|
||
Worker *worker = new Worker();
|
||
|
||
// 将 Worker 对象移动到 QThread 中
|
||
worker->moveToThread(thread);
|
||
|
||
// 连接信号和槽
|
||
QObject::connect(thread, SIGNAL(started()), worker, SLOT(startServer()));
|
||
QObject::connect(worker, SIGNAL(serverError()), thread, SLOT(quit()));
|
||
QObject::connect(worker, SIGNAL(serverError()), worker, SLOT(deleteLater()));
|
||
QObject::connect(thread, SIGNAL(finished()), thread, SLOT(deleteLater()));
|
||
|
||
// 启动线程
|
||
thread->start();
|
||
|
||
// 确保在应用退出时，线程也能正确退出
|
||
QObject::connect(&a, SIGNAL(aboutToQuit()), thread, SLOT(quit()));
|
||
|
||
return a.exec();
|
||
}
|
||
|
||
void try_start_ontimer_thread()
|
||
{
|
||
static int ontimer_thread_created = 0;
|
||
if (!ontimer_thread_created) {
|
||
onTimerThrd.start();
|
||
ontimer_thread_created = 1;
|
||
}
|
||
}
|
||
//WW 2023-08-22 end
|
||
|
||
///////////////////////////////////////////
|
||
//ZW 2024-01-31 补招数据模式优化
|
||
static QMap<QString, int> mvl_type_ctrl_map;//ZW 2024-01-31 用于保存单次获取的模型
|
||
static int mvl_type_ctrl_map_size;//计数
|
||
//添加doname对应的数据模型
|
||
void add_mvl_type_ctrl(char doname[], int ctrl)
|
||
{
|
||
if (!mvl_type_ctrl_map.contains(doname))
|
||
{
|
||
mvl_type_ctrl_map.insert(doname, ctrl);
|
||
}
|
||
}
|
||
|
||
//删除map中所有数据模型
|
||
void del_mvl_type_ctrl()
|
||
{
|
||
for (QMap<QString, int>::iterator it = mvl_type_ctrl_map.begin(); it != mvl_type_ctrl_map.end(); ++it) {
|
||
QString key = it.key();
|
||
int value = it.value();
|
||
mvl_type_id_destroy(value);
|
||
}
|
||
mvl_type_ctrl_map.clear();
|
||
}
|
||
|
||
int get_mvl_type_ctrl_map_size()
|
||
{
|
||
return mvl_type_ctrl_map.count();
|
||
}
|
||
//查找对应doname的数据模型是否存在map中
|
||
int sel_mvl_type_ctrl_flag(char doname[])
|
||
{
|
||
if (mvl_type_ctrl_map.contains(doname))
|
||
{
|
||
return mvl_type_ctrl_map.value(doname);
|
||
}
|
||
else
|
||
{
|
||
return -1;
|
||
}
|
||
}
|
||
//ZW 2024-01-31 end
|