openubmc-bingo 0.5.242__py3-none-any.whl → 0.5.253__py3-none-any.whl

bmcgo/functional/diff.py

@@ -48,7 +48,7 @@ class BmcgoCommand:
         self.bconfig = bconfig
         if len(args) != 1 or len(args[0]) != 2:
             log.info("\n".join(command_info.help_info))
-            raise errors.bingoException("参数格式错误, 请查看上述提示")
+            raise errors.BmcGoException("参数格式错误, 请查看上述提示")
         self.version_before = args[0][0]
         self.version_after = args[0][1]
 
@@ -227,9 +227,9 @@ class BmcgoCommand:
 
     def run(self):
         if "@" in self.version_before and "@" in self.version_after:
-            raise errors.bingoException(f"不支持两个组件版本对比")
+            raise errors.BmcGoException(f"不支持两个组件版本对比")
         elif "@" not in self.version_before and "@" not in self.version_after:
             self.parse_commit_merge()
         else:
-            raise errors.bingoException("输入的版本号无法解析")
+            raise errors.BmcGoException("输入的版本号无法解析")
         return 0

bmcgo/functional/upgrade.py

@@ -60,16 +60,46 @@ class BmcgoCommand:
             default=install_consts.INSTALL_DEFAULT,
             help="列出所有配置"
         )
+        parser.add_argument(
+            "-f",
+            "--force",
+            action=misc.STORE_TRUE,
+            help="跳过确认，直接安装"
+        )
+        parser.add_argument(
+            "-l",
+            "--list",
+            action=misc.STORE_TRUE,
+            help="列出可安装版本"
+        )
 
         args, _ = parser.parse_known_args()
+
         self.version = args.version
+        self.force = args.force
+        self.list = args.list
+
         self.installer = InstallManager()
         self.plugin_path = Path(bconfig.bmcgo_config_list.get(misc.CUSTOM_PLUGINS, misc.DEFAULT_PLUGINS_PATH))
 
     def run(self):
-        self.installer.install(*self._parse_version(), self.plugin_path)
+        app, opt, ver = self._parse_version()
+        self.installer.init(app, opt, ver, self.plugin_path)
+
+        if self.list:
+            self._list_all_versions()
+            return 0
+
+        self.installer.pre_install()
+        self.installer.install(self.force)
+        self.installer.post_install()
+
+        log.info(f"安装{self.version}已完成！")
         return 0
 
+    def _list_all_versions(self):
+        self.installer.show_versions()
+
     def _parse_version(self):
         match = re.search(self.VERSION_PATTERN, self.version)
         if match:

bmcgo/misc.py

@@ -17,7 +17,7 @@ from bmcgo.logger import Logger
 
 log = Logger("work_prepare")
 
-CACHE_DIR = "/tmp/bmcgo"
+CACHE_DIR = f"{os.path.expanduser('~')}/.bmcgo_log"
 CONAN_REPO = "openubmc_dev"
 CONAN_USER = 'openUBMC'
 
@@ -48,7 +48,7 @@ NO_PROXY_CONST = "no_proxy"
 TIMESTAMP_SIGN_SERVER = "timestamp_sign_server"
 JARSIGNER_HTTP_PROXY = "jarsigner_http_proxy"
 CUSTOM_PLUGINS = "plugins_path"
-DEFAULT_PLUGINS_PATH = "/usr/share/bmcgo/plugins/"
+DEFAULT_PLUGINS_PATH = os.path.join(os.environ["HOME"], ".bmcgo", "plugins")
 
 DEPLOY_HOST_CONST = "deploy-host"
 PORT_CONST = "port"
@@ -73,6 +73,35 @@ HELP = "help"
 ROOTCA_DER = "rootca.der"
 CMS_CRL = "cms.crl"
 
