openubmc-bingo 0.5.240__py3-none-any.whl

bmcgo/utils/fetch_component_code.py

@@ -0,0 +1,232 @@
+#!/usr/bin/env python3
+# encoding=utf-8
+# 描述：根据conan包拉取组件代码
+# Copyright (c) 2024 Huawei Technologies Co., Ltd.
+# openUBMC is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#         http://license.coscl.org.cn/MulanPSL2
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+import os
+import re
+import shutil
+import subprocess
+from multiprocessing import Pool
+import patch_ng
+import yaml
+from git import Repo
+
+from bmcgo.misc import errors
+from bmcgo import misc
+from bmcgo.utils.tools import Tools
+
+tools = Tools("fetch_component_code")
+log = tools.log
+
+
+def process_err_cb(err):
+    log.error("!!!!!!!!!!!!!!!!!!!!!!!!!!! 拉取代码失败, 错误: %s", err)
+
+
+class FetchComponentCode:
+    def __init__(self, packages, target_dir, conan_remote, include_open_source=True):
+        self.conan = shutil.which(misc.CONAN)
+        if self.conan is None:
+            raise RuntimeError("找不到 conan 工具")
+        self.packages = packages
+        self.target_dir = target_dir
+        self.remote = conan_remote
+        self.include_open_source = include_open_source
+
+    @staticmethod
+    def resolve_version_range(component_name, version_range):
+        cmd = f"conan info '{version_range}' --package-filter={component_name}/*" \
+             f" -r {misc.CONAN_REPO} --only None 2>/dev/null"
+        ret, output = subprocess.getstatusoutput(cmd)
+        output = output.strip()
+        if ret != 0 or not output:
+            return None
+        return output.split("\n")[-1]
+
+    @staticmethod
+    def patch(patch_file=None):
+        patchset = patch_ng.fromfile(patch_file)
+        if not patchset:
+            raise errors.BmcGoException("Failed to parse patch: %s" % (patch_file))
+        if not patchset.apply(strip=0, root="./", fuzz=False):
+            raise errors.BmcGoException("Failed to apply patch: %s" % patch_file)
+
+    @staticmethod
+    def _get_patch_changed_files(patch_file):
+        files = {}
+        for line in open(patch_file):
+            if not line.startswith("diff --git"):
+                continue
+            line = line.strip()
+            chunk = line.split()
+            a_file = chunk[-2][2:]
+            b_file = chunk[-1][2:]
+            files[a_file] = b_file
+        return files
+
+    @staticmethod
+    def _apply_patches_direct(real_patch, patch_file, changed_files):
+        FetchComponentCode.patch(patch_file=real_patch)
+        for a_file, b_file in changed_files.items():
+            if a_file != b_file:
+                if a_file != "/dev/null" and b_file != "/dev/null":
+                    os.rename(a_file, b_file)
+                    cmd = f"git rm -f {a_file}"
+                    tools.run_command(cmd)
+                elif a_file != "/dev/null":
+                    cmd = f"git rm -f {a_file}"
+                    tools.run_command(cmd)
+                    continue
+            cmd = f"git add {b_file}"
+            tools.run_command(cmd)
+        cmd = f"git commit -m \"{patch_file}\""
+        tools.run_command(cmd)
+
+    @staticmethod
+    def __apply_patches(conandata_file, patches, code_dir):
+        cwd = os.getcwd()
+        recipe_folder = os.path.join(os.path.dirname(conandata_file), "..", "export_source")
+        recipe_folder = os.path.realpath(recipe_folder)
+        os.chdir(os.path.join(cwd, code_dir))
+        for patch in patches:
+            patch_file = patch.get("patch_file")
+            if not patch_file:
+                log.warning(f"{code_dir} 组件的conandata.yml文件缺少patch_file，跳过git apply操作")
+            real_patch = os.path.join(recipe_folder, patch_file)
+            if not os.path.isfile(real_patch):
+                log.error(f"{code_dir} 组件申明的补丁文件{real_patch}不存在，可能产生错误，请人工处理")
+                continue
+            changed_files = FetchComponentCode._get_patch_changed_files(real_patch)
+            log.info(f"{code_dir} 开始应用源码补丁{patch_file}")
+            try:
+                FetchComponentCode._apply_patches_direct(real_patch, patch_file, changed_files)
+            except errors.BmcGoException:
+                # 尝试还原文件修改
+                for a_file, b_file in changed_files.items():
+                    cmd = f"git checkout -- {a_file}"
+                    tools.run_command(cmd, ignore_error=True)
+                    cmd = f"git checkout -- {b_file}"
+                    tools.run_command(cmd, ignore_error=True)
+                cmd = "git am " + real_patch
+                tools.run_command(cmd)
+            log.info(f"{code_dir} 应用源码补丁{patch_file}")
+        os.chdir(cwd)
+
+    @staticmethod
+    def __update_code_by_commit_id(code_dir, url, commit_id):
+        if os.path.exists(code_dir):
+            repo = Repo(code_dir)
+            repo.git.fetch('origin')
+        else:
+            Repo.clone_from(url, to_path=code_dir)
+            repo = Repo(code_dir)
+
+        repo.index.reset(commit=commit_id, head=True, working_tree=True)
+        repo.git.clean('-dfx')
+        log.info("更新代码(组件: %s, 地址: %s, 提交节点: %s)", code_dir, url, commit_id)
+
+    @staticmethod
+    def __update_code_by_branch(code_dir, deps):
+        url = deps['url']
+        branch = deps['branch'].split('/')[-1]
+
+        if os.path.exists(code_dir):
+            repo = Repo(code_dir)
+            repo.git.fetch('origin', branch)
+            repo.git.pull('origin', branch)
+            repo.git.checkout(branch)
+        else:
+            Repo.clone_from(url, to_path=code_dir, branch=branch)
+            repo = Repo(code_dir)
+        log.info("更新代码(组件: %s, 地址: %s, 分支: %s)", code_dir, url, branch)
+
+    @staticmethod
+    def __update_component_code_by_conandata(name, version, conandata_file):
+        with open(conandata_file, 'r') as f_:
+            conandata = yaml.safe_load(f_)
+            deps = conandata.get("sources", {}).get(version, {})
+            if 'url' in deps:
+                FetchComponentCode.__update_code_by_branch(name, deps)
+                patches = conandata.get("patches", {}).get(version)
+                if patches:
+                    FetchComponentCode.__apply_patches(conandata_file, patches, name)
+            else:
+                for comp, deps in deps.items():
+                    FetchComponentCode.__update_code_by_branch(comp, deps)
+
+    @staticmethod
+    def __getinfo_from_conanfile(conanfile):
+        with open(conanfile, "r") as file:
+            lines = file.readlines()
+            for idx, line in enumerate(lines):
+                if line.find('scm = {"revision":') > 0:
+                    revision = re.split(r'["]', line)[-2]
+                    url = re.split(r'["]', lines[idx + 2])[-2]
+                    break
+            else:
+                raise RuntimeError("无法找到版本(revision)和地址(url)字段")
+
+            return revision, url
+
+    def run(self):
+        packages_to_fetch = dict()
+        for component_name, package in self.packages.items():
+            version_str = re.split("/|@", package)[1]
+            if "[" not in version_str:
+                if self.include_open_source or re.fullmatch("\d+\.\d+\.\d+", version_str) is not None:
+                    packages_to_fetch[component_name] = package
+                continue
+            resolved_package = self.resolve_version_range(component_name, package)
+            if resolved_package is None:
+                log.warning("查找不到与 %s 范围匹配的版本", package)
+            else:
+                packages_to_fetch[component_name] = resolved_package
+                log.info("查找到与 %s 范围匹配的版本 %s", package, resolved_package)
+
+        process_count = min(len(packages_to_fetch), os.cpu_count())
+        log.info("创建 %u 个进程拉取代码", process_count)
+        pool = Pool(processes=process_count)
+        for component_name, conan_version in packages_to_fetch.items():
+            pool.apply_async(func=self.update_component_code, args=(component_name, conan_version),
+                             error_callback=process_err_cb)
+        pool.close()
+        pool.join()
+
+    def update_component_code(self, component_name, conan_version):
+        """
+        update component code by conan version
+        """
+        try:
+            os.chdir(self.target_dir)
+            log.info("更新 %s 组件代码到 %s 开始", component_name, conan_version)
+
+            version_split = re.split(r'[/, @]', conan_version)
+            conan_dir = os.path.join(os.path.expanduser('~'), '.conan/data/', *version_split, 'export')
+            conandata = os.path.join(conan_dir, 'conandata.yml')
+            if not os.path.exists(conan_dir):
+                conan_remote_list = tools.get_conan_remote_list(self.remote)
+                tools.download_conan_recipes(conan_version, conan_remote_list)
+            if os.path.exists(conandata):
+                FetchComponentCode.__update_component_code_by_conandata(version_split[0], version_split[1], conandata)
+                return
+
+            conanfile = os.path.join(conan_dir, 'conanfile.py')
+            if os.path.exists(conanfile):
+                revision, url = FetchComponentCode.__getinfo_from_conanfile(conanfile)
+                FetchComponentCode.__update_code_by_commit_id(component_name, url, revision)
+                return
+
+            log.error("conandata(%s) 和 conanfile(%s) 都没有找到", conandata, conanfile)
+            log.info("更新组件 %s 代码到 %s 失败, 无法获取到 conan 信息", component_name,
+                     conan_version)
+        except Exception as exp:
+            log.error("工作状态错误: %s", exp)
+            log.error("更新组件代码到 %s 失败", conan_version)

