hedgequantx 2.6.162 → 2.7.0

package/src/lib/n/r6.js

@@ -0,0 +1,425 @@
+/**
+ * Rithmic Connection Pool
+ * Manages reusable connections for optimal performance
+ * Prevents creating new connections for every request
+ */
+
+const { RithmicMarketData } = require('./r4');
+const { RithmicTrading } = require('./r3');
+const { RithmicPnL } = require('./r5');
+const { getPropFirmConfig, RITHMIC_GATEWAYS } = require('./r7');
+
+class RithmicConnectionPool {
+  constructor(options = {}) {
+    // Pools for each plant type
+    this.marketDataPool = new Map(); // key -> RithmicMarketData
+    this.tradingPool = new Map();    // key -> RithmicTrading
+    this.pnlPool = new Map();        // key -> RithmicPnL
+    
+    // Pending connections (mutex for concurrent requests)
+    this.pendingMarketData = new Map();
+    this.pendingTrading = new Map();
+    this.pendingPnL = new Map();
+    
+    // Configuration
+    this.idleTimeout = options.idleTimeout || 30 * 60 * 1000; // 30 minutes
+    this.cleanupInterval = options.cleanupInterval || 60 * 1000; // 1 minute
+    this.debug = options.debug || false;
+    
+    // Stats
+    this.stats = {
+      marketDataHits: 0,
+      marketDataMisses: 0,
+      tradingHits: 0,
+      tradingMisses: 0,
+      pnlHits: 0,
+      pnlMisses: 0
+    };
+    
+    // Start cleanup timer
+    this._cleanupTimer = setInterval(() => this._cleanup(), this.cleanupInterval);
+  }
+
+  /**
+   * Generate pool key from credentials
+   */
+  _getKey(userId, systemName) {
+    return `${userId}:${systemName}`;
+  }
+
+  /**
+   * Get or create Market Data connection
+   */
+  async getMarketData(credentials) {
+    const { userId, password, systemName, gateway } = credentials;
+    const key = this._getKey(userId, systemName);
+    
+    // Check if pending
+    if (this.pendingMarketData.has(key)) {
+      return this.pendingMarketData.get(key);
+    }
+    
+    // Check pool
+    let pooled = this.marketDataPool.get(key);
+    if (pooled && pooled.client.isConnected) {
+      pooled.lastUsed = Date.now();
+      this.stats.marketDataHits++;
+      return pooled.client;
+    }
+    
+    // Create new connection
+    this.stats.marketDataMisses++;
+    
+    const connectPromise = this._createMarketData(credentials);
+    this.pendingMarketData.set(key, connectPromise);
+    
+    try {
+      const client = await connectPromise;
+      this.marketDataPool.set(key, {
+        client,
+        userId,
+        systemName,
+        lastUsed: Date.now()
+      });
+      return client;
+    } finally {
+      this.pendingMarketData.delete(key);
+    }
+  }
+
+  /**
+   * Create new Market Data connection
+   */
+  async _createMarketData(credentials) {
+    const propfirmConfig = getPropFirmConfig(credentials.propfirm);
+    const systemName = credentials.systemName || propfirmConfig?.systemName || 'Apex';
+    const gateway = credentials.gateway || propfirmConfig?.gateway || RITHMIC_GATEWAYS.CHICAGO;
+    
+    const client = new RithmicMarketData({ debug: this.debug });
+    
+    await client.connect({
+      userId: credentials.userId,
+      password: credentials.password,
+      systemName,
+      gateway
+    });
+    
+    return client;
+  }
+
+  /**
+   * Get or create Trading connection
+   */
+  async getTrading(credentials) {
+    const { userId, password, systemName, gateway } = credentials;
+    const key = this._getKey(userId, systemName);
+    
+    // Check if pending
+    if (this.pendingTrading.has(key)) {
+      return this.pendingTrading.get(key);
+    }
+    
+    // Check pool
+    let pooled = this.tradingPool.get(key);
+    if (pooled && pooled.client.isConnected) {
+      pooled.lastUsed = Date.now();
+      this.stats.tradingHits++;
+      return pooled.client;
+    }
+    
+    // Create new connection
+    this.stats.tradingMisses++;
+    
+    const connectPromise = this._createTrading(credentials);
+    this.pendingTrading.set(key, connectPromise);
+    
+    try {
+      const client = await connectPromise;
+      this.tradingPool.set(key, {
+        client,
+        userId,
+        systemName,
+        lastUsed: Date.now()
+      });
+      return client;
+    } finally {
+      this.pendingTrading.delete(key);
+    }
+  }
+
+  /**
+   * Create new Trading connection
+   */
+  async _createTrading(credentials) {
+    const propfirmConfig = getPropFirmConfig(credentials.propfirm);
+    const systemName = credentials.systemName || propfirmConfig?.systemName || 'Apex';
+    const gateway = credentials.gateway || propfirmConfig?.gateway || RITHMIC_GATEWAYS.CHICAGO;
+    
+    const client = new RithmicTrading({ debug: this.debug });
+    
+    await client.connect({
+      userId: credentials.userId,
+      password: credentials.password,
+      systemName,
+      gateway
+    });
+    
+    return client;
+  }
+
+  /**
+   * Get or create P&L connection
+   */
+  async getPnL(credentials) {
+    const { userId, password, systemName, gateway } = credentials;
+    const key = this._getKey(userId, systemName);
+    
+    // Check if pending
+    if (this.pendingPnL.has(key)) {
+      return this.pendingPnL.get(key);
+    }
+    
+    // Check pool
+    let pooled = this.pnlPool.get(key);
+    if (pooled && pooled.client.isConnected) {
+      pooled.lastUsed = Date.now();
+      this.stats.pnlHits++;
+      return pooled.client;
+    }
+    
+    // Create new connection
+    this.stats.pnlMisses++;
+    
+    const connectPromise = this._createPnL(credentials);
+    this.pendingPnL.set(key, connectPromise);
+    
+    try {
+      const client = await connectPromise;
+      this.pnlPool.set(key, {
+        client,
+        userId,
+        systemName,
+        lastUsed: Date.now()
+      });
+      return client;
+    } finally {
+      this.pendingPnL.delete(key);
+    }
+  }
+
+  /**
+   * Create new P&L connection
+   */
+  async _createPnL(credentials) {
+    const propfirmConfig = getPropFirmConfig(credentials.propfirm);
+    const systemName = credentials.systemName || propfirmConfig?.systemName || 'Apex';
+    const gateway = credentials.gateway || propfirmConfig?.gateway || RITHMIC_GATEWAYS.CHICAGO;
+    
+    const client = new RithmicPnL({ debug: this.debug });
+    
+    await client.connect({
+      userId: credentials.userId,
+      password: credentials.password,
+      systemName,
+      gateway
+    });
+    
+    return client;
+  }
+
+  /**
+   * Release a connection (mark as available)
+   */
+  release(userId, systemName) {
+    const key = this._getKey(userId, systemName);
+    
+    for (const pool of [this.marketDataPool, this.tradingPool, this.pnlPool]) {
+      const pooled = pool.get(key);
+      if (pooled) {
+        pooled.lastUsed = Date.now();
+      }
+    }
+    
+  }
+
+  /**
+   * Remove a connection from pool and disconnect
+   */
+  async remove(userId, systemName) {
+    const key = this._getKey(userId, systemName);
+    
+    const pools = [
+      { pool: this.marketDataPool, name: 'MarketData' },
+      { pool: this.tradingPool, name: 'Trading' },
+      { pool: this.pnlPool, name: 'PnL' }
+    ];
+    
+    for (const { pool, name } of pools) {
+      const pooled = pool.get(key);
+      if (pooled) {
+        try {
+          await pooled.client.disconnect();
+        } catch (e) {
+          // Ignore disconnect errors
+        }
+        pool.delete(key);
+      }
+    }
+  }
+
+  /**
+   * Cleanup idle connections
+   */
+  async _cleanup() {
+    const now = Date.now();
+    const toRemove = [];
+    
+    const pools = [
+      { pool: this.marketDataPool, name: 'MarketData' },
+      { pool: this.tradingPool, name: 'Trading' },
+      { pool: this.pnlPool, name: 'PnL' }
+    ];
+    
+    for (const { pool, name } of pools) {
+      for (const [key, pooled] of pool) {
+        const idle = now - pooled.lastUsed;
+        if (idle > this.idleTimeout) {
+          toRemove.push({ pool, key, name, client: pooled.client });
+        }
+      }
+    }
+    
+    if (toRemove.length > 0) {
+      for (const { pool, key, name, client } of toRemove) {
+        try {
+          await client.disconnect();
+        } catch (e) {
+          // Ignore
+        }
+        pool.delete(key);
+      }
+    }
+  }
+
+  /**
+   * Get pool statistics
+   */
+  getStats() {
+    return {
+      marketData: {
+        active: this.marketDataPool.size,
+        pending: this.pendingMarketData.size,
+        hits: this.stats.marketDataHits,
+        misses: this.stats.marketDataMisses
+      },
+      trading: {
+        active: this.tradingPool.size,
+        pending: this.pendingTrading.size,
+        hits: this.stats.tradingHits,
+        misses: this.stats.tradingMisses
+      },
+      pnl: {
+        active: this.pnlPool.size,
+        pending: this.pendingPnL.size,
+        hits: this.stats.pnlHits,
+        misses: this.stats.pnlMisses
+      },
+      total: {
+        active: this.marketDataPool.size + this.tradingPool.size + this.pnlPool.size,
+        hitRate: this._calculateHitRate()
+      }
+    };
+  }
+
+  /**
+   * Calculate overall hit rate
+   */
+  _calculateHitRate() {
+    const hits = this.stats.marketDataHits + this.stats.tradingHits + this.stats.pnlHits;
+    const misses = this.stats.marketDataMisses + this.stats.tradingMisses + this.stats.pnlMisses;
+    const total = hits + misses;
+    return total > 0 ? ((hits / total) * 100).toFixed(1) + '%' : '0%';
+  }
+
+  /**
+   * Get all active connections info
+   */
+  getConnections() {
+    const connections = [];
+    const now = Date.now();
+    
+    for (const [key, pooled] of this.marketDataPool) {
+      connections.push({
+        type: 'MarketData',
+        key,
+        userId: pooled.userId,
+        systemName: pooled.systemName,
+        connected: pooled.client.isConnected,
+        idleSeconds: Math.floor((now - pooled.lastUsed) / 1000)
+      });
+    }
+    
+    for (const [key, pooled] of this.tradingPool) {
+      connections.push({
+        type: 'Trading',
+        key,
+        userId: pooled.userId,
+        systemName: pooled.systemName,
+        connected: pooled.client.isConnected,
+        idleSeconds: Math.floor((now - pooled.lastUsed) / 1000)
+      });
+    }
+    
+    for (const [key, pooled] of this.pnlPool) {
+      connections.push({
+        type: 'PnL',
+        key,
+        userId: pooled.userId,
+        systemName: pooled.systemName,
+        connected: pooled.client.isConnected,
+        idleSeconds: Math.floor((now - pooled.lastUsed) / 1000)
+      });
+    }
+    
+    return connections;
+  }
+
+  /**
+   * Shutdown pool and disconnect all
+   */
+  async shutdown() {
+    // Clear cleanup timer
+    if (this._cleanupTimer) {
+      clearInterval(this._cleanupTimer);
+      this._cleanupTimer = null;
+    }
+    
+    // Disconnect all
+    const pools = [this.marketDataPool, this.tradingPool, this.pnlPool];
+    
+    for (const pool of pools) {
+      for (const [, pooled] of pool) {
+        try {
+          await pooled.client.disconnect();
+        } catch (e) {
+          // Ignore
+        }
+      }
+      pool.clear();
+    }
+  }
+}
+
+// Singleton instance
+const rithmicPool = new RithmicConnectionPool();
+
+// Graceful shutdown on process exit
+process.on('SIGINT', async () => {
+  await rithmicPool.shutdown();
+});
+
+process.on('SIGTERM', async () => {
+  await rithmicPool.shutdown();
+});
+
+module.exports = { RithmicConnectionPool, rithmicPool };