openubmc-bingo 0.5.243__py3-none-any.whl → 0.5.254__py3-none-any.whl

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
 

bmcgo/utils/installations/install_workflow.py

@@ -14,11 +14,15 @@
 from typing import Dict, List
 from pathlib import Path
 import yaml
+from bmcgo.utils.tools import Tools
 from bmcgo.utils.installations import install_consts
 
 
+tools = Tools("install")
+
+
 class InstallWorkflow:
-    logger = None
+    logger = tools.log
     _workflows: Dict[str, List[str]] = {}
     search_paths: List[Path] = [Path(__file__).resolve().parent / install_consts.PLUGIN_INSTALL_PLAN_PATH]
 
@@ -26,7 +30,7 @@ class InstallWorkflow:
     def discover_workflows(cls):
         for path in cls.search_paths:
             if not path.exists():
-                cls.logger and cls.logger.warning(f"未找到安装配置路径：w{str(path)}")
+                cls.logger and cls.logger.warning(f"未找到安装配置路径：{str(path)}, 跳过")
                 continue
 
             for yml_file in path.glob("*.yml"):

bmcgo/utils/installations/installers/apt_installer.py

@@ -11,167 +11,89 @@
 # MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
 # See the Mulan PSL v2 for more details.
 import os
-import base64
-import tempfile
-import requests
+import shutil
 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):
+    type_name = "apt"
 
-
-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()
-
+        super().__init__()
+        self._apt_cmd = None
+        self._doc = None
+
+    def pre_install(self):
+        self._apt_cmd = shutil.which("apt-get")
+        if not self._apt_cmd:
+            raise RuntimeError("未找到 apt-get 指令")
+        
         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
+            self.tools.run_command(["apt", "policy", self._pkg_name], capture_output=True)
         except Exception as e:
-            raise RuntimeError("下载公钥失败")
-        
-        lines = key_data.splitlines()
-        in_block = False
-        b64data = []
+            self.info(f"本地源未正确配置，请参考社区文档进行配置：{self._doc}")
 
-        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("公钥出错")
+    def install(self, force: bool):
+        if self.current_version == self.target_version and not force:
+            yes = input(f"[apt]当前版本已满足(=={self.target_version}), 是否覆盖安装?[Y/n]")
+            if yes == "n":
+                self.info(f"用户跳过覆盖安装{self._pkg_name}={self.target_version}")
+                return
 
-        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)
+        pkg = f"{self._pkg_name}={self.target_version}"
+        self.info(f"开始安装{pkg}")
+        self._install_package(pkg, force)
+        self.info(f"安装{pkg}完成！")
 
-    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
+    def show_versions(self):
+        versions = self.get_versions()
+        if not versions:
+            self.error("未找到可用的版本")
+            return
+        self.info(f"可用版本: {", ".join(versions)}")
 
+    def get_versions(self) -> List[PkgVersion]:
+        result = self.tools.run_command(["apt-cache", "madison", self._pkg_name], capture_output=True)
+        if not result or not result.stdout:
+            return []
+        versions = [line.split("|")[1].strip() for line in result.stdout.splitlines()]
+        versions.sort(key=PkgVersion, reverse=True)
+        return versions
+    
+    def get_current_version(self):
         try:
-            tool.run_command(["mv", tmp_path, str(self._config_file)], sudo=True)
-            tool.run_command(["chmod", "644", str(self._config_file)], sudo=True)
+            result = self.tools.run_command(["dpkg-query", "-W", "-f=${Version}", self._pkg_name], capture_output=True)
+            if not result or not result.stdout:
+                return
+            self._cur_ver = result.stdout
         except Exception as e:
-            os.remove(tmp_path)
-            raise RuntimeError(f"写入仓库配置失败: {str(e)}")
+            return
+
+    def parse_custom_plan(self, plan: Dict[str, List[str]]):
+        self._doc = plan.get(install_consts.PLAN_DOC)
+        if not self._doc:
+            self.warning(f"未配置 {install_consts.PLAN_DOC}")
 
     def _update_cache(self):
-        self.logger and self.logger.info("更新 apt 缓存")
+        self.info("更新 apt 缓存")
         try:
-            tool.run_command(["apt-get", "update"], sudo=True)
+            self.tools.run_command(["apt-get", "update"], sudo=(os.getuid() != 0))
         except Exception as e:
             raise RuntimeError(f"安装失败： {str(e)}")
         
-    def _install_package(self, pkg: str):
-        self.logger and self.logger.info(f"安装: {pkg}")
+    def _install_package(self, pkg: str, force: bool):
+        self.info(f"安装: {pkg}")
         try:
