EventNotifications: send/handle foreign events. Objects serialization: ApiCall and Event

Author: etienne-85

ApiModule.cpp

@@ -12,22 +12,7 @@ ApiModule::ApiModule(std::string msgType) {
 // STATIC DEF
 std::map<std::string, ApiModule *> ApiModule::registeredApiModules;
 
-std::string ApiModule::dispatchApiRequest(std::string apiRequestMsg) {
-  JsonDocument apiRequest;
-  // convert to a json object
-  DeserializationError error = deserializeJson(apiRequest, apiRequestMsg);
-  std::string interfaceType = "<type>";
-  LogStore::dbg("[MessageInterface::onMessage] received message on " +
-                interfaceType + " interface: " + apiRequestMsg);
-  // root msg level props
-  // std::string msgContext = msgRoot["context"];
-  // API module, submodule, command
-  JsonObject apiData = apiRequest["api"];
-  std::string apiModuleName = apiData["module"];
-  std::string apiSubmodule = apiData["submod"];
-  std::string apiCmd = apiData["cmd"];
-  std::string apiInput = apiData["input"]; // API module/submodule input data
-
+std::string ApiModule::dispatchApiCall(ApiCall &apiCall) {
   // TODO
   // std::string msgSrc = type; // interface type (LORA,WS)
   // std::string msgCtx = msgRoot["ctx"];
@@ -40,13 +25,12 @@ std::string ApiModule::dispatchApiRequest(std::string apiRequestMsg) {
   // bool bypassEvtQueue(msgMode == "sync");
   // EventQueue::pushEvent(event, bypassEvtQueue);
   // find corresponding sub service
-  auto apiModule = ApiModule::registeredApiModules.find(apiModuleName);
+  auto apiModule = ApiModule::registeredApiModules.find(apiCall.apiModule);
   if (apiModule != ApiModule::registeredApiModules.end()) {
     LogStore::info(
-        "[ApiModule::dispatchApiRequest] API request dispatched to module " +
-        apiModuleName);
-    //     std::string dataOut = apiModule->second->onApiCall(incomingMsg,
-    //     clientKey);
+        "[ApiModule::dispatchApiCall] API request dispatched to module " +
+        apiCall.apiModule);
+    std::string dataOut = apiModule->second->onApiCall(apiCall);
     //     // default empty reply
     //     std::string outgoingMsg("");
     //     bool expectedReply = timestamp > 0 || dataOut.length() > 0;
@@ -72,8 +56,8 @@ std::string ApiModule::dispatchApiRequest(std::string apiRequestMsg) {
     //     }
     //     return outgoingMsg;
   } else {
-    LogStore::info("[ApiModule::dispatchMsg] unregistered API module: " +
-                   apiModuleName);
+    LogStore::info("[ApiModule::dispatchApiCall] unregistered API module: " +
+                   apiCall.apiModule);
   }
   return "";
 }

ApiModule.h

@@ -1,7 +1,9 @@
 #pragma once
 #include <map>
+#include <CommonObjects.h>
 
 /*
+ * API modules reachable through MessageInterface
  * Each inheriting class will be registered as service and must be singleton
  * When api call or request is received, it will be dispatched to matching
  declared service instance
@@ -15,9 +17,16 @@
  which is identified depends on interface type
  * - LORA: deviceId
  * - WS: opened socket (clientKey)
- *
+ * 
+ * Modules examples: Test, Monitor, Benchmark, 
+ * API usescases:
+ - device capabilities: API modules available on device, 
+ - device monitoring: report ESP32 internal state like EventQueue, registered EventListeners
+ - benchmark device: latency by sending multiple requests, 
+ - configure runtime config like frequency of lora notifications, LORA dutycyle
  */
 // class ApiRequestHandler {
+
 class ApiModule {
   static std::map<std::string, ApiModule *> registeredApiModules;
   // static std::map<std::string, ApiModule *> serviceHandlers;
@@ -27,8 +36,8 @@ class ApiModule {
   ApiModule(std::string serviceId);
 
 public:
-  static std::string dispatchApiRequest(std::string apiRequestMsg);
+  static std::string dispatchApiCall(ApiCall &apiCall);
   // TO BE IMPLEMENTED IN CHILD CLASS
 
-  virtual std::string onApiCall(std::string rawMsg) = 0;
+  virtual std::string onApiCall(ApiCall &apiCall) = 0;
 };

CommonObjects.cpp

@@ -0,0 +1,82 @@
+#include <ArduinoJson.h>
+#include <CommonObjects.h>
+#include <LogStore.h>
+#include <iostream>
+#include <utils.h>
+
+// ApiCall::ApiCall(std::string apiModule, std::string call, std::string data)
+//     : apiModule(apiModule), call(call), data(data){};
+
+/*
+Parse API call from MSG
+*/
+void ApiCall::fromMsg(std::string msg) {
+  JsonDocument msgData;
+  // convert to a json object
+  DeserializationError error = deserializeJson(msgData, msg);
+  std::string apiModuleCall = msgData["apiCall"];
+  std::string sData = msgData["data"];
+  std::vector<std::string> items = splitFromCharDelim(apiModuleCall, ':');
+  apiModule = items.at(0);
+  call = items.at(1);
+  data = sData;
+}
+
+std::string ApiCall::toMsg() {
+  // convert object to JSON
+  JsonDocument jsonObj;
+  jsonObj["apiCall"] = apiModule + ":" + call;
+  jsonObj["data"] = data;
+  std::cout << std::hex << apiModule << std::endl;
+  std::string jsonMsg("");
+  serializeJson(jsonObj, jsonMsg);
+  return jsonMsg;
+}
+
+// /*
+// Transport API call over MSG
+// */
+// std::string ApiCall::toMsg() {
+//   JsonDocument apiCall;
+//   apiCall["module"] = apiModule;
+//   apiCall["call"] = call;
+//   apiCall["data"] = data;
+//   std::string apiCallMsg;
+//   serializeJson(req, apiCallMsg);
+//   return apiCallMsg;
+// }
+
+ForeignEvent::ForeignEvent() {}
+
+ForeignEvent::ForeignEvent(Event evt, std::string source) : Event(evt) {
+  context.source = source;
+}
+
+// create event object from JSON
+void ForeignEvent::fromObjContent(std::string objContent) {
+  JsonDocument objData;
+  // convert content to a json object
+  DeserializationError error = deserializeJson(objData, objContent);
+  // parse JSON and fill object fields
+  std::string evtType = objData["evtType"];
+  std::string evtData = objData["evtData"];
+  std::string evtSrc = objData["evtSender"];
+  EventContext evtContext; // use default, customise any required fields
+  evtContext.source = evtSrc;
+  // evtCtx.timestamp = msgTime ? msgTime : evtCtx.time;
+  // evtCtx.priority = 0;
+  type = evtType;
+  data = evtData;
+  context = evtContext;
+}
+
+// convert event object to JSON
+std::string Event::toObjContent() {
+  JsonDocument jsonObj;
+  jsonObj["evtType"] = type;
+  jsonObj["evtData"] = data;
+  jsonObj["evtSender"] = context.source;
+  std::string jsonMsg("");
+  serializeJson(jsonObj, jsonMsg);
+  return jsonMsg;
+}

CommonObjects.h

@@ -0,0 +1,69 @@
+#pragma once
+#include <string>
+/*
+Object container to be put in message
+Typical objects to be carried over messages are:
+- API calls
+- Foreign events
+*/
+
+// class MsgObj {
+//   template <class T> static T &fromString(std::string msgObj);
+//   template <class T> static T &fromMinifiedString(std::string msgObj);
+//   // export foreign event content to send over MSG
+//   virtual std::string toString() = 0;
+//   virtual std::string toMinifiedString() = 0;
+// };
+
+// template <T>
+// MsgObj::fromMsgObj(std::string msgObj){
+//     return T::fromMsgObj(msgObj);
+// }
+
+// class ApiCall : public MsgObj {
+class ApiCall {
+public:
+  std::string apiModule;
+  std::string call;
+  std::string data;
+
+  // ApiCall(std::string apiModule, std::string call, std::string data);
+
+  void fromMsg(std::string msg);
+  void fromMinifiedString(std::string msg);
+  std::string toMsg();
+  std::string toMinifiedString();
+};
+
+/*
+
+Event -- (export to EVTOBJ) --> MSG -- (parse from EVTOBJ) --> ForeignEvent
+*/
+// additional information about event
+// events can be filtered based on context
+typedef struct {
+  // EventOrigin origin = EventOrigin::LOCAL;
+  std::string source = "local"; // original source from where event comes from
+  int timestamp = 0;
+  int priority = 0;
+} EventContext;
+
+class Event {
+public:
+  std::string type;
+  std::string data;
+  EventContext context;
+  // serialize event content to send over MSG
+  std::string toObjContent();
+};
+/*
+apiCall: "EvtMsgNot:onForeignEvt"
+orig:
+*/
+class ForeignEvent : public Event {
+public:
+  // std::string source;
+  ForeignEvent();
+  ForeignEvent(Event evt, std::string source);
+  void fromObjContent(std::string objContent);
+};