From 833dfd473ec02405f3a96b199a54966b43279925 Mon Sep 17 00:00:00 2001
From: mrDarker <mr.darker@163.com>
Date: 星期三, 09 七月 2025 15:33:59 +0800
Subject: [PATCH] 完成 Auto File Cleanup Tool 核心功能 1. 定期扫描源目录，按目标目录对比文件大小，相同即删除源文件 2. 支持安全模式（仅模拟删除，不执行真正删除） 3. 支持递归删除空文件夹（可选）
---
EdgeInspector_App/WebSocket/WebSocketClient.h | 248 ++++----
EdgeInspector_App/View/ViewMain_HWSetting.cpp | 4
Common_Class/AutoFileCleanupTool/AutoFileCleanupToolDlg.h | 1
Common_Class/AutoFileCleanupTool/AutoFileCleanupToolDlg.cpp | 92 ++
EdgeInspector_App/WebSocket/WebSocketClient.cpp | 646 +++++++++++-----------
EdgeInspector_App/WebSocket/WebSocketClientPool.h | 90 +-
EdgeInspector_App/Process/InspectCamera.cpp | 60 +
EdgeInspector_App/WebSocket/WebSocketClientPool.cpp | 550 +++++++++---------
8 files changed, 889 insertions(+), 802 deletions(-)
diff --git a/Common_Class/AutoFileCleanupTool/AutoFileCleanupToolDlg.cpp b/Common_Class/AutoFileCleanupTool/AutoFileCleanupToolDlg.cpp
index b22c993..2657c2b 100644
--- a/Common_Class/AutoFileCleanupTool/AutoFileCleanupToolDlg.cpp
+++ b/Common_Class/AutoFileCleanupTool/AutoFileCleanupToolDlg.cpp
@@ -9,6 +9,9 @@
#include "afxdialogex.h"
#include "Config.h"
+#include <string>
+#include <functional>
+
#ifdef _DEBUG
#define new DEBUG_NEW
#endif
@@ -82,6 +85,88 @@
, m_bDeleteEmptyFolders(FALSE) // 榛樿涓嶅垹闄ょ┖鏂囦欢澶�
{
m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
+}
+
+void CAutoFileCleanupToolDlg::PerformCleanupTask()
+{
+ // 閬嶅巻婧愮洰褰�
+ CFileFind finder;
+ CString strSearchPath = m_strSourceFolder + _T("\\*.*");
+
+ if (!finder.FindFile(strSearchPath)) {
+ AppendLogLineRichStyled(_T("Source folder not found or empty."), LOG_COLOR_WARNING);
+ return;
+ }
+
+ std::function<void(const CString&)> ProcessFolder;
+ ProcessFolder = [&](const CString& strFolderPath) {
+ CFileFind subFinder;
+ BOOL bWorking = subFinder.FindFile(strFolderPath + _T("\\*.*"));
+ while (bWorking) {
+ bWorking = subFinder.FindNextFile();
+ if (subFinder.IsDots()) {
+ continue;
+ }
+
+ CString srcPath = subFinder.GetFilePath();
+ CString relPath = srcPath.Mid(m_strSourceFolder.GetLength() + 1);
+ CString dstPath = m_strTargetFolder + _T("\\") + relPath;
+
+ if (subFinder.IsDirectory()) {
+ ProcessFolder(srcPath); // 閫掑綊澶勭悊瀛愭枃浠跺す
+ continue;
+ }
+
+ // 姣旇緝鏂囦欢
+ CFileStatus srcStatus, dstStatus;
+ if (CFile::GetStatus(srcPath, srcStatus) && CFile::GetStatus(dstPath, dstStatus)) {
+ if (srcStatus.m_size == dstStatus.m_size) {
+ if (m_bSafeMode) {
+ AppendLogLineRichStyled(_T("Simulated delete: ") + srcPath, LOG_COLOR_WARNING);
+ }
+ else {
+ CFile::Remove(srcPath);
+ if (PathFileExists(srcPath)) {
+ AppendLogLineRichStyled(_T("Failed to delete: ") + srcPath, LOG_COLOR_ERROR);
+ }
+ else {
+ AppendLogLineRichStyled(_T("Deleted: ") + srcPath, LOG_COLOR_SUCCESS);
+ }
+ }
+ }
+ }
+ }
+ subFinder.Close();
+
+ // 鍒犻櫎绌烘枃浠跺す锛堝彲閫夛級
+ if (m_bDeleteEmptyFolders) {
+ BOOL bFound = finder.FindFile(strFolderPath + _T("\\*.*"));
+ BOOL bEmpty = TRUE;
+ while (bFound) {
+ bFound = finder.FindNextFile();
+
+ if (finder.IsDots()) {
+ continue;
+ }
+
+ // 鏈夋枃浠舵垨鏂囦欢澶癸紝涓嶆槸绌虹殑
+ bEmpty = FALSE;
+ break;
+ }
+ finder.Close();
+
+ if (bEmpty) {
+ if (RemoveDirectory(strFolderPath)) {
+ AppendLogLineRichStyled(_T("Deleted empty folder: ") + strFolderPath, LOG_COLOR_SUCCESS);
+ }
+ else {
+ AppendLogLineRichStyled(_T("Failed to delete empty folder: ") + strFolderPath, LOG_COLOR_ERROR);
+ }
+ }
+ }
+ };
+
+ ProcessFolder(m_strSourceFolder);
}
void CAutoFileCleanupToolDlg::SaveSettings()
@@ -458,12 +543,7 @@
// 娓呯悊閫昏緫鏀捐繖閲�
AppendLogLineRichStyled(_T("Performing auto cleanup..."), LOG_COLOR_NORMAL);
- if (m_bSafeMode) {
- AppendLogLineRichStyled(_T("Safe mode: No files will be deleted."), LOG_COLOR_NORMAL);
- }
- else {
- AppendLogLineRichStyled(_T("Scanning and cleaning files..."), LOG_COLOR_NORMAL);
- }
+ PerformCleanupTask();
AppendLogLineRichStyled(_T("Cleanup cycle completed."), LOG_COLOR_SUCCESS);
}
diff --git a/Common_Class/AutoFileCleanupTool/AutoFileCleanupToolDlg.h b/Common_Class/AutoFileCleanupTool/AutoFileCleanupToolDlg.h
index 0c448b5..db19024 100644
--- a/Common_Class/AutoFileCleanupTool/AutoFileCleanupToolDlg.h
+++ b/Common_Class/AutoFileCleanupTool/AutoFileCleanupToolDlg.h
@@ -13,6 +13,7 @@
CAutoFileCleanupToolDlg(CWnd* pParent = nullptr); // 鏍囧噯鏋勯�犲嚱鏁�
private:
+ void PerformCleanupTask();
void SaveSettings();
void LoadSettings();
void StartCleanup();
diff --git a/EdgeInspector_App/Process/InspectCamera.cpp b/EdgeInspector_App/Process/InspectCamera.cpp
index ed0c25f..7c6fa50 100644
--- a/EdgeInspector_App/Process/InspectCamera.cpp
+++ b/EdgeInspector_App/Process/InspectCamera.cpp
@@ -3934,7 +3934,7 @@
double th = (double) m_pRecipe->m_SideParam[(int) emDim].m_NotchPrm[nNotchIdx].m_nReferece_Line_Threshold;
int nNotchCenterOffset = m_pRecipe->m_SideParam[(int) emDim].m_NotchPrm[nNotchIdx].m_nNotchCenter_Offset_pxl;
- cvThreshold(scr, img_Bin_MeasureLine, th, 50, CV_THRESH_BINARY);
+ cvThreshold(scr, img_Bin_MeasureLine, th, 255, CV_THRESH_BINARY);
// 1. Find Seed
CvPoint ptSeed;
@@ -6240,46 +6240,52 @@
BOOL CInspectCamera::ProcessFrame(int iThread,DimensionDir emDim,stFrameIndex stFrame)
{
- // 1. Find End Line.. (Corner甫 力寇茄 Side扼牢阑 茫扁 困秦 End Line何磐 茫绰促)
- FindEndLine(iThread, emDim, stFrame);
+ try {
+ // 1. Find End Line.. (Corner甫 力寇茄 Side扼牢阑 茫扁 困秦 End Line何磐 茫绰促)
+ FindEndLine(iThread, emDim, stFrame);
- // 2. Find Side Line.. (秦寸 橇饭烙俊辑 Corner/Notch 甫 力寇茄 Side 扼牢 茫扁)
+ // 2. Find Side Line.. (秦寸 橇饭烙俊辑 Corner/Notch 甫 力寇茄 Side 扼牢 茫扁)
#if USE_AI_DETECT
- FindSideLine(iThread, emDim, stFrame);
+ FindSideLine(iThread, emDim, stFrame);
#else
- FindSideLine_ExceptNotch(iThread, emDim, stFrame);
+ FindSideLine_ExceptNotch(iThread, emDim, stFrame);
#endif // USE_AI_DETECT
- // 3. Find Top Corner
- FindTopCorner(iThread,emDim,stFrame);
+ // 3. Find Top Corner
+ FindTopCorner(iThread, emDim, stFrame);
- // 4. Find Top Align Mark
- FindTopAlignMark(iThread,emDim,stFrame);
+ // 4. Find Top Align Mark
+ FindTopAlignMark(iThread, emDim, stFrame);
- // 5. Find Bot Corner
- FindBotCorner(iThread,emDim,stFrame);
+ // 5. Find Bot Corner
+ FindBotCorner(iThread, emDim, stFrame);
- // 6. Find Bot Align Mark
- FindBotAlignMark(iThread,emDim,stFrame);
-
+ // 6. Find Bot Align Mark
+ FindBotAlignMark(iThread, emDim, stFrame);
+
#if USE_AI_DETECT
- SendFrameScanDataOverAI(iThread, emDim, stFrame);
+ SendFrameScanDataOverAI(iThread, emDim, stFrame);
#else
- // 7. Inspect Defect
- InspectDefect_Side(iThread, emDim, stFrame);
+ // 7. Inspect Defect
+ InspectDefect_Side(iThread, emDim, stFrame);
- // 8. Notch Process
- Notch_Process(iThread, emDim, stFrame);
+ // 8. Notch Process
+ Notch_Process(iThread, emDim, stFrame);
#endif // USE_WEBSOCKET
- // 9. Measure
- Measure(iThread,emDim,stFrame);
-
- // 10. User Defect
- UserDefect_Process(iThread,emDim,stFrame);
+ // 9. Measure
+ Measure(iThread, emDim, stFrame);
- // 11. Exception Area Process
- ExceptionArea_Process(iThread,emDim,stFrame);
+ // 10. User Defect
+ UserDefect_Process(iThread, emDim, stFrame);
+
+ // 11. Exception Area Process
+ ExceptionArea_Process(iThread, emDim, stFrame);
+ }
+ catch (const std::exception&) {
+ g_pLog->DisplayMessage(_T("Exception in ProcessFrame for Camera %d, Dimension %d"), m_iCamera, (int)emDim);
+ return FALSE;
+ }
return TRUE;
}
diff --git a/EdgeInspector_App/View/ViewMain_HWSetting.cpp b/EdgeInspector_App/View/ViewMain_HWSetting.cpp
index ed24d8b..9b51a4e 100644
--- a/EdgeInspector_App/View/ViewMain_HWSetting.cpp
+++ b/EdgeInspector_App/View/ViewMain_HWSetting.cpp
@@ -806,7 +806,7 @@
void CViewMain_HWSetting::OnClickBrowseCopyToolConfig()
{
CString strFilePath;
- CFileDialog dlg(TRUE, NULL, NULL, OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT, _T("Config Files (*.ffs_real;*.json;*.xml)|*.ffs_real;*.json;*.xml||"), this);
+ CFileDialog dlg(TRUE, NULL, NULL, OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT, _T("Config Files (*.ffs_real;*.json;*.xml;*.ini;*.cfg)|*.ffs_real;*.json;*.xml;*.ini;*.cfg||"), this);
if (dlg.DoModal() == IDOK) {
strFilePath = dlg.GetPathName();
m_pDlgHDSettingParm->m_strCopyToolConfigPath = strFilePath;
@@ -828,7 +828,7 @@
void CViewMain_HWSetting::OnClickBrowseDeleteToolConfig()
{
CString strFilePath;
- CFileDialog dlg(TRUE, NULL, NULL, OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT, _T("Config Files (*.ffs_real;*.json;*.xml;*.ini)|*.ffs_real;*.json;*.xml;*.ini||"), this);
+ CFileDialog dlg(TRUE, NULL, NULL, OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT, _T("Config Files (*.ffs_real;*.json;*.xml;*.ini;*.cfg)|*.ffs_real;*.json;*.xml;*.ini;*.cfg||"), this);
if (dlg.DoModal() == IDOK) {
strFilePath = dlg.GetPathName();
m_pDlgHDSettingParm->m_strDeleteToolConfigPath = strFilePath;
diff --git a/EdgeInspector_App/WebSocket/WebSocketClient.cpp b/EdgeInspector_App/WebSocket/WebSocketClient.cpp
index e02dcc5..84ef4b0 100644
--- a/EdgeInspector_App/WebSocket/WebSocketClient.cpp
+++ b/EdgeInspector_App/WebSocket/WebSocketClient.cpp
@@ -1,326 +1,326 @@
#include "stdafx.h"
#include "WebSocketClient.h"
-WebSocketClient::WebSocketClient() : m_connected(false), m_reconnect(true), m_close_done(false), m_message_received(false), m_heartbeat_interval(5) {
- // 清除之前的客户端配置并重新初始化
- m_client.clear_access_channels(websocketpp::log::alevel::all);
- m_client.clear_error_channels(websocketpp::log::elevel::all);
- m_client.init_asio();
-
- // 设置事件回调
- m_client.set_open_handler([this](websocketpp::connection_hdl hdl) { on_open(hdl); });
- m_client.set_message_handler([this](websocketpp::connection_hdl hdl, message_ptr msg) { on_message(hdl, msg); });
- m_client.set_close_handler([this](websocketpp::connection_hdl hdl) { on_close(hdl); });
- m_client.set_fail_handler([this](websocketpp::connection_hdl hdl) { on_fail(hdl); });
- m_client.set_pong_handler([this](websocketpp::connection_hdl hdl, const std::string& payload) { on_pong(hdl, payload); });
-}
-
-WebSocketClient::~WebSocketClient() {
- close();
-}
-
-void WebSocketClient::connect(const std::string& uri) {
- websocketpp::lib::error_code ec;
- {
- m_connected.store(false);
- m_reconnect.store(false);
- m_client.clear_access_channels(websocketpp::log::alevel::all);
- m_client.clear_error_channels(websocketpp::log::elevel::all);
-
- std::lock_guard<std::mutex> lock(m_mutex); // 保护共享资源
- auto con = m_client.get_connection(uri, ec);
-
- if (ec) {
- std::cerr << "Get connection failed: " << ec.message() << std::endl;
- return;
- }
-
- m_hdl = con->get_handle();
- m_client.connect(con);
- }
-
- // 启动工作线程
- m_thread = std::thread(&WebSocketClient::run, this);
-}
-
-bool WebSocketClient::is_busy() const {
- return m_busy.load();
-}
-
-void WebSocketClient::set_busy(bool busy) {
- m_busy.store(busy);
-}
-
-void WebSocketClient::send(const std::string& message) {
- std::lock_guard<std::mutex> lock(m_mutex);
- if (m_connected.load()) {
- websocketpp::lib::error_code ec;
- m_client.send(m_hdl, message, websocketpp::frame::opcode::text, ec);
- if (ec) {
- std::cerr << "Send failed: " << ec.message() << std::endl;
- }
- }
- else {
- std::cerr << "Not connected, cannot send message." << std::endl;
- }
-}
-
-void WebSocketClient::send_binary(const std::vector<char>& binary_data) {
- std::lock_guard<std::mutex> lock(m_mutex);
- if (m_connected.load()) {
- websocketpp::lib::error_code ec;
- m_client.send(m_hdl, binary_data.data(), binary_data.size(), websocketpp::frame::opcode::binary, ec);
- if (ec) {
- std::cerr << "Send binary data failed: " << ec.message() << std::endl;
- }
- }
- else {
- std::cerr << "Not connected, cannot send binary data." << std::endl;
- }
-}
-
-void WebSocketClient::enqueue_message(const std::string& message) {
- m_message_queue.push(message);
- process_next_message();
-}
-
-void WebSocketClient::enqueue_binary(const std::vector<char>& binary_data) {
- m_binary_queue.push(binary_data);
- process_next_binary();
-}
-
-void WebSocketClient::process_next_message() {
- if (!m_message_queue.empty() && !is_busy()) {
- set_busy(true);
- std::string message = m_message_queue.front();
- m_message_queue.pop();
-
- send(message); // 发送消息
-
- set_busy(false); // 设置为空闲状态，并处理下一个
- process_next_message();
- }
-}
-
-void WebSocketClient::process_next_binary() {
- if (!m_binary_queue.empty() && !is_busy()) {
- set_busy(true);
- std::vector<char> binary_data = m_binary_queue.front();
- m_binary_queue.pop();
-
- send_binary(binary_data); // 发送二进制数据
-
- set_busy(false); // 设置为空闲状态，并处理下一个
- process_next_binary();
- }
-}
-
-bool WebSocketClient::send_and_wait(const std::string& message, int timeout_ms) {
- std::unique_lock<std::mutex> lock(m_mutex);
- m_message_received = false;
-
- if (m_connected.load()) {
- // 发送消息
- websocketpp::lib::error_code ec;
- m_client.send(m_hdl, message, websocketpp::frame::opcode::text, ec);
- if (ec) {
- std::cerr << "Send failed: " << ec.message() << std::endl;
- return false;
- }
-
- // 等待消息或超时
- if (m_cv.wait_for(lock, std::chrono::milliseconds(timeout_ms), [this]() { return m_message_received; })) {
- std::cout << "Server response received." << std::endl;
- return true;
- }
- else {
- std::cerr << "Timeout: No response from server." << std::endl;
- return false;
- }
- }
- else {
- std::cerr << "Not connected, cannot send message." << std::endl;
- }
-}
-
-bool WebSocketClient::send_binary_and_wait(const std::vector<char>& binary_data, int timeout_ms) {
- std::unique_lock<std::mutex> lock(m_mutex);
- m_message_received = false;
-
- if (m_connected.load()) {
- // 发送消息
- websocketpp::lib::error_code ec;
- m_client.send(m_hdl, binary_data.data(), binary_data.size(), websocketpp::frame::opcode::binary, ec);
- if (ec) {
- std::cerr << "Send failed: " << ec.message() << std::endl;
- return false;
- }
-
- // 等待消息或超时
- if (m_cv.wait_for(lock, std::chrono::milliseconds(timeout_ms), [this]() { return m_message_received; })) {
- std::cout << "Server response received." << std::endl;
- return true;
- }
- else {
- std::cerr << "Timeout: No response from server." << std::endl;
- return false;
- }
- }
- else {
- std::cerr << "Not connected, cannot send binary data." << std::endl;
- }
-}
-
-void WebSocketClient::close() {
- if (!m_connected.load()) {
- return;
- }
-
- try {
- m_reconnect.store(false);
- m_client.close(m_hdl, websocketpp::close::status::normal, "Closing connection");
- }
- catch (const std::exception& e) {
- std::cerr << "Error during close: " << e.what() << std::endl;
- }
-
- std::unique_lock<std::mutex> lock(m_mutex);
- m_cv.wait(lock, [this] { return m_close_done; });
- m_close_done = false;
-
- m_client.stop();
- if (m_thread.joinable()) {
- m_thread.join();
- }
-
- m_client.reset();
-}
-
-void WebSocketClient::set_open_handler(OpenHandler handler) {
- std::lock_guard<std::mutex> lock(m_mutex);
- m_open_handler = handler;
-}
-
-void WebSocketClient::set_message_handler(MessageHandler handler) {
- std::lock_guard<std::mutex> lock(m_mutex);
- m_message_handler = handler;
-}
-
-void WebSocketClient::set_close_handler(CloseHandler handler) {
- std::lock_guard<std::mutex> lock(m_mutex);
- m_close_handler = handler;
-}
-
-void WebSocketClient::set_fail_handler(FailHandler handler) {
- std::lock_guard<std::mutex> lock(m_mutex);
- m_fail_handler = handler;
-}
-
-void WebSocketClient::set_pong_handler(PongHandler handler) {
- std::lock_guard<std::mutex> lock(m_mutex);
- m_pong_handler = handler;
-}
-
-void WebSocketClient::set_heartbeat_interval(int interval) {
- std::lock_guard<std::mutex> lock(m_mutex);
- m_heartbeat_interval = interval;
-}
-
-std::string WebSocketClient::get_current_url() {
- std::lock_guard<std::mutex> lock(m_mutex);
- auto con = m_client.get_con_from_hdl(m_hdl);
- return con->get_uri()->str();
-}
-
-bool WebSocketClient::is_connected() const {
- return m_connected.load();
-}
-
-void WebSocketClient::run() {
- try {
- m_client.run();
- }
- catch (const std::exception& e) {
- std::cerr << "Error in run: " << e.what() << std::endl;
- }
-
- m_connected.store(false);
-}
-
-void WebSocketClient::heartbeat() {
- while (m_reconnect.load()) {
- std::this_thread::sleep_for(std::chrono::seconds(m_heartbeat_interval));
- if (!m_connected.load()) {
- std::cerr << "Attempting to reconnect..." << std::endl;
- connect(get_current_url());
- }
- }
-}
-
-void WebSocketClient::on_open(websocketpp::connection_hdl hdl) {
- std::cout << "Connection established" << std::endl;
- std::lock_guard<std::mutex> lock(m_mutex);
- m_connected.store(true);
- m_reconnect.store(true);
- if (m_open_handler) {
- m_open_handler();
- }
-}
-
-void WebSocketClient::on_message(connection_hdl hdl, message_ptr msg) {
- std::cout << "Received message: " << msg->get_payload() << std::endl;
- std::lock_guard<std::mutex> lock(m_mutex);
- if (m_message_handler) {
- m_message_handler(msg->get_payload());
- }
-
- m_message_received = true;
- m_cv.notify_one(); // 唤醒等待线程
-}
-
-void WebSocketClient::on_close(connection_hdl hdl) {
- std::cout << "Connection closed." << std::endl;
- std::lock_guard<std::mutex> lock(m_mutex);
-
- m_hdl.reset(); // 清空连接句柄
- m_connected.store(false);
- if (m_close_handler) {
- m_close_handler();
- }
-
- // 如果需要重连
- if (m_reconnect.load()) {
-
- // 停止当前运行的事件循环
- //m_client.stop();
- //if (m_thread.joinable()) {
- // m_thread.join();
- //}
- std::cerr << "Connection lost. Attempting to reconnect..." << std::endl;
- //reconnect(); // 启动重连机制
- }
- else {
- m_cv.notify_one();
- m_close_done = true;
- }
-}
-
-void WebSocketClient::on_fail(websocketpp::connection_hdl hdl) {
- std::cerr << "Connection failed" << std::endl;
- std::lock_guard<std::mutex> lock(m_mutex);
- m_connected.store(false);
-
- if (m_fail_handler) {
- m_fail_handler();
- }
-}
-
-void WebSocketClient::on_pong(websocketpp::connection_hdl hdl, const std::string& payload) {
- std::cout << "Received pong response with payload: " << payload << std::endl;
- std::lock_guard<std::mutex> lock(m_mutex);
- m_connected.store(true);
-
- if (m_pong_handler) {
- m_pong_handler(payload);
- }
-}
\ No newline at end of file
+//WebSocketClient::WebSocketClient() : m_connected(false), m_reconnect(true), m_close_done(false), m_message_received(false), m_heartbeat_interval(5) {
+// // 清除之前的客户端配置并重新初始化
+// m_client.clear_access_channels(websocketpp::log::alevel::all);
+// m_client.clear_error_channels(websocketpp::log::elevel::all);
+// m_client.init_asio();
+//
+// // 设置事件回调
+// m_client.set_open_handler([this](websocketpp::connection_hdl hdl) { on_open(hdl); });
+// m_client.set_message_handler([this](websocketpp::connection_hdl hdl, message_ptr msg) { on_message(hdl, msg); });
+// m_client.set_close_handler([this](websocketpp::connection_hdl hdl) { on_close(hdl); });
+// m_client.set_fail_handler([this](websocketpp::connection_hdl hdl) { on_fail(hdl); });
+// m_client.set_pong_handler([this](websocketpp::connection_hdl hdl, const std::string& payload) { on_pong(hdl, payload); });
+//}
+//
+//WebSocketClient::~WebSocketClient() {
+// close();
+//}
+//
+//void WebSocketClient::connect(const std::string& uri) {
+// websocketpp::lib::error_code ec;
+// {
+// m_connected.store(false);
+// m_reconnect.store(false);
+// m_client.clear_access_channels(websocketpp::log::alevel::all);
+// m_client.clear_error_channels(websocketpp::log::elevel::all);
+//
+// std::lock_guard<std::mutex> lock(m_mutex); // 保护共享资源
+// auto con = m_client.get_connection(uri, ec);
+//
+// if (ec) {
+// std::cerr << "Get connection failed: " << ec.message() << std::endl;
+// return;
+// }
+//
+// m_hdl = con->get_handle();
+// m_client.connect(con);
+// }
+//
+// // 启动工作线程
+// m_thread = std::thread(&WebSocketClient::run, this);
+//}
+//
+//bool WebSocketClient::is_busy() const {
+// return m_busy.load();
+//}
+//
+//void WebSocketClient::set_busy(bool busy) {
+// m_busy.store(busy);
+//}
+//
+//void WebSocketClient::send(const std::string& message) {
+// std::lock_guard<std::mutex> lock(m_mutex);
+// if (m_connected.load()) {
+// websocketpp::lib::error_code ec;
+// m_client.send(m_hdl, message, websocketpp::frame::opcode::text, ec);
+// if (ec) {
+// std::cerr << "Send failed: " << ec.message() << std::endl;
+// }
+// }
+// else {
+// std::cerr << "Not connected, cannot send message." << std::endl;
+// }
+//}
+//
+//void WebSocketClient::send_binary(const std::vector<char>& binary_data) {
+// std::lock_guard<std::mutex> lock(m_mutex);
+// if (m_connected.load()) {
+// websocketpp::lib::error_code ec;
+// m_client.send(m_hdl, binary_data.data(), binary_data.size(), websocketpp::frame::opcode::binary, ec);
+// if (ec) {
+// std::cerr << "Send binary data failed: " << ec.message() << std::endl;
+// }
+// }
+// else {
+// std::cerr << "Not connected, cannot send binary data." << std::endl;
+// }
+//}
+//
+//void WebSocketClient::enqueue_message(const std::string& message) {
+// m_message_queue.push(message);
+// process_next_message();
+//}
+//
+//void WebSocketClient::enqueue_binary(const std::vector<char>& binary_data) {
+// m_binary_queue.push(binary_data);
+// process_next_binary();
+//}
+//
+//void WebSocketClient::process_next_message() {
+// if (!m_message_queue.empty() && !is_busy()) {
+// set_busy(true);
+// std::string message = m_message_queue.front();
+// m_message_queue.pop();
+//
+// send(message); // 发送消息
+//
+// set_busy(false); // 设置为空闲状态，并处理下一个
+// process_next_message();
+// }
+//}
+//
+//void WebSocketClient::process_next_binary() {
+// if (!m_binary_queue.empty() && !is_busy()) {
+// set_busy(true);
+// std::vector<char> binary_data = m_binary_queue.front();
+// m_binary_queue.pop();
+//
+// send_binary(binary_data); // 发送二进制数据
+//
+// set_busy(false); // 设置为空闲状态，并处理下一个
+// process_next_binary();
+// }
+//}
+//
+//bool WebSocketClient::send_and_wait(const std::string& message, int timeout_ms) {
+// std::unique_lock<std::mutex> lock(m_mutex);
+// m_message_received = false;
+//
+// if (m_connected.load()) {
+// // 发送消息
+// websocketpp::lib::error_code ec;
+// m_client.send(m_hdl, message, websocketpp::frame::opcode::text, ec);
+// if (ec) {
+// std::cerr << "Send failed: " << ec.message() << std::endl;
+// return false;
+// }
+//
+// // 等待消息或超时
+// if (m_cv.wait_for(lock, std::chrono::milliseconds(timeout_ms), [this]() { return m_message_received; })) {
+// std::cout << "Server response received." << std::endl;
+// return true;
+// }
+// else {
+// std::cerr << "Timeout: No response from server." << std::endl;
+// return false;
+// }
+// }
+// else {
+// std::cerr << "Not connected, cannot send message." << std::endl;
+// }
+//}
+//
+//bool WebSocketClient::send_binary_and_wait(const std::vector<char>& binary_data, int timeout_ms) {
+// std::unique_lock<std::mutex> lock(m_mutex);
+// m_message_received = false;
+//
+// if (m_connected.load()) {
+// // 发送消息
+// websocketpp::lib::error_code ec;
+// m_client.send(m_hdl, binary_data.data(), binary_data.size(), websocketpp::frame::opcode::binary, ec);
+// if (ec) {
+// std::cerr << "Send failed: " << ec.message() << std::endl;
+// return false;
+// }
+//
+// // 等待消息或超时
+// if (m_cv.wait_for(lock, std::chrono::milliseconds(timeout_ms), [this]() { return m_message_received; })) {
+// std::cout << "Server response received." << std::endl;
+// return true;
+// }
+// else {
+// std::cerr << "Timeout: No response from server." << std::endl;
+// return false;
+// }
+// }
+// else {
+// std::cerr << "Not connected, cannot send binary data." << std::endl;
+// }
+//}
+//
+//void WebSocketClient::close() {
+// if (!m_connected.load()) {
+// return;
+// }
+//
+// try {
+// m_reconnect.store(false);
+// m_client.close(m_hdl, websocketpp::close::status::normal, "Closing connection");
+// }
+// catch (const std::exception& e) {
+// std::cerr << "Error during close: " << e.what() << std::endl;
+// }
+//
+// std::unique_lock<std::mutex> lock(m_mutex);
+// m_cv.wait(lock, [this] { return m_close_done; });
+// m_close_done = false;
+//
+// m_client.stop();
+// if (m_thread.joinable()) {
+// m_thread.join();
+// }
+//
+// m_client.reset();
+//}
+//
+//void WebSocketClient::set_open_handler(OpenHandler handler) {
+// std::lock_guard<std::mutex> lock(m_mutex);
+// m_open_handler = handler;
+//}
+//
+//void WebSocketClient::set_message_handler(MessageHandler handler) {
+// std::lock_guard<std::mutex> lock(m_mutex);
+// m_message_handler = handler;
+//}
+//
+//void WebSocketClient::set_close_handler(CloseHandler handler) {
+// std::lock_guard<std::mutex> lock(m_mutex);
+// m_close_handler = handler;
+//}
+//
+//void WebSocketClient::set_fail_handler(FailHandler handler) {
+// std::lock_guard<std::mutex> lock(m_mutex);
+// m_fail_handler = handler;
+//}
+//
+//void WebSocketClient::set_pong_handler(PongHandler handler) {
+// std::lock_guard<std::mutex> lock(m_mutex);
+// m_pong_handler = handler;
+//}
+//
+//void WebSocketClient::set_heartbeat_interval(int interval) {
+// std::lock_guard<std::mutex> lock(m_mutex);
+// m_heartbeat_interval = interval;
+//}
+//
+//std::string WebSocketClient::get_current_url() {
+// std::lock_guard<std::mutex> lock(m_mutex);
+// auto con = m_client.get_con_from_hdl(m_hdl);
+// return con->get_uri()->str();
+//}
+//
+//bool WebSocketClient::is_connected() const {
+// return m_connected.load();
+//}
+//
+//void WebSocketClient::run() {
+// try {
+// m_client.run();
+// }
+// catch (const std::exception& e) {
+// std::cerr << "Error in run: " << e.what() << std::endl;
+// }
+//
+// m_connected.store(false);
+//}
+//
+//void WebSocketClient::heartbeat() {
+// while (m_reconnect.load()) {
+// std::this_thread::sleep_for(std::chrono::seconds(m_heartbeat_interval));
+// if (!m_connected.load()) {
+// std::cerr << "Attempting to reconnect..." << std::endl;
+// connect(get_current_url());
+// }
+// }
+//}
+//
+//void WebSocketClient::on_open(websocketpp::connection_hdl hdl) {
+// std::cout << "Connection established" << std::endl;
+// std::lock_guard<std::mutex> lock(m_mutex);
+// m_connected.store(true);
+// m_reconnect.store(true);
+// if (m_open_handler) {
+// m_open_handler();
+// }
+//}
+//
+//void WebSocketClient::on_message(connection_hdl hdl, message_ptr msg) {
+// std::cout << "Received message: " << msg->get_payload() << std::endl;
+// std::lock_guard<std::mutex> lock(m_mutex);
+// if (m_message_handler) {
+// m_message_handler(msg->get_payload());
+// }
+//
+// m_message_received = true;
+// m_cv.notify_one(); // 唤醒等待线程
+//}
+//
+//void WebSocketClient::on_close(connection_hdl hdl) {
+// std::cout << "Connection closed." << std::endl;
+// std::lock_guard<std::mutex> lock(m_mutex);
+//
+// m_hdl.reset(); // 清空连接句柄
+// m_connected.store(false);
+// if (m_close_handler) {
+// m_close_handler();
+// }
+//
+// // 如果需要重连
+// if (m_reconnect.load()) {
+//
+// // 停止当前运行的事件循环
+// //m_client.stop();
+// //if (m_thread.joinable()) {
+// // m_thread.join();
+// //}
+// std::cerr << "Connection lost. Attempting to reconnect..." << std::endl;
+// //reconnect(); // 启动重连机制
+// }
+// else {
+// m_cv.notify_one();
+// m_close_done = true;
+// }
+//}
+//
+//void WebSocketClient::on_fail(websocketpp::connection_hdl hdl) {
+// std::cerr << "Connection failed" << std::endl;
+// std::lock_guard<std::mutex> lock(m_mutex);
+// m_connected.store(false);
+//
+// if (m_fail_handler) {
+// m_fail_handler();
+// }
+//}
+//
+//void WebSocketClient::on_pong(websocketpp::connection_hdl hdl, const std::string& payload) {
+// std::cout << "Received pong response with payload: " << payload << std::endl;
+// std::lock_guard<std::mutex> lock(m_mutex);
+// m_connected.store(true);
+//
+// if (m_pong_handler) {
+// m_pong_handler(payload);
+// }
+//}
\ No newline at end of file
diff --git a/EdgeInspector_App/WebSocket/WebSocketClient.h b/EdgeInspector_App/WebSocket/WebSocketClient.h
index bd47a7b..e1f3789 100644
--- a/EdgeInspector_App/WebSocket/WebSocketClient.h
+++ b/EdgeInspector_App/WebSocket/WebSocketClient.h
@@ -1,129 +1,129 @@
#ifndef WEBSOCKETCLIENT_H
#define WEBSOCKETCLIENT_H
-#include <websocketpp/config/asio_no_tls_client.hpp>
-#include <websocketpp/client.hpp>
-#include <string>
-#include <vector>
-#include <iostream>
-#include <thread>
-#include <atomic>
-#include <mutex>
-#include <functional>
-#include <chrono>
-
-typedef websocketpp::client<websocketpp::config::asio_client> client;
-
-class WebSocketClient {
-public:
- using message_ptr = websocketpp::config::asio_client::message_type::ptr;
- using connection_hdl = websocketpp::connection_hdl;
- using OpenHandler = std::function<void()>;
- using MessageHandler = std::function<void(const std::string&)>;
- using CloseHandler = std::function<void()>;
- using FailHandler = std::function<void()>;
- using PongHandler = std::function<void(const std::string&)>;
-
- WebSocketClient();
- ~WebSocketClient();
-
- // 连接到指定的URI
- void connect(const std::string& uri);
-
- // 增加客户端的状态标识
- bool is_busy() const;
- void set_busy(bool busy);
-
- // 发送文本消息
- void send(const std::string& message);
-
- // 发送二进制数据
- void send_binary(const std::vector<char>& binary_data);
-
- // 通过队列发送文本消息
- void enqueue_message(const std::string& message);
-
- // 通过队列发送二进制数据
- void enqueue_binary(const std::vector<char>& binary_data);
-
- // 处理下一个消息
- void process_next_message();
- void process_next_binary();
-
- // 发送文本消息并等待回复
- bool send_and_wait(const std::string& message, int timeout_ms);
-
- // 发送二进制数据并等待回复
- bool send_binary_and_wait(const std::vector<char>& binary_data, int timeout_ms);
-
- // 关闭连接
- void close();
-
- // 设置各种回调函数
- void set_open_handler(OpenHandler handler);
- void set_message_handler(MessageHandler handler);
- void set_close_handler(CloseHandler handler);
- void set_fail_handler(FailHandler handler);
- void set_pong_handler(PongHandler handler);
-
- // 设置心跳间隔（单位：秒）
- void set_heartbeat_interval(int interval);
-
- // 获取当前连接的URL
- std::string get_current_url();
-
- // 检查当前连接是否仍然有效
- bool is_connected() const;
-
-private:
- // WebSocket 运行函数
- void run();
-
- // 心跳检查函数
- void heartbeat();
-
- // 回调函数触发器
- void on_open(websocketpp::connection_hdl hdl);
- void on_message(connection_hdl hdl, message_ptr msg);
- void on_close(websocketpp::connection_hdl hdl);
- void on_fail(websocketpp::connection_hdl hdl);
- void on_pong(websocketpp::connection_hdl hdl, const std::string& payload);
-
-private:
- // WebSocket客户端实例
- client m_client;
-
- // WebSocket 连接句柄
- connection_hdl m_hdl;
-
- // 线程相关
- std::thread m_thread;
- std::thread m_heartbeat_thread;
- std::atomic<bool> m_connected;
- std::atomic<bool> m_reconnect;
- int m_heartbeat_interval;
- bool m_message_received;
-
- // 发送队列
- std::queue<std::string> m_message_queue;
- std::queue<std::vector<char>> m_binary_queue;
-
- // 标识客户端是否忙碌
- std::atomic<bool> m_busy;
-
- // 线程同步相关
- bool m_close_done;
- std::condition_variable m_cv;
-
- // 互斥锁，用于保护共享资源
- std::mutex m_mutex;
-
- // 回调函数
- OpenHandler m_open_handler;
- MessageHandler m_message_handler;
- CloseHandler m_close_handler;
- FailHandler m_fail_handler;
- PongHandler m_pong_handler;
-};
+//#include <websocketpp/config/asio_no_tls_client.hpp>
+//#include <websocketpp/client.hpp>
+//#include <string>
+//#include <vector>
+//#include <iostream>
+//#include <thread>
+//#include <atomic>
+//#include <mutex>
+//#include <functional>
+//#include <chrono>
+//
+//typedef websocketpp::client<websocketpp::config::asio_client> client;
+//
+//class WebSocketClient {
+//public:
+// using message_ptr = websocketpp::config::asio_client::message_type::ptr;
+// using connection_hdl = websocketpp::connection_hdl;
+// using OpenHandler = std::function<void()>;
+// using MessageHandler = std::function<void(const std::string&)>;
+// using CloseHandler = std::function<void()>;
+// using FailHandler = std::function<void()>;
+// using PongHandler = std::function<void(const std::string&)>;
+//
+// WebSocketClient();
+// ~WebSocketClient();
+//
+// // 连接到指定的URI
+// void connect(const std::string& uri);
+//
+// // 增加客户端的状态标识
+// bool is_busy() const;
+// void set_busy(bool busy);
+//
+// // 发送文本消息
+// void send(const std::string& message);
+//
+// // 发送二进制数据
+// void send_binary(const std::vector<char>& binary_data);
+//
+// // 通过队列发送文本消息
+// void enqueue_message(const std::string& message);
+//
+// // 通过队列发送二进制数据
+// void enqueue_binary(const std::vector<char>& binary_data);
+//
+// // 处理下一个消息
+// void process_next_message();
+// void process_next_binary();
+//
+// // 发送文本消息并等待回复
+// bool send_and_wait(const std::string& message, int timeout_ms);
+//
+// // 发送二进制数据并等待回复
+// bool send_binary_and_wait(const std::vector<char>& binary_data, int timeout_ms);
+//
+// // 关闭连接
+// void close();
+//
+// // 设置各种回调函数
+// void set_open_handler(OpenHandler handler);
+// void set_message_handler(MessageHandler handler);
+// void set_close_handler(CloseHandler handler);
+// void set_fail_handler(FailHandler handler);
+// void set_pong_handler(PongHandler handler);
+//
+// // 设置心跳间隔（单位：秒）
+// void set_heartbeat_interval(int interval);
+//
+// // 获取当前连接的URL
+// std::string get_current_url();
+//
+// // 检查当前连接是否仍然有效
+// bool is_connected() const;
+//
+//private:
+// // WebSocket 运行函数
+// void run();
+//
+// // 心跳检查函数
+// void heartbeat();
+//
+// // 回调函数触发器
+// void on_open(websocketpp::connection_hdl hdl);
+// void on_message(connection_hdl hdl, message_ptr msg);
+// void on_close(websocketpp::connection_hdl hdl);
+// void on_fail(websocketpp::connection_hdl hdl);
+// void on_pong(websocketpp::connection_hdl hdl, const std::string& payload);
+//
+//private:
+// // WebSocket客户端实例
+// client m_client;
+//
+// // WebSocket 连接句柄
+// connection_hdl m_hdl;
+//
+// // 线程相关
+// std::thread m_thread;
+// std::thread m_heartbeat_thread;
+// std::atomic<bool> m_connected;
+// std::atomic<bool> m_reconnect;
+// int m_heartbeat_interval;
+// bool m_message_received;
+//
+// // 发送队列
+// std::queue<std::string> m_message_queue;
+// std::queue<std::vector<char>> m_binary_queue;
+//
+// // 标识客户端是否忙碌
+// std::atomic<bool> m_busy;
+//
+// // 线程同步相关
+// bool m_close_done;
+// std::condition_variable m_cv;
+//
+// // 互斥锁，用于保护共享资源
+// std::mutex m_mutex;
+//
+// // 回调函数
+// OpenHandler m_open_handler;
+// MessageHandler m_message_handler;
+// CloseHandler m_close_handler;
+// FailHandler m_fail_handler;
+// PongHandler m_pong_handler;
+//};
#endif // WEBSOCKETCLIENT_H
\ No newline at end of file
diff --git a/EdgeInspector_App/WebSocket/WebSocketClientPool.cpp b/EdgeInspector_App/WebSocket/WebSocketClientPool.cpp
index a1dbc92..ebd36c4 100644
--- a/EdgeInspector_App/WebSocket/WebSocketClientPool.cpp
+++ b/EdgeInspector_App/WebSocket/WebSocketClientPool.cpp
@@ -1,278 +1,278 @@
#include "StdAfx.h"
#include "WebSocketClientPool.h"
-WebSocketClientPool::WebSocketClientPool(size_t thread_count) : m_thread_pool(thread_count) {}
-
-WebSocketClientPool::~WebSocketClientPool() {}
-
-void WebSocketClientPool::init_clients(const std::vector<std::string>& uris) {
- m_clients.clear();
-
- for (const auto& uri : uris) {
- try {
- if (!uri.empty() && uri.size() > 8)
- {
- // "ws://localhost:8080"
- auto client = std::make_shared<WebSocketClient>();
- client->connect(uri);
- m_clients.push_back(client);
- }
- }
- catch (const std::exception& e) {
- std::cerr << "Error connecting to " << uri << ": " << e.what() << std::endl;
- exit_clients();
- }
- }
-}
-
-void WebSocketClientPool::exit_clients() {
- for (auto& client : m_clients) {
- if (client->is_connected())
- {
- client->close();
- }
- }
-
- // 清空之前的客户端，确保是干净的状态
- m_clients.clear();
-}
-
-void WebSocketClientPool::post_to_all(const std::string& message) {
- for (auto& client : m_clients) {
- m_thread_pool.enqueue([client, message]() {
- if (client->is_connected())
- {
- client->send(message);
- }
- });
- }
-}
-
-void WebSocketClientPool::post_binary_to_all(const std::vector<char>& binary_data) {
- for (auto& client : m_clients) {
- m_thread_pool.enqueue([client, binary_data]() {
- if (client->is_connected())
- {
- client->send_binary(binary_data);
- }
- });
- }
-}
-
-bool WebSocketClientPool::post_to_idle_client(const std::string& message) {
- for (auto& client : m_clients) {
- if (client->is_connected()) {
- // 提交发送任务到线程池
- m_thread_pool.enqueue([client, message]() {
- client->set_busy(true); // 标记为忙碌
- client->send(message); // 发送消息
- client->set_busy(false); // 完成后标记为空闲
- });
- return true; // 成功提交任务
- }
- }
- return false; // 没有可用客户端
-}
-
-bool WebSocketClientPool::post_binary_to_idle_client(const std::vector<char>& binary_data) {
- for (auto& client : m_clients) {
- if (client->is_connected()) {
- // 提交发送任务到线程池
- m_thread_pool.enqueue([client, binary_data]() {
- client->set_busy(true); // 标记为忙碌
- client->send_binary(binary_data); // 发送二进制数据
- client->set_busy(false); // 完成后标记为空闲
- });
- return true; // 成功提交任务
- }
- }
- return false; // 没有可用客户端
-}
-
-bool WebSocketClientPool::send_to_idle_client(const std::string& message, int timeout_ms) {
- for (auto& client : m_clients) {
- if (!client->is_busy() && client->is_connected()) {
- // 标记为忙
- client->set_busy(true);
-
- // 使用线程池发送消息
- m_thread_pool.enqueue([client, message, timeout_ms]() {
- // 发送消息并等待服务器回复
- client->send_and_wait(message, timeout_ms); // 5秒超时
- client->set_busy(false); // 标记为空闲
- });
-
- return true; // 成功发送消息，返回 true
- }
- }
- return false; // 没有空闲客户端
-}
-
-bool WebSocketClientPool::send_binary_to_idle_client(const std::vector<char>& binary_data, int timeout_ms) {
- for (auto& client : m_clients) {
- if (!client->is_busy() && client->is_connected()) {
- // 标记为忙
- client->set_busy(true);
-
- // 使用线程池发送消息
- m_thread_pool.enqueue([client, binary_data, timeout_ms]() {
- // 发送消息并等待服务器回复
- client->send_binary_and_wait(binary_data, timeout_ms);
- client->set_busy(false); // 标记为空闲
- });
-
- return true; // 成功发送消息，返回 true
- }
- }
- return false; // 没有空闲客户端
-}
-
-bool WebSocketClientPool::send_to_idle_client_and_wait(const std::string& message, int timeout_ms) {
- for (auto& client : m_clients) {
- if (!client->is_busy() && client->is_connected()) {
- client->set_busy(true); // 标记为忙
-
- try {
- // 直接在当前线程调用 send_and_wait，阻塞直到任务完成
- bool result = client->send_and_wait(message, timeout_ms);
- client->set_busy(false); // 设置为空闲状态
- return result; // 返回结果
- }
- catch (const std::exception& e) {
- std::cerr << "Exception during sending: " << e.what() << std::endl;
- client->set_busy(false); // 即使发生异常，也要重置为未忙状态
- return false; // 发生异常，返回失败
- }
- }
- }
- return false; // 没有空闲客户端
-}
-
-bool WebSocketClientPool::send_binary_to_idle_client_and_wait(const std::vector<char>& binary_data, int timeout_ms) {
- for (auto& client : m_clients) {
- if (!client->is_busy() && client->is_connected()) {
- client->set_busy(true); // 标记为忙
-
- try {
- // 直接在当前线程调用 send_and_wait，阻塞直到任务完成
- bool result = client->send_binary_and_wait(binary_data, timeout_ms);
- client->set_busy(false); // 设置为空闲状态
- return result; // 返回结果
- }
- catch (const std::exception& e) {
- std::cerr << "Exception during sending: " << e.what() << std::endl;
- client->set_busy(false); // 即使发生异常，也要重置为未忙状态
- return false; // 发生异常，返回失败
- }
- }
- }
- return false; // 没有空闲客户端
-}
-
-bool WebSocketClientPool::send_to_idle_client_with_retry(const std::string& message, int total_timeout_ms, int retry_interval_ms) {
- auto start_time = std::chrono::steady_clock::now();
-
- while (true) {
- // 查找空闲客户端
- for (auto& client : m_clients) {
- if (!client->is_busy() && client->is_connected()) {
- // 标记为忙
- client->set_busy(true);
-
- // 使用线程池发送消息
- m_thread_pool.enqueue([client, message]() {
- try {
- // 发送消息并等待服务器回复
- client->send_and_wait(message, 5000); // 这里的超时可以根据需要调整
- }
- catch (const std::exception& e) {
- std::cerr << "Error sending data: " << e.what() << std::endl;
- }
- client->set_busy(false); // 标记为空闲
- });
-
- return true; // 成功发送
- }
- }
-
- // 计算已使用的时间
- auto elapsed_time = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now() - start_time).count();
-
- if (elapsed_time >= total_timeout_ms) {
- std::cerr << "Timeout: failed to send data within the specified timeout of " << total_timeout_ms << " ms." << std::endl;
- return false; // 超时，无法发送
- }
-
- // 没有找到空闲客户端，等待 retry_interval_ms 毫秒后重试
- std::this_thread::sleep_for(std::chrono::milliseconds(retry_interval_ms));
- }
-}
-
-bool WebSocketClientPool::send_binary_to_idle_client_with_retry(std::vector<char>&& binary_data, int total_timeout_ms, int retry_interval_ms) {
- auto start_time = std::chrono::steady_clock::now();
-
- while (true) {
- // 查找空闲客户端
- for (auto& client : m_clients) {
- if (!client->is_busy() && client->is_connected()) {
- // 标记为忙
- client->set_busy(true);
-
- // 使用线程池发送消息
- m_thread_pool.enqueue([client, binary_data = std::move(binary_data)]() mutable {
- try {
- // 发送消息并等待服务器回复
- client->send_binary_and_wait(binary_data, 5000); // 这里的超时可以根据需要调整
- }
- catch (const std::exception& e) {
- std::cerr << "Error sending binary data: " << e.what() << std::endl;
- }
- client->set_busy(false); // 标记为空闲
- });
-
- return true; // 成功发送
- }
- }
-
- // 计算已使用的时间
- auto elapsed_time = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now() - start_time).count();
-
- if (elapsed_time >= total_timeout_ms) {
- std::cerr << "Timeout: failed to send data within the specified timeout of " << total_timeout_ms << " ms." << std::endl;
- return false; // 超时，无法发送
- }
-
- // 没有找到空闲客户端，等待 retry_interval_ms 毫秒后重试
- std::this_thread::sleep_for(std::chrono::milliseconds(retry_interval_ms));
- }
-}
-
-void WebSocketClientPool::set_open_handler(WebSocketClient::OpenHandler handler) {
- for (auto& client : m_clients) {
- client->set_open_handler(handler);
- }
-}
-
-void WebSocketClientPool::set_message_handler(WebSocketClient::MessageHandler handler) {
- for (auto& client : m_clients) {
- client->set_message_handler(handler);
- }
-}
-
-void WebSocketClientPool::set_close_handler(WebSocketClient::CloseHandler handler) {
- for (auto& client : m_clients) {
- client->set_close_handler(handler);
- }
-}
-
-void WebSocketClientPool::set_fail_handler(WebSocketClient::FailHandler handler) {
- for (auto& client : m_clients) {
- client->set_fail_handler(handler);
- }
-}
-
-void WebSocketClientPool::set_pong_handler(WebSocketClient::PongHandler handler) {
- for (auto& client : m_clients) {
- client->set_pong_handler(handler);
- }
-}
\ No newline at end of file
+//WebSocketClientPool::WebSocketClientPool(size_t thread_count) : m_thread_pool(thread_count) {}
+//
+//WebSocketClientPool::~WebSocketClientPool() {}
+//
+//void WebSocketClientPool::init_clients(const std::vector<std::string>& uris) {
+// m_clients.clear();
+//
+// for (const auto& uri : uris) {
+// try {
+// if (!uri.empty() && uri.size() > 8)
+// {
+// // "ws://localhost:8080"
+// auto client = std::make_shared<WebSocketClient>();
+// client->connect(uri);
+// m_clients.push_back(client);
+// }
+// }
+// catch (const std::exception& e) {
+// std::cerr << "Error connecting to " << uri << ": " << e.what() << std::endl;
+// exit_clients();
+// }
+// }
+//}
+//
+//void WebSocketClientPool::exit_clients() {
+// for (auto& client : m_clients) {
+// if (client->is_connected())
+// {
+// client->close();
+// }
+// }
+//
+// // 清空之前的客户端，确保是干净的状态
+// m_clients.clear();
+//}
+//
+//void WebSocketClientPool::post_to_all(const std::string& message) {
+// for (auto& client : m_clients) {
+// m_thread_pool.enqueue([client, message]() {
+// if (client->is_connected())
+// {
+// client->send(message);
+// }
+// });
+// }
+//}
+//
+//void WebSocketClientPool::post_binary_to_all(const std::vector<char>& binary_data) {
+// for (auto& client : m_clients) {
+// m_thread_pool.enqueue([client, binary_data]() {
+// if (client->is_connected())
+// {
+// client->send_binary(binary_data);
+// }
+// });
+// }
+//}
+//
+//bool WebSocketClientPool::post_to_idle_client(const std::string& message) {
+// for (auto& client : m_clients) {
+// if (client->is_connected()) {
+// // 提交发送任务到线程池
+// m_thread_pool.enqueue([client, message]() {
+// client->set_busy(true); // 标记为忙碌
+// client->send(message); // 发送消息
+// client->set_busy(false); // 完成后标记为空闲
+// });
+// return true; // 成功提交任务
+// }
+// }
+// return false; // 没有可用客户端
+//}
+//
+//bool WebSocketClientPool::post_binary_to_idle_client(const std::vector<char>& binary_data) {
+// for (auto& client : m_clients) {
+// if (client->is_connected()) {
+// // 提交发送任务到线程池
+// m_thread_pool.enqueue([client, binary_data]() {
+// client->set_busy(true); // 标记为忙碌
+// client->send_binary(binary_data); // 发送二进制数据
+// client->set_busy(false); // 完成后标记为空闲
+// });
+// return true; // 成功提交任务
+// }
+// }
+// return false; // 没有可用客户端
+//}
+//
+//bool WebSocketClientPool::send_to_idle_client(const std::string& message, int timeout_ms) {
+// for (auto& client : m_clients) {
+// if (!client->is_busy() && client->is_connected()) {
+// // 标记为忙
+// client->set_busy(true);
+//
+// // 使用线程池发送消息
+// m_thread_pool.enqueue([client, message, timeout_ms]() {
+// // 发送消息并等待服务器回复
+// client->send_and_wait(message, timeout_ms); // 5秒超时
+// client->set_busy(false); // 标记为空闲
+// });
+//
+// return true; // 成功发送消息，返回 true
+// }
+// }
+// return false; // 没有空闲客户端
+//}
+//
+//bool WebSocketClientPool::send_binary_to_idle_client(const std::vector<char>& binary_data, int timeout_ms) {
+// for (auto& client : m_clients) {
+// if (!client->is_busy() && client->is_connected()) {
+// // 标记为忙
+// client->set_busy(true);
+//
+// // 使用线程池发送消息
+// m_thread_pool.enqueue([client, binary_data, timeout_ms]() {
+// // 发送消息并等待服务器回复
+// client->send_binary_and_wait(binary_data, timeout_ms);
+// client->set_busy(false); // 标记为空闲
+// });
+//
+// return true; // 成功发送消息，返回 true
+// }
+// }
+// return false; // 没有空闲客户端
+//}
+//
+//bool WebSocketClientPool::send_to_idle_client_and_wait(const std::string& message, int timeout_ms) {
+// for (auto& client : m_clients) {
+// if (!client->is_busy() && client->is_connected()) {
+// client->set_busy(true); // 标记为忙
+//
+// try {
+// // 直接在当前线程调用 send_and_wait，阻塞直到任务完成
+// bool result = client->send_and_wait(message, timeout_ms);
+// client->set_busy(false); // 设置为空闲状态
+// return result; // 返回结果
+// }
+// catch (const std::exception& e) {
+// std::cerr << "Exception during sending: " << e.what() << std::endl;
+// client->set_busy(false); // 即使发生异常，也要重置为未忙状态
+// return false; // 发生异常，返回失败
+// }
+// }
+// }
+// return false; // 没有空闲客户端
+//}
+//
+//bool WebSocketClientPool::send_binary_to_idle_client_and_wait(const std::vector<char>& binary_data, int timeout_ms) {
+// for (auto& client : m_clients) {
+// if (!client->is_busy() && client->is_connected()) {
+// client->set_busy(true); // 标记为忙
+//
+// try {
+// // 直接在当前线程调用 send_and_wait，阻塞直到任务完成
+// bool result = client->send_binary_and_wait(binary_data, timeout_ms);
+// client->set_busy(false); // 设置为空闲状态
+// return result; // 返回结果
+// }
+// catch (const std::exception& e) {
+// std::cerr << "Exception during sending: " << e.what() << std::endl;
+// client->set_busy(false); // 即使发生异常，也要重置为未忙状态
+// return false; // 发生异常，返回失败
+// }
+// }
+// }
+// return false; // 没有空闲客户端
+//}
+//
+//bool WebSocketClientPool::send_to_idle_client_with_retry(const std::string& message, int total_timeout_ms, int retry_interval_ms) {
+// auto start_time = std::chrono::steady_clock::now();
+//
+// while (true) {
+// // 查找空闲客户端
+// for (auto& client : m_clients) {
+// if (!client->is_busy() && client->is_connected()) {
+// // 标记为忙
+// client->set_busy(true);
+//
+// // 使用线程池发送消息
+// m_thread_pool.enqueue([client, message]() {
+// try {
+// // 发送消息并等待服务器回复
+// client->send_and_wait(message, 5000); // 这里的超时可以根据需要调整
+// }
+// catch (const std::exception& e) {
+// std::cerr << "Error sending data: " << e.what() << std::endl;
+// }
+// client->set_busy(false); // 标记为空闲
+// });
+//
+// return true; // 成功发送
+// }
+// }
+//
+// // 计算已使用的时间
+// auto elapsed_time = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now() - start_time).count();
+//
+// if (elapsed_time >= total_timeout_ms) {
+// std::cerr << "Timeout: failed to send data within the specified timeout of " << total_timeout_ms << " ms." << std::endl;
+// return false; // 超时，无法发送
+// }
+//
+// // 没有找到空闲客户端，等待 retry_interval_ms 毫秒后重试
+// std::this_thread::sleep_for(std::chrono::milliseconds(retry_interval_ms));
+// }
+//}
+//
+//bool WebSocketClientPool::send_binary_to_idle_client_with_retry(std::vector<char>&& binary_data, int total_timeout_ms, int retry_interval_ms) {
+// auto start_time = std::chrono::steady_clock::now();
+//
+// while (true) {
+// // 查找空闲客户端
+// for (auto& client : m_clients) {
+// if (!client->is_busy() && client->is_connected()) {
+// // 标记为忙
+// client->set_busy(true);
+//
+// // 使用线程池发送消息
+// m_thread_pool.enqueue([client, binary_data = std::move(binary_data)]() mutable {
+// try {
+// // 发送消息并等待服务器回复
+// client->send_binary_and_wait(binary_data, 5000); // 这里的超时可以根据需要调整
+// }
+// catch (const std::exception& e) {
+// std::cerr << "Error sending binary data: " << e.what() << std::endl;
+// }
+// client->set_busy(false); // 标记为空闲
+// });
+//
+// return true; // 成功发送
+// }
+// }
+//
+// // 计算已使用的时间
+// auto elapsed_time = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now() - start_time).count();
+//
+// if (elapsed_time >= total_timeout_ms) {
+// std::cerr << "Timeout: failed to send data within the specified timeout of " << total_timeout_ms << " ms." << std::endl;
+// return false; // 超时，无法发送
+// }
+//
+// // 没有找到空闲客户端，等待 retry_interval_ms 毫秒后重试
+// std::this_thread::sleep_for(std::chrono::milliseconds(retry_interval_ms));
+// }
+//}
+//
+//void WebSocketClientPool::set_open_handler(WebSocketClient::OpenHandler handler) {
+// for (auto& client : m_clients) {
+// client->set_open_handler(handler);
+// }
+//}
+//
+//void WebSocketClientPool::set_message_handler(WebSocketClient::MessageHandler handler) {
+// for (auto& client : m_clients) {
+// client->set_message_handler(handler);
+// }
+//}
+//
+//void WebSocketClientPool::set_close_handler(WebSocketClient::CloseHandler handler) {
+// for (auto& client : m_clients) {
+// client->set_close_handler(handler);
+// }
+//}
+//
+//void WebSocketClientPool::set_fail_handler(WebSocketClient::FailHandler handler) {
+// for (auto& client : m_clients) {
+// client->set_fail_handler(handler);
+// }
+//}
+//
+//void WebSocketClientPool::set_pong_handler(WebSocketClient::PongHandler handler) {
+// for (auto& client : m_clients) {
+// client->set_pong_handler(handler);
+// }
+//}
\ No newline at end of file
diff --git a/EdgeInspector_App/WebSocket/WebSocketClientPool.h b/EdgeInspector_App/WebSocket/WebSocketClientPool.h
index 87b5e5f..21357e9 100644
--- a/EdgeInspector_App/WebSocket/WebSocketClientPool.h
+++ b/EdgeInspector_App/WebSocket/WebSocketClientPool.h
@@ -1,50 +1,50 @@
#ifndef WEBSOCKETCLIENTWITHPOOL_H
#define WEBSOCKETCLIENTWITHPOOL_H
-#include "WebSocketClient.h"
-#include "ThreadPool.h"
-
-class WebSocketClientPool {
-public:
- explicit WebSocketClientPool(size_t thread_count);
- ~WebSocketClientPool();
-
- // 初始化客户端
- void init_clients(const std::vector<std::string>& uris);
-
- // 退出所有客户端
- void exit_clients();
-
- // 使用线程池发送消息
- void post_to_all(const std::string& message);
- void post_binary_to_all(const std::vector<char>& binary_data);
-
- // 从池中选择一个空闲的客户端进行发送，不需要服务器响应
- bool post_to_idle_client(const std::string& message);
- bool post_binary_to_idle_client(const std::vector<char>& binary_data);
-
- // 从池中选择一个空闲的客户端进行发送，并需要服务器响应
- bool send_to_idle_client(const std::string& message, int timeout_ms);
- bool send_binary_to_idle_client(const std::vector<char>& binary_data, int timeout_ms);
-
- // 从池中选择一个空闲的客户端进行发送，并等待服务器响应
- bool send_to_idle_client_and_wait(const std::string& message, int timeout_ms);
- bool send_binary_to_idle_client_and_wait(const std::vector<char>& binary_data, int timeout_ms);
-
- // 从池中选择一个空闲的客户端进行发送，并等待服务器响应，如果超时则重试
- bool send_to_idle_client_with_retry(const std::string& message, int total_timeout_ms, int retry_interval_ms);
- bool send_binary_to_idle_client_with_retry(std::vector<char>&& binary_data, int total_timeout_ms, int retry_interval_ms);
-
- // 设置 WebSocket 客户端事件处理程序
- void set_open_handler(WebSocketClient::OpenHandler handler);
- void set_message_handler(WebSocketClient::MessageHandler handler);
- void set_close_handler(WebSocketClient::CloseHandler handler);
- void set_fail_handler(WebSocketClient::FailHandler handler);
- void set_pong_handler(WebSocketClient::PongHandler handler);
-
-private:
- std::vector<std::shared_ptr<WebSocketClient>> m_clients;
- ThreadPool m_thread_pool;
-};
+//#include "WebSocketClient.h"
+//#include "ThreadPool.h"
+//
+//class WebSocketClientPool {
+//public:
+// explicit WebSocketClientPool(size_t thread_count);
+// ~WebSocketClientPool();
+//
+// // 初始化客户端
+// void init_clients(const std::vector<std::string>& uris);
+//
+// // 退出所有客户端
+// void exit_clients();
+//
+// // 使用线程池发送消息
+// void post_to_all(const std::string& message);
+// void post_binary_to_all(const std::vector<char>& binary_data);
+//
+// // 从池中选择一个空闲的客户端进行发送，不需要服务器响应
+// bool post_to_idle_client(const std::string& message);
+// bool post_binary_to_idle_client(const std::vector<char>& binary_data);
+//
+// // 从池中选择一个空闲的客户端进行发送，并需要服务器响应
+// bool send_to_idle_client(const std::string& message, int timeout_ms);
+// bool send_binary_to_idle_client(const std::vector<char>& binary_data, int timeout_ms);
+//
+// // 从池中选择一个空闲的客户端进行发送，并等待服务器响应
+// bool send_to_idle_client_and_wait(const std::string& message, int timeout_ms);
+// bool send_binary_to_idle_client_and_wait(const std::vector<char>& binary_data, int timeout_ms);
+//
+// // 从池中选择一个空闲的客户端进行发送，并等待服务器响应，如果超时则重试
+// bool send_to_idle_client_with_retry(const std::string& message, int total_timeout_ms, int retry_interval_ms);
+// bool send_binary_to_idle_client_with_retry(std::vector<char>&& binary_data, int total_timeout_ms, int retry_interval_ms);
+//
+// // 设置 WebSocket 客户端事件处理程序
+// void set_open_handler(WebSocketClient::OpenHandler handler);
+// void set_message_handler(WebSocketClient::MessageHandler handler);
+// void set_close_handler(WebSocketClient::CloseHandler handler);
+// void set_fail_handler(WebSocketClient::FailHandler handler);
+// void set_pong_handler(WebSocketClient::PongHandler handler);
+//
+//private:
+// std::vector<std::shared_ptr<WebSocketClient>> m_clients;
+// ThreadPool m_thread_pool;
+//};
#endif // WEBSOCKETCLIENTWITHPOOL_H
\ No newline at end of file
--
Gitblit v1.9.3