"""插件加载器插件 - 支持能力扫描和扩展""" import sys import json import importlib.util from pathlib import Path from typing import Any, Optional from oss.plugin.types import Plugin, register_plugin_type from oss.plugin.capabilities import scan_capabilities class PluginInfo: """插件信息""" def __init__(self): self.name: str = "" self.version: str = "" self.author: str = "" self.description: str = "" self.readme: str = "" self.config: dict[str, Any] = {} self.extensions: dict[str, Any] = {} self.lifecycle: Any = None self.capabilities: set[str] = set() self.dependencies: list[str] = [] class PermissionError(Exception): """权限错误""" pass class PluginProxy: """插件代理 - 防止越级访问""" def __init__(self, plugin_name: str, plugin_instance: Any, allowed_plugins: list[str], all_plugins: dict[str, dict[str, Any]]): self._plugin_name = plugin_name self._plugin_instance = plugin_instance self._allowed_plugins = set(allowed_plugins) self._all_plugins = all_plugins def get_plugin(self, name: str) -> Any: """获取其他插件实例（带权限检查）""" if name not in self._allowed_plugins and "*" not in self._allowed_plugins: raise PermissionError(f"插件 '{self._plugin_name}' 无权访问插件 '{name}'") if name not in self._all_plugins: return None return self._all_plugins[name]["instance"] def list_plugins(self) -> list[str]: """列出有权限访问的插件""" if "*" in self._allowed_plugins: return list(self._all_plugins.keys()) return [name for name in self._allowed_plugins if name in self._all_plugins] def get_capability(self, capability: str) -> Any: """获取能力（带权限检查）""" # 能力访问不需要额外权限，能力注册表会自动处理 return None def __getattr__(self, name: str): """代理其他属性到插件实例""" return getattr(self._plugin_instance, name) class CapabilityRegistry: """能力注册表""" def __init__(self, permission_check: bool = True): self.providers: dict[str, dict[str, Any]] = {} self.consumers: dict[str, list[str]] = {} self.permission_check = permission_check def register_provider(self, capability: str, plugin_name: str, instance: Any): """注册能力提供者""" self.providers[capability] = { "plugin": plugin_name, "instance": instance, } if capability not in self.consumers: self.consumers[capability] = [] def register_consumer(self, capability: str, plugin_name: str): """注册能力消费者""" if capability not in self.consumers: self.consumers[capability] = [] if plugin_name not in self.consumers[capability]: self.consumers[capability].append(plugin_name) def get_provider(self, capability: str, requester: str = "", allowed_plugins: list[str] = None) -> Optional[Any]: """获取能力提供者实例（带权限检查）""" if capability not in self.providers: return None if self.permission_check and allowed_plugins is not None: provider_name = self.providers[capability]["plugin"] if provider_name != requester and provider_name not in allowed_plugins and "*" not in allowed_plugins: raise PermissionError(f"插件 '{requester}' 无权使用能力 '{capability}'") return self.providers[capability]["instance"] def has_capability(self, capability: str) -> bool: """检查是否有某个能力""" return capability in self.providers def get_consumers(self, capability: str) -> list[str]: """获取能力消费者列表""" return self.consumers.get(capability, []) class PluginManager: """插件管理器""" def __init__(self, permission_check: bool = True): self.plugins: dict[str, dict[str, Any]] = {} self.lifecycle_plugin: Optional[Any] = None self._dependency_plugin: Optional[Any] = None # dependency 插件引用 self.capability_registry = CapabilityRegistry(permission_check=permission_check) self.permission_check = permission_check def set_lifecycle(self, lifecycle_plugin: Any): """设置生命周期插件""" self.lifecycle_plugin = lifecycle_plugin def _load_manifest(self, plugin_dir: Path) -> dict[str, Any]: """加载 manifest.json""" manifest_file = plugin_dir / "manifest.json" if not manifest_file.exists(): return {} with open(manifest_file, "r", encoding="utf-8") as f: return json.load(f) def _load_readme(self, plugin_dir: Path) -> str: """加载 README.md""" readme_file = plugin_dir / "README.md" if not readme_file.exists(): return "" with open(readme_file, "r", encoding="utf-8") as f: return f.read() def _load_config(self, plugin_dir: Path) -> dict[str, Any]: """加载 Python 配置文件（带安全措施）""" config_file = plugin_dir / "config.py" if not config_file.exists(): return {} safe_globals = { "__builtins__": { "True": True, "False": False, "None": None, "dict": dict, "list": list, "str": str, "int": int, "float": float, "bool": bool, } } local_vars = {} with open(config_file, "r", encoding="utf-8") as f: code = compile(f.read(), str(config_file), "exec") exec(code, safe_globals, local_vars) return { k: v for k, v in local_vars.items() if not k.startswith("_") and not callable(v) } def _load_extensions(self, plugin_dir: Path) -> dict[str, Any]: """加载扩展语法（Python 文件）""" ext_file = plugin_dir / "extensions.py" if not ext_file.exists(): return {} safe_globals = { "__builtins__": { "True": True, "False": False, "None": None, "dict": dict, "list": list, "str": str, "int": int, "float": float, "bool": bool, } } local_vars = {} with open(ext_file, "r", encoding="utf-8") as f: code = compile(f.read(), str(ext_file), "exec") exec(code, safe_globals, local_vars) return { k: v for k, v in local_vars.items() if not k.startswith("_") and not callable(v) } def load(self, plugin_dir: Path, use_sandbox: bool = True) -> Optional[Any]: """加载单个插件""" main_file = plugin_dir / "main.py" if not main_file.exists(): return None manifest = self._load_manifest(plugin_dir) readme = self._load_readme(plugin_dir) config = self._load_config(plugin_dir) extensions = self._load_extensions(plugin_dir) # 自动扫描能力 capabilities = scan_capabilities(plugin_dir) plugin_name = plugin_dir.name # 清理插件名（去掉 } 后缀） plugin_name = plugin_dir.name.rstrip("}") # 解析权限 permissions = manifest.get("permissions", []) # 沙箱加载 if use_sandbox: from oss.plugin.loader import PluginLoader as FrameworkLoader framework_loader = FrameworkLoader(enable_sandbox=True) result = framework_loader.load_sandbox_plugin(plugin_dir) if not result: return None module = result["module"] instance = result["instance"] else: spec = importlib.util.spec_from_file_location( f"plugin.{plugin_name}", str(main_file) ) module = importlib.util.module_from_spec(spec) sys.modules[spec.name] = module spec.loader.exec_module(module) if not hasattr(module, "New"): return None instance = module.New() # 创建代理包装器 if self.permission_check and permissions: instance = PluginProxy(plugin_name, instance, permissions, self.plugins) info = PluginInfo() meta = manifest.get("metadata", {}) info.name = meta.get("name", plugin_name) info.version = meta.get("version", "") info.author = meta.get("author", "") info.description = meta.get("description", "") info.readme = readme info.config = manifest.get("config", {}).get("args", config) info.extensions = extensions info.capabilities = capabilities info.dependencies = manifest.get("dependencies", []) # 注册能力 for cap in capabilities: self.capability_registry.register_provider(cap, plugin_name, instance) # 创建生命周期 if self.lifecycle_plugin and plugin_name != "lifecycle": lc = self.lifecycle_plugin.create(plugin_name) info.lifecycle = lc self.plugins[plugin_name] = { "instance": instance, "module": module, "info": info, "permissions": permissions, } return instance def load_all(self, store_dir: str = "store"): """加载 store 和 data/pkg 下所有插件（跳过自己）""" # 检查是否有任何插件存在 has_plugins = self._check_any_plugins(store_dir) if not has_plugins: print("[plugin-loader] 未检测到任何插件，自动引导安装...") self._bootstrap_installation() # 可选：加载 lifecycle lifecycle_plugin = None lifecycle_dir = Path(store_dir) / "@{FutureOSS}" / "lifecycle" if lifecycle_dir.exists() and (lifecycle_dir / "main.py").exists(): try: instance = self.load(lifecycle_dir) if instance: lifecycle_plugin = instance self.plugins.pop("lifecycle", None) except Exception: pass # 可选：加载 dependency dependency_plugin = None dependency_dir = Path(store_dir) / "@{FutureOSS}" / "dependency" if dependency_dir.exists() and (dependency_dir / "main.py").exists(): try: instance = self.load(dependency_dir) if instance: dependency_plugin = instance self._dependency_plugin = instance # 保存引用供拓扑排序使用 self.plugins.pop("dependency", None) except Exception: pass # 加载 lifecycle if lifecycle_plugin: self.set_lifecycle(lifecycle_plugin) # 加载其他插件 self._load_plugins_from_dir(Path(store_dir)) self._load_plugins_from_dir(Path("./data/pkg")) # 可选：按依赖排序 if dependency_plugin: self._sort_by_dependencies(dependency_plugin) def _load_plugins_from_dir(self, store_dir: Path): """从指定目录加载插件""" if not store_dir.exists(): return # 第一遍：加载所有插件 for author_dir in store_dir.iterdir(): if author_dir.is_dir(): for plugin_dir in author_dir.iterdir(): if plugin_dir.is_dir() and plugin_dir.name not in ("plugin-loader", "lifecycle", "dependency"): if (plugin_dir / "main.py").exists(): self.load(plugin_dir) # 第二遍：关联能力 self._link_capabilities() def _check_any_plugins(self, store_dir: str) -> bool: """检查是否存在任何插件""" store = Path(store_dir) if store.exists(): for author_dir in store.iterdir(): if author_dir.is_dir(): for plugin_dir in author_dir.iterdir(): if plugin_dir.is_dir() and (plugin_dir / "main.py").exists(): return True pkg_dir = Path("./data/pkg") if pkg_dir.exists(): for d in pkg_dir.iterdir(): if d.is_dir() and (d / "main.py").exists(): return True return False def _bootstrap_installation(self): """引导安装 FutureOSS 官方插件""" # 加载 pkg 插件 pkg_dir = Path("store/@{FutureOSS}/pkg") if pkg_dir.exists() and (pkg_dir / "main.py").exists(): try: pkg_instance = self.load(pkg_dir, use_sandbox=False) if pkg_instance: pkg_mgr = pkg_instance.manager print("[plugin-loader] 正在搜索可用插件...") results = pkg_mgr.search() if not results: print("[plugin-loader] 未找到远程插件") return print(f"[plugin-loader] 发现 {len(results)} 个插件，开始安装...") installed_count = 0 for pkg_info in results: print(f"[plugin-loader] 安装: {pkg_info.name}") if pkg_mgr.install(pkg_info.name): installed_count += 1 if installed_count > 0: print(f"[plugin-loader] 已安装 {installed_count} 个插件，重新扫描加载...") # pkg 保留，重新加载其他插件 except Exception as e: print(f"[plugin-loader] 引导安装失败: {e}") else: print("[plugin-loader] pkg 插件不存在，跳过引导安装") def _sort_by_dependencies(self, dep_plugin): """按依赖关系排序""" if not dep_plugin: return # 添加所有插件的依赖 for name, info in self.plugins.items(): deps = info["info"].dependencies dep_plugin.add_plugin(name, deps) try: order = dep_plugin.resolve() # 重新排序 plugins sorted_plugins = {} for name in order: if name in self.plugins: sorted_plugins[name] = self.plugins[name] # 检查是否所有插件都在排序结果中 missing = set(self.plugins.keys()) - set(sorted_plugins.keys()) for name in missing: sorted_plugins[name] = self.plugins[name] self.plugins = sorted_plugins except Exception as e: print(f"[plugin-loader] 依赖解析失败: {e}") def _link_capabilities(self): """关联能力：带权限检查""" for plugin_name, info in self.plugins.items(): caps = info["info"].capabilities allowed = info.get("permissions", []) for cap in caps: # 如果这个插件是某个能力的提供者 if self.capability_registry.has_capability(cap): # 找到所有需要这个能力的消费者 consumers = self.capability_registry.get_consumers(cap) for consumer_name in consumers: if consumer_name in self.plugins: consumer_info = self.plugins[consumer_name]["info"] consumer_allowed = self.plugins[consumer_name].get("permissions", []) # 权限检查 try: provider = self.capability_registry.get_provider( cap, requester=consumer_name, allowed_plugins=consumer_allowed ) if provider and hasattr(consumer_info, "extensions"): consumer_info.extensions[f"_{cap}_provider"] = provider except PermissionError as e: print(f"[plugin-loader] 权限拒绝: {e}") def start_all(self): """启动所有插件（假设已初始化）""" # 注入依赖实例 self._inject_dependencies() # 启动所有插件 for name, info in self.plugins.items(): try: info["instance"].start() except Exception as e: print(f"[plugin-loader] 启动失败 {name}: {e}") def init_and_start_all(self): """初始化并启动所有插件 正确顺序： 1. 注入依赖实例 2. 按拓扑顺序 init() 所有插件 3. 按拓扑顺序 start() 所有插件 """ print(f"[plugin-loader] init_and_start_all 被调用，plugins={len(self.plugins)}") # 1. 注入依赖实例 self._inject_dependencies() # 2. 获取拓扑排序 ordered_plugins = self._get_ordered_plugins() print(f"[plugin-loader] 插件启动顺序: {' -> '.join(ordered_plugins)}") # 3. 初始化所有插件（跳过 plugin-loader 自己） print("[plugin-loader] 开始初始化所有插件...") for name in ordered_plugins: if "plugin-loader" in name: continue info = self.plugins[name] try: print(f"[plugin-loader] 初始化: {name}") info["instance"].init() except Exception as e: print(f"[plugin-loader] 初始化失败 {name}: {e}") # 4. 启动所有插件（跳过 plugin-loader 自己） print("[plugin-loader] 开始启动所有插件...") for name in ordered_plugins: if "plugin-loader" in name: continue info = self.plugins[name] try: print(f"[plugin-loader] 启动: {name}") info["instance"].start() except Exception as e: print(f"[plugin-loader] 启动失败 {name}: {e}") def _get_ordered_plugins(self) -> list[str]: """获取按依赖排序的插件列表""" # 如果没有 dependency 插件，直接返回原始顺序 if not hasattr(self, '_dependency_plugin') or not self._dependency_plugin: return list(self.plugins.keys()) try: # 使用 dependency 插件解析 order = self._dependency_plugin.resolve() # 过滤出实际存在的插件 return [name for name in order if name in self.plugins] except Exception as e: print(f"[plugin-loader] 依赖解析失败，使用原始顺序: {e}") return list(self.plugins.keys()) def _inject_dependencies(self): """注入插件依赖实例""" print(f"[plugin-loader] 开始注入依赖，共 {len(self.plugins)} 个插件") # 构建名称映射（处理 } 后缀问题） name_map = {} for name in self.plugins: clean = name.rstrip("}") name_map[clean] = name name_map[clean + "}"] = name for name, info in self.plugins.items(): instance = info["instance"] info_obj = info.get("info") if not info_obj: continue deps = info_obj.dependencies if not deps: continue print(f"[plugin-loader] {name} 依赖: {deps}") for dep_name in deps: # 使用名称映射查找 actual_dep = name_map.get(dep_name) or name_map.get(dep_name + "}") if actual_dep and actual_dep in self.plugins: dep_instance = self.plugins[actual_dep]["instance"] setter_name = f"set_{dep_name.replace('-', '_')}" print(f"[plugin-loader] 尝试注入: {name} <- {actual_dep} ({setter_name})") if hasattr(instance, setter_name): try: getattr(instance, setter_name)(dep_instance) print(f"[plugin-loader] 注入成功: {name} <- {actual_dep}") except Exception as e: print(f"[plugin-loader] 注入依赖失败 {name}.{setter_name}: {e}") else: print(f"[plugin-loader] 警告: {name} 没有 {setter_name} 方法") def stop_all(self): """停止所有插件""" for name, info in reversed(list(self.plugins.items())): try: info["instance"].stop() except Exception: pass if self.lifecycle_plugin: self.lifecycle_plugin.stop_all() def get_info(self, name: str) -> Optional[PluginInfo]: """获取插件信息""" if name in self.plugins: return self.plugins[name]["info"] return None def has_capability(self, capability: str) -> bool: """检查系统是否有某个能力""" return self.capability_registry.has_capability(capability) def get_capability_provider(self, capability: str) -> Optional[Any]: """获取能力提供者""" return self.capability_registry.get_provider(capability) class PluginLoaderPlugin(Plugin): """插件加载器插件""" def __init__(self): self.manager = PluginManager() self._loaded = False self._started = False def init(self, deps: dict = None): """加载所有插件""" if self._loaded: return self._loaded = True print("[plugin-loader] 开始加载插件...") self.manager.load_all() def start(self): """启动所有插件""" if self._started: return self._started = True print("[plugin-loader] 启动插件...") self.manager.init_and_start_all() def stop(self): """停止所有插件""" print("[plugin-loader] 停止插件...") self.manager.stop_all() # 注册类型 register_plugin_type("PluginManager", PluginManager) register_plugin_type("PluginInfo", PluginInfo) register_plugin_type("CapabilityRegistry", CapabilityRegistry) def New(): return PluginLoaderPlugin()