+# hpm签名CA根证书配置
+HPM_SIGN_ROOTCA_DER = "rootca_der"
+
+# hpm服务器签名配置
+HPM_SERVER_SIGN = "hpm_server_sign"
+HPM_SERVER_SIGN_CERT_ID = "cert_id"
+HPM_SERVER_SIGN_URL = "url"
+HPM_SERVER_SIGN_SSL_VERYFY = "ssl_verify"
+
+# hpm自签名配置
+HPM_SELF_SIGN = "hpm_self_sign"
+HPM_SELF_SIGN_ROOTCA_CRL = "rootca_crl"
+HPM_SELF_SIGN_SIGNER_PEM = "signer_pem"
+HPM_SELF_SIGN_TS_PEM = "ts_signer_pem"
+HPM_SELF_SIGN_TS_CNF = "ts_signer_cnf"
+
+# eeprom服务器签名配置
+E2P_SERVER_SIGN = "eeprom_server_sign"
+E2P_SERVER_SIGN_URL = "url"
+
+# eeprom自签名配置
+E2P_SELF_SIGN = "eeprom_self_sign"
+E2P_SELF_SIGN_PEM = "priv_pem"
+
+# hpm加密配置
+HPM_ENCRYPT = "hpm_encrypt"
+HPM_ENCRYPT_ENABLE = "enable"
+HPM_ENCRYPT_TOOL = "crypto_tool"
+
 
 class StageEnum(Enum):
     STAGE_DEV = "dev"

bmcgo/target/install_sdk.yml

@@ -11,5 +11,11 @@ subworks:
       - work.prepare_env
   - name: task_download_dependency
     klass: bmcgo.tasks.task_download_dependency
+    wait:
+      - work.prepare_env
+  - name: work.task_prepare_tools
+    klass: works.packet.work_prepare_tools.TaskClass
+    # 当类不存在时，不执行
+    ignore_not_exist: true
     wait:
       - work.prepare_env

bmcgo/target/personal.yml

@@ -21,6 +21,10 @@ subworks:
     klass: bmcgo.tasks.task_build_conan
     wait:
       - work.build.download
+  - name: work.build_wbd_up
+    klass: bmcgo.tasks.task_build_wbd_up
+    wait:
+      - work.build.conan
   - name: work.task_build_rootfs_img
     klass: bmcgo.tasks.task_build_rootfs_img
     subworks:
@@ -46,6 +50,7 @@ subworks:
         ignore_not_exist: true
     wait:
       - work.build.conan
+      - work.build_wbd_up
       - task_download_dependency
   - name: work.create_interface_config
     klass: bmcgo.tasks.task_create_interface_config

bmcgo/target/publish.yml

@@ -15,6 +15,10 @@
   klass: bmcgo.tasks.task_build_conan
   wait:
     - work.build.download
+- name: work.build_wbd_up
+  klass: bmcgo.tasks.task_build_wbd_up
+  wait:
+    - work.build.app
 - name: work.task_build_rootfs_img
   klass: bmcgo.tasks.task_build_rootfs_img
   subworks:
@@ -42,4 +46,5 @@
         - work.task_build_qemu_rootfs
       ignore_not_exist: true
   wait:
+    - work.build_wbd_up
     - work.build.app

bmcgo/tasks/task.py

@@ -257,50 +257,12 @@ class Task(Process):
         return self.tools.pipe_command(commands, out_file, **kwargs)
 
     def signature(self, unsigned_file, cms_output, crl_output, ca_output):
-        sign_server = self.get_manufacture_config("base/signature/simple_signer_server")
-        if not sign_server:
-            """自签名方法"""
-            unsigned_file = os.path.realpath(unsigned_file)
-            cms_output = os.path.realpath(cms_output)
-            tmp_dir = tempfile.TemporaryDirectory()
-            cwd = os.getcwd()
-            self.chdir(tmp_dir.name)
-            rootca_der = self.config.rootca_der
-            rootca_crl = self.config.rootca_crl
-            signer_pem = self.config.signer_pem
-            ts_signer_pem = self.config.ts_signer_pem
-            ts_signer_cnf = self.config.ts_signer_cnf
-            self.run_command(f"openssl x509 -in {rootca_der} -inform der -outform pem -out rootca.pem")
-            self.run_command(f"openssl crl -in {rootca_crl} -inform der -outform pem -out cms.crl.pem")
-            cmd = f"hpm_signer -s {signer_pem} -t {ts_signer_pem} -T {ts_signer_cnf} -i {unsigned_file} -o {cms_output}"
-            self.run_command(cmd)
-            self.run_command(f"hpm_verify -r rootca.pem -C cms.crl.pem -c {unsigned_file} -s {cms_output}")
-            self.chdir(cwd)
-            self.tools.copy(rootca_crl, crl_output)
-            self.tools.copy(rootca_der, ca_output)
+        manifest_sign_server = self.get_manufacture_config("base/signature/simple_signer_server") 
+        hpm_server_sign = self.config.bconfig.hpm_server_sign
+        if manifest_sign_server or hpm_server_sign:
+            self._server_signature(unsigned_file, cms_output, crl_output, ca_output)
         else:
