hsync 0.19.0 → 0.21.0

package/hsync-web.js

@@ -14,20 +14,14 @@ setRTC(rtc);
 setNet(net);
 setMqtt(mqtt);
 
-async function dynamicConnect(dynamicHost, useLocalStorage, configObj = {}) {
-  if (typeof useLocalStorage === 'object') {
-    configObj = useLocalStorage;
-  }
-  else {
-    configObj.useLocalStorage = useLocalStorage;
-  }
-
+async function dynamicConnect(configObj = { useLocalStorage: true }) {
   const fullConfig = {...config, ...configObj};
+  fullConfig.dynamicHost = fullConfig.dynamicHost || fullConfig.defaultDynamicHost;
   if (fullConfig.net) {
     setNet(fullConfig.net);
   }
   let con;
-  if (useLocalStorage) {
+  if (configObj.useLocalStorage) {
     const localConfigStr = localStorage.getItem('hsyncConfig');
     if (localConfigStr) {
       const localConfig = JSON.parse(localConfigStr);
@@ -39,13 +33,9 @@ async function dynamicConnect(dynamicHost, useLocalStorage, configObj = {}) {
       }
     }
   
-    if (!fullConfig.hsyncSecret) {
-      fullConfig.dynamicHost = dynamicHost || fullConfig.defaultDynamicHost;
-    }
-  
     con = await createHsync(fullConfig);
   
-    if (fullConfig.dynamicHost) {
+    if (!fullConfig.hsyncSecret) {
       const storeConfig = {
         hsyncSecret: con.hsyncSecret,
         hsyncServer: con.hsyncServer,
@@ -58,7 +48,6 @@ async function dynamicConnect(dynamicHost, useLocalStorage, configObj = {}) {
     return con;
   }
 
-  fullConfig.dynamicHost = dynamicHost || fullConfig.defaultDynamicHost;
   con = await createHsync(fullConfig);
 
   return con;

package/hsync.js

@@ -1,5 +1,6 @@
 const net = require('net');
 const mqtt = require('mqtt');
+const debugError = require('debug')('errors');
 const { createHsync, setNet, setMqtt } = require('./connection');
 const config = require('./config');
 const { setRTC } = require('./lib/peers');
@@ -9,11 +10,18 @@ setRTC(rtc);
 setNet(net);
 setMqtt(mqtt);
 
-async function dynamicConnect(dynamicHost, configObj = {}) {
+process.on('unhandledRejection', (reason, p) => {
+  debugError(reason, 'Unhandled Rejection at Promise', p, reason.stack, p.stack);
+});
+process.on('uncaughtException', err => {
+  debugError(err, 'Uncaught Exception thrown', err.stack);
+});
+
+async function dynamicConnect(configObj = {}) {
   const fullConfig = {...config, ...configObj};
   let con;
 
-  fullConfig.dynamicHost = dynamicHost || fullConfig.defaultDynamicHost;
+  fullConfig.dynamicHost = fullConfig.dynamicHost || fullConfig.defaultDynamicHost;
   con = await createHsync(fullConfig);
 
   return con;

package/lib/fetch.js

@@ -11,20 +11,16 @@ function getContent(res) {
   return res.blob();
 }
 
-function handledFetch(path, options) {
-  return fetch(path, options)
-    .then((res) => {
-      if (res.status >= 400) {
-        const err = new Error('Bad response from server');
-        err.status = res.status;
-        return getContent(res)
-          .then((content) => {
-            err.content = content;
-            throw err;
-          });
-      }
-      return res;
-    });
+async function handledFetch(path, options) {
+  const rawRes = await fetch(path, options);
+  const content = await getContent(rawRes);
+  if (rawRes.status >= 400) {
+    const err = new Error('Bad response from server');
+    err.status = rawRes.status;
+    err.content = content;
+    throw err;
+  }
+  return content;
 }
 
 function apiFetch(path, options = {}) {
@@ -42,8 +38,7 @@ function apiFetch(path, options = {}) {
     'Content-Type': 'application/json',
     ...options.headers,
   };
-  return handledFetch(`${path}${qs}`, options)
-    .then(getContent);
+  return handledFetch(`${path}${qs}`, options);
 }
 
 apiFetch.post = (path, body) => {

package/lib/peers.js

@@ -10,20 +10,8 @@ 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',
@@ -43,207 +31,238 @@ function parsePacket(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 = {};
+let rtc;
 
-  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';
-  }
+function setRTC(rtcImpl) {
+  rtc = rtcImpl;
+}
 
-  peer.rtcEvents.on('packet', async (packet) => {
-    debug('↓ on packet', packet);
-    let toParse = packet;
-    try {
-      if (packet instanceof Blob) {
-        toParse = await packet.arrayBuffer();
-      }
-      const msg = await parsePacket(toParse);
-      const [p1, p2, p3] = msg.topic.split('/');
-      if (p1 === 'rpc') {
-        transport.receiveData(JSON.parse(msg.payload.toString()));
-      } else if (p1 === 'socketData') {
-        handleSocketPacket(msg);
-      } else if (p1 === 'test') {
-        debug('test topic', msg.payload);
-      } else {
-        debug('other topic', msg.topic);
+function initPeers(hsyncClient) {
+  const cachedPeers = {};
+  function getRPCPeer(options = {}) {
+    const { hostName, temporary, timeout = 10000, hsyncClient } = options;
+    let peer = cachedPeers[hostName];
+    if (!peer) {
+      debug('CREATING peer', hostName);
+      peer = createRPCPeer({hostName, hsyncClient, timeout});
+      peer.myAuth = b64id.generateId();
+      if (temporary) {
+        peer.rpcTemporary = true;
       }
-    } catch (e) {
-      debug('bad packet', e, packet);
+      cachedPeers[hostName] = peer;
     }
-  });
-
-  peer.rtcEvents.on('dcOpen', () => {
-    debug('dcOpen');
-    peer.packAndSend = (topic, payload) => {
-      const packet = createPacket(topic, payload);
-      if (topic === 'test') {
-        debug('sending test packet', packet);
-      }
-      peer.rtcSend(packet);
+    return peer;
+  }
+  
+  function createRPCPeer(options = {}) {
+    const { hostName, timeout = 10000, useRTC = true } = options;
+    if (!hostName) {
+      throw new Error('No hostname specified');
     }
-    // firefox is weird about the first bit of data, so send a test packet
-    peer.packAndSend('test', 'test');
-  });
-
-  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);
-      }
+    if (hostName === hsyncClient.myHostName) {
+      throw new Error('Peer must be a different host');
     }
-  });
-
-  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);
+    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.connectRTC = async () => {
-    debug('connectRTC');
-    
-    return new Promise(async (resolve, reject) => {
+  
+    peer.rtcEvents.on('packet', async (packet) => {
+      debug('↓ on packet', packet);
+      let toParse = packet;
       try {
-        const offer = await rtc.offerPeer(peer);
-        peer.rtcEvents.once('dcOpen', () => {
-          debug('dcOpen!');
-          resolve(offer);
-        });
+        if (packet instanceof Blob) {
+          toParse = await packet.arrayBuffer();
+        }
+        const msg = await parsePacket(toParse);
+        const [p1, p2, p3] = msg.topic.split('/');
+        if (p1 === 'rpc') {
+          const rpcMsg = JSON.parse(msg.payload.toString());
+          debug('↓ peer RTC rpc', rpcMsg);
+          // if (rpcMsg.method) {
+          transport.receiveData(rpcMsg);
+          //   return;
+          // }
+        } else if (p1 === 'socketData') {
+          handleSocketPacket(msg);
+        } else if (p1 === 'test') {
+          debug('test topic', msg.payload);
+        } else {
+          debug('other topic', msg.topic);
+        }
       } catch (e) {
-        reject(e);
+        debug('bad packet', e, packet);
       }
     });
-  };
-
-  transport.send = async (msg) => {
-    const fullMsg = {
-      msg,
-      myAuth,
-      toHost: hostName,
-      fromHost: hsyncClient.webUrl,
+  
+    peer.rtcEvents.on('dcOpen', () => {
+      debug('dcOpen');
+      peer.packAndSend = (topic, payload) => {
+        const packet = createPacket(topic, payload);
+        if (topic === 'test') {
+          debug('sending test packet', packet);
+        }
+        peer.rtcSend(packet);
+      }
+      // firefox is weird about the first bit of data, so send a test packet
+      peer.packAndSend('test', 'test');
+    });
+  
+    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);
+          debug('offer', offer);
+          peer.rtcEvents.once('dcOpen', () => {
+            debug('dcOpen!');
+            resolve(offer);
+          });
+        } catch (e) {
+          debug('error connecting to rtc', e);
+          reject(e);
+        }
+      });
     };
-
-    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);
+  
+    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;
       }
-      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});
+  
+      try {
+        const path = `${hostName}/_hs/rpc`;
+        debug('fetching', path, fullMsg, useRTC);
+        const result = await fetch.post(path, fullMsg);
+        debug('fetch result', result);
+        if (msg.id) {
+          transport.receiveData({id: msg.id, result, jsonrpc: msg.jsonrpc});
+        }
+      } catch(e) {
+        debug('error sending peer RPC request', e);
+        if (msg.id) { // only send error if it's a request, not a notification
+          transport.receiveData({
+            id: msg.id,
+            error: e.message,
+            method: msg.method,
+            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);
-  };
+    transport.receiveData = (msg) => {
+      debug('↓ transport.receiveData', msg);
+      if(typeof msg === 'string') {
+        msg = JSON.parse(msg);
+      }
+      debug('↓ peer rpc receivedData', msg);
+      if (msg.params && Array.isArray(msg.params)) {
+        debug('unshifting', msg.params);
+        msg.params.unshift(peer);
+      }
+      transport.emit('rpc', msg);
+      // debug('transport emitted', 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 outbound', msg);
+      hsyncClient.mqConn.publish(topic, Buffer.from(msg));
+    };
+    transport.receiveData = (msg) => {
+      if(msg) {
+        msg = JSON.parse(msg);
+      }
+      debug('↓ server rpc inbound', msg);
+      transport.emit('rpc', msg);
+    };
+    const peer = rawr({transport, methods, timeout: 5000});
+    return peer;
+  }
 
-  peer.myAuth = myAuth;
-  peer.hostName = hostName;
-  return peer;
-}
+  hsyncClient.cachedPeers = cachedPeers;
+  hsyncClient.getRPCPeer = getRPCPeer;
+  hsyncClient.createServerPeer  = createServerPeer;
 
-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);
+  return {
+    getRPCPeer,
+    createRPCPeer,
+    createServerPeer,
   };
-  const peer = rawr({transport, methods, timeout: 5000});
-  return peer;
 }
 
 module.exports = {
-  createRPCPeer,
-  createServerPeer,
-  getRPCPeer,
+  initPeers,
   setRTC,
 };