windows-exe-decompiler-mcp-server 0.1.0

package/dist/worker-pool.d.ts

@@ -0,0 +1,204 @@
+/**
+ * Worker Pool - Manages worker processes for job execution
+ *
+ * Implements requirements 21.3, 27.2, and operational constraint 4:
+ * - Worker process management
+ * - Task allocation and status updates
+ * - Concurrency control (max 4 concurrent Ghidra analyses)
+ */
+import { EventEmitter } from 'events';
+import type { Job, JobResult } from './types.js';
+import { JobQueue } from './job-queue.js';
+/**
+ * Worker pool configuration
+ */
+export interface WorkerPoolConfig {
+    maxStaticWorkers?: number;
+    maxDecompileWorkers?: number;
+    maxDotNetWorkers?: number;
+    maxSandboxWorkers?: number;
+    heartbeatIntervalMs?: number;
+    workerTimeoutMs?: number;
+    testExecutor?: (job: Job) => Promise<JobResult>;
+}
+/**
+ * Worker pool that manages worker processes and allocates jobs
+ *
+ * Features:
+ * - Per-worker-type concurrency limits
+ * - Automatic worker allocation
+ * - Job status tracking
+ * - Worker health monitoring
+ */
+export declare class WorkerPool extends EventEmitter {
+    private workers;
+    private config;
+    private jobQueue;
+    private heartbeatTimer?;
+    private allocationTimer?;
+    private isRunning;
+    constructor(jobQueue: JobQueue, config?: WorkerPoolConfig);
+    /**
+     * Start the worker pool
+     *
+     * Begins monitoring the job queue and allocating jobs to workers
+     */
+    start(): void;
+    /**
+     * Stop the worker pool
+     *
+     * Stops allocating new jobs and waits for running jobs to complete
+     */
+    stop(): Promise<void>;
+    /**
+     * Allocate jobs from the queue to available workers
+     *
+     * Requirements: 21.3 - Task allocation
+     */
+    private allocateJobs;
+    /**
+     * Check if we have capacity to run more jobs
+     */
+    private hasCapacity;
+    /**
+     * Allocate a worker for a job
+     *
+     * @param job - Job to allocate worker for
+     * @returns Worker state or undefined if no capacity
+     */
+    private allocateWorker;
+    /**
+     * Create a new worker
+     *
+     * @param type - Worker type
+     * @returns New worker state
+     */
+    private createWorker;
+    /**
+     * Execute a job on a worker
+     *
+     * Requirements: 21.3 - Task allocation and status updates
+     * Requirements: 21.5, 28.2 - Failure retry mechanism with exponential backoff
+     * Requirements: 21.6, 操作约束 5 - Timeout control and worker termination
+     *
+     * @param worker - Worker to execute job on
+     * @param job - Job to execute
+     */
+    private executeJob;
+    /**
+     * Handle job timeout
+     *
+     * Requirements: 21.6 - Terminate worker process and mark task as failed when timeout occurs
+     * Requirements: 操作约束 5 - Enforce configurable timeout limits
+     *
+     * @param worker - Worker that timed out
+     * @param job - Job that timed out
+     */
+    private handleJobTimeout;
+    /**
+     * Terminate a worker process
+     *
+     * Requirements: 21.6 - Worker process termination on timeout
+     *
+     * This method terminates the worker process to free up resources.
+     * In a real implementation, this would kill the actual subprocess.
+     *
+     * @param worker - Worker to terminate
+     */
+    private terminateWorker;
+    /**
+     * Determine if a job should be retried
+     *
+     * Requirements: 21.5, 28.2 - Retry policy with max 3 attempts
+     *
+     * @param job - Job that failed
+     * @param errorMessage - Error message from failure
+     * @returns True if job should be retried
+     */
+    private shouldRetryJob;
+    /**
+     * Retry a failed job with exponential backoff
+     *
+     * Requirements: 21.5, 28.2 - Exponential backoff retry
+     *
+     * @param job - Job to retry
+     */
+    private retryJob;
+    /**
+     * Execute a job based on its type
+     *
+     * This is a placeholder that will be implemented by specific worker implementations
+     *
+     * @param job - Job to execute
+     * @returns Job result
+     */
+    private executeJobByType;
+    /**
+     * Check worker health and handle timeouts
+     *
+     * Requirements: 27.2 - Worker process management
+     */
+    private checkWorkerHealth;
+    /**
+     * Wait for all workers to finish their current jobs
+     */
+    private waitForWorkers;
+    /**
+     * Get worker counts by type and status
+     */
+    private getWorkerCounts;
+    /**
+     * Get count of workers by type and status
+     */
+    private getWorkerCountByType;
+    /**
+     * Get maximum workers for a job type
+     */
+    private getMaxWorkers;
+    /**
+     * Get pool statistics
+     */
+    getStats(): {
+        isRunning: boolean;
+        queueLength: number;
+        workers: {
+            static: {
+                total: number;
+                idle: number;
+                busy: number;
+                failed: number;
+                max: number;
+            };
+            decompile: {
+                total: number;
+                idle: number;
+                busy: number;
+                failed: number;
+                max: number;
+            };
+            dotnet: {
+                total: number;
+                idle: number;
+                busy: number;
+                failed: number;
+                max: number;
+            };
+            sandbox: {
+                total: number;
+                idle: number;
+                busy: number;
+                failed: number;
+                max: number;
+            };
+        };
+    };
+    /**
+     * Update worker heartbeat
+     *
+     * Should be called by worker implementations to indicate they're still alive
+     *
+     * @param workerId - Worker identifier
+     */
+    updateHeartbeat(workerId: string): void;
+}
+//# sourceMappingURL=worker-pool.d.ts.map