-            cert_id = sign_server.get("cert_id")
-            url = sign_server.get("url")
-            ssl_verify = sign_server.get("ssl_verify")
-            rootca_der = sign_server.get("rootca_der")
-            if not os.path.isfile(rootca_der):
-                raise FileNotFoundError(f"签名根证书{rootca_der}不存在")
-            unsigned_file = os.path.realpath(unsigned_file)
-            cms_output = os.path.realpath(cms_output)
-            crl_output = os.path.realpath(crl_output)
-            ca_output = os.path.realpath(ca_output)
-            cwd = os.getcwd()
-            tmpdir = tempfile.TemporaryDirectory()
-            self.chdir(tmpdir.name)
-            args = ["-i", unsigned_file, "-s", cert_id, "-u", url, "-v", ssl_verify]
-            cmd = SimpleSign(self.config.bconfig, args)
-            cmd.run()
-            # 签名工具会输出rootca.crl和signed.cms
-            self.tools.copy("signed.cms", cms_output)
-            self.tools.copy("rootca.crl", crl_output)
-            # 签名根证书在manifest.yml中配置
-            self.tools.copy(rootca_der, ca_output)
-            os.chdir(cwd)
+            self._local_signature(unsigned_file, cms_output, crl_output, ca_output)
 
     def error(self, msg, *args, **kwargs):
         uptrace = kwargs.get("uptrace", None)
@@ -381,3 +343,67 @@ class Task(Process):
             self.info(f"执行脚本 {comp}/include/customization.py 开始")
             post = ComponentPost(self.config, os.path.join(conan_install, comp), profile)
             post.post_work(os.getcwd(), action)
+
+    def _local_signature(self, unsigned_file, cms_output, crl_output, ca_output):
+        """自签名方法"""
+        self_sign_config = self.config.bconfig.hpm_self_sign
+        unsigned_file = os.path.realpath(unsigned_file)
+        cms_output = os.path.realpath(cms_output)
+        tmp_dir = tempfile.TemporaryDirectory()
+        cwd = os.getcwd()
+        self.chdir(tmp_dir.name)
+        certificates = self.get_manufacture_config("base/signature/certificates")
+        if certificates:
+            rootca_der = self.config.rootca_der
+            rootca_crl = self.config.rootca_crl
+            signer_pem = self.config.signer_pem
+            ts_signer_pem = self.config.ts_signer_pem
+            ts_signer_cnf = self.config.ts_signer_cnf
+        else:
+            rootca_der = self_sign_config.rootca_der
+            rootca_crl = self_sign_config.rootca_crl
+            signer_pem = self_sign_config.signer_pem
+            ts_signer_pem = self_sign_config.ts_signer_pem
+            ts_signer_cnf = self_sign_config.ts_signer_cnf
+        self.run_command(f"openssl x509 -in {rootca_der} -inform der -outform pem -out rootca.pem")
+        self.run_command(f"openssl crl -in {rootca_crl} -inform der -outform pem -out cms.crl.pem")
+        cmd = f"hpm_signer -s {signer_pem} -t {ts_signer_pem} -T {ts_signer_cnf} -i {unsigned_file} -o {cms_output}"
+        self.run_command(cmd)
+        self.run_command(f"hpm_verify -r rootca.pem -C cms.crl.pem -c {unsigned_file} -s {cms_output}")
+        self.log.info(f"使用 hpm_signer 自签名 {unsigned_file} 成功")
+        self.chdir(cwd)
+        self.tools.copy(rootca_crl, crl_output)
+        self.tools.copy(rootca_der, ca_output)
+    
+    def _server_signature(self, unsigned_file, cms_output, crl_output, ca_output):
+        manifest_sign_server = self.get_manufacture_config("base/signature/simple_signer_server")
+        hpm_server_sign = self.config.bconfig.hpm_server_sign
+        if manifest_sign_server:
+            rootca_der = manifest_sign_server.get("rootca_der")
+            url = manifest_sign_server.get("url")
+            cert_id = manifest_sign_server.get("cert_id")
+            ssl_verify = manifest_sign_server.get("ssl_verify")
+        else:
+            rootca_der = hpm_server_sign.rootca_der
+            url = hpm_server_sign.url
+            cert_id = hpm_server_sign.cert_id
+            ssl_verify = hpm_server_sign.ssl_verify
+
+        if not os.path.isfile(rootca_der):
+            raise FileNotFoundError(f"签名根证书{rootca_der}不存在")
+        unsigned_file = os.path.realpath(unsigned_file)
+        cms_output = os.path.realpath(cms_output)
+        crl_output = os.path.realpath(crl_output)
+        ca_output = os.path.realpath(ca_output)
+        cwd = os.getcwd()
+        tmpdir = tempfile.TemporaryDirectory()
+        self.chdir(tmpdir.name)
+        args = ["-i", unsigned_file, "-s", cert_id, "-u", url, "-v", ssl_verify]
+        cmd = SimpleSign(self.config.bconfig, args)
+        cmd.run()
+        # 签名工具会输出rootca.crl和signed.cms
+        self.tools.copy("signed.cms", cms_output)
+        self.tools.copy("rootca.crl", crl_output)
+        # 签名根证书在manifest.yml中配置
+        self.tools.copy(rootca_der, ca_output)
+        os.chdir(cwd)