bmcgo/utils/install_manager.py

@@ -0,0 +1,61 @@
+#!/usr/bin/env python3
+# encoding=utf-8
+# 描述：安装管理器
+# Copyright (c) 2025 Huawei Technologies Co., Ltd.
+# openUBMC is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#         http://license.coscl.org.cn/MulanPSL2
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+
+from pathlib import Path
+from bmcgo.utils.tools import Logger
+from bmcgo.utils.installations import install_consts
+from bmcgo.utils.installations.install_workflow import InstallWorkflow
+from bmcgo.utils.installations.base_installer import BaseInstaller
+
+logger = Logger(name="upgrade", log_file="/usr/share/bmcgo/install.log")
+InstallWorkflow.logger = logger
+BaseInstaller.logger = logger
+
+
+class InstallManager:
+    def __init__(self):
+        self._custom_path = None
+
+    @property
+    def custom_installer_path(self):
+        return self._custom_path / install_consts.PLUGIN_INSTALLER_PATH
+    
+    @property
+    def custom_install_plan_path(self):
+        return self._custom_path / install_consts.PLUGIN_INSTALL_PLAN_PATH
+
+    def install(self, app_name, operator, version, custom_path):
+        self._set_custom_path(custom_path)
+        BaseInstaller.discover_installers()
+        InstallWorkflow.discover_workflows()
+
+        workflows = []
+        if app_name == install_consts.INSTALL_ALL:
+            workflows = list(InstallWorkflow.get_all_plans())
+        else:
+            workflows = [app_name]
+
+        for wname in workflows:
+            logger.info(f"安装{wname}...")
+            plans = InstallWorkflow.parse(wname)
+            for plan in plans.get(install_consts.PLAN_STEPS, []):
+                inst_type = plan.get(install_consts.PLAN_INSTALL_TYPE)
+                BaseInstaller.get_installer(inst_type).install(plan, operator, version)
+
+    def _set_custom_path(self, custom_path: str):
+        self._custom_path = Path(custom_path).resolve()
+        if not self._custom_path.exists() or not self._custom_path.is_dir():
+            logger.warning(f"无效的地址: {self._custom_path}")
+            return
+        BaseInstaller.add_installer_dir(self.custom_installer_path)
+        InstallWorkflow.add_plan_dir(self.custom_install_plan_path)

