@joystick.js/db-canary 0.0.0-canary.2209

package/src/server/lib/connection_manager.js

@@ -0,0 +1,218 @@
+/**
+ * @fileoverview Connection management system for JoystickDB TCP server.
+ * Handles client connection lifecycle, idle timeouts, request timeouts, and connection limits.
+ * Provides connection tracking, activity monitoring, and graceful shutdown capabilities.
+ */
+
+import create_logger from './logger.js';
+
+const { create_context_logger } = create_logger('connection_manager');
+
+/**
+ * Creates a connection manager instance for handling TCP client connections.
+ * @param {Object} [options={}] - Configuration options for the connection manager
+ * @param {number} [options.max_connections=1000] - Maximum number of concurrent connections
+ * @param {number} [options.idle_timeout=600000] - Idle timeout in milliseconds (10 minutes)
+ * @param {number} [options.request_timeout=5000] - Request timeout in milliseconds (5 seconds)
+ * @returns {Object} Connection manager instance with management methods
+ * @returns {function} returns.add_connection - Adds a new connection
+ * @returns {function} returns.remove_connection - Removes a connection
+ * @returns {function} returns.update_activity - Updates connection activity
+ * @returns {function} returns.create_request_timeout - Creates request timeout
+ * @returns {function} returns.get_stats - Gets connection statistics
+ * @returns {function} returns.shutdown - Shuts down all connections
+ */
+const create_connection_manager = (options = {}) => {
+  const {
+    max_connections = 1000,
+    idle_timeout = 10 * 60 * 1000,
+    request_timeout = 5 * 1000
+  } = options;
+  
+  /** @type {Map<string, Object>} Map of socket IDs to connection information */
+  const connections = new Map();
+  const log = create_context_logger();
+  
+  /**
+   * Adds a new connection to the manager with idle timeout handling.
+   * @param {Object} socket - TCP socket instance
+   * @param {string} socket.id - Unique socket identifier
+   * @returns {boolean} True if connection added successfully, false if limit reached
+   */
+  const add_connection = (socket) => {
+    if (connections.size >= max_connections) {
+      log.warn('Connection limit reached', {
+        current_connections: connections.size,
+        max_connections,
+        rejected_socket_id: socket.id
+      });
+      
+      socket.destroy();
+      return false;
+    }
+    
+    const connection_info = {
+      socket,
+      connected_at: Date.now(),
+      last_activity: Date.now(),
+      idle_timer: null,
+      request_count: 0
+    };
+    
+    connection_info.idle_timer = setTimeout(() => {
+      log.info('Connection idle timeout', {
+        socket_id: socket.id,
+        idle_duration_ms: Date.now() - connection_info.last_activity
+      });
+      
+      remove_connection(socket.id);
+      socket.destroy();
+    }, idle_timeout);
+    
+    connections.set(socket.id, connection_info);
+    
+    log.info('Connection added', {
+      socket_id: socket.id,
+      total_connections: connections.size,
+      max_connections
+    });
+    
+    return true;
+  };
+  
+  /**
+   * Removes a connection from the manager and cleans up timers.
+   * @param {string} socket_id - Unique socket identifier
+   */
+  const remove_connection = (socket_id) => {
+    const connection_info = connections.get(socket_id);
+    
+    if (connection_info) {
+      if (connection_info.idle_timer) {
+        clearTimeout(connection_info.idle_timer);
+      }
+      
+      connections.delete(socket_id);
+      
+      log.info('Connection removed', {
+        socket_id,
+        total_connections: connections.size,
+        connection_duration_ms: Date.now() - connection_info.connected_at,
+        request_count: connection_info.request_count
+      });
+    }
+  };
+  
+  /**
+   * Updates connection activity timestamp and resets idle timer.
+   * @param {string} socket_id - Unique socket identifier
+   */
+  const update_activity = (socket_id) => {
+    const connection_info = connections.get(socket_id);
+    
+    if (connection_info) {
+      connection_info.last_activity = Date.now();
+      connection_info.request_count++;
+      
+      if (connection_info.idle_timer) {
+        clearTimeout(connection_info.idle_timer);
+      }
+      
+      connection_info.idle_timer = setTimeout(() => {
+        log.info('Connection idle timeout', {
+          socket_id,
+          idle_duration_ms: Date.now() - connection_info.last_activity
+        });
+        
+        remove_connection(socket_id);
+        connection_info.socket.destroy();
+      }, idle_timeout);
+    }
+  };
+  
+  /**
+   * Creates a request timeout that will close the connection if exceeded.
+   * @param {string} socket_id - Unique socket identifier
+   * @param {string} operation - Name of the operation being timed
+   * @returns {NodeJS.Timeout} Timeout handle that can be cleared
+   */
+  const create_request_timeout = (socket_id, operation) => {
+    return setTimeout(() => {
+      const connection_info = connections.get(socket_id);
+      
+      if (connection_info) {
+        log.warn('Request timeout', {
+          socket_id,
+          operation,
+          timeout_ms: request_timeout
+        });
+        
+        remove_connection(socket_id);
+        connection_info.socket.destroy();
+      }
+    }, request_timeout);
+  };
+  
+  /**
+   * Gets current connection statistics and metrics.
+   * @returns {Object} Statistics object
+   * @returns {number} returns.total_connections - Current number of active connections
+   * @returns {number} returns.max_connections - Maximum allowed connections
+   * @returns {number} returns.total_requests - Total requests processed across all connections
+   * @returns {number} returns.oldest_connection_age_ms - Age of oldest connection in milliseconds
+   * @returns {number} returns.idle_timeout_ms - Idle timeout setting in milliseconds
+   * @returns {number} returns.request_timeout_ms - Request timeout setting in milliseconds
+   */
+  const get_stats = () => {
+    const now = Date.now();
+    let total_requests = 0;
+    let oldest_connection = now;
+    
+    for (const connection_info of connections.values()) {
+      total_requests += connection_info.request_count;
+      oldest_connection = Math.min(oldest_connection, connection_info.connected_at);
+    }
+    
+    return {
+      total_connections: connections.size,
+      max_connections,
+      total_requests,
+      oldest_connection_age_ms: connections.size > 0 ? now - oldest_connection : 0,
+      idle_timeout_ms: idle_timeout,
+      request_timeout_ms: request_timeout
+    };
+  };
+  
+  /**
+   * Shuts down the connection manager by closing all active connections.
+   * Clears all timers and destroys all sockets gracefully.
+   */
+  const shutdown = () => {
+    log.info('Shutting down connection manager', {
+      active_connections: connections.size
+    });
+    
+    for (const [socket_id, connection_info] of connections) {
+      if (connection_info.idle_timer) {
+        clearTimeout(connection_info.idle_timer);
+      }
+      
+      connection_info.socket.destroy();
+    }
+    
+    connections.clear();
+  };
+  
+  return {
+    add_connection,
+    remove_connection,
+    update_activity,
+    create_request_timeout,
+    get_stats,
+    shutdown
+  };
+};
+
+export {
+  create_connection_manager
+};