bmcgo/tasks/task_build_conan.py

@@ -540,15 +540,19 @@ class TaskClass(Task):
         self.run_command(f"rm -rf {self.top_rootfs_dir}")
         self.run_command(f"cp -rf {top_rootfs} {self.top_rootfs_dir}")
 
+        version_path = self.top_rootfs_dir
         # 复制单板目录下的权限配置和rootfs文件
         rootfs_dir = os.path.join(self.config.board_path, "rootfs")
         if os.path.isdir(rootfs_dir):
             self.run_command(f"rm -rf {self.openubmc_ins_dir}")
             self.run_command(f"cp -rf {rootfs_dir} {self.openubmc_ins_dir}")
-            self.config.version_conf(f"{self.openubmc_ins_dir}/etc/version.json")
-            self.config.show_version_conf(f"{self.openubmc_ins_dir}/etc/version.json")
         else:
             os.makedirs(self.openubmc_ins_dir)
+
+        if os.path.isfile(f"{self.openubmc_ins_dir}/etc/version.json"):
+            version_path = self.openubmc_ins_dir
+        self.config.version_conf(f"{version_path}/etc/version.json")
+        self.config.show_version_conf(f"{version_path}/etc/version.json")
         per_file = os.path.join(self.config.board_path, "permissions.ini")
         if os.path.isfile(per_file):
             shutil.copy(per_file, self.openubmc_ins_dir)

bmcgo/tasks/task_build_wbd_up.py

