hsync 0.17.0 → 0.18.0

package/dist/hsync.min.js.LICENSE.txt

@@ -8,3 +8,5 @@
 /*! For license information please see mqtt.browser.js.LICENSE.txt */
 
 /*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */
+
+/*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */

package/hsync-web.js

@@ -2,11 +2,15 @@ const mqtt = require('precompiled-mqtt');
 const buffer = require('buffer');
 const net = require('net-web');
 const { createHsync, setNet, setMqtt } = require('./connection');
+const { setRTC } = require('./lib/peers');
+const rtc = require('./lib/rtc-web');
 const config = require('./config');
 
+
 // TODO need to make this work with web/service workers
 window.Buffer = buffer.Buffer;
 
+setRTC(rtc);
 setNet(net);
 setMqtt(mqtt);
 

package/hsync.js

@@ -2,7 +2,10 @@ const net = require('net');
 const mqtt = require('mqtt');
 const { createHsync, setNet, setMqtt } = require('./connection');
 const config = require('./config');
+const { setRTC } = require('./lib/peers');
+const rtc = require('./lib/rtc-node');
 
+setRTC(rtc);
 setNet(net);
 setMqtt(mqtt);
 

package/lib/peers.js

@@ -0,0 +1,237 @@
+const rawr = require('rawr');
+const b64id = require('b64id');
+const debug = require('debug')('hsync:peers');
+const EventEmitter = require('events').EventEmitter;
+const buffer = require('buffer');
+const mqttPacket = require('mqtt-packet-web');
+
+globalThis.Buffer = buffer.Buffer;
+
+const { handleSocketPacket } = require('./socket-map');
+const fetch = require('./fetch');
+
+const peers = {};
+
+let rtc;
+
+function setRTC(rtcImpl) {
+  rtc = rtcImpl;
+}
+
+function createPacket(topic, payload) {
+  let payloadStr = payload;
+  // console.log('mqttPacket', { topic, payload });
+  // if (payload instanceof Uint8Array) {
+  //   console.log('str payload', new TextDecoder().decode(payload));
+  // }
+  const packet =  mqttPacket.generate({
+    qos: 0,
+    cmd: 'publish',
+    topic,
+    payload: payloadStr,
+  });
+  // console.log('packet', packet);
+  return packet;
+}
+
+function parsePacket(packet) {
+  const parser = mqttPacket.parser();
+  return new Promise((resolve, reject) => {
+    parser.on('packet', resolve);
+    parser.on('error', reject);
+    parser.parse(packet);
+  });
+}
+
+function getRPCPeer(options = {}) {
+  const { hostName, temporary, timeout = 10000, hsyncClient } = options;
+  let peer = peers[hostName];
+  if (!peer) {
+    debug('CREATING peer', hostName);
+    peer = createRPCPeer({hostName, hsyncClient, timeout});
+    if (temporary) {
+      peer.rpcTemporary = true;
+    }
+    peers[hostName] = peer;
+  }
+  return peer;
+}
+
+function createRPCPeer(options = {}) {
+  const { hostName, hsyncClient, timeout = 10000, useRTC = true } = options;
+  if (!hostName) {
+    throw new Error('No hostname specified');
+  }
+  if (hostName === hsyncClient.myHostName) {
+    throw new Error('Peer must be a different host');
+  }
+  const myAuth = b64id.generateId();
+  const transport = new EventEmitter();
+  const peer = rawr({transport, methods: Object.assign({}, hsyncClient.peerMethods), timeout, idGenerator: b64id.generateId});
+  peer.hostName = hostName;
+  peer.rtcEvents = new EventEmitter();
+  peer.localMethods = Object.assign({}, hsyncClient.peerMethods);
+  peer.sockets = {};
+
+  peer.localMethods.rtcSignal = (peerInfo, signal) => {
+    debug('rtcSignal', signal.type);
+    if (signal.type === 'offer' && !peer.rtcCon && !signal.alreadySent) {
+      rtc.answerPeer(peer, signal);
+    } else if (signal.type === 'answer') {
+      peer.handleRtcAnswer(signal);
+    }
+    return 'rtcSignal ok';
+  }
+
+  peer.rtcEvents.on('packet', async (packet) => {
+    try {
+      const msg = await parsePacket(packet);
+      const [p1, p2, p3] = msg.topic.split('/');
+      if (p1 === 'rpc') {
+        transport.receiveData(JSON.parse(msg.payload.toString()));
+      } else if (p1 === 'socketData'){
+        handleSocketPacket(msg);
+      } else {
+        debug('other topic', msg.topic);
+      }
+    } catch (e) {
+      debug('bad packet', e);
+    }
+  });
+
+  peer.rtcEvents.on('dcOpen', () => {
+    debug('dcOpen');
+    peer.packAndSend = (topic, payload) => {
+      const packet = createPacket(topic, payload);
+      peer.rtcSend(packet);
+    }
+  });
+
+  peer.rtcEvents.on('closed', () => {
+    peer.dcOpen = false;
+    delete peer.packAndSend;
+    debug('rtc closed');
+    for (s in peer.sockets) {
+      try {
+        debug('closing socket', s);
+        peer.sockets[s].destroy();
+        delete peer.sockets[s];
+      } catch (e) {
+        debug('error closing socket', e);
+      }
+    }
+  });
+
+  peer.rtcEvents.on('disconnected', () => {
+    peer.dcOpen = false;
+    delete peer.packAndSend;
+    debug('rtc disconnected');
+    for (s in peer.sockets) {
+      try {
+        debug('closing socket', s);
+        peer.sockets[s].destroy();
+        delete peer.sockets[s];
+      } catch (e) {
+        debug('error closing socket', e);
+      }
+    }
+  });
+
+  peer.connectRTC = async () => {
+    debug('connectRTC');
+    
+    return new Promise(async (resolve, reject) => {
+      try {
+        const offer = await rtc.offerPeer(peer);
+        peer.rtcEvents.once('dcOpen', () => {
+          debug('dcOpen!');
+          resolve(offer);
+        });
+      } catch (e) {
+        reject(e);
+      }
+    });
+  };
+
+  transport.send = async (msg) => {
+    const fullMsg = {
+      msg,
+      myAuth,
+      toHost: hostName,
+      fromHost: hsyncClient.webUrl,
+    };
+
+    debug('↑ peer rpc', peer.dcOpen ? 'RTC' : 'REST', `${hostName}/_hs/rpc`, msg.method);
+
+    if (peer.dcOpen) {
+      let payload = msg;
+      if (typeof msg === 'object') {
+        payload = JSON.stringify(payload);
+      }
+      const packet = createPacket('rpc', payload);
+      peer.rtcSend(packet);
+      return;
+    }
+
+    try {
+      debug('fetching', fullMsg, useRTC);
+      const result = await fetch.post(`${hostName}/_hs/rpc`, fullMsg);
+      debug('fetch result', result);
+      if (msg.id) {
+        transport.receiveData({id: msg.id, result, jsonrpc: msg.jsonrpc});
+      }
+      // if (!peer.rtcCon && useRTC) {
+      //   debug('STARTING rtc creation');
+      //   rtc.offerPeer(peer);
+      // }
+    } catch(e) {
+      debug('error sending peer RPC request', e);
+      transport.receiveData({id: msg.id, error: e, method: msg.method, jsonrpc: msg.jsonrpc});
+    }
+  
+  };
+
+  transport.receiveData = (msg) => {
+    if(typeof msg === 'string') {
+      msg = JSON.parse(msg);
+    }
+    debug('↓ peer rpc receivedData', msg, msg.params);
+    if (msg.params && Array.isArray(msg.params)) {
+      debug('unshifting', msg.params);
+      msg.params.unshift(peer);
+    }
+    transport.emit('rpc', msg);
+  };
+
+  peer.myAuth = myAuth;
+  peer.hostName = hostName;
+  return peer;
+}
+
+function createServerPeer(hsyncClient, methods) {
+  const transport = new EventEmitter();
+  transport.send = (msg) => {
+    if(typeof msg === 'object') {
+      msg = JSON.stringify(msg);
+    }
+    const topic = `srpc/${hsyncClient.myHostName}`;
+    debug('↑ server rpc request', msg);
+    hsyncClient.mqConn.publish(topic, Buffer.from(msg));
+  };
+  transport.receiveData = (msg) => {
+    if(msg) {
+      msg = JSON.parse(msg);
+    }
+    debug('↓ server rpc reply', msg.method, msg.id);
+    transport.emit('rpc', msg);
+  };
+  const peer = rawr({transport, methods, timeout: 5000});
+  return peer;
+}
+
+module.exports = {
+  createRPCPeer,
+  createServerPeer,
+  getRPCPeer,
+  setRTC,
+};

