diodejs 0.1.4 → 0.1.6

package/README.md

@@ -15,6 +15,35 @@ If you want to enable debug logs, set environment variable DEBUG to true.
 
 Can also use .env files
 
+### Connection Settings
+
+Connection retry behavior can be configured via environment variables:
+
+| Environment Variable | Description | Default |
+|----------------------|-------------|---------|
+| DIODE_MAX_RETRIES | Maximum number of reconnection attempts | Infinity |
+| DIODE_RETRY_DELAY | Initial delay between retries (ms) | 1000 |
+| DIODE_MAX_RETRY_DELAY | Maximum delay between retries (ms) | 30000 |
+| DIODE_AUTO_RECONNECT | Whether to automatically reconnect | true |
+
+Example `.env` file:
+```
+DIODE_MAX_RETRIES=10
+DIODE_RETRY_DELAY=2000
+DIODE_MAX_RETRY_DELAY=20000
+DIODE_AUTO_RECONNECT=true
+```
+
+These settings can also be configured programmatically:
+```javascript
+connection.setReconnectOptions({
+  maxRetries: 10,
+  retryDelay: 2000,
+  maxRetryDelay: 20000,
+  autoReconnect: true
+});
+```
+
 ### Test RPC
 
 Here's a quick example to get you started with RPC functions using `DiodeRPC` Class