-            tool.run_command(["apt-get", "install", "-y", "--allow-downgrades", pkg], sudo=True)
+            cmd = ["apt-get", "install", "--allow-downgrades", pkg]
+            if force:
+               cmd.append("-y") 
+            self.tools.run_command(cmd, sudo=(os.getuid() != 0))
+
         except Exception as e:
             raise RuntimeError(f"安装失败: {str(e)}")
         

bmcgo/utils/installations/installers/pip_installer.py

@@ -11,28 +11,28 @@
 # MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
 # See the Mulan PSL v2 for more details.
 import sys
-import shutil
+from importlib.metadata import distributions
 from typing import Dict, List
-from bmcgo.utils.tools import Tools
 from bmcgo.utils.installations import install_consts
+from bmcgo.utils.installations import version_util
 from bmcgo.utils.installations.base_installer import BaseInstaller
 
 
-tool = Tools("pip_install")
+class PipInstaller(BaseInstaller):
+    type_name = "pip"
 
+    def __init__(self):
+        super().__init__()
+        self._app_name = None
 
-class PipInstaller(BaseInstaller, installer_type="pip"):
-    def install(self, plan: Dict[str, List[str]], operator: str, version: str):
-        if operator == "=":
-            operator = "=="
+    def install(self, force):
+        if self.current_version == self.target_version and not force:
+            yes = input(f"[pip]: 当前版本已满足(=={self.target_version}), 是否覆盖安装?[Y/n]")
+            if yes == "n":
+                self.info(f"用户跳过覆盖安装{self._pkg_name}={self.target_version}")
+                return
 
-        pkg_name = plan.get(install_consts.PLAN_PACKAGE_NAME)
-        app_name = plan.get(install_consts.PLAN_MODULE_NAME)
-
-        if version == install_consts.INSTALL_LATEST or not operator:
-            pkg_info = pkg_name
-        else:
-            pkg_info = "".join([pkg_name, operator, version])
+        pkg_info = f"{self._pkg_name}=={self.target_version}"
         cmds = [sys.executable, "-m", "pip", "install", "--upgrade", pkg_info]
         
         with open("/etc/issue", "r") as fp:
@@ -40,7 +40,41 @@ class PipInstaller(BaseInstaller, installer_type="pip"):
             if issue.startswith("Ubuntu 24.04"):
                 cmds.append("--break-system-packages")
 
-        self.logger and self.logger.info(f"pip 开始安装{pkg_info}")
-        need_sudo = shutil.which(app_name).startswith("/home")
-        tool.run_command(cmds, sudo=need_sudo, show_log=True)
-        self.logger and self.logger.info(f"pip 安装{pkg_info}完成！")
+        self.info(f"pip 开始安装{pkg_info}")
+        self.tools.run_command(cmds, show_log=True)
+        self.info(f"pip 安装{pkg_info}完成！")
+
+    def parse_custom_plan(self, plan: Dict[str, List[str]]):
+        self._app_name = plan.get(install_consts.PLAN_MODULE_NAME)
+
+    def show_versions(self):
+        versions_mirror = self.get_versions()
+        if not versions_mirror:
+            self.error(f"未找到可用的版本")
+        self.info(f"可用版本: {", ".join(versions_mirror)}")
+
+    def get_versions(self, index_url=None):
+        cmd = [sys.executable, "-m", "pip", "index", "versions", self._pkg_name]
+        if index_url is not None:
+            cmd.extend(["-i", index_url])
+        ret = self.tools.run_command(cmd, capture_output=True)
+        for l in ret.stdout.splitlines():
+            if l.strip().startswith("Available versions: "):
+                # 跳过 Available, versions:
+                versions = [v.strip() for v in l.replace("Available versions:", "").split(",")]
+                versions.sort(key=version_util.PkgVersion, reverse=True)
+                return versions
+        else:
+            if index_url:
+                self.error(f"从 {index_url} 获取版本号失败!")
+            else:
+                self.error("获取版本号失败!")
+        return []
+    
+    def get_current_version(self):
+        for dist in distributions():
+            metadata = dist.metadata
+            if self._pkg_name == metadata["Name"]:
+                self._cur_ver = metadata["Version"]
+                break
+        

bmcgo/utils/installations/version_util.py

@@ -89,7 +89,7 @@ class PkgVersion:
             return self._digit.match(s).group()
         return self._non_digit.match(s).group()
     
-    def __compare(self, other: type["PkgVersion"]):
+    def __compare(self, other):
         if self.epoch != other.epoch:
             return -1 if self.epoch < other.epoch else 1