@@ -0,0 +1,69 @@
+#!/usr/bin/env python3
+# coding: 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 os
+import shutil
+
+from bmcgo.tasks.task import Task
+
+
+class TaskClass(Task):
+    def __init__(self, config, work_name=""):
+        super(TaskClass, self).__init__(config, work_name=work_name)
+        self.wbd_build_dir = os.path.join(self.config.build_path, "wbd_build_dir")
+
+    def get_wbd_file_config(self):
+        wbd_up_file_config = None
+        if self.config.manufacture_code:
+            wbd_config_path = f"manufacture/{self.config.manufacture_code}/wbd_up_files"
+            wbd_up_file_config = self.get_manufacture_config(wbd_config_path)
+        elif self.config.tosupporte_code:
+            wbd_config_path = f"tosupporte/{self.config.tosupporte_code}/wbd_up_files"
+            wbd_up_file_config = self.get_manufacture_config(wbd_config_path)
+        else:
+            pass
+            
+        wbd_up_file_config = wbd_up_file_config or self.get_manufacture_config("wbd_up_files")
+        return wbd_up_file_config
+
+
+    def generate_wbd_package(self, wbd_up_file_config):
+        self.chdir(self.wbd_build_dir)
+
+        if "repo" in wbd_up_file_config and "tag" in wbd_up_file_config:
+            repo = wbd_up_file_config.get("repo")
+            tag = wbd_up_file_config.get("tag")
+            if not repo.startswith("https"):
+                self.info("建议使用 https 协议的仓库地址")
+            self.run_command(f"git clone {repo} -b {tag} --depth=1")
+            
+        # 复制manifest.yml中配置的文件到build目录
+        files = wbd_up_file_config.get("files")
+        self.copy_manifest_files(files)
+        
+        # 约定压缩打包wbd_up_file目录
+        self.run_command(f"tar --format=gnu -zcvf wbd_up_file.tar.gz wbd_up_file")
+        rootfs_wbd_path = os.path.join(self.config.rootfs_path, "opt/bmc/white_branding")
+        self.run_command(f"mkdir -p {rootfs_wbd_path}", sudo=True)
+        self.run_command(f"cp -f wbd_up_file.tar.gz {rootfs_wbd_path}", sudo=True)
+
+    def run(self):
+        wbd_up_file_config = self.get_wbd_file_config()
+        if not wbd_up_file_config:
+            self.info("未在manifest.yml中找到 wbd_up_files 配置, 跳过白牌打包")
+            return
+
+        shutil.rmtree(self.wbd_build_dir, ignore_errors=True)
+        os.makedirs(self.wbd_build_dir, exist_ok=True)
+
+        self.info(f"----打包 {self.config.board_name} wbd_up_file.tar.gz 到BMC hpm包中 ------------> [开始]")
+        self.generate_wbd_package(wbd_up_file_config)
+        self.info(f"----打包  {self.config.board_name}wbd_up_file.tar.gz 到BMC hpm包中 ----------> [结束]")

bmcgo/utils/config.py

@@ -142,10 +142,15 @@ class Config:
 
     @property
     def self_sign(self):
-        certificates = self.get_manufacture_config("base/signature/certificates")
-        if not certificates:
-            certificates = self.get_manufacture_config("base/signature/simple_signer_server")
-        return certificates is not None
+        self_sign_config = self.get_manufacture_config("base/signature/simple_signer_server")
+        if not self_sign_config:
+            self_sign_config = self.get_manufacture_config("base/signature/certificates")
+        if not self_sign_config:
+            self_sign_config = self.bconfig.hpm_server_sign
+        if not self_sign_config:
+            self_sign_config = self.bconfig.hpm_self_sign
+
+        return self_sign_config is not None
 
     @property
     def rootca_der(self):
@@ -1012,8 +1017,12 @@ class Config:
     def parse_args(self, args=None):
         parser = self.argparser(self.code_path)
         args, _ = parser.parse_known_args(args)
+        if args.zip_code and args.supporte_code != "default":
+            raise errors.ConfigException("manufacture 编码和 tosupporte 编码不能同时存在")
+
         self.set_manufacture_code(args.zip_code)
-        self.set_tosupporte_code(args.supporte_code)
+        if not args.zip_code:
+            self.set_tosupporte_code(args.supporte_code)
         self.set_from_source(args.from_source)
         self.set_build_type(args.build_type)
         self.set_stage(args.stage)
@@ -1035,14 +1044,17 @@ class Config:
         self.get_archive()
         self.init_conan_profile(args.profile)
 
-        if self.manufacture_code is not None and self.tosupporte_code != "default":
-            raise errors.ConfigException("manufacture 编码和 tosupport E 编码不能同时存在")
-
         # 构建阶段检查
         bt = ["dt", "debug", "release"]
         if args.build_type not in bt:
             raise errors.ConfigException("构建类型 build_type 错误, 可用选项为: [debug, release, dt], 请检查参数")
 
