module_executor

🚀 模块执行器和监控器 (Module Executor & Monitor)

本文档是从 @module_manager 分割出来的执行和监控部分。

⚠️ 执行原则

MUST 遵循以下模块执行准则：

• MUST 在执行前验证所有依赖项
• NEVER 跳过模块初始化检查
• ALWAYS 监控执行性能和资源使用
• DO NOT 在未处理错误的情况下继续执行
• MUST 确保线程安全和并发控制
• ALWAYS 记录执行日志用于审计

加载策略 (Loading Strategies)

即时加载 (Immediate Loading)

class ImmediateLoader implements ModuleLoader {
  async load(moduleName: string): Promise<ModuleInstance> {
    const module = await this.registry.get(moduleName);
    if (!module) {
      throw new Error(`Module ${moduleName} not found`);
    }

    // 检查缓存
    const cached = this.cache.get(moduleName);
    if (cached && this.isCacheValid(cached, module)) {
      return cached.instance;
    }

    // 解析依赖
    const resolution = await this.resolver.resolve(moduleName);

    // 按顺序加载依赖
    for (const depName of resolution.loadOrder) {
      if (depName !== moduleName) {
        await this.load(depName);
      }
    }

    // 加载主模块
    const instance = await this.loadModuleInstance(module);

    // 缓存实例
    this.cache.set(moduleName, {
      instance,
      timestamp: Date.now(),
      metadata: module.metadata
    });

    return instance;
  }
}

懒加载 (Lazy Loading)

class LazyLoader implements ModuleLoader {
  private loadingPromises: Map<string, Promise<ModuleInstance>> = new Map();

  async load(moduleName: string): Promise<ModuleInstance> {
    if (this.loadingPromises.has(moduleName)) {
      return this.loadingPromises.get(moduleName)!;
    }

    const loadPromise = this.performLazyLoad(moduleName);
    this.loadingPromises.set(moduleName, loadPromise);

    return loadPromise;
  }

  private async performLazyLoad(moduleName: string): Promise<ModuleInstance> {
    // 延迟加载逻辑
    await this.delay(100); // 模拟网络延迟或其他准备时间

    const module = await this.registry.get(moduleName);
    if (!module) {
      throw new Error(`Module ${moduleName} not found`);
    }

    return this.loadModuleInstance(module);
  }
}