package/lib/rtc-node.js

@@ -0,0 +1,168 @@
+const debug = require('debug')('hsync:rtc-node');
+const debugError = require('debug')('errors');
+let nodeDataChannel;
+try {
+  nodeDataChannel = require('node-datachannel');
+} catch (e) {
+  debugError(e);
+}
+
+const rtc = {
+  PeerConnection: nodeDataChannel?.PeerConnection,
+};
+
+
+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;
+  
+  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();
+    }
+  }
+
+  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('dc from offerer', dc);
+    peer.dc = dc;
+  });
+
+  const dc = con.createDataChannel('fromofferer');
+  dc.onOpen(() => {
+    peer.dc = dc;
+    peer.dcOpen = true;
+    peer.rtcEvents.emit('dcOpen', dc);
+    peer.rtcSend = (packet) => {
+      dc.sendMessageBinary(packet);
+    };
+    // 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';
+  }
+}
+
+async function answerPeer(peer, offer) {
+  if (!rtc.PeerConnection) {
+    throw new Error('node-datachannel not installed');
+  }
+
+  const con = new rtc.PeerConnection('pc', defaultOptions);
+  peer.rtcCon = con;
+  
+  function sendAnswer() {
+    const desc = con.localDescription();
+    peer.methods.rtcSignal({type: desc.type, sdp: desc.sdp});
+  }
+
+  con.onStateChange((state) => {
+    debug('answerer onStateChange: ', state);
+    if (state === 'connected') {
+      peer.connected = true;
+      peer.rtcEvents.emit('connected', con);
+    }
+  });
+
+  con.onGatheringStateChange((state) => {
+    debug('answerer GATHERING STATE: ', state);
+
+    if (state == 'complete') {
+      sendAnswer();
+    }
+  });
+
+  con.setRemoteDescription(offer.sdp, offer.type);
+  con.setLocalDescription();
+
+  con.onDataChannel((dc) => {
+    debug("node answerer got dataChannel: ", dc.getLabel());
+    dc.onMessage((msg) => {
+      debug('node answerer Received Msg:', msg.length);
+      peer.rtcEvents.emit('packet', msg);
+    });
+
+    // dc.sendMessage("Hello From node answerer");
+    peer.dcOpen = true;
+    peer.dc = dc;
+    peer.rtcEvents.emit('dcOpen', dc);
+    peer.rtcSend = (packet) => {
+      dc.sendMessageBinary(packet);
+    };
+
+    // peer.dc.onStateChange((state) => {
+    //   debug('dc state change', state);
+    // });
+  });
+
+}
+
+rtc.offerPeer = offerPeer;
+rtc.answerPeer = answerPeer;
+
+
+module.exports = rtc;

