rl-rockcli 0.0.8 → 0.0.10

package/commands/sandbox/core/replay/batch-orchestrator.js

@@ -0,0 +1,536 @@
+const path = require('path');
+const fs = require('fs-extra');
+const logger = require('../../../../utils/logger');
+const { SandboxClient, SandboxConfig } = require('../../../../sdks/sandbox');
+const { RequestAnalyzer } = require('./analyzer');
+const { ReplayExecutor } = require('./executor');
+const { SandboxTask, BatchReplayResult, TaskStatus, formatDuration } = require('./batch-task');
+const { HistoryFetcher } = require('./history-fetcher');
+
+/**
+ * 批量回放协调器
+ * 管理多个沙箱的批量回放流程
+ */
+class BatchReplayOrchestrator {
+  /**
+   * @param {Object} options - 配置选项
+   * @param {number} options.concurrency - 并发数
+   * @param {Object} options.baseConfig - 基础沙箱配置
+   * @param {string} options.mode - 回放模式
+   * @param {string} options.timing - 时间控制
+   * @param {Array} options.filters - 过滤器
+   * @param {boolean} options.autoFetchHistory - 是否自动获取历史
+   * @param {boolean} options.continueOnError - 错误时是否继续
+   * @param {boolean} options.quiet - 静默模式
+   * @param {boolean} options.dryRun - 预演模式
+   * @param {boolean} options.executeStop - 是否执行 stop 请求
+   * @param {string} options.reportFile - 报告文件路径
+   * @param {string} options.logFileBase - 日志文件基础路径
+   */
+  constructor(options) {
+    this.concurrency = options.concurrency || 1;
+    this.baseConfig = options.baseConfig;
+    this.mode = options.mode || 'smart';
+    this.timing = options.timing || 'none';
+    this.interval = options.interval || 5;
+    this.filters = options.filters || [];
+    this.autoFetchHistory = options.autoFetchHistory !== false;
+    this.continueOnError = options.continueOnError !== false;
+    this.quiet = options.quiet || false;
+    this.dryRun = options.dryRun || false;
+    this.executeStop = options.executeStop || false;
+    this.reportFile = options.reportFile || 'batch-replay-report.json';
+    this.logFileBase = options.logFileBase || 'replay.log';
+    this.verboseLog = options.verboseLog || false;
+
+    this.historyFetcher = new HistoryFetcher();
+    this.tasks = [];
+    this.result = null;
+    this.progressIntervalId = null;
+  }
+
+  /**
+   * 解析输入文件
+   * @param {string} filePath - 输入文件路径
+   * @returns {Object} - 解析后的输入数据
+   */
+  parseInputFile(filePath) {
+    if (!fs.existsSync(filePath)) {
+      throw new Error(`Input file not found: ${filePath}`);
+    }
+
+    const content = fs.readFileSync(filePath, 'utf8');
+    let data;
+
+    try {
+      data = JSON.parse(content);
+    } catch (error) {
+      throw new Error(`Failed to parse JSON from ${filePath}: ${error.message}`);
+    }
+
+    // 支持单个 history 文件格式 (有 sandboxId 和 requests)
+    if (data.sandboxId && data.requests && Array.isArray(data.requests)) {
+      // 转换为标准批量格式
+      return {
+        metadata: {
+          description: `Single sandbox replay: ${data.name || data.sandboxId}`,
+          sourceFile: filePath
+        },
+        defaults: {},
+        sandboxes: [data]
+      };
+    }
+
+    // 验证标准批量格式
+    if (!data.sandboxes || !Array.isArray(data.sandboxes)) {
+      throw new Error('Invalid input format: "sandboxes" array is required, or provide a single sandbox history file with "sandboxId" and "requests"');
+    }
+
+    if (data.sandboxes.length === 0) {
+      throw new Error('No sandboxes specified in input file');
+    }
+
+    // 验证每个沙箱配置
+    data.sandboxes.forEach((sandbox, index) => {
+      if (!sandbox.sandboxId) {
+        throw new Error(`Invalid sandbox at index ${index}: "sandboxId" is required`);
+      }
+    });
+
+    return data;
+  }
+
+  /**
+   * 从输入数据创建任务列表
+   * @param {Object} inputData - 解析后的输入数据
+   * @returns {SandboxTask[]}
+   */
+  createTasks(inputData) {
+    const defaults = inputData.defaults || {};
+    const tasks = [];
+
+    inputData.sandboxes.forEach((sandboxConfig, index) => {
+      const task = new SandboxTask(index, sandboxConfig, defaults);
+      tasks.push(task);
+    });
+
+    return tasks;
+  }
+
+  /**
+   * 执行批量回放
+   * @param {string} inputFilePath - 输入文件路径
+   * @returns {Promise<BatchReplayResult>}
+   */
+  async execute(inputFilePath) {
+    // 1. 解析输入文件
+    const inputData = this.parseInputFile(inputFilePath);
+
+    // 2. 初始化结果对象
+    this.result = new BatchReplayResult({
+      inputFile: inputFilePath,
+      inputMetadata: inputData.metadata || null,
+      concurrency: this.concurrency,
+      mode: this.mode,
+      timing: this.timing
+    });
+    this.result.start();
+
+    // 3. 创建任务列表
+    this.tasks = this.createTasks(inputData);
+
+    if (!this.quiet) {
+      this.displayBatchSummary();
+    }
+
+    // 4. 预演模式 - 只显示输入文件摘要，不获取历史
+    if (this.dryRun) {
+      this.displayDryRunSummaryFromInput();
+      this.result.end();
+      return this.result;
+    }
+
+    // 5. 获取历史（如果需要）
+    if (this.autoFetchHistory) {
+      await this.fetchHistories();
+    } else {
+      // 标记所有预加载的任务为 ready，并显示进度
+      if (!this.quiet) {
+        console.log('\n📥 Phase 1/2: Validating Pre-loaded Histories');
+        console.log('-'.repeat(40));
+      }
+
+      let completedCount = 0;
+      this.tasks.forEach(task => {
+        completedCount++;
+        if (task.hasRequests()) {
+          task.status = TaskStatus.READY;
+          if (!this.quiet) {
+            console.log(`  [${completedCount}/${this.tasks.length}] ✅ ${task.name} (${task.requests.length} requests)`);
+          }
+        } else {
+          task.status = TaskStatus.FAILED;
+          task.error = 'No requests provided and auto-fetch-history is disabled';
+          task.errorPhase = 'parse';
+          if (!this.quiet) {
+            console.log(`  [${completedCount}/${this.tasks.length}] ❌ ${task.name} (no requests)`);
+          }
+        }
+      });
+    }
+
+    // 6. 过滤出可执行的任务
+    const validTasks = this.tasks.filter(t => t.status === TaskStatus.READY);
+
+    if (validTasks.length === 0) {
+      if (!this.quiet) {
+        logger.warn('No valid tasks to execute after history fetch.');
+      }
+      this.result.end();
+      this.result.generateFromTasks(this.tasks);
+      await this.saveReport();
+      return this.result;
+    }
+
+    // 7. 执行回放
+    await this.executeReplays(validTasks);
+
+    // 8. 生成结果
+    this.result.end();
+    this.result.generateFromTasks(this.tasks);
+
+    // 9. 保存报告
+    await this.saveReport();
+
+    // 10. 显示摘要
+    if (!this.quiet) {
+      this.displayFinalSummary();
+    }
+
+    return this.result;
+  }
+
+  /**
+   * 显示批量回放摘要
+   */
+  displayBatchSummary() {
+    console.log('\n' + '═'.repeat(70));
+    console.log('📋 Batch Replay Mode');
+    console.log('═'.repeat(70));
+    console.log(`   Total Sandboxes: ${this.tasks.length}`);
+    console.log(`   Concurrency: ${this.concurrency}`);
+    console.log(`   Mode: ${this.mode}`);
+    console.log(`   Timing: ${this.timing}`);
+    console.log(`   Auto Fetch History: ${this.autoFetchHistory}`);
+    console.log('═'.repeat(70) + '\n');
+  }
+
+  /**
+   * 获取所有沙箱的历史
+   */
+  async fetchHistories() {
+    if (!this.quiet) {
+      console.log('\n📥 Phase 1/2: Fetching Histories');
+      console.log('-'.repeat(40));
+    }
+
+    await this.historyFetcher.fetchBatch(
+      this.tasks,
+      this.concurrency,
+      {
+        quiet: this.quiet,
+        onProgress: (completed, total, task) => {
+          if (!this.quiet) {
+            const status = task.status === TaskStatus.READY ? '✅' : '❌';
+            const requestCount = task.requests ? task.requests.length : 0;
+            console.log(`  [${completed}/${total}] ${status} ${task.name} (${requestCount} requests)`);
+          }
+        }
+      }
+    );
+  }
+
+  /**
+   * 执行回放任务
+   * @param {SandboxTask[]} tasks - 待执行的任务
+   */
+  async executeReplays(tasks) {
+    if (!this.quiet) {
+      console.log('\n🔄 Phase 2/2: Executing Replays');
+      console.log('-'.repeat(40));
+    }
+
+    // 创建任务队列
+    const queue = [...tasks];
+    let completed = 0;
+
+    // 启动进度监控
+    if (!this.quiet) {
+      this.startProgressMonitor(tasks);
+    }
+
+    // Worker 函数
+    const worker = async (workerId) => {
+      while (queue.length > 0) {
+        const task = queue.shift();
+        if (!task) break;
+
+        await this.executeReplayTask(task, workerId);
+        completed++;
+
+        if (!this.quiet) {
+          const status = task.status === TaskStatus.COMPLETED ? '✅' :
+            task.status === TaskStatus.FAILED ? '❌' : '⏸️';
+          const successCount = task.replayResult ? task.replayResult.success : 0;
+          const failedCount = task.replayResult ? task.replayResult.failed : 0;
+          console.log(`  [${completed}/${tasks.length}] ${status} ${task.name} (success: ${successCount}, failed: ${failedCount})`);
+        }
+      }
+    };
+
+    // 启动并发 workers
+    const workers = [];
+    const actualConcurrency = Math.min(this.concurrency, tasks.length);
+
+    for (let i = 0; i < actualConcurrency; i++) {
+      workers.push(worker(i + 1));
+    }
+
+    // 等待所有 workers 完成
+    await Promise.allSettled(workers);
+
+    // 停止进度监控
+    this.stopProgressMonitor();
+  }
+
+  /**
+   * 执行单个回放任务
+   * @param {SandboxTask} task - 任务
+   * @param {number} workerId - Worker ID
+   */
+  async executeReplayTask(task, workerId) {
+    task.startReplay();
+    task.logFile = this.getTaskLogFileName(task.index);
+
+    try {
+      // 创建沙箱配置
+      const config = new SandboxConfig({
+        baseUrl: this.baseConfig.baseUrl,
+        xrlAuthorization: this.baseConfig.xrlAuthorization,
+        cluster: task.cluster || this.baseConfig.cluster,
+        userId: task.userId || this.baseConfig.userId,
+        experimentId: task.experimentId || this.baseConfig.experimentId,
+        extraHeaders: this.baseConfig.extraHeaders || {},
+      });
+
+      // 创建客户端
+      const client = new SandboxClient(config);
+
+      // 分析请求
+      const analyzer = new RequestAnalyzer({
+        mode: task.mode || this.mode,
+        filters: [...this.filters, ...task.filters],
+        executeStop: this.executeStop
+      });
+
+      const plan = analyzer.analyze(task.requests);
+
+      if (plan.executeCount === 0) {
+        task.completeReplay({
+          total: 0,
+          success: 0,
+          failed: 0,
+          skipped: plan.skippedCount
+        }, null, []);
+        return;
+      }
+
+      // 创建执行器
+      const executor = new ReplayExecutor(client, {
+        timing: task.timing || this.timing,
+        interval: this.interval,
+        quiet: true,  // 批量模式下强制静默
+        logFile: task.logFile,
+        verboseLog: this.verboseLog,
+        plan: plan,
+        workerId: workerId
+      });
+
+      // 执行回放
+      const results = await executor.execute(plan);
+
+      // 完成任务
+      task.completeReplay(
+        results,
+        executor.currentSandboxId
+      );
+
+    } catch (error) {
+      task.failReplay(error);
+
+      if (!this.continueOnError) {
+        throw error;
+      }
+    }
+  }
+
+  /**
+   * 获取任务专属的日志文件名
+   * @param {number} taskIndex - 任务索引
+   * @returns {string}
+   */
+  getTaskLogFileName(taskIndex) {
+    const ext = path.extname(this.logFileBase);
+    const base = path.basename(this.logFileBase, ext);
+    const dir = path.dirname(this.logFileBase);
+    return path.join(dir, `${base}-sandbox-${taskIndex}${ext}`);
+  }
+
+  /**
+   * 启动进度监控
+   * @param {SandboxTask[]} tasks - 任务列表
+   */
+  startProgressMonitor(tasks) {
+    this.progressIntervalId = setInterval(() => {
+      const running = tasks.filter(t => t.status === TaskStatus.RUNNING);
+      const completed = tasks.filter(t => t.status === TaskStatus.COMPLETED || t.status === TaskStatus.FAILED);
+
+      console.log('\n--- Progress Update ---');
+      console.log(`  Completed: ${completed.length}/${tasks.length}`);
+      running.forEach(task => {
+        console.log(`  ⏳ ${task.name}... running`);
+      });
+      console.log('-'.repeat(23) + '\n');
+    }, 30000);  // 每 30 秒更新一次
+  }
+
+  /**
+   * 停止进度监控
+   */
+  stopProgressMonitor() {
+    if (this.progressIntervalId) {
+      clearInterval(this.progressIntervalId);
+      this.progressIntervalId = null;
+    }
+  }
+
+  /**
+   * 显示预演摘要（从输入文件，不获取历史）
+   */
+  displayDryRunSummaryFromInput() {
+    console.log('\n' + '═'.repeat(70));
+    console.log('🔍 DRY RUN - Preview Only (no history fetched, no requests executed)');
+    console.log('═'.repeat(70));
+
+    console.log(`\n📊 Configuration:`);
+    console.log(`   Total Sandboxes: ${this.tasks.length}`);
+    console.log(`   Concurrency: ${this.concurrency}`);
+    console.log(`   Mode: ${this.mode}`);
+    console.log(`   Timing: ${this.timing}`);
+    console.log(`   Auto Fetch History: ${this.autoFetchHistory}`);
+
+    const preloadedCount = this.tasks.filter(t => t.hasRequests()).length;
+    console.log(`\n📋 Sandboxes:`);
+    console.log(`   With Pre-loaded Requests: ${preloadedCount}`);
+    console.log(`   Need History Fetch: ${this.tasks.length - preloadedCount}`);
+
+    console.log(`\n📝 Sandbox List:`);
+    this.tasks.forEach((task, index) => {
+      const hasRequests = task.hasRequests();
+      const requestInfo = hasRequests ? `${task.requests.length} requests (pre-loaded)` : 'will fetch history';
+      console.log(`   ${index + 1}. ${task.name} (${task.sandboxId.substring(0, 8)}...) - ${requestInfo}`);
+    });
+
+    console.log('\n' + '═'.repeat(70));
+    console.log('Dry run completed - no history fetched, no requests executed');
+    console.log('═'.repeat(70) + '\n');
+  }
+
+  /**
+   * 显示预演摘要（获取历史后）
+   * @param {SandboxTask[]} validTasks - 有效任务
+   */
+  displayDryRunSummary(validTasks) {
+    console.log('\n' + '═'.repeat(70));
+    console.log('🔍 DRY RUN - Preview Only (no requests will be executed)');
+    console.log('═'.repeat(70));
+
+    console.log(`\n📊 Summary:`);
+    console.log(`   Total Sandboxes: ${this.tasks.length}`);
+    console.log(`   Valid for Replay: ${validTasks.length}`);
+    console.log(`   Failed History Fetch: ${this.tasks.filter(t => t.status === TaskStatus.FAILED).length}`);
+
+    console.log(`\n📋 Sandboxes to Replay:`);
+    validTasks.forEach((task, index) => {
+      const requestCount = task.requests ? task.requests.length : 0;
+      console.log(`   ${index + 1}. ${task.name} (${task.sandboxId.substring(0, 8)}...) - ${requestCount} requests`);
+    });
+
+    console.log('\n' + '═'.repeat(70));
+    console.log('Dry run completed - no requests were executed');
+    console.log('═'.repeat(70) + '\n');
+  }
+
+  /**
+   * 显示最终摘要
+   */
+  displayFinalSummary() {
+    const summary = this.result.summary;
+
+    console.log('\n' + '═'.repeat(70));
+    console.log('📊 Batch Replay Summary');
+    console.log('═'.repeat(70));
+
+    console.log(`\nTotal Sandboxes: ${summary.totalSandboxes}`);
+    console.log(`├── ✅ Successful: ${summary.successful}`);
+    console.log(`├── ❌ Failed: ${summary.failed}`);
+    console.log(`└── ⏭️  Skipped: ${summary.skipped}`);
+
+    console.log(`\nDuration: ${summary.totalDuration}`);
+
+    // 显示每个沙箱的结果
+    if (this.result.sandboxResults.length > 0) {
+      console.log('\nPer-Sandbox Results:');
+      console.log('┌' + '─'.repeat(8) + '┬' + '─'.repeat(24) + '┬' + '─'.repeat(10) + '┬' + '─'.repeat(10) + '┬' + '─'.repeat(12) + '┐');
+      console.log('│ Index  │ Name                   │ Status   │ Success  │ Duration   │');
+      console.log('├' + '─'.repeat(8) + '┼' + '─'.repeat(24) + '┼' + '─'.repeat(10) + '┼' + '─'.repeat(10) + '┼' + '─'.repeat(12) + '┤');
+
+      this.result.sandboxResults.forEach(result => {
+        const status = result.status === TaskStatus.COMPLETED ? '✅' :
+          result.status === TaskStatus.FAILED ? '❌' : '⏸️';
+        const success = result.replay ? result.replay.success.toString() : '-';
+        const duration = result.replay && result.replay.duration ?
+          formatDuration(result.replay.duration) : '-';
+        const name = result.name.length > 22 ? result.name.substring(0, 19) + '...' : result.name;
+
+        console.log(`│ ${result.index.toString().padEnd(6)} │ ${name.padEnd(22)} │ ${status.padEnd(8)} │ ${success.padEnd(8)} │ ${duration.padEnd(10)} │`);
+      });
+
+      console.log('└' + '─'.repeat(8) + '┴' + '─'.repeat(24) + '┴' + '─'.repeat(10) + '┴' + '─'.repeat(10) + '┴' + '─'.repeat(12) + '┘');
+    }
+
+    // 显示失败的沙箱
+    if (this.result.failedSandboxes.length > 0) {
+      console.log('\nFailed Sandboxes:');
+      this.result.failedSandboxes.forEach((failed, index) => {
+        console.log(`├── [${failed.name}] ${failed.error} (phase: ${failed.phase})`);
+      });
+    }
+
+    console.log(`\n📝 Report saved to: ${this.reportFile}`);
+    console.log('═'.repeat(70) + '\n');
+  }
+
+  /**
+   * 保存报告
+   */
+  async saveReport() {
+    try {
+      await fs.writeJson(this.reportFile, this.result.toJSON(), { spaces: 2 });
+    } catch (error) {
+      logger.warn(`Failed to save report to ${this.reportFile}: ${error.message}`);
+    }
+  }
+}
+
+module.exports = { BatchReplayOrchestrator };