add error_code

src/iflytop/components/iflytop_front_end_service/iflytop_front_end_service.cpp

@@ -1,14 +1,18 @@
 #include "iflytop_front_end_service.hpp"
+
+#include "iflytop/core/components/timeutils.hpp"
+#include "iflytop/core/core.hpp"
+#include "iflytop/core/error/error_code.hpp"
 using namespace nlohmann;
 using namespace iflytop;
 using namespace std;
 using namespace core;
 using namespace ix;
 
-void IflytopFrontEndService::initialize() {
+void IflytopFrontEndService::initialize(string ip) {
   logger->info("IflytopFrontEndService initialize {}", 19001);
 
-  m_server.reset(new WebSocketServer(19001, "0.0.0.0"));
+  m_server.reset(new WebSocketServer(19001, ip));
   m_server->setOnConnectionCallback([this](weak_ptr<WebSocket> webSocket, shared_ptr<ConnectionState> connectionState) {
     logger->info("Remote ip: {}", connectionState->getRemoteIp());
     auto ws = webSocket.lock();
@@ -22,21 +26,48 @@ void IflytopFrontEndService::initialize() {
     });
   });
 
+  m_report_server.reset(new WebSocketServer(19002, ip));
   m_initialized = true;
 }
 void IflytopFrontEndService::startListen() {
-  auto res = m_server->listen();
-  if (!res.first) {
+  if (!m_server->listen().first) {
+    logger->error("listen error!!!!");
+    return;
+  }
+
+  if (!m_report_server->listen().first) {
     logger->error("listen error!!!!");
     return;
   }
+
   m_server->disablePerMessageDeflate();
   m_server->start();
   // m_server->wait();
+
+  m_report_server->disablePerMessageDeflate();
+  m_report_server->start();
+
   logger->info("IflytopFrontEndService initialize done");
 }
 
-void IflytopFrontEndService::sendMessage(const string& message) {
+// void IflytopFrontEndService::sendMessage(const string& message) {
+//   if (!m_initialized) {
+//     logger->error("IflytopFrontEndService not initialized");
+//     return;
+//   }
+//   /**
+//    * @brief 广播消息给所有连接的客户端
+//    */
+//   logger->debug("uplink msg: {}", message);
+//   auto clients = m_server->getClients();
+//   for (auto& each : clients) {
+//     if (each) {
+//       each->sendText(message);
+//     }
+//   }
+// }
+
+void IflytopFrontEndService::sendReport(json& report) {
   if (!m_initialized) {
     logger->error("IflytopFrontEndService not initialized");
     return;
@@ -44,11 +75,14 @@ void IflytopFrontEndService::sendMessage(const string& message) {
   /**
    * @brief 广播消息给所有连接的客户端
    */
-  logger->debug("uplink msg: {}", message);
-  auto clients = m_server->getClients();
+
+  report["timeStamp"] = duration_cast<milliseconds>(system_clock::now().time_since_epoch()).count();
+  logger->debug("uplink msg: {}", report.dump());
+
+  auto clients = m_report_server->getClients();
   for (auto& each : clients) {
     if (each) {
-      each->sendText(message);
+      each->sendText(report.dump());
     }
   }
 }
@@ -65,9 +99,51 @@ void IflytopFrontEndService::onMessageCallback(weak_ptr<WebSocket> webSocket, sh
     onConnect(webSocket, msg);
   } else if (msg->type == ix::WebSocketMessageType::Message) {
     logger->debug("downlink msg: {}", msg->str);
-    onMessage(webSocket, msg);
+    try {
+      processRxMessage(webSocket, msg);
+    } catch (const std::exception& e) {
+      logger->error("catch exception,processRxMessage error: {}", e.what());
+    }
+    // onMessage(webSocket, msg);
   } else if (msg->type == ix::WebSocketMessageType::Close) {
     logger->info("{} Closed connection", msg->closeInfo.remote);
     onDisconnect(webSocket, msg);
   }
 }
+void IflytopFrontEndService::processRxMessage(weak_ptr<WebSocket> webSocket, const ix::WebSocketMessagePtr& msg) {
+  if (msg->binary) {
+    logger->warn("receive binary message,ignore");
+    return;
+  }
+
+  string msgtext = msg->str;
+  json   message;
+
+  try {
+    json command = json::parse(msgtext);
+    json receipt;
+    receipt["messageId"] = command["messageId"];
+    receipt["ackcode"]   = 0;
+    receipt["timeStamp"] = duration_cast<milliseconds>(system_clock::now().time_since_epoch()).count();
+    try {
+      onMessage(webSocket, command, receipt);
+      if (command["need_receipt"]) {
+        shared_ptr<WebSocket> ws = webSocket.lock();
+        if (ws) ws->sendText(receipt.dump());
+      }
+    } catch (const std::exception& e) {
+      logger->error("m_iflytopWSService:onMessag,process rx json failed,exception:{},{}", e.what(), msgtext);
+      if (command["need_receipt"]) {
+        shared_ptr<WebSocket> ws = webSocket.lock();
+        receipt["ackcode"]       = err::error_code_get_get_ecode(err::kcommon_error_code, err::kparse_json_err);
+        receipt["ackcodeInfo"]   = err::error_code_get_desc(err::kcommon_error_code, err::kparse_json_err, e.what());
+
+        if (ws) ws->sendText(receipt.dump());
+      }
+    }
+
+  } catch (const std::exception& e) {
+    logger->error("m_iflytopWSService:onMessag,parse json failed,exception:{},{}", e.what(), msgtext);
+    return;
+  }
+}

src/iflytop/components/iflytop_front_end_service/iflytop_front_end_service.hpp

@@ -34,30 +34,35 @@ using namespace std;
 using namespace iflytop;
 using namespace core;
 using namespace ix;
-
+using namespace nlohmann;
 
 class IflytopFrontEndService : public enable_shared_from_this<IflytopFrontEndService> {
   ENABLE_LOGGER(IflytopFrontEndService);
 
  public:
-  nod::signal<void(weak_ptr<WebSocket> webSocket, const ix::WebSocketMessagePtr& msg)> onMessage;
+  // nod::signal<void(weak_ptr<WebSocket> webSocket, const ix::WebSocketMessagePtr& msg)> onMessage;
   nod::signal<void(weak_ptr<WebSocket> webSocket, const ix::WebSocketMessagePtr& msg)> onConnect;
   nod::signal<void(weak_ptr<WebSocket> webSocket, const ix::WebSocketMessagePtr& msg)> onDisconnect;
 
+  nod::signal<void(weak_ptr<WebSocket> webSocket, json& cmd, json& receipt)> onMessage;
+
  private:
   //
   // WebSocketServer的使用参考:http://192.168.1.3:3000/z3rd_lib/IXWebSocket/src/branch/master/docs/usage.md
   //
   shared_ptr<ix::WebSocketServer> m_server;
+  shared_ptr<ix::WebSocketServer> m_report_server;
   bool                            m_initialized = false;
 
  public:
-  void initialize();
+  void initialize(string ip = "0.0.0.0");
   void startListen();
 
-  void sendMessage(const string& message);
+  // void sendMessage(const string& message);
+  void sendReport(json& report);
 
  private:
   void onMessageCallback(weak_ptr<WebSocket> webSocket, shared_ptr<ConnectionState> connectionState, const ix::WebSocketMessagePtr& msg);
+  void processRxMessage(weak_ptr<WebSocket> webSocket, const ix::WebSocketMessagePtr& msg);
 };
 }  // namespace iflytop

src/iflytop/core/core.hpp

@@ -0,0 +1,6 @@
+#pragma once
+
+#include "iflytop/core/basic/nod/nod.hpp"
+#include "iflytop/core/components/timeutils.hpp"
+#include "iflytop/core/error/error_code.hpp"
+#include "iflytop/core/spdlogfactory/logger.hpp"

src/iflytop/core/error/error_code.cpp

@@ -0,0 +1,32 @@
+#include "error_code.hpp"
+
+namespace iflytop {
+namespace err {
+
+using namespace std;
+
+// static set<error_code_desc_t> ecode_desc_set = {
+//     {kcommon_error_code, kovertime, "overtime"},
+//     {kcommon_error_code, kdevice_offline, "kdevice_offline"},
+//     {kcommon_error_code, kpasswd_error, "kpasswd_error"},
+// };
+
+static vector<error_code_desc_t> ecode_desc_set = {
+    {kcommon_error_code, kovertime, "overtime"},
+    {kcommon_error_code, kdevice_offline, "kdevice_offline"},
+    {kcommon_error_code, kpasswd_error, "kpasswd_error"},
+};
+
+int32_t error_code_get_get_ecode(error_type_t error_type, int sub_error_code) {  //
+  return error_type * 1000 + sub_error_code;
+}
+string error_code_get_desc(error_type_t error_type, int sub_error_code, string extdes) {  //
+  for (auto& ecode_desc : ecode_desc_set) {
+    if (ecode_desc.error_type == error_type && ecode_desc.sub_error_code == sub_error_code) {
+      return fmt::format("{},{}", ecode_desc.desc, extdes);
+    }
+  }
+  return fmt::format("unkown_e({}-{}),{}", (int)error_type, sub_error_code, extdes);
+}
+}  // namespace err
+}  // namespace iflytop

src/iflytop/core/error/error_code.hpp

@@ -0,0 +1,43 @@
+#pragma once
+#include <fstream>
+#include <functional>
+#include <iostream>
+#include <list>
+#include <map>
+#include <memory>
+#include <set>
+#include <sstream>
+#include <string>
+#include <vector>
+
+#include "iflytop/core/basic/nod/nod.hpp"
+#include "iflytop/core/spdlogfactory/logger.hpp"
+namespace iflytop {
+
+namespace err {
+using namespace std;
+typedef enum {
+  kovertime        = 1,
+  kdevice_offline  = 2,
+  kpasswd_error    = 3,
+  kparse_json_err  = 4,
+  kcatch_exception = 5,
+} common_error_code_t;
+
+typedef enum {
+  kcommon_error_code = 1,
+} error_type_t;
+
+class error_code_desc_t {
+ public:
+  error_type_t error_type;
+  int          sub_error_code;
+  string       desc;
+};
+
+int32_t error_code_get_get_ecode(error_type_t error_type, int sub_error_code);
+string  error_code_get_desc(error_type_t error_type, int sub_error_code, string extdes);
+
+}  // namespace err
+
+}  // namespace iflytop