rl-rockcli 0.0.8 → 0.0.10

package/commands/sandbox/replay/analyzer.js

@@ -0,0 +1,311 @@
+const {
+  RequestCategory,
+  RequestAction,
+  ReplayRequest,
+  ReplayPlan
+} = require('./request');
+
+/**
+ * 请求分析器
+ * 负责对请求进行分类和优化
+ */
+class RequestAnalyzer {
+  /**
+   * @param {Object} options
+   * @param {string} options.mode - 回放模式: 'full' | 'smart' | 'minimal'
+   * @param {string[]} options.filters - 自定义过滤规则
+   * @param {boolean} options.executeStop - 是否执行 stop 请求
+   */
+  constructor(options = {}) {
+    this.mode = options.mode || 'smart';
+    this.filters = options.filters || [];
+    this.executeStop = options.executeStop || false;
+  }
+
+  /**
+   * 分析请求列表，生成回放计划
+   * @param {Object[]} rawRequests - 原始请求列表
+   * @returns {ReplayPlan}
+   */
+  analyze(rawRequests) {
+    const plan = new ReplayPlan();
+    plan.originalCount = rawRequests.length;
+
+    if (rawRequests.length === 0) {
+      return plan;
+    }
+
+    // 第一遍：分类
+    const classified = rawRequests.map((raw, index) => this.classify(raw, index));
+
+    // 第二遍：根据模式决定动作
+    const actioned = this.assignActions(classified);
+
+    // 第三遍：应用自定义过滤器和 stop 处理
+    const filtered = this.applyFilters(actioned);
+
+    // 分配到计划中
+    for (const req of filtered) {
+      this.updateStats(plan.stats, req);
+
+      if (req.action === RequestAction.SKIP) {
+        plan.skippedRequests.push(req);
+      } else if (req.action === RequestAction.MERGE) {
+        plan.mergedRequests.push(req);
+      } else {
+        plan.requests.push(req);
+      }
+    }
+
+    return plan;
+  }
+
+  /**
+   * 分类单个请求
+   * @param {Object} raw - 原始请求对象
+   * @param {number} index - 请求索引
+   * @returns {ReplayRequest}
+   */
+  classify(raw, index) {
+    const req = new ReplayRequest(raw, index);
+    const uri = req.uri || '';
+    const command = req.getCommand();
+
+    // 按 URI 分类
+    if (uri.includes('start_async')) {
+      req.category = RequestCategory.STARTUP;
+    } else if (uri.includes('get_status')) {
+      req.category = RequestCategory.STARTUP_POLLING;
+    } else if (uri.includes('create_session') || uri.includes('close_session')) {
+      req.category = RequestCategory.SESSION;
+    } else if (uri.includes('upload')) {
+      req.category = RequestCategory.UPLOAD;
+    } else if (uri.includes('/stop')) {
+      req.category = RequestCategory.STOP;
+    } else if (uri.includes('run_in_session')) {
+      // 按命令内容进一步分类
+      if (this.isNohupCommand(command)) {
+        req.category = RequestCategory.NOHUP_COMMAND;
+      } else if (this.isProcessCheck(command)) {
+        req.category = RequestCategory.PROCESS_CHECK;
+      } else if (this.isLogQuery(command)) {
+        req.category = RequestCategory.LOG_QUERY;
+      } else {
+        req.category = RequestCategory.OTHER;
+      }
+    } else {
+      req.category = RequestCategory.OTHER;
+    }
+
+    return req;
+  }
+
+  /**
+   * 根据模式分配动作
+   * @param {ReplayRequest[]} requests
+   * @returns {ReplayRequest[]}
+   */
+  assignActions(requests) {
+    switch (this.mode) {
+      case 'full':
+        return this.assignFullModeActions(requests);
+      case 'smart':
+        return this.assignSmartModeActions(requests);
+      case 'minimal':
+        return this.assignMinimalModeActions(requests);
+      default:
+        return this.assignSmartModeActions(requests);
+    }
+  }
+
+  /**
+   * Full 模式：保留所有请求，跳过进程检测
+   * @param {ReplayRequest[]} requests
+   * @returns {ReplayRequest[]}
+   */
+  assignFullModeActions(requests) {
+    return requests.map(req => {
+      switch (req.category) {
+        case RequestCategory.NOHUP_COMMAND:
+          req.action = RequestAction.EXECUTE_WITH_PROCESS_WAIT;
+          break;
+        case RequestCategory.PROCESS_CHECK:
+          // 跳过所有 kill -0，由 nohup 执行后自动等待进程结束
+          req.action = RequestAction.SKIP;
+          req.skipReason = 'Process check (handled by automatic process wait)';
+          break;
+        default:
+          req.action = RequestAction.EXECUTE;
+      }
+      return req;
+    });
+  }
+
+  /**
+   * Smart 模式：跳过启动轮询，跳过进程检测（由 nohup 自动等待）
+   * @param {ReplayRequest[]} requests
+   * @returns {ReplayRequest[]}
+   */
+  assignSmartModeActions(requests) {
+    let afterStartup = false;
+
+    for (const req of requests) {
+      switch (req.category) {
+        case RequestCategory.STARTUP:
+          afterStartup = true;
+          req.action = RequestAction.EXECUTE;
+          break;
+
+        case RequestCategory.STARTUP_POLLING:
+          if (afterStartup) {
+            req.action = RequestAction.SKIP;
+            req.skipReason = 'Startup polling (replaced by built-in wait)';
+          } else {
+            req.action = RequestAction.EXECUTE;
+          }
+          break;
+
+        case RequestCategory.SESSION:
+          afterStartup = false;
+          req.action = RequestAction.EXECUTE;
+          break;
+
+        case RequestCategory.NOHUP_COMMAND:
+          req.action = RequestAction.EXECUTE_WITH_PROCESS_WAIT;
+          break;
+
+        case RequestCategory.PROCESS_CHECK:
+          // 跳过所有 kill -0，由 nohup 执行后自动等待进程结束
+          req.action = RequestAction.SKIP;
+          req.skipReason = 'Process check (handled by automatic process wait)';
+          break;
+
+        case RequestCategory.LOG_QUERY:
+          req.action = RequestAction.EXECUTE;
+          break;
+
+        case RequestCategory.OTHER:
+          req.action = RequestAction.EXECUTE;
+          break;
+
+        default:
+          req.action = RequestAction.EXECUTE;
+      }
+    }
+
+    return requests;
+  }
+
+  /**
+   * Minimal 模式：只保留关键操作
+   * @param {ReplayRequest[]} requests
+   * @returns {ReplayRequest[]}
+   */
+  assignMinimalModeActions(requests) {
+    return requests.map(req => {
+      switch (req.category) {
+        case RequestCategory.STARTUP:
+          req.action = RequestAction.EXECUTE;
+          break;
+
+        case RequestCategory.SESSION:
+          req.action = RequestAction.EXECUTE;
+          break;
+
+        case RequestCategory.NOHUP_COMMAND:
+          req.action = RequestAction.EXECUTE_WITH_PROCESS_WAIT;
+          break;
+
+        case RequestCategory.UPLOAD:
+          req.action = RequestAction.EXECUTE;
+          break;
+
+        case RequestCategory.STARTUP_POLLING:
+          req.action = RequestAction.SKIP;
+          req.skipReason = 'Startup polling (minimal mode)';
+          break;
+
+        case RequestCategory.PROCESS_CHECK:
+          req.action = RequestAction.SKIP;
+          req.skipReason = 'Process check (minimal mode)';
+          break;
+
+        case RequestCategory.LOG_QUERY:
+          req.action = RequestAction.SKIP;
+          req.skipReason = 'Log query (minimal mode)';
+          break;
+
+        case RequestCategory.OTHER:
+          // 保留非轮询类命令
+          req.action = RequestAction.EXECUTE;
+          break;
+
+        default:
+          req.action = RequestAction.EXECUTE;
+      }
+      return req;
+    });
+  }
+
+  /**
+   * 应用自定义过滤器和 stop 处理
+   * @param {ReplayRequest[]} requests
+   * @returns {ReplayRequest[]}
+   */
+  applyFilters(requests) {
+    return requests.map(req => {
+      // 处理 stop 请求
+      if (req.category === RequestCategory.STOP) {
+        if (!this.executeStop) {
+          req.action = RequestAction.SKIP;
+          req.skipReason = 'Stop request (use --stop to execute)';
+        }
+        return req;
+      }
+
+      // 应用自定义过滤器
+      if (this.filters.length > 0 && req.action !== RequestAction.SKIP) {
+        for (const filter of this.filters) {
+          if (req.uri.includes(filter) ||
+              req.getCommand().includes(filter)) {
+            req.action = RequestAction.SKIP;
+            req.skipReason = `Custom filter: "${filter}"`;
+            break;
+          }
+        }
+      }
+
+      return req;
+    });
+  }
+
+  // 辅助方法
+  isNohupCommand(command) {
+    return /^nohup\s+/.test(command) && /&/.test(command);
+  }
+
+  isProcessCheck(command) {
+    return /^kill\s+-0\s+\d+$/.test(command);
+  }
+
+  isLogQuery(command) {
+    return /^head\s+-c\s+\d+\s+/.test(command) ||
+           /^tail\s+/.test(command);
+  }
+
+  updateStats(stats, req) {
+    switch (req.category) {
+      case RequestCategory.STARTUP: stats.startup++; break;
+      case RequestCategory.STARTUP_POLLING: stats.startupPolling++; break;
+      case RequestCategory.SESSION: stats.session++; break;
+      case RequestCategory.NOHUP_COMMAND: stats.nohupCommand++; break;
+      case RequestCategory.PROCESS_CHECK: stats.processCheck++; break;
+      case RequestCategory.LOG_QUERY: stats.logQuery++; break;
+      case RequestCategory.UPLOAD: stats.upload++; break;
+      case RequestCategory.STOP: stats.stop++; break;
+      case RequestCategory.OTHER: stats.other++; break;
+    }
+  }
+}
+
+module.exports = { RequestAnalyzer };