bmcgo/utils/installations/__init__.py

@@ -0,0 +1,10 @@
+# coding: utf-8
+# Copyright (c) 2024 Huawei Technologies Co., Ltd.
+# openUBMC is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#         http://license.coscl.org.cn/MulanPSL2
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.

bmcgo/utils/installations/base_installer.py

@@ -0,0 +1,70 @@
+#!/usr/bin/env python3
+# encoding=utf-8
+# 描述：安装工具工厂类
+# Copyright (c) 2025 Huawei Technologies Co., Ltd.
+# openUBMC is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#         http://license.coscl.org.cn/MulanPSL2
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+import abc
+import sys
+import importlib.util
+from pathlib import Path
+from typing import Dict, List, Type
+from bmcgo.utils.installations import install_consts
+
+
+class BaseInstaller(abc.ABC):
+    logger = None
+    _intallers: Dict[str, Type["BaseInstaller"]] = {}
+    search_paths: List[Path] = [Path(__file__).resolve().parent / install_consts.PLUGIN_INSTALLER_PATH]
+
+    def __init_subclass__(cls, installer_type: str, **kwargs):
+        super.__init_subclass__(**kwargs)
+
+        key = installer_type or cls.__name__.lower()
+        if key in cls._intallers:
+            cls.logger and cls.logger.warning(f"{installer_type}({cls._intallers[key]} 被替换为: {cls})")
+        cls._intallers[installer_type] = cls
+
+    @classmethod
+    def add_installer_dir(cls, directory: Path):
+        if directory not in cls.search_paths:
+            cls.search_paths.append(directory)
+
+    @classmethod
+    def discover_installers(cls):
+        for path in cls.search_paths:
+            if not path.exists():
+                cls.logger and cls.logger.warning(f"未知安装工具路径：: {str(path)}，跳过")
+                continue
+
+            for inst in path.glob("*.py"):
+                if inst.name == "__init__.py":
+                    continue
+
+                module_name = inst.stem
+                spec = importlib.util.spec_from_file_location(f"installer_{module_name}", inst)
+                if spec and spec.loader:
+                    module = importlib.util.module_from_spec(spec)
+                    try:
+                        sys.modules[module.__name__] = module
+                        spec.loader.exec_module(module)
+                    except Exception as e:
+                        cls.logger and cls.logger.exception(f"加载安装器 {inst} 失败: {str(e)}")
+                        continue
+
+    @classmethod
+    def get_installer(cls, installer_type: str) -> "BaseInstaller":
+        installer_cls = cls._intallers.get(installer_type)
+        if not installer_cls:
+            raise ValueError(f"未定义的安装方法：{installer_type}")
+        return installer_cls()
+
+    @abc.abstractmethod
+    def install(self, plan: Dict[str, List[str]], operator: str, version: str):
+        """ 安装入口 """

