kubeview-mcp 1.0.0

package/src/kubernetes/ConnectionPool.ts

@@ -0,0 +1,551 @@
+import * as k8s from '@kubernetes/client-node';
+import { Logger } from 'winston';
+import { EventEmitter } from 'events';
+
+/**
+ * Configuration options for connection pooling
+ */
+export interface ConnectionPoolConfig {
+  /**
+   * Maximum number of connections per pool
+   */
+  maxConnections?: number;
+
+  /**
+   * Minimum number of connections to maintain
+   */
+  minConnections?: number;
+
+  /**
+   * Maximum idle time for a connection before removal (ms)
+   */
+  maxIdleTime?: number;
+
+  /**
+   * Time to wait for a connection to become available (ms)
+   */
+  acquireTimeout?: number;
+
+  /**
+   * Interval for health check runs (ms)
+   */
+  healthCheckInterval?: number;
+
+  /**
+   * Number of retries for failed health checks
+   */
+  healthCheckRetries?: number;
+
+  /**
+   * Enable connection warm-up on pool initialization
+   */
+  enableWarmup?: boolean;
+
+  /**
+   * Logger instance for debug output
+   */
+  logger?: Logger;
+}
+
+/**
+ * Default configuration values
+ */
+const DEFAULT_CONFIG: Required<Omit<ConnectionPoolConfig, 'logger'>> = {
+  maxConnections: 10,
+  minConnections: 2,
+  maxIdleTime: 300000, // 5 minutes
+  acquireTimeout: 30000, // 30 seconds
+  healthCheckInterval: 60000, // 1 minute
+  healthCheckRetries: 3,
+  enableWarmup: true,
+};
+
+/**
+ * Connection state enum
+ */
+export enum ConnectionState {
+  IDLE = 'idle',
+  IN_USE = 'in-use',
+  UNHEALTHY = 'unhealthy',
+  DISPOSED = 'disposed',
+}
+
+/**
+ * Connection entry tracking individual API client instances
+ */
+export class ConnectionEntry {
+  private _state: ConnectionState = ConnectionState.IDLE;
+  private _lastUsed: Date = new Date();
+  private _createdAt: Date = new Date();
+  private _useCount: number = 0;
+  private _lastHealthCheck?: Date;
+  private _healthCheckFailures: number = 0;
+
+  constructor(
+    public readonly id: string,
+    public readonly kubeConfig: k8s.KubeConfig,
+    private readonly logger?: Logger,
+  ) {}
+
+  /**
+   * Get the current state of the connection
+   */
+  get state(): ConnectionState {
+    return this._state;
+  }
+
+  /**
+   * Set the connection state
+   */
+  set state(value: ConnectionState) {
+    this.logger?.debug(`Connection ${this.id} state changed: ${this._state} -> ${value}`);
+    this._state = value;
+  }
+
+  /**
+   * Get the last used timestamp
+   */
+  get lastUsed(): Date {
+    return this._lastUsed;
+  }
+
+  /**
+   * Get the creation timestamp
+   */
+  get createdAt(): Date {
+    return this._createdAt;
+  }
+
+  /**
+   * Get the use count
+   */
+  get useCount(): number {
+    return this._useCount;
+  }
+
+  /**
+   * Get health check failure count
+   */
+  get healthCheckFailures(): number {
+    return this._healthCheckFailures;
+  }
+
+  /**
+   * Get last health check timestamp
+   */
+  get lastHealthCheck(): Date | undefined {
+    return this._lastHealthCheck;
+  }
+
+  /**
+   * Mark the connection as used
+   */
+  markUsed(): void {
+    this._lastUsed = new Date();
+    this._useCount++;
+    this.state = ConnectionState.IN_USE;
+  }
+
+  /**
+   * Release the connection back to the pool
+   */
+  release(): void {
+    if (this.state === ConnectionState.IN_USE) {
+      this.state = ConnectionState.IDLE;
+    }
+  }
+
+  /**
+   * Perform a health check on the connection
+   */
+  async checkHealth(): Promise<boolean> {
+    try {
+      const api = this.kubeConfig.makeApiClient(k8s.CoreV1Api);
+      await api.listNamespace();
+
+      this._lastHealthCheck = new Date();
+      this._healthCheckFailures = 0;
+
+      if (this.state === ConnectionState.UNHEALTHY) {
+        this.state = ConnectionState.IDLE;
+        this.logger?.info(`Connection ${this.id} recovered`);
+      }
+
+      return true;
+    } catch (error) {
+      this._healthCheckFailures++;
+      this.logger?.warn(`Health check failed for connection ${this.id}: ${error}`);
+
+      if (this.state !== ConnectionState.IN_USE) {
+        this.state = ConnectionState.UNHEALTHY;
+      }
+
+      return false;
+    }
+  }
+
+  /**
+   * Check if the connection has been idle too long
+   */
+  isIdleExpired(maxIdleTime: number): boolean {
+    if (this.state !== ConnectionState.IDLE) {
+      return false;
+    }
+
+    const idleTime = Date.now() - this.lastUsed.getTime();
+    return idleTime > maxIdleTime;
+  }
+
+  /**
+   * Dispose of the connection
+   */
+  dispose(): void {
+    this.state = ConnectionState.DISPOSED;
+    this.logger?.debug(`Connection ${this.id} disposed`);
+  }
+
+  /**
+   * Create an API client of the specified type
+   */
+  makeApiClient<T extends k8s.ApiType>(apiClientType: new (config: k8s.Configuration) => T): T {
+    return this.kubeConfig.makeApiClient(apiClientType);
+  }
+}
+
+/**
+ * Connection pool for managing Kubernetes API client connections
+ */
+export class ConnectionPool extends EventEmitter {
+  private readonly config: Required<Omit<ConnectionPoolConfig, 'logger'>>;
+  private readonly connections: Map<string, ConnectionEntry> = new Map();
+  private readonly waitQueue: Array<(conn: ConnectionEntry | null) => void> = [];
+  private healthCheckTimer?: NodeJS.Timeout;
+  private idleCheckTimer?: NodeJS.Timeout;
+  private disposed = false;
+  private connectionCounter = 0;
+
+  constructor(
+    private readonly contextName: string,
+    private readonly kubeConfigFactory: () => k8s.KubeConfig,
+    config: ConnectionPoolConfig = {},
+  ) {
+    super();
+    this.config = { ...DEFAULT_CONFIG, ...config };
+    this.logger = config.logger;
+
+    this.logger?.info(`Creating connection pool for context: ${contextName}`, {
+      config: this.config,
+    });
+
+    if (this.config.enableWarmup) {
+      this.warmup();
+    }
+
+    this.startHealthChecks();
+    this.startIdleChecks();
+  }
+
+  private logger?: Logger;
+
+  /**
+   * Get pool statistics
+   */
+  get stats(): {
+    total: number;
+    idle: number;
+    inUse: number;
+    unhealthy: number;
+    waitQueueLength: number;
+  } {
+    let idle = 0;
+    let inUse = 0;
+    let unhealthy = 0;
+
+    for (const conn of this.connections.values()) {
+      switch (conn.state) {
+        case ConnectionState.IDLE:
+          idle++;
+          break;
+        case ConnectionState.IN_USE:
+          inUse++;
+          break;
+        case ConnectionState.UNHEALTHY:
+          unhealthy++;
+          break;
+      }
+    }
+
+    return {
+      total: this.connections.size,
+      idle,
+      inUse,
+      unhealthy,
+      waitQueueLength: this.waitQueue.length,
+    };
+  }
+
+  /**
+   * Warm up the pool by creating minimum connections
+   */
+  private async warmup(): Promise<void> {
+    this.logger?.debug(`Warming up pool for context: ${this.contextName}`);
+
+    const promises: Promise<ConnectionEntry>[] = [];
+    for (let i = 0; i < this.config.minConnections; i++) {
+      promises.push(this.createConnection());
+    }
+
+    await Promise.all(promises);
+    this.logger?.info(`Pool warmed up with ${this.config.minConnections} connections`);
+  }
+
+  /**
+   * Create a new connection
+   */
+  private async createConnection(): Promise<ConnectionEntry> {
+    const id = `${this.contextName}-${++this.connectionCounter}`;
+    const kubeConfig = this.kubeConfigFactory();
+
+    const connection = new ConnectionEntry(id, kubeConfig, this.logger);
+
+    // Verify the connection works
+    const isHealthy = await connection.checkHealth();
+    if (!isHealthy) {
+      throw new Error(`Failed to create healthy connection for context: ${this.contextName}`);
+    }
+
+    this.connections.set(id, connection);
+    this.emit('connectionCreated', connection);
+
+    this.logger?.debug(`Created connection: ${id}`);
+    return connection;
+  }
+
+  /**
+   * Acquire a connection from the pool
+   */
+  async acquire(): Promise<ConnectionEntry> {
+    if (this.disposed) {
+      throw new Error('Connection pool has been disposed');
+    }
+
+    // Try to find an idle connection
+    for (const conn of this.connections.values()) {
+      if (conn.state === ConnectionState.IDLE) {
+        conn.markUsed();
+        this.emit('connectionAcquired', conn);
+        return conn;
+      }
+    }
+
+    // Create a new connection if under the limit
+    if (this.connections.size < this.config.maxConnections) {
+      try {
+        const conn = await this.createConnection();
+        conn.markUsed();
+        this.emit('connectionAcquired', conn);
+        return conn;
+      } catch (error) {
+        this.logger?.error(`Failed to create new connection: ${error}`);
+        throw error;
+      }
+    }
+
+    // Wait for a connection to become available
+    return new Promise((resolve, reject) => {
+      const timeoutId = setTimeout(() => {
+        const index = this.waitQueue.indexOf(callback);
+        if (index !== -1) {
+          this.waitQueue.splice(index, 1);
+        }
+        reject(new Error(`Connection acquire timeout after ${this.config.acquireTimeout}ms`));
+      }, this.config.acquireTimeout);
+
+      const callback = (conn: ConnectionEntry | null) => {
+        clearTimeout(timeoutId);
+        if (conn) {
+          conn.markUsed();
+          this.emit('connectionAcquired', conn);
+          resolve(conn);
+        } else {
+          reject(new Error('Failed to acquire connection'));
+        }
+      };
+
+      this.waitQueue.push(callback);
+    });
+  }
+
+  /**
+   * Release a connection back to the pool
+   */
+  release(connection: ConnectionEntry): void {
+    if (connection.state !== ConnectionState.IN_USE) {
+      this.logger?.warn(`Attempting to release connection ${connection.id} that is not in use`);
+      return;
+    }
+
+    connection.release();
+    this.emit('connectionReleased', connection);
+
+    // If there are waiting requests, fulfill them
+    if (this.waitQueue.length > 0) {
+      const callback = this.waitQueue.shift();
+      if (callback) {
+        callback(connection);
+        return;
+      }
+    }
+
+    // Check if we have too many idle connections
+    const stats = this.stats;
+    if (stats.idle > this.config.minConnections) {
+      // Remove this connection if it's the oldest idle one
+      let oldestIdle: ConnectionEntry | null = null;
+      for (const conn of this.connections.values()) {
+        if (conn.state === ConnectionState.IDLE && conn !== connection) {
+          if (!oldestIdle || conn.lastUsed < oldestIdle.lastUsed) {
+            oldestIdle = conn;
+          }
+        }
+      }
+
+      if (oldestIdle && oldestIdle.lastUsed < connection.lastUsed) {
+        this.removeConnection(oldestIdle.id);
+      }
+    }
+  }
+
+  /**
+   * Remove a connection from the pool
+   */
+  private removeConnection(connectionId: string): void {
+    const conn = this.connections.get(connectionId);
+    if (conn) {
+      conn.dispose();
+      this.connections.delete(connectionId);
+      this.emit('connectionRemoved', conn);
+      this.logger?.debug(`Removed connection: ${connectionId}`);
+    }
+  }
+
+  /**
+   * Start periodic health checks
+   */
+  private startHealthChecks(): void {
+    if (this.config.healthCheckInterval <= 0) {
+      return;
+    }
+
+    this.healthCheckTimer = setInterval(async () => {
+      await this.performHealthChecks();
+    }, this.config.healthCheckInterval);
+  }
+
+  /**
+   * Perform health checks on all connections
+   */
+  private async performHealthChecks(): Promise<void> {
+    if (this.disposed) {
+      return;
+    }
+
+    this.logger?.debug(`Performing health checks for pool: ${this.contextName}`);
+    const promises: Promise<void>[] = [];
+
+    for (const conn of this.connections.values()) {
+      if (conn.state !== ConnectionState.IN_USE) {
+        promises.push(
+          conn.checkHealth().then((healthy) => {
+            if (!healthy && conn.healthCheckFailures >= this.config.healthCheckRetries) {
+              this.logger?.warn(`Connection ${conn.id} failed health checks, removing from pool`);
+              this.removeConnection(conn.id);
+            }
+          }),
+        );
+      }
+    }
+
+    await Promise.all(promises);
+
+    // Ensure minimum connections
+    const stats = this.stats;
+    if (stats.total < this.config.minConnections && !this.disposed) {
+      const toCreate = this.config.minConnections - stats.total;
+      for (let i = 0; i < toCreate; i++) {
+        try {
+          await this.createConnection();
+        } catch (error) {
+          this.logger?.error(`Failed to create connection during health check: ${error}`);
+        }
+      }
+    }
+  }
+
+  /**
+   * Start periodic idle connection checks
+   */
+  private startIdleChecks(): void {
+    this.idleCheckTimer = setInterval(() => {
+      this.removeIdleConnections();
+    }, 30000); // Check every 30 seconds
+  }
+
+  /**
+   * Remove connections that have been idle too long
+   */
+  private removeIdleConnections(): void {
+    if (this.disposed) {
+      return;
+    }
+
+    const stats = this.stats;
+    if (stats.total <= this.config.minConnections) {
+      return;
+    }
+
+    for (const conn of this.connections.values()) {
+      if (conn.isIdleExpired(this.config.maxIdleTime) && stats.total > this.config.minConnections) {
+        this.removeConnection(conn.id);
+        stats.total--;
+      }
+    }
+  }
+
+  /**
+   * Dispose of the connection pool
+   */
+  async dispose(): Promise<void> {
+    if (this.disposed) {
+      return;
+    }
+
+    this.disposed = true;
+    this.logger?.info(`Disposing connection pool for context: ${this.contextName}`);
+
+    // Clear timers
+    if (this.healthCheckTimer) {
+      clearInterval(this.healthCheckTimer);
+    }
+    if (this.idleCheckTimer) {
+      clearInterval(this.idleCheckTimer);
+    }
+
+    // Reject all waiting requests
+    while (this.waitQueue.length > 0) {
+      const callback = this.waitQueue.shift();
+      if (callback) {
+        callback(null);
+      }
+    }
+
+    // Dispose all connections
+    for (const conn of this.connections.values()) {
+      conn.dispose();
+    }
+    this.connections.clear();
+
+    this.emit('disposed');
+    this.removeAllListeners();
+  }
+}