hsync 0.17.0 → 0.18.0

package/lib/socket-listen-handler.js

@@ -1,9 +1,9 @@
 const b64id = require('b64id');
 const debug = require('debug')('hsync:listener');
 const debugError = require('debug')('hsync:error');
-// const { getRTCPeer } = require('./data-channel');
 
-const { getRPCPeer } = require('./rpc');
+const { getRPCPeer } = require('./peers');
+const { sockets } = require('./socket-map');
 
 let net;
 
@@ -11,19 +11,9 @@ 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 }) {
+function receiveRelayData(remotePeer, { socketId, data }) {
   debug('receiveRelayData', socketId, data, 'sockets', Object.keys(sockets));
   if (!sockets[socketId]) {
     throw new Error('listener has no matching socket for relay: ' + socketId);
@@ -33,21 +23,25 @@ function receiveRelayData(requestInfo, { socketId, data }) {
     dataBuffer = Buffer.from(dataBuffer, 'base64');
   }
   sockets[socketId].write(dataBuffer);
-  return 'ok';
+  return 'receiveRelayData ok';
 }
 
-function createSocketListenHandler({hostName, port, targetPort, targetHost, hsyncClient}) {
-  debug('creating handler', { hostName, port, targetPort, targetHost });
+function createSocketListenHandler(options = {}) {
+  const { hostName, port, targetPort, targetHost, hsyncClient } = options;
+  debug('creating handler', port, targetHost);
   
-  // const rpcPeer = getRPCPeer({hostName, hsyncClient});
   const rpcPeer = getRPCPeer({hostName: targetHost, hsyncClient});
 
-  debug('peer crated');
-
   const socketServer = net.createServer(async (socket) => {
 
+    if (!rpcPeer.rtcCon) {
+      await rpcPeer.connectRTC();
+    }
+
     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}`;
@@ -55,12 +49,12 @@ function createSocketListenHandler({hostName, port, targetPort, targetHost, hsyn
     const dataQueue = [];
 
     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;
-      // }
+      if (rpcPeer.packAndSend) {
+        debug('sending data via rtc', hostName, socket.socketId, data.length);
+        rpcPeer.packAndSend(`socketData/${socket.socketId}`, data);
+        return;
+      }
+      debug('sending data via rpc', hostName, data.length);
       // hsyncClient.mqConn.publish(pubTopic, data);
       const result = await rpcPeer.methods.receiveListenerData({
         socketId: socket.socketId,
@@ -70,7 +64,7 @@ function createSocketListenHandler({hostName, port, targetPort, targetHost, hsyn
     }
 
     socket.on('data', async (data) => {
-      debug('socket data', data?.length);
+      debug('socket data', data ? data.length : '');
       // if (!socket.peerConnected) {
       //   dataQueue.push(data);
       //   return;
@@ -83,7 +77,6 @@ function createSocketListenHandler({hostName, port, targetPort, targetHost, hsyn
       if (sockets[socket.socketId]) {
         delete sockets[socket.socketId];
       }
-      // hsyncClient.mqConn.publish(closeTopic, '');
     });
   
     socket.on('error', (error) => {
@@ -91,20 +84,19 @@ function createSocketListenHandler({hostName, port, targetPort, targetHost, hsyn
       if (sockets[socket.socketId]) {
         delete sockets[socket.socketId];
       }
-      // hsyncClient.mqConn.publish(closeTopic, '');
     });
   
     try {
-      debug('connecting remotely', socket.socketId, targetPort);
-      const result = await rpcPeer.methods.connectSocket({socketId: socket.socketId, port: targetPort});
+      debug('connecting remotely', socket.socketId, targetPort, rpcPeer.hostName, targetHost);
+      const result = await rpcPeer.methods.connectSocket({
+        socketId: socket.socketId,
+        port: targetPort,
+        hostName: rpcPeer.hostName,
+        wut: 'huh',
+      });
       debug('connect result', result);
       socket.peerConnected = true;
-      dataQueue.forEach(sendData);
-      // const p = getRTCPeer(hostName, hsyncClient);
-      // if (p.pc) {
-      //   p.createDC();
-      // }
-      
+      dataQueue.forEach(sendData);      
     } catch (e) {
       debugError('cant connect remotely', hostName, targetPort, e);
       if (sockets[socket.socketId]) {
@@ -112,13 +104,10 @@ function createSocketListenHandler({hostName, port, targetPort, targetHost, hsyn
       }
       socket.end();
     }
-    
-
   });
 
   socketServer.listen(port);
 
-
   function end() {
     const sockKeys = Object.keys(sockets);
     sockKeys.forEach((sk) => {

package/lib/socket-map.js

@@ -0,0 +1,19 @@
+const debug = require('debug')('hsync:socket-map');
+const sockets = {};
+
+function handleSocketPacket(packet) {
+  const [topic, socketId] = packet.topic.split('/');
+  const socket = sockets[socketId];
+  if (!socket) {
+    return;
+  }
+  if (topic === 'socketData') {
+    debug('socketData', typeof packet.payload, !!socket.listenerSocket, packet.payload.length);
+    socket.write(packet.payload);
+  }
+}
+
+module.exports = {
+  sockets,
+  handleSocketPacket,
+};

package/lib/socket-relay-handler.js

@@ -1,8 +1,7 @@
-const b64id = require('b64id');
 const debug = require('debug')('hsync:relay');
 const debugError = require('debug')('hsync:error');
-// const { getRTCPeer } = require('./data-channel');
-const { getRPCPeer } = require('./rpc');
+const { getRPCPeer } = require('./peers');
+const { sockets } = require('./socket-map');
 
 debugError.color = 1;
 
@@ -12,11 +11,9 @@ function setNet(netImpl) {
   net = netImpl;
 }
 
-
 const relays = {};
-const sockets = {};
 
-function receiveListenerData(requestInfo, { socketId, data }) {
+function receiveListenerData(remotePeer, { socketId, data }) {
   debug('receiveListenerData', socketId, data, 'sockets', Object.keys(sockets));
   if (!sockets[socketId]) {
     throw new Error('relay has no matching socket for listener : ' + socketId);
@@ -26,16 +23,16 @@ function receiveListenerData(requestInfo, { socketId, data }) {
     dataBuffer = Buffer.from(dataBuffer, 'base64');
   }
   sockets[socketId].write(dataBuffer);
-  return 'ok';
+  return 'receiveListenerData ok';
 }
 
-function connectSocket({ hsyncClient, fromHost }, {port, socketId}) {
+function connectSocket(remotePeer, { 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 rpcPeer = getRPCPeer({hostName: fromHost, hsyncClient});
   // const relayDataTopic = `msg/${hostName}/${hsyncClient.myHostName}/relayData/${socketId}`;
   return new Promise((resolve, reject) => {
     const socket = new net.Socket();
@@ -48,7 +45,12 @@ function connectSocket({ hsyncClient, fromHost }, {port, socketId}) {
 
     socket.on('data', async (data) => {
       debug(`data in ${socket.socketId}`, relay.targetPort, relay.targetHost, data.length);
-      const result = await rpcPeer.methods.receiveRelayData({
+      if (remotePeer.packAndSend) {
+        debug('sending relay data via rtc', socket.socketId, data.length);
+        remotePeer.packAndSend(`socketData/${socket.socketId}`, Buffer.from(data));
+        return;
+      }
+      const result = await remotePeer.methods.receiveRelayData({
         socketId,
         data: Buffer.from(data).toString('base64'),
       });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hsync",
-  "version": "0.17.0",
+  "version": "0.18.0",
   "description": "client for hsync-server",
   "main": "hsync.js",
   "scripts": {
@@ -35,13 +35,17 @@
     "debug": "^4.3.1",
     "isomorphic-fetch": "^3.0.0",
     "mqtt": "^4.2.6",
+    "mqtt-packet-web": "^8.2.0",
     "net-web": "^0.2.0",
     "precompiled-mqtt": "^4.3.14-beta",
-    "rawr": "^0.14.0"
+    "rawr": "^0.15.1",
+    "webpack": "^5.88.2",
+    "webpack-cli": "^4.10.0"
+  },
+  "optionalDependencies": {
+    "node-datachannel": "^0.4.3"
   },
   "devDependencies": {
-    "nodemon": "^2.0.20",
-    "webpack": "^5.75.0",
-    "webpack-cli": "^5.0.1"
+    "nodemon": "^3.0.1"
   }
 }

package/tn.js

@@ -0,0 +1,34 @@
+const net = require('net');
+
+process.stdin.setRawMode( true );
+
+const client = net.createConnection({ port: 2323 }, () => {
+  // 'connect' listener.
+  // console.log('connected to server!');
+  // client.write('world!\r\n');
+  client.on('data', (data) => {
+    process.stdout.write(data);
+  });
+
+  process.stdin.on('data', (data) => {
+    client.write(data);
+    // ctrl-c ( end of text )
+    if ( String(data) === '\u0003' ) {
+      process.exit();
+    }
+  });
+
+  // on any data into stdin
+// 
+
+
+  client.on('end', () => {
+    console.log('disconnected from server');
+    process.exit();
+  });
+
+  client.on('error', (err) => {
+    console.error(err);
+  });
+  
+});

package/lib/rpc.js

@@ -1,95 +0,0 @@
-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.myHostName) {
-    throw new Error('Peer must be a different host');
-  }
-  const myAuth = b64id.generateId();
-  const transport = new EventEmitter();
-  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});
-    }
-  
-  };
-  transport.receiveData = (msg) => {
-    debug('↓ peer rpc', msg);
-    if(typeof msg === 'string') {
-      msg = JSON.parse(msg);
-    }
-    if (Array.isArray(msg.params)) {
-      msg.params.unshift(hostName);
-    }
-    transport.emit('rpc', msg);
-  };
-
-  const peer = rawr({transport, methods: Object.assign({}, methods), timeout, idGenerator: b64id.generateId});
-  peer.myAuth = myAuth;
-  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) => {
-    debug('↓ server rpc reply', msg);
-    if(msg) {
-      msg = JSON.parse(msg);
-    }
-    transport.emit('rpc', msg);
-  };
-  const peer = rawr({transport, methods, timeout: 5000});
-  return peer;
-}
-
-module.exports = {
-  createRPCPeer,
-  createServerPeer,
-  getRPCPeer,
-};

package/lib/web-net.js

@@ -1,67 +0,0 @@
-const EventEmitter = require('events').EventEmitter;
-
-const events = new EventEmitter();
-
-const listeners = {};
-
-function Socket() {
-  const socket = new EventEmitter();
-  
-  socket.connect = function(port, host, clientCallback) {
-    events.emit(('socket_connect_' + port), {
-      port,
-      host,
-      clientSocket: socket,
-      clientCallback,
-    });  
-  }
-
-  socket.write = function(message) {
-    if (socket.serverSocket) {
-      socket.serverSocket.emit('data', message);
-    }
-  };
-
-  socket.end = function() {
-    if (socket.serverSocket) {
-      socket.serverSocket.emit('close');
-    }
-    
-  }
-
-  return socket;
-}
-
-function createServer(cb) {
-  const server = new EventEmitter();
-  server.listen = (port) => {
-    debug('server.listen', port);
-    listeners['l' + port] = server;
-    events.on('socket_connect_' + port, ({ clientSocket, clientCallback }) => {
-      debug('socket_connect_' + port, clientSocket);
-      const serverSocket = new EventEmitter();
-      clientSocket.serverSocket = serverSocket;
-      if (server.cb) {
-        server.cb(serverSocket);
-      }
-      serverSocket.write = (data) => {
-        clientSocket.emit('data', data);
-      }
-      serverSocket.end = () => {
-        clientSocket.emit('close');
-      }
-      
-      if (clientCallback) {
-        clientCallback();
-      }
-    });
-  };
-  server.cb = cb;
-  return server;
-}
-
-module.exports = {
-  Socket,
-  createServer,
-  events,
-};