package/lib/rtc-web.js

@@ -0,0 +1,172 @@
+const debug = require('debug')('hsync:rtc-web');
+const debugError = require('debug')('errors');
+
+const rtc = {
+  PeerConnection: RTCPeerConnection,
+};
+
+
+const defaultOptions = {
+  // Recommended for libdatachannel
+  // bundlePolicy: "max-bundle",
+  iceServers: [{ 'urls': 'stun:stun.l.google.com:19302' }] 
+};
+
+const GATHERING_TIMEOUT = 4000;
+
+async function offerPeer(peer) {
+
+  const con = new RTCPeerConnection(defaultOptions);
+  // window.rtc = rtc;
+
+  peer.rtcCon = con;
+  peer.rtcOfferer = true;
+  
+  let gatheringComplete = false;
+  let offerSent = false;
+  const start = Date.now();
+
+  function sendOffer(alreadySent) {
+    debug('send offer', alreadySent);
+    const desc = con.localDescription;
+    peer.methods.rtcSignal({type: desc.type, sdp: desc.sdp, alreadySent});
+  }
+
+  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.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;
+  };
+
+  const dc = con.createDataChannel('from web');
+
+  peer.dc = dc;
+  dc.onmessage = (event) => { 
+    debug('dc event', event.data);
+    peer.rtcEvents.emit('packet', event.data);
+  };
+  dc.onopen = (event) => { 
+    peer.dcOpen = true;
+    peer.dc = dc;
+    peer.rtcEvents.emit('dcOpen', dc);
+    peer.rtcSend = (packet) => {
+      dc.send(packet);
+    };
+    // dc.send('yo waddup from the browser');
+  };
+
+  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);
+
+  peer.handleRtcAnswer = (answer) => {
+    debug('node handleRtcAnswer', answer.sdp.length);
+    con.setRemoteDescription(answer);
+    return 'web handleRtcAnswer ok';
+  }
+}
+
+async function answerPeer(peer, offer) {
+  const options = {...defaultOptions, bundlePolicy: "max-bundle"};
+  const con = new RTCPeerConnection(options);
+  // window.rtc = rtc;
+
+  peer.rtcCon = con;
+  
+  let gatheringComplete = false;
+  const start = Date.now();
+
+  function sendAnswer() {
+    const desc = con.localDescription;
+    peer.methods.rtcSignal({type: desc.type, sdp: desc.sdp});
+  }
+
+  con.onicegatheringstatechange = (state) => {
+    if (con.iceGatheringState === 'complete') {
+      gatheringComplete = true;
+      debug('answerer icegathering done', Date.now() - start);
+      sendAnswer();
+    }
+  }
+  await con.setRemoteDescription(offer);
+
+  let answer = await con.createAnswer();
+  await con.setLocalDescription(answer);
+
+  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);
+    } else if (con.connectionState === 'disconnected') {
+      peer.connected = false;
+      peer.rtcEvents.emit('disconnected', con);
+      peer.rtcCon = null;
+      peer.dc = null;
+    } else if (con.connectionState === 'closed') {
+      peer.connected = false;
+      peer.rtcEvents.emit('closed', con);
+      peer.rtcCon = null;
+      peer.dc = null;
+    }
+  };
+
+  con.ondatachannel = (event) => {
+    debug('dc from node', event);
+    peer.dcOpen = true;
+    peer.dc = event.channel;
+    peer.rtcEvents.emit('dcOpen', peer.dc);
+    peer.rtcSend = (packet) => {
+      peer.dc.send(packet);
+    };
+    peer.dc.onmessage = (event) => {
+      peer.rtcEvents.emit('packet', event.data);
+    };
+  };
+
+  setTimeout(() => {
+    if (!gatheringComplete) {
+      debug('didnt finish gathering');
+      sendAnswer();
+    }
+  }, GATHERING_TIMEOUT);
+
+}
+
+
+rtc.offerPeer = offerPeer;
+rtc.answerPeer = answerPeer;
+
+module.exports = rtc;