package/src/server/lib/disk_utils.js

@@ -0,0 +1,118 @@
+/**
+ * @fileoverview Disk space utilities for JoystickDB LMDB map size management.
+ * Provides functions to detect available disk space, calculate optimal LMDB map sizes,
+ * and determine when map size growth is needed based on usage patterns and disk capacity.
+ * Ensures efficient memory-mapped file allocation while preventing disk space exhaustion.
+ */
+
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import create_logger from './logger.js';
+
+/** @type {Function} Promisified version of child_process.exec for async/await usage */
+const exec_async = promisify(exec);
+
+const { create_context_logger } = create_logger('disk_utils');
+
+/**
+ * Gets the total disk size for the specified path using the df command.
+ * Executes system df command to retrieve disk space information and parses the output
+ * to extract total available space in bytes.
+ * @param {string} [path='.'] - Path to check disk size for
+ * @returns {Promise<number>} Total disk size in bytes
+ * @throws {Error} When df command fails or output cannot be parsed
+ */
+const get_disk_size = async (path = '.') => {
+  const log = create_context_logger();
+  
+  try {
+    const { stdout } = await exec_async(`df -k ${path}`);
+    const lines = stdout.trim().split('\n');
+    
+    if (lines.length < 2) {
+      throw new Error('Unable to parse df output');
+    }
+    
+    const data_line = lines[1];
+    const columns = data_line.split(/\s+/);
+    
+    if (columns.length < 4) {
+      throw new Error('Invalid df output format');
+    }
+    
+    const total_kb = parseInt(columns[1]);
+    const total_bytes = total_kb * 1024;
+    
+    log.info('Disk size detected', {
+      path,
+      total_kb,
+      total_bytes,
+      total_gb: Math.round(total_bytes / (1024 * 1024 * 1024) * 100) / 100
+    });
+    
+    return total_bytes;
+  } catch (error) {
+    log.error('Failed to get disk size', { path, error: error.message });
+    throw error;
+  }
+};
+
+/**
+ * Calculates optimal LMDB map size based on available disk space.
+ * Uses 80% of available disk space as the maximum map size to prevent disk exhaustion
+ * while allowing for adequate database growth. Falls back to 10GB default on failure.
+ * @param {string} [database_path='./data'] - Path to the database directory
+ * @returns {Promise<number>} Calculated map size in bytes (80% of disk space or 10GB default)
+ */
+const calculate_map_size = async (database_path = './data') => {
+  const log = create_context_logger();
+  
+  try {
+    const disk_size = await get_disk_size(database_path);
+    const map_size = Math.floor(disk_size * 0.8);
+    
+    log.info('Map size calculated', {
+      database_path,
+      disk_size,
+      map_size,
+      percentage: 80
+    });
+    
+    return map_size;
+  } catch (error) {
+    log.warn('Failed to calculate map_size, using default', {
+      database_path,
+      error: error.message,
+      default_size: 1024 * 1024 * 1024 * 10
+    });
+    
+    return 1024 * 1024 * 1024 * 10;
+  }
+};
+
+/**
+ * Determines if LMDB map size should be grown based on current usage.
+ * Evaluates if current usage exceeds 80% threshold and calculates new size
+ * by doubling current size, capped at 80% of available disk space.
+ * @param {number} current_size - Current LMDB map size in bytes
+ * @param {number} used_size - Currently used space in bytes
+ * @param {number} disk_size - Total available disk space in bytes
+ * @returns {number|null} New map size in bytes if growth needed, null otherwise
+ */
+const should_grow_map_size = (current_size, used_size, disk_size) => {
+  const usage_percentage = used_size / current_size;
+  const growth_threshold = 0.8;
+  
+  if (usage_percentage >= growth_threshold) {
+    const new_size = Math.min(current_size * 2, Math.floor(disk_size * 0.8));
+    return new_size > current_size ? new_size : null;
+  }
+  
+  return null;
+};
+
+export {
+  get_disk_size,
+  calculate_map_size,
+  should_grow_map_size
+};