hsync 0.16.1 → 0.18.0

package/Readme.md

@@ -2,27 +2,41 @@
 
 [![NPM](https://nodei.co/npm/hsync.svg)](https://nodei.co/npm/hsync/)
 
-Client for the ([hsync-server](https://github.com/monteslu/hsync-server)).
-Share your local webserver as a secure public URL, and more.
+hsync is a [reverse-proxy](https://en.wikipedia.org/wiki/Reverse_proxy) client for node.js and browsers that connects to an [hsync-server](https://github.com/monteslu/hsync-server).
+
+You can share your local webserver as a secure public URL, as well as tunnel whatever tcp/ip traffic you'd like between two hsync clients.
+
 
 ## basic usage
 
-clone repo
-`npm i`
+## install globally
+`npm i -g hsync`
+
+### run
+`hsync`
 
-set enviroment:
+## run with npx
 
+`npx hsync`
 
-### hsync server URL
-`export HSYNC_SERVER="wss://myhost.myserver.com"`
+## configuration
 
+by default hsync will connect to the default hsync.tech server and allow a connection for up to 4 hours.
 
-### secret for your hsync client
-`export HSYNC_SECRET="*****************"`
+However you can pass flags to the command line or configure env variables:
+
+| flag | long flag              | type    | env variable       | description                                                |
+| ---- | ---------------------  | ------- | ------------------ | ---------------------------------------------------------- |
+| -p   | -port                  | number  | PORT               | port for local webserver                                   |  
+| -d   | --dynamic-host         | url     | HSYNC_DYNAMIC_HOST | host to get a dynamic connection from                      |
+| -s   | --hsync-server         | url     | HSYNC_SERVER       | hsync-server location ex: wss://sub.mydomain.com           |
+| -hs  | --hsync-secret         | string  | HSYNC_SECRET       | password to connect to hsync-server                        |
+| -llp | --listener-local-port  | number  | HSYNC_LLP          | local port to open for listener                            |
+| -lth | --listener-target-host | url     | HSYNC_LTH          | target host for listener                                   |
+| -ltp | --listener-target-port | number  | HSYNC_LTP          | target port for listener                                   |
+| -rip | --relay-inbound-port   | number  | HSYNC_RIP          | inbound port for remote relay requests                     |
+| -rth | --relay-target-host    | url     | HSYNC_RTH          | target host for relay to open tcp connection on            |
+| -rtp | --relay-target-port    | number  | HSYNC_RTP          | target port for relay to open tcp connection on            |
 
-### local webserver port
-`export PORT="8080"`
 
-### run
-`node index`
 

package/cli.js

@@ -16,9 +16,9 @@ program
   .addOption(new Option('-llp, --listener-local-port <number>', 'local port to open for listener').env('HSYNC_LLP'))
   .addOption(new Option('-lth, --listener-target-host <url>', 'target host for listener').env('HSYNC_LTH'))
   .addOption(new Option('-ltp, --listener-target-port <number>', 'target port for listener').env('HSYNC_LTP'))
-  .addOption(new Option('-rip, --relay-inbound-port <number>', 'inbound port to open for relay').env('HSYNC_RIP'))
-  .addOption(new Option('-rth, --relay-target-host <string>', 'target host for relay').env('HSYNC_RTH'))
-  .addOption(new Option('-rtp, --relay-target-port <number>', 'target port for relay').env('HSYNC_RTP'));
+  .addOption(new Option('-rip, --relay-inbound-port <number>', 'inbound port for remote relay requests').env('HSYNC_RIP'))
+  .addOption(new Option('-rth, --relay-target-host <url>', 'target host for relay to open tcp connection on').env('HSYNC_RTH'))
+  .addOption(new Option('-rtp, --relay-target-port <number>', 'target port for relay to open tcp connection on').env('HSYNC_RTP'));
 
 program.parse();
 
@@ -70,4 +70,5 @@ config.connections.forEach(async (conConfig) => {
   console.log();
   console.log('Admin ui at: ', con.webAdmin);
   console.log('Secret: ', con.hsyncSecret);
+  console.log();
 });

package/connection.js

@@ -3,7 +3,7 @@ const b64id = require('b64id');
 const debug = require('debug')('hsync:info');
 const debugVerbose = require('debug')('hsync:verbose');
 const debugError = require('debug')('hsync:error');
-const { getRPCPeer, createServerPeer } = require('./lib/rpc');
+const { getRPCPeer, createServerPeer } = require('./lib/peers');
 const { createWebHandler, setNet: webSetNet } = require('./lib/web-handler');
 const { createSocketListenHandler, setNet: listenSetNet, receiveRelayData } = require('./lib/socket-listen-handler');
 const { createSocketRelayHandler, setNet: relaySetNet, receiveListenerData, connectSocket } = require('./lib/socket-relay-handler');
@@ -15,6 +15,8 @@ debugError.color = 1;
 
 let mqtt;
 
+console.log('connection from hsync');
+
 function setNet(netImpl) {
   webSetNet(netImpl);
   listenSetNet(netImpl);
@@ -116,65 +118,14 @@ async function createHsync(config) {
         } catch (e) {
           debugError('error parsing json message');
         }
-      } else if (action === 'rpc') {
-        const peer = getRPCPeer({hostName: from, temporary: true, hsyncClient});
-        // const peer = getPeer({hostName: from, temporary: true});
-        peer.transport.receiveData(message.toString());
       }
       else if (!action && (segment3 === 'srpc')) {
         hsyncClient.serverPeer.transport.receiveData(message.toString());
       }
-      else if (action === 'socketData') {
-        // events.emit('socketData', from, segment5, message);
-        receiveSocketData(segment5, message);
-      }
-      else if (action === 'relayData') {
-        // events.emit('socketData', from, segment5, message);
-        receiveRelayData(segment5, message);
-      }
-      else if (action === 'socketClose') {
-        events.emit('socketClose', from, segment5);
-      }
     }
 
   });
 
-  // function getPeer({hostName, temporary, timeout = 10000}) {
-  //   let peer = peers[hostName];
-  //   if (!peer) {
-  //     peer = createRPCPeer({hostName, hsyncClient, timeout, methods: peerMethods});
-  //     if (temporary) {
-  //       peer.rpcTemporary = true;
-  //     }
-  //     peers[host] = peer;
-  //   }
-  //   return peer;
-  // }
-
-  function sendJson(host, json) {
-    if (!host || !json) {
-      return;
-    }
-
-    if (host === myHostName) {
-      debugError('cannot send message to self', host);
-    }
-
-    if (typeof json === 'object') {
-      json = JSON.stringify(json);
-    } else if (typeof json === 'string') {
-      try {
-        json = JSON.stringify(JSON.parse(json));
-      } catch(e) {
-        debugError('not well formed json or object', e);
-        return;
-      }
-    } else {
-      return;
-    }
-    mqConn.publish(`msg/${host}/${myHostName}/json`, json);
-  }
-
   function endClient(force, callback) {
     if (force) {
       mqConn.end(force);
@@ -232,32 +183,41 @@ async function createHsync(config) {
     peerRpc: async (requestInfo) => {
       requestInfo.hsyncClient = hsyncClient;
       const { msg } = requestInfo;
-      debug('peerRpc handler', requestInfo.fromHost, msg);
-      const reply = {id: msg.id};
+      debug('peerRpc handler', requestInfo.fromHost, msg.method);
+      const peer = getRPCPeer({hostName: requestInfo.fromHost, hsyncClient});
+      if (!msg.id) {
+        // notification
+        if (Array.isArray(msg.params)) {
+          msg.params.unshift(peer);
+        }
+        peer.transport.emit('rpc', msg);
+        return { result: {}, id: msg.id};
+      }
+      const reply = {id: msg.id, jsonrpc:'2.0'};
       try {
-        if (!peerMethods[msg.method]) {
+        if (!peer.localMethods[msg.method]) {
           const notFoundError = new Error('method not found');
           notFoundError.code = -32601;
           throw notFoundError;
         }
-        const result = await peerMethods[msg.method](requestInfo, ...msg.params);
+        const result = await peer.localMethods[msg.method](requestInfo, ...msg.params);
         reply.result = result;
         return result;
       } catch (e) {
         debug('peer rpc error', e, msg);
-        msg.error = {
+        reply.error = {
           code: e.code || 500,
           message: e.toString(),
         };
-        return msg;
+        return reply;
       }
     }
   };
 
   const peerMethods = {
-    ping: (host, greeting) => {
-      debug('ping called', host, greeting);
-      return `${greeting} back atcha, ${host}.`;
+    ping: (remotePeer, greeting) => {
+      debug('ping called', remotePeer.hostName, greeting);
+      return `${greeting} back atcha, ${remotePeer.hostName}.`;
     },
     connectSocket,
     receiveListenerData,
@@ -265,9 +225,10 @@ async function createHsync(config) {
   };
 
   hsyncClient.serverPeer = createServerPeer(hsyncClient, serverReplyMethods);
-
+  hsyncClient.getPeer = (hostName) => {
+    return getRPCPeer({hostName, hsyncClient});
+  };
   hsyncClient.hsyncBase = hsyncBase;
-  hsyncClient.sendJson = sendJson;
   hsyncClient.endClient = endClient;
   hsyncClient.serverReplyMethods = serverReplyMethods;
   hsyncClient.getRPCPeer = getRPCPeer;
@@ -276,23 +237,40 @@ async function createHsync(config) {
   hsyncClient.hsyncServer = hsyncServer;
   hsyncClient.dynamicTimeout = dynamicTimeout;
   const { host, protocol } = new URL(hsyncServer);
-  debug('url', host, protocol);
   if (protocol === 'wss:') {
     hsyncClient.webUrl = `https://${host}`;
   } else {
     hsyncClient.webUrl = `http://${host}`;
   }
+  debug('url', host, protocol, hsyncClient.webUrl);
   hsyncClient.webAdmin = `${hsyncClient.webUrl}/${hsyncBase}/admin`;
   hsyncClient.webBase = `${hsyncClient.webUrl}/${hsyncBase}`;
   hsyncClient.port = port;
 
   if (listenerLocalPort) {
     listenerLocalPort.forEach((llp, i) => {
-      const lth = listenerTargetHost ? listenerTargetHost[i] : null;
+      let lth = listenerTargetHost ? listenerTargetHost[i] || listenerTargetHost[0] : null;
       if (lth) {
+        if (lth.endsWith('/')) {
+          lth = lth.substring(0, lth.length - 1);
+        }
         const ltp = listenerTargetPort ? listenerTargetPort[i] : llp;
         addSocketListener(llp, myHostName, ltp, lth);
-        console.log('relaying local', llp, 'to', lth, ltp);
+        debug('relaying local', llp, 'to', lth, ltp);
+      }
+    });
+  }
+
+  if (relayInboundPort) {
+    relayInboundPort.forEach((rip, i) => {
+      const rth = relayTargetHost ? relayTargetHost[i] : relayTargetHost[0] || 'localhost';
+      if (rth) {
+        if (rth.endsWith('/')) {
+          rth = rth.substring(0, rth.length - 1);
+        }
+        const rtp = relayTargetPort ? relayTargetPort[i] : rip;
+        addSocketRelay(rip, myHostName, rtp, rth);
+        debug('relaying inbound', rip, 'to', rth, rtp);
       }
     });
   }