rcc-pipeline/dist/framework/PipelineScheduler.d.ts

RCC Pipeline Module - Pipeline system and workflow management based on pipeline-framework

/**
 * Pipeline Scheduler - Handles scheduling for one virtual model
 * 流水线调度器 - 处理单个虚拟模型的调度
 */
import { Pipeline } from './Pipeline';
import { PipelineTracker } from './PipelineTracker';
type OperationType = 'chat' | 'streamChat' | 'healthCheck';
export interface SchedulerConfig {
    maxConcurrentRequests: number;
    requestTimeout: number;
    healthCheckInterval: number;
    retryStrategy: {
        maxRetries: number;
        baseDelay: number;
        maxDelay: number;
        backoffMultiplier: number;
    };
    loadBalancingStrategy: 'round-robin' | 'weighted' | 'least-connections' | 'random';
    enableCircuitBreaker: boolean;
    circuitBreakerThreshold: number;
    circuitBreakerTimeout: number;
}
export interface SchedulerMetrics {
    totalRequests: number;
    successfulRequests: number;
    failedRequests: number;
    currentConcurrentRequests: number;
    averageResponseTime: number;
    errorRate: number;
    uptime: number;
    lastHealthCheck: number;
    circuitBreakerTripped: boolean;
    circuitBreakerTripCount: number;
    queueLength: number;
    averageQueueTime: number;
}
export interface SchedulerHealth {
    status: 'healthy' | 'degraded' | 'unhealthy';
    checks: {
        pipelineHealth: boolean;
        errorRate: boolean;
        responseTime: boolean;
        circuitBreaker: boolean;
        concurrency: boolean;
    };
    details: {
        healthyPipelines: number;
        totalPipelines: number;
        currentErrorRate: number;
        averageResponseTime: number;
        circuitBreakerTripped: boolean;
        currentConcurrency: number;
        maxConcurrency: number;
    };
}
export interface RequestPriority {
    level: 'low' | 'medium' | 'high' | 'critical';
    score: number;
    timestamp: number;
}
export interface ScheduledRequest {
    id: string;
    request: any;
    operation: OperationType;
    priority: RequestPriority;
    timestamp: number;
    timeout?: number;
    metadata?: Record<string, any>;
}
export interface SchedulerOptions {
    timeout?: number;
    retries?: number;
    priority?: RequestPriority['level'];
    healthCheck?: boolean;
    circuitBreaker?: boolean;
    metadata?: Record<string, any>;
}
/**
 * Pipeline Scheduler - Manages request scheduling for a single virtual model
 * 流水线调度器 - 管理单个虚拟模型的请求调度
 */
export declare class PipelineScheduler {
    private virtualModelId;
    private config;
    private pipelines;
    private pipelineTracker;
    private currentPipelineIndex;
    private metrics;
    private requestQueue;
    private activeRequests;
    private healthCheckInterval?;
    private circuitBreakerState;
    constructor(virtualModelId: string, config: SchedulerConfig, pipelineTracker: PipelineTracker);
    /**
     * Add pipeline to scheduler
     * 向调度器添加流水线
     */
    addPipeline(pipeline: Pipeline): void;
    /**
     * Remove pipeline from scheduler
     * 从调度器移除流水线
     */
    removePipeline(pipelineId: string): boolean;
    /**
     * Execute request through scheduler
     * 通过调度器执行请求
     */
    execute(request: any, operation: OperationType, options?: SchedulerOptions): Promise<any>;
    /**
     * Execute streaming request through scheduler
     * 通过调度器执行流式请求
     */
    executeStreaming(request: any, operation: OperationType, options?: SchedulerOptions): AsyncGenerator<any, void, unknown>;
    /**
     * Execute with retry logic
     * 带重试逻辑执行
     */
    private executeWithRetry;
    /**
     * Queue request for later processing
     * 将请求排队等待后续处理
     */
    private queueRequest;
    /**
     * Start request processing from queue
     * 开始从队列处理请求
     */
    private startRequestProcessing;
    /**
     * Process queued requests
     * 处理排队请求
     */
    private processQueue;
    /**
     * Select pipeline using configured strategy
     * 使用配置策略选择流水线
     */
    private selectPipeline;
    /**
     * Round-robin pipeline selection
     * 轮询流水线选择
     */
    private selectRoundRobin;
    /**
     * Weighted pipeline selection
     * 加权流水线选择
     */
    private selectWeighted;
    /**
     * Least connections pipeline selection
     * 最少连接流水线选择
     */
    private selectLeastConnections;
    /**
     * Random pipeline selection
     * 随机流水线选择
     */
    private selectRandom;
    /**
     * Calculate retry delay with exponential backoff
     * 计算带指数退避的重试延迟
     */
    private calculateRetryDelay;
    /**
     * Calculate priority score
     * 计算优先级分数
     */
    private calculatePriorityScore;
    /**
     * Circuit breaker operations
     * 熔断器操作
     */
    private isCircuitBreakerTripped;
    private updateCircuitBreaker;
    private resetCircuitBreaker;
    /**
     * Health check operations
     * 健康检查操作
     */
    private startHealthChecks;
    private performHealthCheck;
    private updateHealthCheck;
    /**
     * Update average response time
     * 更新平均响应时间
     */
    private updateAverageResponseTime;
    /**
     * Utility functions
     * 实用函数
     */
    private sleep;
    /**
     * Get scheduler metrics
     * 获取调度器指标
     */
    getMetrics(): SchedulerMetrics;
    /**
     * Get scheduler health (simplified - always healthy)
     * 获取调度器健康状态（简化 - 总是健康的）
     */
    getHealth(): SchedulerHealth;
    /**
     * Get scheduler configuration
     * 获取调度器配置
     */
    getConfig(): SchedulerConfig;
    /**
     * Get all pipelines
     * 获取所有流水线
     */
    getPipelines(): Pipeline[];
    /**
     * Get virtual model ID
     * 获取虚拟模型ID
     */
    getVirtualModelId(): string;
    /**
     * Destroy scheduler and cleanup resources
     * 销毁调度器并清理资源
     */
    destroy(): void;
}
export {};
//# sourceMappingURL=PipelineScheduler.d.ts.map