@omindu/yaksha 1.0.0

package/src/features/multi-path.js

@@ -0,0 +1,394 @@
+'use strict';
+
+/**
+ * Yaksha Multi-Path Routing
+ * Establish multiple connections and distribute traffic
+ */
+
+const EventEmitter = require('events');
+const Connection = require('../core/connection');
+const Logger = require('../utils/logger');
+
+// Path selection strategies
+const STRATEGIES = {
+  ROUND_ROBIN: 'round-robin',
+  LEAST_LATENCY: 'least-latency',
+  LOAD_BALANCED: 'load-balanced',
+  WEIGHTED: 'weighted'
+};
+
+class MultiPath extends EventEmitter {
+  constructor(securityLevel = 'medium', options = {}) {
+    super();
+    
+    this.securityLevel = securityLevel;
+    this.pathCount = this._selectPathCount(securityLevel);
+    this.strategy = options.strategy || STRATEGIES.LOAD_BALANCED;
+    this.enabled = options.enabled !== false;
+    
+    this.paths = [];
+    this.pathStats = [];
+    this.currentPathIndex = 0;
+    this.sequenceNumber = 0;
+    this.receivedPackets = new Map(); // sequence -> packet data
+    this.expectedSequence = 0;
+
+    this.logger = new Logger({ prefix: 'MultiPath' });
+  }
+
+  /**
+   * Select number of paths based on security level
+   */
+  _selectPathCount(level) {
+    switch (level) {
+      case 'low':
+        return 2;
+      case 'medium':
+        return 4;
+      case 'high':
+        return 5;
+      default:
+        return 3;
+    }
+  }
+
+  /**
+   * Initialize multiple paths to server
+   */
+  async initializePaths(serverHosts, serverPort, connectionOptions = {}) {
+    if (!this.enabled) {
+      // Single path mode
+      const connection = new Connection({
+        host: serverHosts[0] || serverHosts,
+        port: serverPort,
+        ...connectionOptions
+      });
+      
+      await connection.connect();
+      this.paths.push(connection);
+      this.pathStats.push(this._createPathStats(0));
+      return;
+    }
+
+    // Create multiple connections
+    const hosts = Array.isArray(serverHosts) ? serverHosts : [serverHosts];
+    const promises = [];
+
+    for (let i = 0; i < this.pathCount; i++) {
+      // Distribute across multiple hosts or use same host with different connections
+      const host = hosts[i % hosts.length];
+      
+      const connection = new Connection({
+        host,
+        port: serverPort,
+        ...connectionOptions
+      });
+
+      // Set up event handlers
+      connection.on('tcp:data', (data) => {
+        this.pathStats[i].bytesReceived += data.length;
+        this.pathStats[i].packetsReceived++;
+        this.emit('data', data, i);
+      });
+
+      connection.on('udp:data', (data, rinfo) => {
+        this.pathStats[i].bytesReceived += data.length;
+        this.pathStats[i].packetsReceived++;
+        this.emit('data', data, i);
+      });
+
+      connection.on('error', (error) => {
+        this.pathStats[i].errors++;
+        this.pathStats[i].available = false;
+        this.logger.warn(`Path ${i} error:`, error.message);
+        this.emit('path-error', i, error);
+      });
+
+      connection.on('disconnected', () => {
+        this.pathStats[i].available = false;
+        this.logger.info(`Path ${i} disconnected`);
+        this.emit('path-disconnected', i);
+      });
+
+      promises.push(connection.connect().then(() => {
+        this.paths.push(connection);
+        this.pathStats.push(this._createPathStats(i));
+        this.logger.info(`Path ${i} established to ${host}:${serverPort}`);
+      }).catch(error => {
+        this.logger.error(`Failed to establish path ${i}:`, error.message);
+        throw error;
+      }));
+    }
+
+    // Wait for all connections
+    await Promise.all(promises);
+    
+    this.logger.info(`Multi-path routing initialized with ${this.paths.length} paths`);
+  }
+
+  /**
+   * Create path statistics object
+   */
+  _createPathStats(index) {
+    return {
+      index,
+      available: true,
+      latency: 0,
+      packetsSent: 0,
+      packetsReceived: 0,
+      bytesSent: 0,
+      bytesReceived: 0,
+      errors: 0,
+      lastUsed: Date.now(),
+      score: 100
+    };
+  }
+
+  /**
+   * Measure path latency
+   */
+  async measureLatency(pathIndex) {
+    const path = this.paths[pathIndex];
+    if (!path || !path.isConnected()) {
+      return Infinity;
+    }
+
+    const start = Date.now();
+    
+    try {
+      // Send a keepalive packet and measure response time
+      await new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => reject(new Error('Timeout')), 5000);
+        
+        path.once('tcp:data', () => {
+          clearTimeout(timeout);
+          resolve();
+        });
+
+        // In production, send actual keepalive packet
+        resolve(); // Simulate immediate response
+      });
+
+      const latency = Date.now() - start;
+      this.pathStats[pathIndex].latency = latency;
+      return latency;
+    } catch (error) {
+      this.pathStats[pathIndex].latency = Infinity;
+      return Infinity;
+    }
+  }
+
+  /**
+   * Calculate path score for load balancing
+   */
+  _calculatePathScore(pathIndex) {
+    const stats = this.pathStats[pathIndex];
+    
+    if (!stats.available) {
+      return 0;
+    }
+
+    // Score based on latency, packet loss, and load
+    const latencyScore = stats.latency > 0 ? 1000 / stats.latency : 100;
+    const lossRate = stats.packetsSent > 0 
+      ? 1 - (stats.errors / stats.packetsSent)
+      : 1;
+    const loadScore = 100 - (stats.packetsSent % 100);
+
+    const score = (latencyScore * 0.5) + (lossRate * 30) + (loadScore * 0.2);
+    stats.score = Math.max(0, Math.min(100, score));
+
+    return stats.score;
+  }
+
+  /**
+   * Select next path based on strategy
+   */
+  _selectPath() {
+    // Filter available paths
+    const availablePaths = this.pathStats
+      .map((stat, index) => ({ ...stat, index }))
+      .filter(stat => stat.available);
+
+    if (availablePaths.length === 0) {
+      throw new Error('No available paths');
+    }
+
+    if (availablePaths.length === 1) {
+      return availablePaths[0].index;
+    }
+
+    let selectedIndex;
+
+    switch (this.strategy) {
+      case STRATEGIES.ROUND_ROBIN:
+        selectedIndex = this.currentPathIndex % availablePaths.length;
+        this.currentPathIndex = (this.currentPathIndex + 1) % availablePaths.length;
+        return availablePaths[selectedIndex].index;
+
+      case STRATEGIES.LEAST_LATENCY:
+        return availablePaths.reduce((min, path) => 
+          path.latency < min.latency ? path : min
+        ).index;
+
+      case STRATEGIES.LOAD_BALANCED:
+        // Calculate scores for all paths
+        availablePaths.forEach(path => {
+          this._calculatePathScore(path.index);
+        });
+        
+        // Select path with highest score
+        return availablePaths.reduce((best, path) => 
+          path.score > best.score ? path : best
+        ).index;
+
+      case STRATEGIES.WEIGHTED:
+        // Weighted random selection based on scores
+        const totalScore = availablePaths.reduce((sum, path) => 
+          sum + this._calculatePathScore(path.index), 0
+        );
+        
+        let random = Math.random() * totalScore;
+        for (const path of availablePaths) {
+          random -= path.score;
+          if (random <= 0) {
+            return path.index;
+          }
+        }
+        return availablePaths[0].index;
+
+      default:
+        return availablePaths[0].index;
+    }
+  }
+
+  /**
+   * Send data across multiple paths
+   */
+  async send(data, protocol = 'tcp') {
+    if (!this.enabled || this.paths.length === 1) {
+      // Single path mode
+      const path = this.paths[0];
+      if (protocol === 'tcp') {
+        return await path.sendTCP(data);
+      } else {
+        return await path.sendUDP(data);
+      }
+    }
+
+    // Select path
+    const pathIndex = this._selectPath();
+    const path = this.paths[pathIndex];
+    const stats = this.pathStats[pathIndex];
+
+    try {
+      // Add sequence number for packet reordering
+      const sequence = this.sequenceNumber++;
+      const packetWithSeq = Buffer.allocUnsafe(4 + data.length);
+      packetWithSeq.writeUInt32BE(sequence, 0);
+      data.copy(packetWithSeq, 4);
+
+      // Send via selected path
+      if (protocol === 'tcp') {
+        await path.sendTCP(packetWithSeq);
+      } else {
+        await path.sendUDP(packetWithSeq);
+      }
+
+      stats.packetsSent++;
+      stats.bytesSent += data.length;
+      stats.lastUsed = Date.now();
+
+      return pathIndex;
+    } catch (error) {
+      stats.errors++;
+      this.logger.error(`Failed to send on path ${pathIndex}:`, error.message);
+      
+      // Try failover to another path
+      if (this.paths.length > 1) {
+        this.logger.info('Attempting failover to another path');
+        stats.available = false;
+        return await this.send(data, protocol);
+      }
+      
+      throw error;
+    }
+  }
+
+  /**
+   * Receive and reorder packets
+   */
+  receive(data, pathIndex) {
+    // Extract sequence number
+    if (data.length < 4) {
+      return null;
+    }
+
+    const sequence = data.readUInt32BE(0);
+    const payload = data.slice(4);
+
+    // Store packet
+    this.receivedPackets.set(sequence, payload);
+
+    // Try to deliver in-order packets
+    const deliveredPackets = [];
+    
+    while (this.receivedPackets.has(this.expectedSequence)) {
+      const packet = this.receivedPackets.get(this.expectedSequence);
+      deliveredPackets.push(packet);
+      this.receivedPackets.delete(this.expectedSequence);
+      this.expectedSequence++;
+    }
+
+    return deliveredPackets;
+  }
+
+  /**
+   * Get path statistics
+   */
+  getPathStats() {
+    return this.pathStats.map(stat => ({ ...stat }));
+  }
+
+  /**
+   * Get overall statistics
+   */
+  getStats() {
+    const totalStats = {
+      pathCount: this.paths.length,
+      activePaths: this.pathStats.filter(s => s.available).length,
+      strategy: this.strategy,
+      totalBytesSent: 0,
+      totalBytesReceived: 0,
+      totalPacketsSent: 0,
+      totalPacketsReceived: 0,
+      totalErrors: 0
+    };
+
+    for (const stat of this.pathStats) {
+      totalStats.totalBytesSent += stat.bytesSent;
+      totalStats.totalBytesReceived += stat.bytesReceived;
+      totalStats.totalPacketsSent += stat.packetsSent;
+      totalStats.totalPacketsReceived += stat.packetsReceived;
+      totalStats.totalErrors += stat.errors;
+    }
+
+    return totalStats;
+  }
+
+  /**
+   * Close all paths
+   */
+  closeAll() {
+    for (const path of this.paths) {
+      path.disconnect();
+    }
+    
+    this.paths = [];
+    this.pathStats = [];
+    this.logger.info('All paths closed');
+  }
+}
+
+module.exports = MultiPath;
+module.exports.STRATEGIES = STRATEGIES;