hsync 0.13.0 → 0.15.0

package/hsync-web.js

@@ -10,27 +10,38 @@ window.Buffer = buffer.Buffer;
 setNet(net);
 setMqtt(mqtt);
 
-async function dynamicConnect(dynamicHost, useLocalStorage) {
+async function dynamicConnect(dynamicHost, useLocalStorage, configObj = {}) {
+  if (typeof useLocalStorage === 'object') {
+    configObj = useLocalStorage;
+  }
+  else {
+    configObj.useLocalStorage = useLocalStorage;
+  }
+
+  const fullConfig = {...config, ...configObj};
+  if (fullConfig.net) {
+    setNet(fullConfig.net);
+  }
   let con;
   if (useLocalStorage) {
     const localConfigStr = localStorage.getItem('hsyncConfig');
     if (localConfigStr) {
       const localConfig = JSON.parse(localConfigStr);
       if ((Date.now() - localConfig.created) < (localConfig.timeout * 0.66)) {
-        config.hsyncSecret = localConfig.hsyncSecret;
-        config.hsyncServer = localConfig.hsyncServer;
+        fullConfig.hsyncSecret = localConfig.hsyncSecret;
+        fullConfig.hsyncServer = localConfig.hsyncServer;
       } else {
         localStorage.removeItem('hsyncConfig');
       }
     }
   
-    if (!config.hsyncSecret) {
-      config.dynamicHost = dynamicHost || config.defaultDynamicHost;
+    if (!fullConfig.hsyncSecret) {
+      fullConfig.dynamicHost = dynamicHost || fullConfig.defaultDynamicHost;
     }
   
-    con = await createHsync(config);
+    con = await createHsync(fullConfig);
   
-    if (config.dynamicHost) {
+    if (fullConfig.dynamicHost) {
       const storeConfig = {
         hsyncSecret: con.hsyncSecret,
         hsyncServer: con.hsyncServer,
@@ -43,16 +54,21 @@ async function dynamicConnect(dynamicHost, useLocalStorage) {
     return con;
   }
 
-  config.dynamicHost = dynamicHost || config.defaultDynamicHost;
-  con = await createHsync(config);
+  fullConfig.dynamicHost = dynamicHost || fullConfig.defaultDynamicHost;
+  con = await createHsync(fullConfig);
 
   return con;
   
 }
 
+function createConnection(configObj = {}) {
+  const fullConfig = {...config, ...configObj};
+  return createHsync(fullConfig);
+}
+
 
 const hsync = globalThis.hsync || {
-  createConnection: createHsync,
+  createConnection,
   dynamicConnect,
   net,
   config,

package/hsync.js

@@ -6,17 +6,23 @@ const config = require('./config');
 setNet(net);
 setMqtt(mqtt);
 
-async function dynamicConnect(dynamicHost) {
+async function dynamicConnect(dynamicHost, configObj = {}) {
+  const fullConfig = {...config, ...configObj};
   let con;
 
-  config.dynamicHost = dynamicHost || config.defaultDynamicHost;
-  con = await createHsync(config);
+  fullConfig.dynamicHost = dynamicHost || fullConfig.defaultDynamicHost;
+  con = await createHsync(fullConfig);
 
   return con;
 }
 
+function createConnection(configObj = {}) {
+  const fullConfig = {...config, ...configObj};
+  return createHsync(fullConfig);
+}
+
 module.exports = {
-  createConnection: createHsync,
+  createConnection,
   dynamicConnect,
   config,
 };

package/lib/fetch.js

@@ -0,0 +1,61 @@
+const fetch = require('isomorphic-fetch');
+
+function getContent(res) {
+  const contentType = res.headers.get('content-type');
+  if (contentType.startsWith('application/json')) {
+    return res.json();
+  }
+  if (contentType.startsWith('text')) {
+    return res.text();
+  }
+  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;
+    });
+}
+
+function apiFetch(path, options = {}) {
+  let qs = '';
+  if (typeof options.body === 'object') {
+    options.body = JSON.stringify(options.body);
+  }
+  if (options.query) {
+    if (Object.keys(options.query).length) {
+      qs = `?${(new URLSearchParams(options.query)).toString()}`;
+    }
+  }
+  Object.assign(options, { credentials: 'include' });
+  options.headers = {
+    'Content-Type': 'application/json',
+    ...options.headers,
+  };
+  return handledFetch(`${path}${qs}`, options)
+    .then(getContent);
+}
+
+apiFetch.post = (path, body) => {
+  return apiFetch(path, { method: 'POST', body });
+};
+
+apiFetch.put = (path, body) => {
+  return apiFetch(path, { method: 'PUT', body });
+};
+
+apiFetch.del = (path, body = {}) => {
+  return apiFetch(path, { method: 'DELETE', body });
+};
+
+module.exports = apiFetch;

package/lib/rpc.js

@@ -2,26 +2,57 @@ const rawr = require('rawr');
 const b64id = require('b64id');
 const debug = require('debug')('hsync:rpc');
 const EventEmitter = require('events').EventEmitter;
+// const { peerMethods } = require('./peer-methods');
+const fetch = require('./fetch');
+
+const peers = {};
+
+function getRPCPeer({hostName, temporary, timeout = 10000, hsyncClient}) {
+  let peer = peers[hostName];
+  if (!peer) {
+    debug('creating peer', hostName);
+    peer = createRPCPeer({hostName, hsyncClient, timeout, methods: hsyncClient.peerMethods});
+    if (temporary) {
+      peer.rpcTemporary = true;
+    }
+    peers[hostName] = peer;
+  }
+  return peer;
+}
+
 
 function createRPCPeer({ hostName, hsyncClient, timeout = 10000, methods = {} }) {
   if (!hostName) {
     throw new Error('No hostname specified');
   }
-  if (hostName === hsyncClient.username) {
+  if (hostName === hsyncClient.myHostName) {
     throw new Error('Peer must be a different host');
   }
+  const myAuth = b64id.generateId();
   const transport = new EventEmitter();
-  transport.send = (msg) => {
-    if(typeof msg === 'object') {
-      msg = JSON.stringify(msg);
+  transport.send = async (msg) => {
+    const fullMsg = {
+      msg,
+      myAuth,
+      toHost: hostName,
+      fromHost: hsyncClient.webUrl,
+    };
+    // const toSend = JSON.stringify(fullMsg);
+    const topic = `rpc/${hsyncClient.myHostName}`;
+    debug('↑ peer rpc', `${hostName}/_hs/rpc`, msg);
+    // hsyncClient.mqConn.publish(topic, Buffer.from(toSend));
+    try {
+      const result = await fetch.post(`${hostName}/_hs/rpc`, fullMsg);
+      transport.receiveData({id: msg.id, result, jsonrpc: msg.jsonrpc});
+    } catch(e) {
+      debug(e);
+      transport.receiveData({id: msg.id, error: e, method: msg.method, jsonrpc: msg.jsonrpc});
     }
-    const topic = `msg/${hostName}/${hsyncClient.username}/rpc`;
-    debug('↑ peer rpc reply', msg);
-    hsyncClient.mqConn.publish(topic, Buffer.from(msg));
+  
   };
   transport.receiveData = (msg) => {
     debug('↓ peer rpc', msg);
-    if(msg) {
+    if(typeof msg === 'string') {
       msg = JSON.parse(msg);
     }
     if (Array.isArray(msg.params)) {
@@ -30,35 +61,35 @@ function createRPCPeer({ hostName, hsyncClient, timeout = 10000, methods = {} })
     transport.emit('rpc', msg);
   };
 
-  const peer = rawr({transport, methods: Object.assign({}, methods), timeout});
+  const peer = rawr({transport, methods: Object.assign({}, methods), timeout, idGenerator: b64id.generateId});
+  peer.myAuth = myAuth;
   return peer;
   
 }
 
-function createServerReplyPeer({ requestId, hsyncClient, methods = {}}) {
-
+function createServerPeer(hsyncClient, methods) {
   const transport = new EventEmitter();
   transport.send = (msg) => {
     if(typeof msg === 'object') {
       msg = JSON.stringify(msg);
     }
-    const topic = `ssrpc/${hsyncClient.myHostName}/${requestId}`;
-    debug('↑ server rpc reply', msg);
+    const topic = `srpc/${hsyncClient.myHostName}`;
+    debug('↑ server rpc request', msg);
     hsyncClient.mqConn.publish(topic, Buffer.from(msg));
   };
   transport.receiveData = (msg) => {
-    debug('↓ server rpc', msg);
+    debug('↓ server rpc reply', msg);
     if(msg) {
       msg = JSON.parse(msg);
     }
     transport.emit('rpc', msg);
   };
-
-  const peer = rawr({transport, methods});
+  const peer = rawr({transport, methods, timeout: 5000});
   return peer;
 }
 
 module.exports = {
   createRPCPeer,
-  createServerReplyPeer,
+  createServerPeer,
+  getRPCPeer,
 };

package/lib/socket-listen-handler.js

@@ -1,51 +1,88 @@
+const b64id = require('b64id');
 const debug = require('debug')('hsync:listener');
 const debugError = require('debug')('hsync:error');
+// const { getRTCPeer } = require('./data-channel');
 
-const { createRPCPeer } = require('./rpc');
+const { getRPCPeer } = require('./rpc');
 
-debugError.color = 1;
 let net;
 
 function setNet(netImpl) {
   net = netImpl;
 }
 
+
+debugError.color = 1;
+
+const sockets = {};
+
+// function receiveRelayData(socketId, data) {
+//   if (sockets[socketId]) {
+//     debug('receiveRelayData', socketId, data.length);
+//     sockets[socketId].write(data);
+//   }
+// }
+
+function receiveRelayData(requestInfo, { socketId, data }) {
+  debug('receiveRelayData', socketId, data, 'sockets', Object.keys(sockets));
+  if (!sockets[socketId]) {
+    throw new Error('listener has no matching socket for relay: ' + socketId);
+  }
+  let dataBuffer = data;
+  if (typeof dataBuffer === 'string') {
+    dataBuffer = Buffer.from(dataBuffer, 'base64');
+  }
+  sockets[socketId].write(dataBuffer);
+  return 'ok';
+}
+
 function createSocketListenHandler({hostName, port, targetPort, targetHost, hsyncClient}) {
   debug('creating handler', hostName, port, targetPort, targetHost);
-
-  const sockets = {};
   
-  const peer = createRPCPeer({hostName, hsyncClient});
+  const rpcPeer = getRPCPeer({hostName, hsyncClient});
 
   debug('peer crated');
-  
+
   const socketServer = net.createServer(async (socket) => {
 
     socket.socketId = b64id.generateId();
     sockets[socket.socketId] = socket;
+    debug('connected to local listener', port, socket.socketId);
     socket.peerConnected = false;
-    const pubTopic = `msg/${hostName}/${hsyncClient.username}/socketData/${socket.socketId}`;
-    const closeTopic = `msg/${hostName}/${hsyncClient.username}/socketClose/${socket.socketId}`;
+    const pubTopic = `msg/${hostName}/${hsyncClient.myHostName}/socketData/${socket.socketId}`;
+    const closeTopic = `msg/${hostName}/${hsyncClient.myHostName}/socketClose/${socket.socketId}`;
     const dataQueue = [];
 
-    function sendData(data) {
-      hsyncClient.mqConn.publish(pubTopic, data);
+    async function sendData(data) {
+      debug('sending data', hostName, data.length);
+      // const p = getRTCPeer(hostName, hsyncClient);
+      // if (p.connected) {
+      //   p.send(`socketData/${socket.socketId}`, data);
+      //   return;
+      // }
+      // 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) => {
-      if (!socket.peerConnected) {
-        dataQueue.push(data);
-        return;
-      }
+      debug('socket data', data?.length);
+      // if (!socket.peerConnected) {
+      //   dataQueue.push(data);
+      //   return;
+      // }
       sendData(data);
     });
   
     socket.on('close', () => {
-
+      debug('listener socket closed', port, socket.socketId);
       if (sockets[socket.socketId]) {
         delete sockets[socket.socketId];
       }
-      hsyncClient.mqConn.publish(closeTopic, '');
+      // hsyncClient.mqConn.publish(closeTopic, '');
     });
   
     socket.on('error', (error) => {
@@ -53,12 +90,20 @@ function createSocketListenHandler({hostName, port, targetPort, targetHost, hsyn
       if (sockets[socket.socketId]) {
         delete sockets[socket.socketId];
       }
-      hsyncClient.mqConn.publish(closeTopic, '');
+      // hsyncClient.mqConn.publish(closeTopic, '');
     });
   
     try {
-      await peer.methods.connectSocket(targetPort, targetHost);
+      debug('connecting remotely', socket.socketId, targetPort);
+      const result = await rpcPeer.methods.connectSocket({socketId: socket.socketId, port: targetPort});
+      debug('connect result', result);
+      socket.peerConnected = true;
       dataQueue.forEach(sendData);
+      // const p = getRTCPeer(hostName, hsyncClient);
+      // if (p.pc) {
+      //   p.createDC();
+      // }
+      
     } catch (e) {
       debugError('cant connect remotely', hostName, targetPort, e);
       if (sockets[socket.socketId]) {
@@ -67,6 +112,7 @@ function createSocketListenHandler({hostName, port, targetPort, targetHost, hsyn
       socket.end();
     }
     
+
   });
 
   socketServer.listen(port);
@@ -92,7 +138,8 @@ function createSocketListenHandler({hostName, port, targetPort, targetHost, hsyn
   };
 }
 
-module.exports = {
+module.exports = { 
   createSocketListenHandler,
+  receiveRelayData,
   setNet,
 };

package/lib/socket-relay-handler.js

@@ -1,7 +1,8 @@
+const b64id = require('b64id');
 const debug = require('debug')('hsync:relay');
 const debugError = require('debug')('hsync:error');
-
-const { createRPCPeer } = require('./rpc');
+// const { getRTCPeer } = require('./data-channel');
+const { getRPCPeer } = require('./rpc');
 
 debugError.color = 1;
 
@@ -11,86 +12,92 @@ function setNet(netImpl) {
   net = netImpl;
 }
 
-function createHandler({hostName, port, targetPort, targetHost, hsyncClient}) {
-
-  const sockets = {};
-  
-  const peer = createRPCPeer({hostName, hsyncClient});
 
-  const socketServer = net.createServer(async (socket) => {
+const relays = {};
+const sockets = {};
 
-    socket.socketId = b64id.generateId();
-    sockets[socket.socketId] = socket;
-    socket.peerConnected = false;
-    const pubTopic = `msg/${hostName}/${hsyncClient.username}/socketData/${socket.socketId}`;
-    const closeTopic = `msg/${hostName}/${hsyncClient.username}/socketClose/${socket.socketId}`;
-    const dataQueue = [];
+function receiveListenerData(requestInfo, { socketId, data }) {
+  debug('receiveListenerData', socketId, data, 'sockets', Object.keys(sockets));
+  if (!sockets[socketId]) {
+    throw new Error('relay has no matching socket for listener : ' + socketId);
+  }
+  let dataBuffer = data;
+  if (typeof dataBuffer === 'string') {
+    dataBuffer = Buffer.from(dataBuffer, 'base64');
+  }
+  sockets[socketId].write(dataBuffer);
+  return 'ok';
+}
 
-    function sendData(data) {
-      hsyncClient.mqConn.publish(pubTopic, data);
-    }
+function connectSocket({ hsyncClient, fromHost }, {port, socketId}) {
+  const relay = relays['p' + port];
+  debug('connect relay', port, socketId);
+  if (!relay) {
+    throw new Error('no relay found for port: ' + port);
+  }
+  const rpcPeer = getRPCPeer({hostName: fromHost, hsyncClient});
+  // 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);
+      resolve({socketId, targetHost: relay.targetHost, targetPort: relay.targetPort});
+    });
 
     socket.on('data', async (data) => {
-      if (!socket.peerConnected) {
-        dataQueue.push(data);
-        return;
-      }
-      sendData(data);
+      debug(`data in ${socket.socketId}`, relay.targetPort, relay.targetHost, data.length);
+      const result = await rpcPeer.methods.receiveRelayData({
+        socketId,
+        data: Buffer.from(data).toString('base64'),
+      });
+      // const p = getRTCPeer(hostName, hsyncClient);
+      // if (p.connected) {
+      //   p.send(`relayData/${socketId}`, data);
+      //   return;
+      // }
+      // hsyncClient.mqConn.publish(relayDataTopic, data);
     });
-  
     socket.on('close', () => {
-
-      if (sockets[socket.socketId]) {
-        delete sockets[socket.socketId];
-      }
-      hsyncClient.mqConn.publish(closeTopic, '');
+      debug(`LOCAL CONNECTION CLOSED`, socket.socketId, targetHost, targetPort);
+      delete sockets[socket.socketId];
     });
-  
-    socket.on('error', (error) => {
-      debug('socket error', hostName, socket.socketId, error);
-      if (sockets[socket.socketId]) {
-        delete sockets[socket.socketId];
-      }
-      hsyncClient.mqConn.publish(closeTopic, '');
+
+    socket.on('error', (e) => {
+      debugError(`LOCAL CONNECTION ERROR`, socket.socketId, targetHost, targetPort, e);
+      delete sockets[socket.socketId];
+      reject(e);
     });
   
-    try {
-      await peer.methods.connectSocket(targetPort, targetHost);
-      dataQueue.forEach(sendData);
-    } catch (e) {
-      debugError('cant connect remotely', hostName, 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 {
-        sockets[sk].end();
-        delete sockets[sk];
-      }
-      catch(e) {
-        debug('error closing socket', e);
-      }
-    });
-  }
+}
 
-  return {
-    socketServer,
-    sockets,
-    end,
+// function receiveSocketData(socketId, data) {
+//   if (sockets[socketId]) {
+//     debug('receiveSocketData', socketId, data.length);
+//     sockets[socketId].write(data);
+//     return 'ok';
+//   }
+
+//   throw new Error('socket not found: ' + socketId);
+// }
+
+function createSocketRelayHandler({hostName, port, targetPort, targetHost, hsyncClient}) {
+  debug('creating relay', hostName, port, targetPort, targetHost);
+  relays['p' + port] = {
+    hostName,
+    port,
+    targetPort,
+    targetHost,
   };
 }
 
 module.exports = {
-  createHandler,
+  createSocketRelayHandler,
+  connectSocket,
+  // receiveSocketData,
   setNet,
+  receiveListenerData,
 };

package/lib/web-net.js

@@ -35,10 +35,10 @@ function Socket() {
 function createServer(cb) {
   const server = new EventEmitter();
   server.listen = (port) => {
-    console.log('server.listen', port);
+    debug('server.listen', port);
     listeners['l' + port] = server;
     events.on('socket_connect_' + port, ({ clientSocket, clientCallback }) => {
-      console.log('socket_connect_' + port, clientSocket);
+      debug('socket_connect_' + port, clientSocket);
       const serverSocket = new EventEmitter();
       clientSocket.serverSocket = serverSocket;
       if (server.cb) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hsync",
-  "version": "0.13.0",
+  "version": "0.15.0",
   "description": "client for hsync-server",
   "main": "hsync.js",
   "scripts": {

package/dev_dynamic.sh

@@ -1,7 +0,0 @@
-#!/bin/bash
-
-export DEBUG="hsync*,errors*";
-
-export HSYNC_DYNAMIC_HOST="https://foo.hsync.tech";
-
-

package/dev_stripe_hook.sh

@@ -1,8 +0,0 @@
-#!/bin/bash
-
-export DEBUG="hsync*,errors*";
-
-export HSYNC_SECRET="f7glV4m_REeimy_TdwjM4w"
-
-export HSYNC_SERVER="wss://luis-stripe.shiv.to"
-export PORT="3021"