add feedback for msg

src/feedbackManager.js

@@ -0,0 +1,25 @@
+const protocol = "/feedback"
+
+export class FeedbackManager {
+  constructor(logger, wsManager, messageHandler) {
+    this.logger = logger;
+    this.wsManager = wsManager;
+    this.messageHandler = messageHandler;
+  }
+
+  sendFeedbackMessage(response, ws) {
+    this.logger.INFO(response, "feedback handler")
+    const msg = this.#formatMessage(response, protocol)
+    for (const client of this.wsManager.wsServer.clients) {
+      if (ws == client) {
+        client.send(JSON.stringify(msg))
+      }
+    }
+    return
+  }
+
+  #formatMessage(response, protocol) {
+    return { "data": { "feedback": response } , "protocol": protocol}
+  }
+
+}

src/index.js

@@ -5,6 +5,7 @@ import { WebSocketManager } from './wsManager.js';
 import { MessageHandler } from './messageHandler.js';
 import { createDir4SavedData } from '../utils/saveData.js';
 import { Logger } from '../utils/logger.js';
+import { FeedbackManager } from './feedbackManager.js';
 
 async function run() {
   const logger = new Logger();
@@ -13,9 +14,11 @@ async function run() {
 
   const node = await libp2pManager.createNode();
   const messageHandler = new MessageHandler(libp2pManager, logger);
-  const wsManager = new WebSocketManager(messageHandler, logger);
+  const wsManager = new WebSocketManager(messageHandler, logger, node);
   const relayAddr = multiaddr(libp2pManager.realayAddress)
-  wsManager.onConnectionManager(node);
+  const feedbackManager = new FeedbackManager(logger, wsManager, messageHandler)
+  libp2pManager.setFeedbackManager(feedbackManager)
+  wsManager.onConnectionManager();
 
   logger.INFO(`Node started with id ${node.peerId.toString()}`);
   const conn = await node.dial(relayAddr);

src/libp2pManager.js

@@ -20,6 +20,11 @@ export class Libp2pManager {
     this.configuration = new ConfigurationManager(logger);
     this.realayAddress = '/dns4/libp2p-relay-1.robonomics.network/tcp/443/wss/p2p/12D3KooWEMFXXvpZUjAuj1eKR11HuzZTCQ5HmYG9MNPtsnqPSERD';
     this.logger = logger;
+    this.feedbackManager = undefined
+  }
+
+  setFeedbackManager(feedbackManager) {
+    this.feedbackManager = feedbackManager
   }
 
   /**
@@ -174,16 +179,22 @@ export class Libp2pManager {
    * @param data Message to send.
    * @param protocol Name of the Libp2p protocol.
   */
-  async sendMsg(connection, data, protocol) {
+  async sendMsg(connection, data, protocol, ws) {
     try {
       const isRelay = this.#isConnectionNotRelay(connection.remoteAddr.toString());
       if (!isRelay) {
         const response = await this.#request(connection, protocol, data);
         this.logger.INFO(`Sending message to ${connection.remoteAddr.toString()}`);
         this.logger.INFO(response, ' got response from sendMsg');
+        if (!(typeof ws === "undefined")) {
+          this.feedbackManager.sendFeedbackMessage(response, ws)
+        }
       }
     } catch (error) {
       this.logger.ERROR(error.message, 'sendMsg');
+      if (ws) {
+        this.feedbackManager.sendFeedbackMessage(error.message, ws)
+      }
     }
   }
 

src/messageHandler.js

@@ -112,7 +112,7 @@ export class MessageHandler {
    * @param  msg The message from the ws client.
    * @param node Instance of libp2p node
    */
-  onWSMessage(msg, node) {
+  onWSMessage(msg, node, ws) {
     this.logger.INFO('Sending msg from ws to libp2p...');
     const { protocol } = msg;
     const { serverPeerId } = msg;
@@ -127,13 +127,13 @@ export class MessageHandler {
         this.libp2pManager.sendMsg(connection, msg.data, protocol);
       } else {
         this.libp2pManager.connect2NodeViaRelay(node, serverPeerId).then((connection) => {
-          this.libp2pManager.sendMsg(connection, msg.data, protocol);
+          this.libp2pManager.sendMsg(connection, msg.data, protocol, ws)
         }).catch((error) => { this.logger.ERROR(error, "onWSMessage couldn't resolve promise"); });
       }
     } else {
       node.getConnections().forEach((connection) => {
-        this.libp2pManager.sendMsg(connection, msg.data, protocol);
+        this.libp2pManager.sendMsg(connection, msg.data, protocol, ws);
       });
     }
   }
-}
+}

src/wsManager.js

@@ -7,12 +7,13 @@ import { WebSocketServer } from 'ws';
  * @param logger Instance of the Logger class.
  */
 export class WebSocketManager {
-  constructor(messageHandler, logger) {
+  constructor(messageHandler, logger, node) {
     this.wsServer = this.#createWebsocketServer();
     this.messageHandler = messageHandler;
     this.clientIdCounter = 1;
     this.clients = new Map();
     this.logger = logger;
+    this.node = node;
   }
 
   /**
@@ -59,26 +60,26 @@ export class WebSocketManager {
    * @param ws Instance of ws connection.
    * @param newInfo Info to add.
    */
-  onConnectionManager(node) {
+  onConnectionManager() {
     this.wsServer.on('connection', (ws, req) => {
       this.#setClient(ws, req);
-      const multiAddresses = node.getMultiaddrs().map((addr) => addr.toString());
+
+      const multiAddresses = this.node.getMultiaddrs().map((addr) => addr.toString());
       this.messageHandler.sendMsg2WSClients(
         this.wsServer,
         this.clients,
-        { peerId: node.peerId.toString(), multiAddresses },
+        { peerId: this.node.peerId.toString(), multiAddresses },
       );
       ws.on('error', console.error);
       ws.on('message', (data) => {
         try {
           const msg = JSON.parse(data);
-          this.logger.INFO('Received ws message');
 
           if ('protocols_to_listen' in msg) {
             this.updateClientInfo(ws, { protocolsToListen: msg.protocols_to_listen });
-            this.messageHandler.onWSInitialMessage(msg, this.wsServer, this.clients, node);
+            this.messageHandler.onWSInitialMessage(msg, this.wsServer, this.clients, this.node);
           } else {
-            this.messageHandler.onWSMessage(msg, node);
+            this.messageHandler.onWSMessage(msg, this.node, ws);
           }
         } catch (error) {
           this.logger.ERROR(error, 'onConnectionManager');