zhangwen/front_linux
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

modify recall

Browse Source
This commit is contained in:
lnk
2025-10-15 16:29:54 +08:00
parent 24e1bf0125
commit c55f2ab1af
3 changed files with 352 additions and 248 deletions
Download Patch File Download Diff File Expand all files Collapse all files

359
LFtid1056/cloudfront/code/cfg_parser.cpp
View File

@@ -205,7 +205,10 @@ std::vector<std::string> TESTARRAY; //解析的列表数组
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////其他文件定义的函数引用声明
bool enqueue_direct_download(const std::string& dev_id,
const std::string& monitor_id,
const std::string& filename,
const std::vector<std::string>& dir_candidates);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////当前文件函数声明
@@ -1060,6 +1063,49 @@ void create_recall_xml()
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////补招部分
// 工具函数：将时间字符串转为 time_t（秒级）
// ▲新增：从 monitorId 提取结尾数字（不含前导非数字部分），失败返回空串
static std::string extract_monitor_digits(const std::string& monitorId) {
// 例： "00B78D0171091" -> "171091"（按你的“对应的数字”的规则可定制）
// 这里实现：取 monitorId 中最后一段连续数字
std::string digits;
for (int i = static_cast<int>(monitorId.size()) - 1; i >= 0; --i) {
if (std::isdigit(static_cast<unsigned char>(monitorId[i]))) {
digits.push_back(monitorId[i]);
} else if (!digits.empty()) {
break;
}
}
std::reverse(digits.begin(), digits.end());
return digits;
}
// ▲新增：把 "YYYY-MM-DD HH:MM:SS[.ffffff]" -> "YYYYMMDDHHMMSS"（忽略小数部分）
static std::string compact_ts_for_filename(const std::string& ts) {
// 允许 "2025-10-10 14:38:07.000000"
// 输出 "20251010143807"
std::string ymdhms;
ymdhms.reserve(14);
for (size_t i = 0; i < ts.size(); ++i) {
char c = ts[i];
if (std::isdigit(static_cast<unsigned char>(c))) {
ymdhms.push_back(c);
if (ymdhms.size() == 14) break;
}
}
return (ymdhms.size() == 14) ? ymdhms : std::string();
}
// ▲新增：按“数字_时间后缀.后缀”拼直下文件名（返回{*.cfg, *.dat}两种）
static std::vector<std::string> build_direct_filenames(const std::string& monitorDigits,
const std::string& ts_compact)
{
std::vector<std::string> out;
if (monitorDigits.empty() || ts_compact.empty()) return out;
out.push_back(monitorDigits + "_" + ts_compact + ".cfg");
out.push_back(monitorDigits + "_" + ts_compact + ".dat");
return out;
}
static long long parse_time_to_epoch(const std::string& time_str) {
std::tm tm = {};
std::istringstream ss(time_str);
@@ -1138,9 +1184,9 @@ int recall_json_handle_from_mq(const std::string& body)
}
// 解析 messageBody 内层 JSON
nlohmann::json messageBody;
nlohmann::json mb;
try {
messageBody = nlohmann::json::parse(messageBodyStr);
mb = nlohmann::json::parse(messageBodyStr);
} catch (const std::exception& e) {
std::cerr << "Failed to parse 'messageBody' JSON: " << e.what() << std::endl;
DIY_ERRORLOG("process","【ERROR】前置的%d号进程处理topic:%s_%s的补招触发消息失败,messageBody的json结构不正确",
@@ -1148,210 +1194,148 @@ int recall_json_handle_from_mq(const std::string& body)
return 10004;
}
// 提取 guid 并立即回执
if (!messageBody.contains("guid") || !messageBody["guid"].is_string()) {
std::cerr << "'guid' is missing or is not a string" << std::endl;
DIY_ERRORLOG("process","【ERROR】前置的%d号进程处理topic:%s_%s的补招触发消息失败,没有guid字段",
g_front_seg_index, FRONT_INST.c_str(), G_MQCONSUMER_TOPIC_RC.c_str());
return 10004;
}
std::string guid = messageBody["guid"].get<std::string>();
//send_reply_to_queue(guid, static_cast<int>(ResponseCode::OK), "收到补招指令");
if (mb.is_array()) {
// ====== 新格式（数组）：支持 dataType=0/1 的区间补招 & dataType=2 的直下文件 ======
for (const auto& rec : mb) {
if (!rec.is_object()) continue;
// 提取 data 数组
if (!messageBody.contains("data") || !messageBody["data"].is_array()) {
std::cerr << "'data' is missing or is not an array" << std::endl;
DIY_ERRORLOG("process","【ERROR】前置的%d号进程处理topic:%s_%s的补招触发消息失败,没有data字段",
g_front_seg_index, FRONT_INST.c_str(), G_MQCONSUMER_TOPIC_RC.c_str());
return 10004;
}
// 仅用于保留你原先的调试输出
std::string data_dump;
try { data_dump = messageBody["data"].dump(); } catch (...) { data_dump.clear(); }
std::cout << "parseJsonMessageRC: " << data_dump << std::endl;
// 必要字段
std::string guid = rec.value("guid", "");
std::string terminalId = rec.value("terminalId", "");
if (terminalId.empty()) continue;
// 不指定稳态/暂态则全部补招
int stat = 0;
int voltage = 0;
// 2. 遍历每个补招项（这里直接用已解析的 messageBody["data"]）
for (auto& item : messageBody["data"]) {
// 获取必需字段
// ★修改：强制要求 terminalId；
if (!item.contains("terminalId") ||
!item.contains("monitor") ||
!item.contains("timeInterval") ||
!item.contains("dataType"))
{
std::cout << "json内容解析错误" << std::endl;
return 10000;
}
// ★新增：读取 terminalId（必填）
std::string terminalId = item["terminalId"].get<std::string>();
if (terminalId.empty()) {
std::cout << "terminalId为空" << std::endl;
continue;
}
// 2.1 解析 dataType（仅保留稳态/暂态）
std::string datatype = item["dataType"].get<std::string>();
if (!datatype.empty()) {
if (datatype == "0" || datatype == "稳态" || datatype == "steady" || datatype == "STEADY") {
stat = 1; voltage = 0; // 稳态
} else if (datatype == "1" || datatype == "暂态" || datatype == "voltage" || datatype == "VOLTAGE") {
stat = 0; voltage = 1; // 暂态
} else {
stat = voltage = 1; // 其他情况按全补
}
} else {
stat = voltage = 1; // 全补
}
// ★新增：定位并校验该 terminal 是否归属当前进程
std::lock_guard<std::mutex> lock(ledgermtx);
const terminal_dev* targetDev = NULL;
for (std::vector<terminal_dev>::const_iterator it = terminal_devlist.begin();
it != terminal_devlist.end(); ++it)
{
if (it->terminal_id == terminalId) {
targetDev = &(*it);
break;
}
}
if (!targetDev) {
std::cout << "terminalId未匹配当前进程内装置: " << terminalId << std::endl;
continue;
}
// 添加判断装置在线，不注册guid，异步补招
if (ClientManager::instance().get_dev_status(targetDev->terminal_id) != 1) {
std::cout << "terminalId对应装置不在线: " << targetDev->terminal_id << std::endl;
// 响应 web
std::string msg = std::string("装置：") + targetDev->terminal_name + " 不在线，无法补招";
send_reply_to_kafka_recall("12345", "2", static_cast<int>(ResponseCode::INTERNAL_ERROR), msg, targetDev->terminal_id, "", "", "");
continue;//处理下一个装置的补招记录
}
// ★新增：按新结构解析 monitor 层级
nlohmann::json& monitors = item["monitor"];
if (!monitors.is_array() || monitors.empty()) {
std::cout << "monitor数组为空或非数组类型" << std::endl;
continue;
}
for (auto& mobj : monitors) {
if (!mobj.contains("monitorId") || !mobj.contains("timeInterval")) {
std::cout << "monitor项缺少 monitorId 或 timeInterval" << std::endl;
continue;
// ▲dataType 可能是字符串"0"/"1"或数字2
int dt = -1;
if (rec["dataType"].is_number_integer()) {
dt = rec["dataType"].get<int>();
} else if (rec["dataType"].is_string()) {
std::string s = rec["dataType"].get<std::string>();
if (s == "0") dt = 0; else if (s == "1") dt = 1;
}
std::string monitorId = mobj["monitorId"].get<std::string>();
if (monitorId.empty()) continue;
// 不只是判断存在，还要拿到指针 lm 以便后续 push_back
ledger_monitor* lm = NULL;
// 注意：这里需要非常量指针，取 const_cast 后遍历
terminal_dev* dev_nc = const_cast<terminal_dev*>(targetDev);
for (std::vector<ledger_monitor>::iterator itLm = dev_nc->line.begin();
itLm != dev_nc->line.end(); ++itLm)
{
if (!itLm->monitor_id.empty() && itLm->monitor_id == monitorId) {
lm = &(*itLm);
break;
// 统一 monitorId 为数组形式
std::vector<std::string> monitors;
if (rec.contains("monitorId")) {
if (rec["monitorId"].is_array()) {
for (auto& m : rec["monitorId"]) if (m.is_string()) monitors.push_back(m.get<std::string>());
} else if (rec["monitorId"].is_string()) {
monitors.push_back(rec["monitorId"].get<std::string>());
}
}
if (!lm) {
std::cout << "monitorId未在terminal内找到: " << monitorId
<< " @ " << terminalId << std::endl;
continue;
}
if (monitors.empty()) continue;
nlohmann::json& tiArr = mobj["timeInterval"];
if (!tiArr.is_array() || tiArr.empty()) {
std::cout << "timeInterval为空或非数组类型: monitorId=" << monitorId << std::endl;
continue;
}
// 这里拆分时间段并 push 到 lm->recall_list / lm->recall_list_static
for (auto& timeItem : tiArr) {
std::string ti = timeItem.get<std::string>();
std::string::size_type pos = ti.find('~');
if (pos == std::string::npos) {
std::cout << "timeInterval格式错误: " << ti << std::endl;
// ▲沿用：校验终端归属 + 在线性
{
std::lock_guard<std::mutex> lock(ledgermtx);
const terminal_dev* targetDev = NULL;
for (std::vector<terminal_dev>::const_iterator it = terminal_devlist.begin(); it != terminal_devlist.end(); ++it) {
if (it->terminal_id == terminalId) { targetDev = &(*it); break; }
}
if (!targetDev) { std::cout << "terminalId未匹配当前进程内装置: " << terminalId << std::endl; continue; }
if (ClientManager::instance().get_dev_status(targetDev->terminal_id) != 1) {
std::cout << "terminalId对应装置不在线: " << targetDev->terminal_id << std::endl;
std::string msg = std::string("装置：") + targetDev->terminal_name + " 不在线，无法补招";
send_reply_to_kafka_recall("12345", "2", static_cast<int>(ResponseCode::INTERNAL_ERROR), msg, targetDev->terminal_id, "", "", "");
continue;
}
std::string start = ti.substr(0, pos);
std::string end = ti.substr(pos + 1);
}
// 仅对 recall_list（事件）进行 1 小时拆分；recall_list_static（稳态）不拆分
{
// 公共字段（整体区间，不拆分）用于 recall_list_static
RecallFile rm_all; // ★类型正确：稳态列表的元素
rm_all.recall_status = 0; // 初始状态：未补招
rm_all.StartTime = start; // 直接使用字符串
rm_all.EndTime = end;
rm_all.STEADY = std::to_string(stat);
rm_all.VOLTAGE = std::to_string(voltage);
if (dt == 2) {
// ▲直下文件：timeList -> fun1/fun2 -> enqueue_direct_download
if (!rec.contains("timeList") || !rec["timeList"].is_array()) continue;
// 仅当需要事件补招（voltage==1）时，才进行 1 小时拆分并压入 recall_list
if (voltage == 1) {
// 拆分时间段为 1 小时一段，并存入 recall_list
std::vector<RecallInfo> recallinfo_list_hour;
Get_Recall_Time_Char(start, end, recallinfo_list_hour);
for (const auto& monId : monitors) {
// fun1：提取 monitor 数字
std::string digits = extract_monitor_digits(monId);
if (digits.empty()) { std::cout << "monitorId数字提取失败: " << monId << std::endl; continue; }
for (std::size_t i = 0; i < recallinfo_list_hour.size(); ++i) {
const RecallInfo& info = recallinfo_list_hour[i];
for (const auto& t : rec["timeList"]) {
if (!t.is_string()) continue;
std::string ts_compact = compact_ts_for_filename(t.get<std::string>());
if (ts_compact.empty()) { std::cout << "时间解析失败: " << t << std::endl; continue; }
RecallMonitor rm; // ★类型正确：事件列表的元素
rm.recall_status = 0; // 初始状态：未补招
rm.StartTime = epoch_to_datetime_str(info.starttime);
rm.EndTime = epoch_to_datetime_str(info.endtime);
rm.STEADY = std::to_string(stat);
rm.VOLTAGE = std::to_string(voltage);
lm->recall_list.push_back(rm);
// 事件补招列表（recall_list）调试打印
std::cout << "[recall_json_handle] terminal=" << terminalId
<< " monitor=" << monitorId
<< " [recall_list] start=" << lm->recall_list.back().StartTime
<< " end=" << lm->recall_list.back().EndTime
<< " steady="<< lm->recall_list.back().STEADY
<< " voltage="<< lm->recall_list.back().VOLTAGE
<< std::endl;
// fun2：生成 *.cfg/*.dat 两个文件名
std::vector<std::string> fns = build_direct_filenames(digits, ts_compact);
// 加入候选目录（使用 RecallFile 缺省的四个；如需定制可在此传自定义列表）
static const std::vector<std::string> DIRS {
"/cf/COMTRADE", "/bd0/COMTRADE", "/sd0/COMTRADE", "/sd0:1/COMTRADE"
};
for (const auto& fn : fns) {
bool ok = enqueue_direct_download(terminalId, monId, fn, DIRS);
std::cout << "[direct] enqueue " << (ok ? "ok " : "fail ")
<< "dev=" << terminalId << " mon=" << monId
<< " file=" << fn << std::endl;
}
}
}
} else if (dt == 0 || dt == 1) {
// ▲保持老逻辑（与“对象+data”一致）：timeInterval 数组
if (!rec.contains("timeInterval") || !rec["timeInterval"].is_array()) continue;
// 仅当需要稳态补招（stat==1）时，不拆分，直接压入 recall_list_static
if (stat == 1) {
lm->recall_list_static.push_back(rm_all); // 不拆分，整体区间
// 解析 dataType-> stat/voltage
int stat = (dt == 0) ? 1 : 0;
int voltage = (dt == 1) ? 1 : 0;
// 稳态补招列表（recall_list_static）调试打印
std::cout << "[recall_json_handle] terminal=" << terminalId
<< " monitor=" << monitorId
<< " [recall_list_static] start=" << lm->recall_list_static.back().StartTime
<< " end=" << lm->recall_list_static.back().EndTime
<< " steady="<< lm->recall_list_static.back().STEADY
<< " voltage="<< lm->recall_list_static.back().VOLTAGE
<< std::endl;
// 把每个 monitor 的区间写入 recall_list / recall_list_static
std::lock_guard<std::mutex> lock(ledgermtx);
// 找终端
terminal_dev* dev_nc = NULL;
for (auto& d : terminal_devlist) if (d.terminal_id == terminalId) { dev_nc = &d; break; }
if (!dev_nc) continue;
for (const auto& monId : monitors) {
// 找监测点
ledger_monitor* lm = NULL;
for (auto itLm = dev_nc->line.begin(); itLm != dev_nc->line.end(); ++itLm) {
if (!itLm->monitor_id.empty() && itLm->monitor_id == monId) { lm = &(*itLm); break; }
}
if (!lm) { std::cout << "monitorId未在terminal内找到: " << monId << " @ " << terminalId << std::endl; continue; }
// 非法输入保护（保留你原来的保护与返回码）
if (stat == 0 && voltage == 0) {
std::cout << "[recall_json_handle] skip: stat=0 && voltage=0, monitor=" << monitorId
<< " terminal=" << terminalId
<< " start=" << rm_all.StartTime
<< " end=" << rm_all.EndTime
<< std::endl;
return 10003;
for (const auto& ti : rec["timeInterval"]) {
if (!ti.is_string()) continue;
std::string s = ti.get<std::string>();
std::string::size_type pos = s.find('~');
if (pos == std::string::npos) { std::cout << "timeInterval格式错误: " << s << std::endl; continue; }
std::string start = s.substr(0, pos);
std::string end = s.substr(pos + 1);
RecallFile rm_all;
rm_all.recall_status = 0;
rm_all.StartTime = start;
rm_all.EndTime = end;
rm_all.STEADY = std::to_string(stat);
rm_all.VOLTAGE = std::to_string(voltage);
if (voltage == 1) {
std::vector<RecallInfo> recallinfo_list_hour;
Get_Recall_Time_Char(start, end, recallinfo_list_hour);
for (size_t i = 0; i < recallinfo_list_hour.size(); ++i) {
const RecallInfo& info = recallinfo_list_hour[i];
RecallMonitor rm;
rm.recall_status = 0;
rm.StartTime = epoch_to_datetime_str(info.starttime);
rm.EndTime = epoch_to_datetime_str(info.endtime);
rm.STEADY = std::to_string(stat);
rm.VOLTAGE = std::to_string(voltage);
lm->recall_list.push_back(rm);
}
}
if (stat == 1) {
lm->recall_list_static.push_back(rm_all);
}
if (stat == 0 && voltage == 0) return 10003;
}
}
} else {
// 未知 dataType，忽略
continue;
}
}
}
else {
// 不支持的 messageBody 形态
return 10004;
}
}
catch (const std::exception& e) {
std::cout << "处理客户端发送的消息错误，原因：" << e.what() << std::endl;
@@ -4355,15 +4339,14 @@ void check_recall_file() {
auto it = front.dir_files.find(front.cur_dir);
if (it != front.dir_files.end()) {
if (front.direct_mode) {
// ★新增：直下文件（精确匹配文件名）
// ▲直下：支持“目标名列表”
std::set<std::string> want(front.target_filenames.begin(), front.target_filenames.end());
for (const auto& ent : it->second) {
if (ent.flag != 1) continue; // 只要文件
// 安全从 char[64] 转成 std::string
size_t n = ::strnlen(ent.name, sizeof(ent.name));
std::string fname(ent.name, n);
if (fname == front.target_filename) {
if (want.find(fname) != want.end()) {
front.download_queue.push_back(front.cur_dir + "/" + fname);
break; // 找到一个就足够
}
}
} else {
@@ -4546,7 +4529,7 @@ bool enqueue_direct_download(const std::string& dev_id,
rf.EndTime = "1970-01-01 00:00:01";
rf.dir_candidates = dir_candidates; // 传入要检索的目录列表
rf.direct_mode = true; // ★关键：直下文件
rf.target_filename = filename; // ★关键：匹配的目标文件名
rf.target_filenames.push_back(filename); // ▲单个文件名入“列表”
lm_it->recall_list_static.push_back(std::move(rf));