hsync 0.18.3 → 0.20.0

package/lib/rtc-node.js

@@ -16,95 +16,105 @@ const defaultOptions = { iceServers: ['stun:stun.l.google.com:19302'] };
 
 const GATHERING_TIMEOUT = 4000;
 
-async function offerPeer(peer) {
-
-  if (!rtc.PeerConnection) {
-    throw new Error('node-datachannel not installed');
-  }
-
-  const con = new rtc.PeerConnection('pc', defaultOptions);
-  // window.rtc = rtc;
-
-  peer.rtcCon = con;
-  peer.rtcOfferer = true;
+function offerPeer(peer) {
+  return new Promise(async (resolve, reject) => {
+    if (!rtc.PeerConnection) {
+      reject('node-datachannel not installed');
+      return;
+    }
   
-  let gatheringComplete = false;
-  let offerSent = false;
-  const start = Date.now();
-
-  function sendOffer() {
-    const desc = con.localDescription();
-    peer.methods.rtcSignal({type: desc.type, sdp: desc.sdp});
-  }
-
-  con.onGatheringStateChange = (state) => {
-    debug('onGatheringStateChange', state);
-    if (state === 'complete') {
-      debug('icegathering done', Date.now() - start);
-      gatheringComplete = true;
-      // We only want to provide an answer once all of our candidates have been added to the SDP.
-      sendOffer();
+    const con = new rtc.PeerConnection('pc', defaultOptions);
+    // window.rtc = rtc;
+  
+    peer.rtcCon = con;
+    peer.rtcOfferer = true;
+    
+    let gatheringComplete = false;
+    let offerSent = false;
+    const start = Date.now();
+  
+    async function sendOffer() {
+      const desc = con.localDescription();
+      try {
+        const resp = await peer.methods.rtcSignal({type: desc.type, sdp: desc.sdp});
+        resolve(resp);
+      } catch (e) {
+        debugError('error sending offer', e);
+        reject(e);
+      }
+      // peer.methods.rtcSignal({type: desc.type, sdp: desc.sdp});
     }
-  }
-
-  con.onStateChange((state) => {
-    debug('offerer onStateChange: ', state);
-    if (state === 'connected') {
-      peer.connected = true;
-      peer.rtcEvents.emit('connected', con);
-    } else if (state === 'disconnected') {
-      peer.connected = false;
-      peer.rtcEvents.emit('disconnected', con);
-      peer.rtcCon = null;
-      peer.dc = null;
-    } else if (state === 'closed') {
-      peer.connected = false;
-      peer.rtcEvents.emit('closed', con);
-      peer.rtcCon = null;
-      peer.dc = null;
+  
+    con.onGatheringStateChange = (state) => {
+      debug('onGatheringStateChange', state);
+      if (state === 'complete') {
+        debug('icegathering done', Date.now() - start);
+        gatheringComplete = true;
+        // We only want to provide an answer once all of our candidates have been added to the SDP.
+        sendOffer();
+      }
     }
-  });
-
-  con.onDataChannel((dc) => {
-    debug('offerer onDataChannel', dc);
-    peer.dc = dc;
-  });
-
-  const dc = con.createDataChannel('fromofferer');
-  dc.onOpen(() => {
-    peer.dc = dc;
-    peer.dcOpen = true;
-    peer.rtcSend = (packet) => {
-      dc.sendMessageBinary(packet);
-    };
-    peer.rtcEvents.emit('dcOpen', dc);
-    // dc.sendMessage("Hello from node from offerer");
-    // peer.dc.onStateChange((state) => {
-    //   debug('dc state change', state);
-    // });
-    debug('keys', Object.keys(dc));
-  });
-
-  dc.onMessage((msg) => {
-    debug('node offerer received msg:', msg.length);
-    peer.rtcEvents.emit('packet', msg);
-  });
-
-  con.setLocalDescription();
-
-  setTimeout(() => {
-    if (!gatheringComplete) {
-      debug('didnt finish gathering');
-      sendOffer();
-      offerSent = true;
+  
+    con.onStateChange((state) => {
+      debug('offerer onStateChange: ', state);
+      if (state === 'connected') {
+        peer.connected = true;
+        peer.rtcEvents.emit('connected', con);
+      } else if (state === 'disconnected') {
+        peer.connected = false;
+        peer.rtcEvents.emit('disconnected', con);
+        peer.rtcCon = null;
+        peer.dc = null;
+      } else if (state === 'closed') {
+        peer.connected = false;
+        peer.rtcEvents.emit('closed', con);
+        peer.rtcCon = null;
+        peer.dc = null;
+      }
+    });
+  
+    con.onDataChannel((dc) => {
+      debug('offerer onDataChannel', dc);
+      peer.dc = dc;
+    });
+  
+    const dc = con.createDataChannel('fromofferer');
+    dc.onOpen(() => {
+      peer.dc = dc;
+      peer.dcOpen = true;
+      peer.rtcSend = (packet) => {
+        dc.sendMessageBinary(packet);
+      };
+      peer.rtcEvents.emit('dcOpen', dc);
+      // dc.sendMessage("Hello from node from offerer");
+      // peer.dc.onStateChange((state) => {
+      //   debug('dc state change', state);
+      // });
+      debug('keys', Object.keys(dc));
+    });
+  
+    dc.onMessage((msg) => {
+      debug('node offerer received msg:', msg.length);
+      peer.rtcEvents.emit('packet', msg);
+    });
+  
+    con.setLocalDescription();
+  
+    setTimeout(() => {
+      if (!gatheringComplete) {
+        debug('didnt finish gathering');
+        sendOffer();
+        offerSent = true;
+      }
+    }, GATHERING_TIMEOUT);
+  
+    peer.handleRtcAnswer = (answer) => {
+      debug('node handleRtcAnswer', answer.sdp.length);
+      con.setRemoteDescription(answer.sdp, answer.type);
+      return 'node handleRtcAnswer ok';
     }
-  }, GATHERING_TIMEOUT);
 
-  peer.handleRtcAnswer = (answer) => {
-    debug('node handleRtcAnswer', answer.sdp.length);
-    con.setRemoteDescription(answer.sdp, answer.type);
-    return 'node handleRtcAnswer ok';
-  }
+  });
 }
 
 async function answerPeer(peer, offer) {

package/lib/rtc-web.js

@@ -15,83 +15,90 @@ const defaultOptions = {
 const GATHERING_TIMEOUT = 4000;
 
 async function offerPeer(peer) {
+  return new Promise(async (resolve, reject) => {
+    const con = new RTCPeerConnection(defaultOptions);
+    // window.rtc = rtc;
+
+    peer.rtcCon = con;
+    peer.rtcOfferer = true;
+    
+    let gatheringComplete = false;
+    let offerSent = false;
+    const start = Date.now();
+
+    async function sendOffer(alreadySent) {
+      debug('send offer', alreadySent);
+      const desc = con.localDescription;
+      try {
+        const resp = await peer.methods.rtcSignal({type: desc.type, sdp: desc.sdp, alreadySent});
+        resolve(resp);
+      } catch (e) {
+        debugError('error sending offer', e);
+        reject(e);
+      }
+    }
 
-  const con = new RTCPeerConnection(defaultOptions);
-  // window.rtc = rtc;
-
-  peer.rtcCon = con;
-  peer.rtcOfferer = true;
-  
-  let gatheringComplete = false;
-  let offerSent = false;
-  const start = Date.now();
+    con.onicegatheringstatechange = (state) => {
+        debug('state change', con.iceGatheringState);
+        if (con.iceGatheringState === 'complete') {
+          debug('icegathering done', Date.now() - start);
+          gatheringComplete = true;
+          // We only want to provide an answer once all of our candidates have been added to the SDP.
+          sendOffer(offerSent);
+        }
+    }
 
-  function sendOffer(alreadySent) {
-    debug('send offer', alreadySent);
-    const desc = con.localDescription;
-    peer.methods.rtcSignal({type: desc.type, sdp: desc.sdp, alreadySent});
-  }
+    con.onicecandidate = (ice) => {
+      debug('ice candidate', ice);
+    };
 
-  con.onicegatheringstatechange = (state) => {
-      debug('state change', con.iceGatheringState);
-      if (con.iceGatheringState === 'complete') {
-        debug('icegathering done', Date.now() - start);
-        gatheringComplete = true;
-        // We only want to provide an answer once all of our candidates have been added to the SDP.
-        sendOffer(offerSent);
+    con.onconnectionstatechange = (event) => {
+      debug('connection state', con.connectionState, event);
+      if(con.connectionState === 'connected') {
+        peer.connected = true;
+        peer.rtcEvents.emit('connected', con);
       }
-  }
-
-  con.onicecandidate = (ice) => {
-    debug('ice candidate', ice);
-  };
-
-  con.onconnectionstatechange = (event) => {
-    debug('connection state', con.connectionState, event);
-    if(con.connectionState === 'connected') {
-      peer.connected = true;
-      peer.rtcEvents.emit('connected', con);
-    }
-  };
+    };
 
-  con.ondatachannel = (event) => {
-    debug('dc from answerer', event);
-    peer.dc = event.channel;
-  };
+    con.ondatachannel = (event) => {
+      debug('dc from answerer', event);
+      peer.dc = event.channel;
+    };
 
-  const dc = con.createDataChannel('from web');
+    const dc = con.createDataChannel('from web');
 
-  peer.dc = dc;
-  dc.onmessage = (event) => { 
-    debug('dc.onmessage', event.data);
-    peer.rtcEvents.emit('packet', event.data);
-  };
-  dc.onopen = (event) => { 
-    peer.dcOpen = true;
     peer.dc = dc;
-    peer.rtcSend = (packet) => {
-      dc.send(packet);
+    dc.onmessage = (event) => { 
+      debug('dc.onmessage', event.data);
+      peer.rtcEvents.emit('packet', event.data);
+    };
+    dc.onopen = (event) => { 
+      peer.dcOpen = true;
+      peer.dc = dc;
+      peer.rtcSend = (packet) => {
+        dc.send(packet);
+      };
+      peer.rtcEvents.emit('dcOpen', dc);
+      // dc.send('yo waddup from the browser');
     };
-    peer.rtcEvents.emit('dcOpen', dc);
-    // dc.send('yo waddup from the browser');
-  };
 
-  const offer = await con.createOffer({offerToReceiveAudio:true, offerToReceiveVideo:true});
-  await con.setLocalDescription(offer);
+    const offer = await con.createOffer({offerToReceiveAudio:true, offerToReceiveVideo:true});
+    await con.setLocalDescription(offer);
 
-  setTimeout(() => {
-    if (!gatheringComplete) {
-      debug('didnt finish gathering');
-      sendOffer();
-      offerSent = true;
-    }
-  }, GATHERING_TIMEOUT);
+    setTimeout(() => {
+      if (!gatheringComplete) {
+        debug('didnt finish gathering');
+        sendOffer();
+        offerSent = true;
+      }
+    }, GATHERING_TIMEOUT);
 
-  peer.handleRtcAnswer = (answer) => {
-    debug('node handleRtcAnswer', answer.sdp.length);
-    con.setRemoteDescription(answer);
-    return 'web handleRtcAnswer ok';
-  }
+    peer.handleRtcAnswer = (answer) => {
+      debug('node handleRtcAnswer', answer.sdp.length);
+      con.setRemoteDescription(answer);
+      return 'web handleRtcAnswer ok';
+    }
+  });
 }
 
 async function answerPeer(peer, offer) {

package/lib/socket-listeners.js

@@ -0,0 +1,182 @@
+const b64id = require('b64id');
+const debug = require('debug')('hsync:listener');
+const debugError = require('debug')('hsync:error');
+
+const { sockets } = require('./socket-map');
+
+let net;
+
+function setNet(netImpl) {
+  net = netImpl;
+}
+
+debugError.color = 1;
+
+function initListeners(hsyncClient) {
+  const socketListeners = {};
+
+  function getSocketListeners() {
+    const hKeys = Object.keys(socketListeners);
+    debug('getSocketListeners', hKeys);
+    let retVal = hKeys.map((hk) => {
+      const l = socketListeners[hk];
+      return {
+        port: l.port,
+        targetHost: l.targetHost,
+        targetPort: l.targetPort,
+      };
+    });
+    return retVal;
+  }
+
+  function addSocketListener(options = {}) {
+    const { port, targetPort, targetHost } = options;
+    debug('creating handler', port, targetHost);
+    
+    const rpcPeer = hsyncClient.getRPCPeer({ hostName: targetHost });
+
+    const socketServer = net.createServer(async (socket) => {
+
+      if (!rpcPeer.rtcCon) {
+        try {
+          debug('initiating connectRTC from socket listener');
+          await rpcPeer.connectRTC();
+        } catch (e) {
+          debug('error connecting to rtc', e);
+          socket.end();
+          return;
+        }
+      }
+
+      rpcPeer.notifications.oncloseListenerSocket((remotePeer, { socketId }) => {
+        debug('closeListenerSocket', socketId, !!sockets[socketId]);
+        if (sockets[socketId]) {
+          sockets[socketId].end();
+          delete sockets[socketId];
+          return 'closeListenerSocket ok';
+        }
+        return `closeListenerSocket no matching socket for ${socketId}`;
+      });
+
+      socket.socketId = b64id.generateId();
+      sockets[socket.socketId] = socket;
+      rpcPeer.sockets[socket.socketId] = socket;
+      socket.listenerSocket = true;
+      debug('connected to local listener', port, socket.socketId);
+      socket.peerConnected = false;
+      // const pubTopic = `msg/${hostName}/${hsyncClient.myHostName}/socketData/${socket.socketId}`;
+      // const closeTopic = `msg/${hostName}/${hsyncClient.myHostName}/socketClose/${socket.socketId}`;
+      const dataQueue = [];
+
+      async function sendData(data) {
+        // TODO queue data if not connected
+        if (rpcPeer.packAndSend) {
+          debug('sending data via rtc', targetHost, socket.socketId, data.length);
+          rpcPeer.packAndSend(`socketData/${socket.socketId}`, data);
+          return;
+        }
+        // debug('sending data via rpc', targetHost, data.length);
+        // // hsyncClient.mqConn.publish(pubTopic, data);
+        // const result = await rpcPeer.methods.receiveListenerData({
+        //   socketId: socket.socketId,
+        //   data: Buffer.from(data).toString('base64'),
+        // });
+        // debug('sendData from Listener', result);
+      }
+
+      socket.on('data', async (data) => {
+        debug('socket data', data ? data.length : '');
+        // if (!socket.peerConnected) {
+        //   dataQueue.push(data);
+        //   return;
+        // }
+        sendData(data);
+      });
+    
+      socket.on('close', (a, b, c) => {
+        debug('listener socket closed', port, socket.socketId, a, b, c);
+        if (sockets[socket.socketId]) {
+          delete sockets[socket.socketId];
+          try {
+            rpcPeer.notifiers.closeRelaySocket({
+              socketId: socket.socketId,
+            });
+          } catch (e) {
+            debug('error closing relay socket', e);
+          }
+        }
+      });
+    
+      socket.on('error', (error) => {
+        debug('socket error', targetHost, socket.socketId, error);
+        if (sockets[socket.socketId]) {
+          delete sockets[socket.socketId];
+        }
+      });
+    
+      try {
+        debug('connecting remotely', socket.socketId, targetPort, rpcPeer.hostName, targetHost);
+        const result = await rpcPeer.methods.connectSocket({
+          socketId: socket.socketId,
+          port: targetPort,
+          hostName: rpcPeer.hostName,
+        });
+        debug('connect result', result);
+        socket.peerConnected = true;
+        dataQueue.forEach(sendData);      
+      } catch (e) {
+        debugError('cant connect remotely', targetHost, targetPort, e);
+        if (sockets[socket.socketId]) {
+          delete sockets[socket.socketId];
+        }
+        socket.end();
+      }
+    });
+
+    socketServer.listen(port);
+
+    function end() {
+      const sockKeys = Object.keys(sockets);
+      sockKeys.forEach((sk) => {
+        try {
+          if (sockets[sk].listenerSocket) {
+            sockets[sk].end();
+            delete sockets[sk];
+          }
+        }
+        catch(e) {
+          debug('error closing socket', e);
+        }
+      });
+    }
+
+    const listener = {
+      socketServer,
+      sockets,
+      end,
+      targetHost,
+      targetPort,
+      port,
+    };
+
+    socketListeners['p' + port] = listener;
+    return listener;
+  }
+
+  hsyncClient.socketListeners = socketListeners;
+  hsyncClient.addSocketListener = addSocketListener;
+  // hsyncClient.receiveRelayData = receiveRelayData;
+  hsyncClient.getSocketListeners = getSocketListeners;
+  // hsyncClient.closeListenerSocket = closeListenerSocket;
+
+  return {
+    addSocketListener,
+    // receiveRelayData,
+    getSocketListeners,
+  };
+}
+
+module.exports = { 
+  initListeners,
+  setNet,
+};

package/lib/socket-relays.js

@@ -0,0 +1,123 @@
+const debug = require('debug')('hsync:relay');
+const debugError = require('debug')('hsync:error');
+const { sockets } = require('./socket-map');
+
+debugError.color = 1;
+
+let net;
+
+function setNet(netImpl) {
+  net = netImpl;
+}
+
+function initRelays(hsyncClient) {
+  const cachedRelays = {};
+
+  function getSocketRelays() {
+    const hKeys = Object.keys(cachedRelays);
+    debug('getSocketListeners', hKeys);
+    let retVal = hKeys.map((hk) => {
+      const l = cachedRelays[hk];
+      return {
+        port: l.port,
+        targetHost: l.targetHost,
+        targetPort: l.targetPort,
+        whitelist: l.whitelist || '',
+        blacklist: l.blacklist || '',
+      };
+    });
+    return retVal;
+  }
+
+  function connectSocket(remotePeer, { port, socketId }) {
+
+    remotePeer.notifications.oncloseRelaySocket((remotePeer, { socketId }) => {
+      debug('closeRelaySocket', socketId);
+      if (sockets[socketId]) {
+        sockets[socketId].end();
+        delete sockets[socketId];
+        return 'closeRelaySocket ok';
+      }
+      return `closeRelaySocket no matching socket for ${socketId}`;
+    });
+
+    const relay = cachedRelays['p' + port];
+    debug('connect relay', port, socketId, remotePeer.hostName);
+    if (!relay) {
+      throw new Error('no relay found for port: ' + port);
+    }
+
+    //  TODO: check white and black lists on remotePeer
+
+    // const relayDataTopic = `msg/${hostName}/${hsyncClient.myHostName}/relayData/${socketId}`;
+    return new Promise((resolve, reject) => {
+      const socket = new net.Socket();
+      socket.socketId = socketId;
+      sockets[socketId] = socket;
+      socket.connect(relay.targetPort, relay.targetHost, () => {
+        debug(`CONNECTED TO LOCAL SERVER`, socket.socketId, socket.hostName, port);
+        resolve({socketId, targetHost: relay.targetHost, targetPort: relay.targetPort});
+      });
+
+      socket.on('data', async (data) => {
+        debug(`data in ${socket.socketId}`, relay.targetPort, relay.targetHost, data.length);
+        // TODO: queue data if remotePeer is not ready
+        if (remotePeer.packAndSend) {
+          debug('sending relay data via rtc', socket.socketId, data.length);
+          remotePeer.packAndSend(`socketData/${socket.socketId}`, Buffer.from(data));
+          return;
+        }
+      });
+      socket.on('close', async () => {
+        debug(`LOCAL CONNECTION CLOSED`, socket.socketId);
+        if (sockets[socket.socketId]) {
+          try {
+            await remotePeer.notifiers.closeListenerSocket({socketId});
+          } catch (e) {
+            debug('error closing socket', e);
+          }
+          delete sockets[socket.socketId];
+        }
+      });
+
+      socket.on('error', (e) => {
+        debugError(`LOCAL CONNECTION ERROR`, socket.socketId, e);
+        delete sockets[socket.socketId];
+        reject(e);
+      });
+    
+    });
+
+  }
+
+  function addSocketRelay({whitelist, blacklist, port, targetPort, targetHost = 'localhost'}) {
+    targetPort = targetPort || port;
+    debug('creating relay', whitelist, blacklist, port, targetPort, targetHost);
+    const newRelay = {
+      whitelist,
+      blacklist,
+      port,
+      targetPort,
+      targetHost,
+    };
+    cachedRelays['p' + port] = newRelay;
+    return newRelay;
+  }
+
+  hsyncClient.cachedRelays = cachedRelays;
+  hsyncClient.addSocketRelay = addSocketRelay;
+  hsyncClient.getSocketRelays = getSocketRelays;
+  hsyncClient.connectSocket = connectSocket;
+  
+  return {
+    // receiveListenerData,
+    getSocketRelays,
+    connectSocket,
+    addSocketRelay,
+  };
+}
+
+module.exports = {
+  initRelays,
+  setNet,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hsync",
-  "version": "0.18.3",
+  "version": "0.20.0",
   "description": "client for hsync-server",
   "main": "hsync.js",
   "scripts": {
@@ -24,7 +24,8 @@
     "./hsync": "./hsync-web"
   },
   "bin": {
-    "hsync": "./cli.js"
+    "hsync": "./cli.js",
+    "sh-hsync": "./shell.js"
   },
   "author": "Luis Montes",
   "license": "ISC",
@@ -38,14 +39,14 @@
     "mqtt-packet-web": "^8.2.0",
     "net-web": "^0.2.0",
     "precompiled-mqtt": "^4.3.14-beta",
-    "rawr": "^0.15.1",
-    "webpack": "^5.88.2",
-    "webpack-cli": "^4.10.0"
+    "rawr": "^0.15.1"
   },
   "optionalDependencies": {
     "node-datachannel": "^0.4.3"
   },
   "devDependencies": {
-    "nodemon": "^3.0.1"
+    "nodemon": "^3.0.1",
+    "webpack": "^5.88.2",
+    "webpack-cli": "^4.10.0"
   }
 }