bmcgo/utils/installations/install_consts.py

@@ -0,0 +1,30 @@
+#!/usr/bin/env python3
+# encoding=utf-8
+# 描述：安装工具集常量
+# Copyright (c) 2025 Huawei Technologies Co., Ltd.
+# openUBMC is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#         http://license.coscl.org.cn/MulanPSL2
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+
+INSTALLATION_PATH = "instllations"
+
+PLUGIN_INSTALLER_PATH = "installers"
+PLUGIN_INSTALL_PLAN_PATH = "install_plans"
+
+INSTALL_ALL = "all"
+INSTALL_LATEST = "latest"
+INSTALL_DEFAULT = f"{INSTALL_ALL}={INSTALL_LATEST}"
+
+PLAN_STEPS = "install_steps"
+PLAN_INSTALL_TYPE = "type"
+PLAN_PACKAGE_NAME = "package_name"
+PLAN_MODULE_NAME = "module_name"
+PLAN_REPO_URL = "url"
+PLAN_GPG = "gpg"
+PLAN_CONFIG_FILE = "config_file"
+PLAN_PUBLIC_KEY = "public_key"

bmcgo/utils/installations/install_plans/bingo.yml

@@ -0,0 +1,11 @@
+install_steps:
+  - type: pip
+    package_name: openubmc-bingo
+    module_name: bingo
+  - type: apt
+    package_name: openubmc-bingo
+    config_file: bingo.list
+    url: https://openubmc-apt-repo.obs.cn-north-4.myhuaweicloud.com/bingo_test_2
+    gpg: bingo.gpg
+    public_key: gpg_key.public
+

bmcgo/utils/installations/install_workflow.py

