openubmc-bingo 0.5.243__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/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

@@ -22,12 +22,12 @@ class TaskClass(Task):
 
     def get_wbd_file_config(self):
         wbd_up_file_config = None
-        if 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)
-        elif self.config.manufacture_code:
+        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
             

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()

bmcgo/utils/installations/base_installer.py

@@ -15,21 +15,42 @@ import sys
 import importlib.util
 from pathlib import Path
 from typing import Dict, List, Type
+from bmcgo.utils.tools import Tools
 from bmcgo.utils.installations import install_consts
+from bmcgo.utils.installations.version_util import PkgVersion
 
 
 class BaseInstaller(abc.ABC):
-    logger = None
+    tools = Tools("install")
+    logger = tools.log
     _intallers: Dict[str, Type["BaseInstaller"]] = {}
     search_paths: List[Path] = [Path(__file__).resolve().parent / install_consts.PLUGIN_INSTALLER_PATH]
+    type_name = None
 
-    def __init_subclass__(cls, installer_type: str, **kwargs):
+    def __init__(self):
+        self._pkg_name = None
+        self._target_ver = None
+        self._cur_ver = None
+
+    def __init_subclass__(cls, **kwargs):
         super.__init_subclass__(**kwargs)
 
-        key = installer_type or cls.__name__.lower()
+        key = cls.type_name 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
+            cls.logger and cls.logger.warning(f"{key}({cls._intallers[key]} 被替换为: {cls})")
+        cls._intallers[key] = cls
+
+    @property
+    def target_version(self):
+        return self._target_ver
+    
+    @property
+    def current_version(self):
+        return self._cur_ver
+    
+    @property
+    def package_name(self):
+        return self._pkg_name
 
     @classmethod
     def add_installer_dir(cls, directory: Path):
@@ -64,7 +85,93 @@ class BaseInstaller(abc.ABC):
         if not installer_cls:
             raise ValueError(f"未定义的安装方法：{installer_type}")
         return installer_cls()
+    
+    def init(self, plan, operator, version):
+        self.parse_plan(plan)
+
+        versions = self.get_versions()
+        self.resolve_constraint(versions, operator, version)
+
+        self.get_current_version()
+
+    def pre_install(self):
+        """ 安装前检查 """
+        self.info("安装前检查")
+    
+    def post_install(self):
+        """ 安装后清理 """
+        self.info("安装后清理")
+
+    def rollback(self):
+        """ 回退 """
+        self.info("回退")
+
+    def parse_plan(self, plan: Dict[str, List[str]]):
+        self._pkg_name = plan.get(install_consts.PLAN_PACKAGE_NAME)
+        if not self._pkg_name:
+            self.error(f"{install_consts.PLAN_PACKAGE_NAME} 未配置!")
+            return
+        self.parse_custom_plan(plan)
+
+    def resolve_constraint(self, versions, opt, ver):
+        if not versions:
+            self.warning("当前没有可下载版本!")
+            return
+
+        if ver == install_consts.INSTALL_LATEST or not opt:
+            self._target_ver = versions[0]
+            return
+
+        pkg_ver = PkgVersion(ver)
+        for avl_ver in versions:
+            v = PkgVersion(avl_ver)
+            if opt == ">=" and v >= pkg_ver:
+                self._target_ver = v.origin
+                break
+            elif opt == "<=" and v <= pkg_ver:
+                self._target_ver = v.origin
+                break
+            elif opt == "!=" and v != pkg_ver:
+                self._target_ver = v.origin
+                break
+            elif opt == "<" and v < pkg_ver:
+                self._target_ver = v.origin
+                break
+            elif opt == ">" and v > pkg_ver:
+                self._target_ver = v.origin
+                break
+            elif opt == "=" and v == pkg_ver:
+                self._target_ver = v.origin
+                break
+        else:
+            self.warning(f"没有找到匹配的版本：{self._pkg_name}{opt}{ver}")
+            return
+        
+    def info(self, msg):
+        self.logger and self.logger.info(f"[{self.type_name}] {msg}")
+
+    def error(self, msg):
+        self.logger and self.logger.error(f"[{self.type_name}] {msg}")
+
+    def warning(self, msg):
+        self.logger and self.logger.warning(f"[{self.type_name}] {msg}")
+
+    @abc.abstractmethod
+    def parse_custom_plan(self, plan: Dict[str, List[str]]):
+        """ 解析 yml 配置计划 """
+
+    @abc.abstractmethod
+    def install(self, force: bool):
+        """ 安装入口 """
+
+    @abc.abstractmethod
+    def get_versions(self):
+        """ 可用版本 """
+        
+    @abc.abstractmethod
+    def show_versions(self):
+        """ 列出可用版本 """
 
     @abc.abstractmethod
-    def install(self, plan: Dict[str, List[str]], operator: str, version: str):
-        """ 安装入口 """
+    def get_current_version(self):
+        """ 获取当前已安装版本 """

bmcgo/utils/installations/install_consts.py

@@ -20,6 +20,7 @@ INSTALL_ALL = "all"
 INSTALL_LATEST = "latest"
 INSTALL_DEFAULT = f"{INSTALL_ALL}={INSTALL_LATEST}"
 
+PLAN_VERSION_HOMOGENEOUS = "version_homogeneous"
 PLAN_STEPS = "install_steps"
 PLAN_INSTALL_TYPE = "type"
 PLAN_PACKAGE_NAME = "package_name"
@@ -27,4 +28,5 @@ PLAN_MODULE_NAME = "module_name"
 PLAN_REPO_URL = "url"
 PLAN_GPG = "gpg"
 PLAN_CONFIG_FILE = "config_file"
-PLAN_PUBLIC_KEY = "public_key"
+PLAN_PUBLIC_KEY = "public_key"
+PLAN_DOC = "doc"

bmcgo/utils/installations/install_plans/bingo.yml

@@ -1,11 +1,9 @@
+version_homogeneous: true
 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/
-    gpg: bingo.gpg
-    public_key: gpg_key.public
+    doc: https://www.openubmc.cn/marketplace/bingo