@@ -28,6 +57,26 @@ async function main() {
   const keyLocation = './db/keys.json'; // Optional, defaults to './db/keys.json'
 
   const connection = new DiodeConnection(host, port, keyLocation);
+  
+  // Configure reconnection (optional - overrides environment variables)
+  connection.setReconnectOptions({
+    maxRetries: Infinity, // Unlimited reconnection attempts
+    retryDelay: 1000,     // Initial delay of 1 second
+    maxRetryDelay: 30000, // Maximum delay of 30 seconds
+    autoReconnect: true   // Automatically reconnect on disconnection
+  });
+  
+  // Listen for reconnection events (optional)
+  connection.on('reconnecting', (info) => {
+    console.log(`Reconnecting... Attempt #${info.attempt} in ${info.delay}ms`);
+  });
+  connection.on('reconnected', () => {
+    console.log('Successfully reconnected!');
+  });
+  connection.on('reconnect_failed', () => {
+    console.log('Failed to reconnect after maximum attempts');
+  });
+  
   await connection.connect();
 
   const rpc = new DiodeRPC(connection);
@@ -69,7 +118,7 @@ async function main() {
     // Multiple or single port binding with configuration object
     const portsConfig = {
       3002: { targetPort: 80, deviceIdHex: "5365baf29cb7ab58de588dfc448913cb609283e2" },
-      3003: { targetPort: 443, deviceIdHex: "5365baf29cb7ab58de588dfc448913cb609283e2" }
+      3003: { targetPort: 443, deviceIdHex: "0x5365baf29cb7ab58de588dfc448913cb609283e2" } // Works with or without 0x prefix
     };
     
     const portForward = new BindPort(connection, portsConfig);
@@ -157,6 +206,16 @@ main();
   - `createTicketCommand()`: Creates a ticket command for authentication. Returns a promise.
   - `close()`: Closes the connection to the Diode server.
   - `getDeviceCertificate()`: Returns the generated certificate PEM.
+  - `setReconnectOptions(options)`: Configures reconnection behavior with the following options:
+    - `maxRetries` (number): Maximum reconnection attempts (default: Infinity)
+    - `retryDelay` (number): Initial delay between retries in ms (default: 1000)
+    - `maxRetryDelay` (number): Maximum delay between retries in ms (default: 30000)
+    - `autoReconnect` (boolean): Whether to automatically reconnect on disconnection (default: true)
+
+- **Events**:
+  - `reconnecting`: Emitted when a reconnection attempt is about to start, with `attempt` and `delay` information
+  - `reconnected`: Emitted when reconnection is successful
+  - `reconnect_failed`: Emitted when all reconnection attempts have failed
 
 #### `DiodeRPC`
 
@@ -185,17 +244,18 @@ main();
     - `connection` (DiodeConnection): An instance of `DiodeConnection`.
     - `localPort` (number): The local port to bind.
     - `targetPort` (number): The target port on the device.
-    - `deviceIdHex` (string): The device ID in hexadecimal format.
+    - `deviceIdHex` (string): The device ID in hexadecimal format (with or without '0x' prefix).
   
   New Constructor:
   - `new BindPort(connection, portsConfig)`
     - `connection` (DiodeConnection): An instance of `DiodeConnection`.
     - `portsConfig` (object): A configuration object where keys are local ports and values are objects with `targetPort` and `deviceIdHex`.
       Example: `{ 3002: { targetPort: 80, deviceIdHex: "5365baf29cb7ab58de588dfc448913cb609283e2" } }`
+      Note: deviceIdHex can be provided with or without the '0x' prefix.
 
 - **Methods**:
   - `bind()`: Binds all configured local ports to their target ports on the devices.
-  - `addPort(localPort, targetPort, deviceIdHex)`: Adds a new port binding configuration.
+  - `addPort(localPort, targetPort, deviceIdHex)`: Adds a new port binding configuration. deviceIdHex can include '0x' prefix.
   - `removePort(localPort)`: Removes a port binding configuration.
   - `bindSinglePort(localPort)`: Binds a single local port to its target.
   - `closeAllServers()`: Closes all active server instances.

package/bindPort.js

@@ -10,11 +10,21 @@ class BindPort {
     // Handle legacy constructor (connection, localPort, targetPort, deviceIdHex)
     if (typeof localPortOrPortsConfig === 'number' && targetPort !== undefined && deviceIdHex !== undefined) {
       this.portsConfig = {
-        [localPortOrPortsConfig]: { targetPort, deviceIdHex }
+        [localPortOrPortsConfig]: { 
+          targetPort, 
+          deviceIdHex: this._stripHexPrefix(deviceIdHex) 
+        }
       };
     } else {
       // New constructor (connection, portsConfig)
       this.portsConfig = localPortOrPortsConfig || {};
+      
+      // Strip 0x prefix from all deviceIdHex values in portsConfig
+      for (const port in this.portsConfig) {
+        if (this.portsConfig[port].deviceIdHex) {
+          this.portsConfig[port].deviceIdHex = this._stripHexPrefix(this.portsConfig[port].deviceIdHex);
+        }
+      }
     }
     
     this.servers = new Map(); // Track server instances by localPort
@@ -24,6 +34,14 @@ class BindPort {
     this._setupMessageListener();
   }
   
+  // Helper method to strip 0x prefix from hex strings
+  _stripHexPrefix(hexString) {
+    if (typeof hexString === 'string' && hexString.toLowerCase().startsWith('0x')) {
+      return hexString.slice(2);
+    }
+    return hexString;
+  }
+  
   _setupMessageListener() {
     // Listen for data events from the device
     this.connection.on('unsolicited', (message) => {
@@ -88,7 +106,10 @@ class BindPort {
       return false;
     }
     
-    this.portsConfig[localPort] = { targetPort, deviceIdHex };
+    this.portsConfig[localPort] = { 
+      targetPort, 
+      deviceIdHex: this._stripHexPrefix(deviceIdHex) 
+    };
     
     this.bindSinglePort(localPort);
     

package/connection.js

@@ -13,6 +13,8 @@ const DiodeRPC = require('./rpc');
 const abi = require('ethereumjs-abi');
 const logger = require('./logger');
 const path = require('path');
+// Add dotenv for environment variables
+require('dotenv').config();
 
 class DiodeConnection extends EventEmitter {
   constructor(host, port, keyLocation = './db/keys.json') {
@@ -37,9 +39,38 @@ class DiodeConnection extends EventEmitter {
     this.certPem = null;
     // Load or generate keypair
     this.keyPair = loadOrGenerateKeyPair(this.keyLocation);
+    
+    // Load reconnection properties from environment variables with defaults
+    const envMaxRetries = process.env.DIODE_MAX_RETRIES;
+    this.maxRetries = envMaxRetries !== undefined ? 
+                      (envMaxRetries.toLowerCase() === 'infinity' ? Infinity : parseInt(envMaxRetries, 10)) : 
+                      Infinity;
+    
+    this.retryDelay = parseInt(process.env.DIODE_RETRY_DELAY, 10) || 1000; // Default: 1 second
+    this.maxRetryDelay = parseInt(process.env.DIODE_MAX_RETRY_DELAY, 10) || 30000; // Default: 30 seconds
+    
+    // Parse boolean from string ('true'/'false')
+    const envAutoReconnect = process.env.DIODE_AUTO_RECONNECT;
+    this.autoReconnect = envAutoReconnect !== undefined ? 
+                        (envAutoReconnect.toLowerCase() === 'true') : 
+                        true;
+    
+    this.retryCount = 0;
+    this.retryTimeoutId = null;
+    
+    // Log the reconnection settings
+    logger.info(`Connection settings - Auto Reconnect: ${this.autoReconnect}, Max Retries: ${
+      this.maxRetries === Infinity ? 'Infinity' : this.maxRetries
+    }, Retry Delay: ${this.retryDelay}ms, Max Retry Delay: ${this.maxRetryDelay}ms`);
   }
 
   connect() {
+    // Clear any existing retry timeout
+    if (this.retryTimeoutId) {
+      clearTimeout(this.retryTimeoutId);
+      this.retryTimeoutId = null;
+    }
+
     return new Promise((resolve, reject) => {
       // Generate a temporary certificate valid for 1 month
       this.certPem = generateCert(this.keyPair.prvKeyObj, this.keyPair.pubKeyObj);
@@ -56,8 +87,10 @@ class DiodeConnection extends EventEmitter {
 
       this.socket = tls.connect(this.port, this.host, options, async () => {
         logger.info('Connected to Diode.io server');
+        // Reset retry counter on successful connection
+        this.retryCount = 0;
         // Set keep-alive to prevent connection timeout forever
-        this.socket.setKeepAlive(true, 0);
+        this.socket.setKeepAlive(true, 1500);
   
         // Send the ticketv2 command
         try {
@@ -79,14 +112,87 @@ class DiodeConnection extends EventEmitter {
           logger.error(`Error handling data: ${error}`);
         }
       });
+
       this.socket.on('error', (err) => {
         logger.error(`Connection error: ${err}`);
-        reject(err);
+          reject(err);
+      });
+
+      this.socket.on('end', () => {
+        logger.info('Disconnected from server');
+        this._handleDisconnect();
+      });
+
+      this.socket.on('close', (hadError) => {
+        logger.info(`Connection closed${hadError ? ' due to error' : ''}`);
+        this._handleDisconnect();
+      });
+
+      this.socket.on('timeout', () => {
+        logger.warn('Connection timeout');
+        this._handleDisconnect();
       });
-      this.socket.on('end', () => logger.info('Disconnected from server'));
     });
   }
 
+  // New method to handle reconnection with exponential backoff
+  _reconnect() {
+    if (!this.autoReconnect || this.isReconnecting) return;
+    
+    this.retryCount++;
+    
+    if (this.maxRetries !== Infinity && this.retryCount > this.maxRetries) {
+      logger.error(`Maximum reconnection attempts (${this.maxRetries}) reached. Giving up.`);
+      this.emit('reconnect_failed');
+      return;
+    }
+    
+    // Calculate delay with exponential backoff
+    const delay = Math.min(this.retryDelay * Math.pow(1.5, this.retryCount - 1), this.maxRetryDelay);
+    
+    logger.info(`Reconnecting in ${delay}ms... (Attempt ${this.retryCount})`);
+    this.emit('reconnecting', { attempt: this.retryCount, delay });
+    
+    this.retryTimeoutId = setTimeout(() => {
+      this.isReconnecting = true;
+      
+      // Clear existing socket if any
+      if (this.socket) {
+        this.socket.removeAllListeners();
+        if (!this.socket.destroyed) {
+          this.socket.destroy();
+        }
+        this.socket = null;
+      }
+      
+      // Connect again
+      this.connect()
+        .then(() => {
+          this.isReconnecting = false;
+          this.emit('reconnected');
+          logger.info('Successfully reconnected to Diode.io server');
+        })
+        .catch((err) => {
+          this.isReconnecting = false;
+          logger.error(`Reconnection attempt failed: ${err}`);
+        });
+    }, delay);
+  }
+
+  // Helper method to handle disconnection events
+  _handleDisconnect() {
+    // Reset socket to null to ensure we don't try to use it
+    if (this.socket && !this.socket.destroyed) {
+      this.socket.destroy();
+    }
+    this.socket = null;
+    
+    // Don't try to reconnect if we're intentionally closing
+    if (this.autoReconnect && !this.isReconnecting) {
+      this._reconnect();
+    }
+  }
+
   _ensureConnected() {
     if (this.socket && !this.socket.destroyed) {
       return Promise.resolve();
@@ -94,20 +200,58 @@ class DiodeConnection extends EventEmitter {
     if (this.connectPromise) {
       return this.connectPromise;
     }
-    this.isReconnecting = true;
-    this.connectPromise = this.connect()
-      .then(() => {
-        this.isReconnecting = false;
-        this.connectPromise = null;
-      })
-      .catch((err) => {
-        this.isReconnecting = false;
-        this.connectPromise = null;
-        throw err;
-      });
+    
+    this.connectPromise = new Promise((resolve, reject) => {
+
+      if (this.isReconnecting) {
+        // If we're already reconnecting, wait for the reconnection to complete
+        this.once('reconnected', resolve);
+        //wait for max retry delay
+        setTimeout(() => {
+          reject(new Error('Reconnection timed out'));
+        }, this.maxRetryDelay);
+      } else {
+        this._reconnect();
+        this.once('reconnected', resolve);
+        //wait for max retry delay
+        setTimeout(() => {
+          reject(new Error('Reconnection timed out'));
+        }, this.maxRetryDelay);
+      }
+    });
+    
     return this.connectPromise;
   }
 
+  // Method to set reconnection options
+  setReconnectOptions(options = {}) {
+    if (typeof options.maxRetries === 'number') {
+      this.maxRetries = options.maxRetries;
+    }
+    if (typeof options.retryDelay === 'number') {
+      this.retryDelay = options.retryDelay;
+    }
+    if (typeof options.maxRetryDelay === 'number') {
+      this.maxRetryDelay = options.maxRetryDelay;
+    }
+    if (typeof options.autoReconnect === 'boolean') {
+      this.autoReconnect = options.autoReconnect;
+    }
+    return this;
+  }
+
+  // Update close method to prevent reconnection when intentionally closing
+  close() {
+    this.autoReconnect = false;
+    if (this.retryTimeoutId) {
+      clearTimeout(this.retryTimeoutId);
+      this.retryTimeoutId = null;
+    }
+    if (this.socket) {
+      this.socket.end();
+    }
+  }
+
   _handleData(data) {
     // Append new data to the receive buffer
     this.receiveBuffer = Buffer.concat([this.receiveBuffer, data]);
@@ -428,10 +572,6 @@ class DiodeConnection extends EventEmitter {
     return this.requestId;
   }
 
-  close() {
-    this.socket.end();
-  }
-
   // Client sockets management methods (for BindPort)
   addClientSocket(ref, socket) {
     this.clientSockets.set(ref.toString('hex'), socket);

package/examples/portForwardTest.js

@@ -9,7 +9,7 @@ async function main() {
     await connection.connect();
   
     const portForward = new BindPort(connection, {
-        3003: { targetPort: 8080, deviceIdHex: "ca1e71d8105a598810578fb6042fa8cbc1e7f039" },
+        3003: { targetPort: 8080, deviceIdHex: "0xca1e71d8105a598810578fb6042fa8cbc1e7f039" },
         3004: { targetPort: 443, deviceIdHex: "5365baf29cb7ab58de588dfc448913cb609283e2" }
       });
     portForward.bind();
@@ -23,7 +23,7 @@ async function main() {
     // after 10 seconds, add port 3003 back
     setTimeout(() => {
         console.log("Adding port 3003 back");
-        portForward.addPort(3003, 8080, "ca1e71d8105a598810578fb6042fa8cbc1e7f039");
+        portForward.addPort(3003, 8080, "0xca1e71d8105a598810578fb6042fa8cbc1e7f039");
     }, 10000);
     
     

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "diodejs",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "A JavaScript client for interacting with the Diode network. It provides functionalities to bind and publish ports, send RPC commands, and handle responses.",
   "main": "index.js",
   "scripts": {