+        hpm_encrypt = self.bconfig.hpm_encrypt
+        if hpm_encrypt and hpm_encrypt.need_encrypt:
+            if not shutil.which("crypto_tool"):
+                raise errors.BmcGoException(f"开启了hpm加密配置, 在环境中未找到 'crypto_tool', 请确认环境配置是否正确.")
+            os.environ["HPM_ENCRYPT"] = "true"
+
     def _load_manifest_with_template(self, filename, template):
         try:
             real_sha256 = Config._calc_manifest_data_sha256(filename, template)

bmcgo/utils/install_manager.py

@@ -12,19 +12,23 @@
 # See the Mulan PSL v2 for more details.
 
 from pathlib import Path
-from bmcgo.utils.tools import Logger
+from typing import Dict, List
+from bmcgo import misc
+from bmcgo.utils.tools import Tools
 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
+
+tools = Tools("install")
+logger = tools.log
 
 
 class InstallManager:
     def __init__(self):
         self._custom_path = None
+        self._workflows = []
+        self._installers: Dict[str, List[BaseInstaller]] = {}
 
     @property
     def custom_installer_path(self):
@@ -33,29 +37,80 @@ class InstallManager:
     @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):
+    
+    def init(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())
+            self._workflows = list(InstallWorkflow.get_all_plans())
         else:
-            workflows = [app_name]
+            self._workflows = [app_name]
+        
+        for wname in self._workflows:
+            workflow = InstallWorkflow.parse(wname)
+            plans = workflow.get(install_consts.PLAN_STEPS, [])
+            for plan in plans:
+                inst_type = plan.get(install_consts.PLAN_INSTALL_TYPE)
+                if not inst_type:
+                    raise ValueError(f"未配置 {wname}/{install_consts.PLAN_STEPS}/{install_consts.PLAN_INSTALL_TYPE}")
+                inst = BaseInstaller.get_installer(inst_type)
+                inst.init(plan, operator, version)
+                self._installers.setdefault(wname, []).append(inst)
 
-        for wname in workflows:
-            logger.info(f"安装{wname}...")
+    def show_versions(self):
+        for wname in self._workflows:
+            if wname not in self._installers:
+                raise RuntimeError(f"初始化 {wname} 出现问题，请重试！")
+
+            for inst in self._installers[wname]:
+                logger.info(f"获取 {inst.package_name} {inst.type_name} 版本信息...")
+                inst.show_versions()
+
+    def pre_install(self):
+        for wname in self._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)
+            verisons = {}
+            if wname not in self._installers:
+                raise RuntimeError(f"初始化 {wname} 出现问题，请重试！")
+            for inst in self._installers[wname]:
+                inst.pre_install()
+                verisons[inst.type_name] = inst.target_version
+
+            require_version_homogeneous = plans.get(install_consts.PLAN_VERSION_HOMOGENEOUS, False)
+            if require_version_homogeneous and len(set(verisons.values())) > 1:
+                for t, v in verisons.items():
+                    logger.error(f"{t}: {v}")
+                raise ValueError("版本不一致，终止安装!")
+
+    def install(self, force):
+        logger.info("开始安装...")
+        for wname in self._workflows:
+            logger.info(f"安装{wname}...")
+            try:
+                if wname not in self._installers:
+                    raise RuntimeError(f"初始化 {wname} 出现问题，请重试！")
+                for inst in self._installers[wname]:
+                    inst.install(force)
+            except Exception as e:
+                logger.info(f"安装失败，回退{wname}...")
+                if wname not in self._installers:
+                    raise RuntimeError(f"初始化 {wname} 出现问题，请重试！") from e
+                for inst in self._installers[wname]:
+                    inst.rollback()
+                raise RuntimeError("安装失败") from e
+
+    def post_install(self):
+        for wname in self._workflows:
+            logger.info(f"清理安装{wname}的中间文件...")
+            if wname not in self._installers:
+                raise RuntimeError(f"初始化 {wname} 出现问题，请重试！")
+            for inst in self._installers[wname]:
+                inst.post_install()
 
     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)
+        InstallWorkflow.add_plan_dir(self.custom_install_plan_path)
+        BaseInstaller.discover_installers()
+        InstallWorkflow.discover_workflows()