@@ -0,0 +1,50 @@
+#!/usr/bin/env python3
+# encoding=utf-8
+# 描述：安装流程配置
+# Copyright (c) 2025 Huawei Technologies Co., Ltd.
+# openUBMC is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#         http://license.coscl.org.cn/MulanPSL2
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+
+from typing import Dict, List
+from pathlib import Path
+import yaml
+from bmcgo.utils.installations import install_consts
+
+
+class InstallWorkflow:
+    logger = None
+    _workflows: Dict[str, List[str]] = {}
+    search_paths: List[Path] = [Path(__file__).resolve().parent / install_consts.PLUGIN_INSTALL_PLAN_PATH]
+
+    @classmethod
+    def discover_workflows(cls):
+        for path in cls.search_paths:
+            if not path.exists():
+                cls.logger and cls.logger.warning(f"未找到安装配置路径：w{str(path)}")
+                continue
+
+            for yml_file in path.glob("*.yml"):
+                with open(yml_file) as conf:
+                    cls._workflows[yml_file.stem] = yaml.safe_load(conf)
+
+    @classmethod
+    def parse(cls, name: str) -> List[str]:
+        workflow = cls._workflows.get(name)
+        if not workflow:
+            raise ValueError(f"未找到安装配置：{str(workflow)}")
+        return workflow
+
+    @classmethod
+    def add_plan_dir(cls, directory: Path):
+        if directory not in cls.search_paths:
+            cls.search_paths.append(directory)
+
+    @classmethod
+    def get_all_plans(cls):
+        return cls._workflows.keys()

bmcgo/utils/installations/installers/apt_installer.py

@@ -0,0 +1,177 @@
+#!/usr/bin/env python3
+# encoding=utf-8
+# 描述：apt安装工具
+# Copyright (c) 2025 Huawei Technologies Co., Ltd.
+# openUBMC is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#         http://license.coscl.org.cn/MulanPSL2
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+import os
+import base64
+import tempfile
+import requests
+from typing import Dict, List
+from pathlib import Path
+from bmcgo.utils.tools import Tools
+from bmcgo.utils.installations import install_consts
+from bmcgo.utils.installations.version_util import PkgVersion
+from bmcgo.utils.installations.base_installer import BaseInstaller
+
+
+tool = Tools("apt_install")
+
+
+class AptInstaller(BaseInstaller, installer_type="apt"):
+    def __init__(self):
+        self._repo_url = None
+        self._gpg_file = None
+        self._config_file = None
+        self._repo_public_key = None
+        self._pkg_name = None
+        self._pkg_version = None
+
+    def install(self, plan: Dict[str, List[str]], operator: str, version: str):
+        self._parse_plan(plan)
+        self._install_key()
+
+        if not self._check_repo():
+            self.logger and self.logger.info("未检测到仓库配置，开始配置")
+            self._config_repo()
+
+        self._update_cache()
+
+        target = [self._pkg_name]
+        if operator and version:
+            ver = self._resolve_constraint(operator, version)
+            if ver:
+                target.append(ver)
+        pkg = "=".join(target)
+        self._install_package(pkg)
+        self.logger and self.logger.info(f"安装{pkg}完成！")
+
+    def _get_versions(self) -> List[PkgVersion]:
+        result = tool.run_command(["apt-cache", "madison", self._pkg_name], capture_output=True)
+        if not result.stdout:
+            return []
+        return [PkgVersion(line.split("|")[1].strip()) for line in result.stdout.splitlines()]
+    
+    def _resolve_constraint(self, opt: str, ver: str) -> str:
+        versions = self._get_versions()
+        if not versions:
+            self.logger and self.logger.warning("当前没有可下载版本!")
+            return None
+
+        if ver == install_consts.INSTALL_LATEST or not opt:
+            return versions[0].origin
+
+        pkg_ver = PkgVersion(ver)
+        for v in versions:
+            if opt == ">=" and v >= pkg_ver:
+                return v.origin
+            elif opt == "<=" and v <= pkg_ver:
+                return v.origin
+            elif opt == "!=" and v != pkg_ver:
+                return v.origin
+            elif opt == "<" and v < pkg_ver:
+                return v.origin
+            elif opt == ">" and v > pkg_ver:
+                return v.origin
+            elif opt == "=" and v == pkg_ver:
+                return v.origin
+            
+        raise ValueError(f"没有找到匹配的版本：{opt}{ver}")
+
+    def _parse_plan(self, plan: Dict[str, List[str]]):
+        repo_url = plan.get(install_consts.PLAN_REPO_URL)
+        repo_public_key = plan.get(install_consts.PLAN_PUBLIC_KEY)
+        gpg_file = plan.get(install_consts.PLAN_GPG)
+        config_file = plan.get(install_consts.PLAN_CONFIG_FILE)
+        pkg_name = plan.get(install_consts.PLAN_PACKAGE_NAME)
+
+        if not all(val for key, val in locals().items() if key not in ["self", "plan"]):
+            values = [
+                f"{install_consts.PLAN_REPO_URL}: {repo_url}",
+                f"{install_consts.PLAN_PUBLIC_KEY}: {repo_public_key}",
+                f"{install_consts.PLAN_GPG}: {gpg_file}",
+                f"{install_consts.PLAN_CONFIG_FILE}: {config_file}",
+                f"{install_consts.PLAN_PACKAGE_NAME}: {pkg_name}"
+            ]
+            raise ValueError(f"请检查安装配置文件：\n{"\n\t".join(values)}\n")
+
+        self._repo_url = repo_url
+        self._repo_public_key = f"{self._repo_url}{repo_public_key}"
+        self._gpg_file = Path("/usr/share/keyrings") / gpg_file
+        self._config_file = Path("/etc/apt/sources.list.d/") / config_file
+        self._pkg_name = pkg_name
+
+    def _install_key(self):
+        self.logger and self.logger.info("下载公钥")
+        try:
+            key_data = requests.get(self._repo_public_key).content
+        except Exception as e:
+            raise RuntimeError("下载公钥失败")
+        
+        lines = key_data.splitlines()
+        in_block = False
+        b64data = []
+
+        for line in lines:
+            if line.startswith(b"-----BEGIN PGP"):
+                in_block = True
+                continue
+            if line.startswith(b"-----END PGP"):
+                in_block = False
+                continue
+            if in_block and line.strip() and not line.startswith(b"="):
+                b64data.append(line.strip())
+
+        if not b64data:
+            raise ValueError("公钥出错")
+
+        dearmor = base64.b64decode(b"".join(b64data))
+
+        with open(self._gpg_file, "wb") as f:
+            f.write(dearmor)
+        os.chmod(self._gpg_file, 0o644)
+
+    def _check_repo(self):
+        if not self._config_file.exists():
+            return False
+        
+        expect_line = f"deb [signed-by={self._gpg_file}] {self._repo_url} stable main\n"
+        with open(self._config_file) as f:
+            return any(line.strip() == expect_line.strip() for line in f)
+
+    def _config_repo(self):
+        repo_line = f"deb [signed-by={self._gpg_file}] {self._repo_url} stable main\n"
+
+        self.logger and self.logger.info("配置仓资源")
+        with tempfile.NamedTemporaryFile("w", delete=False) as tmp:
+            tmp.write(repo_line)
+            tmp_path = tmp.name
+
+        try:
+            tool.run_command(["mv", tmp_path, str(self._config_file)], sudo=True)
+            tool.run_command(["chmod", "644", str(self._config_file)], sudo=True)
+        except Exception as e:
+            os.remove(tmp_path)
+            raise RuntimeError(f"写入仓库配置失败: {str(e)}")
+
+    def _update_cache(self):
+        self.logger and self.logger.info("更新 apt 缓存")
+        try:
+            tool.run_command(["apt-get", "update"], sudo=True)
+        except Exception as e:
+            raise RuntimeError(f"安装失败： {str(e)}")
+        
+    def _install_package(self, pkg: str):
+        self.logger and self.logger.info(f"安装: {pkg}")
+        try:
+            tool.run_command(["apt-get", "install", "-y", "--allow-downgrades", pkg], sudo=True)
+        except Exception as e:
+            raise RuntimeError(f"安装失败: {str(e)}")
+