openubmc-bingo 0.5.240__py3-none-any.whl

bmcgo/component/build.py

@@ -0,0 +1,222 @@
+#!/usr/bin/python3
+# 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.
+import json
+import os
+import shutil
+import subprocess
+import stat
+import pathlib
+
+from mako.lookup import TemplateLookup
+
+from bmcgo.codegen.c.helper import Helper
+from bmcgo.logger import Logger
+from bmcgo.utils.tools import Tools
+from bmcgo.bmcgo_config import BmcgoConfig
+from bmcgo.errors import BmcGoException
+from bmcgo.component.package_info import InfoComp
+from bmcgo.component.component_helper import ComponentHelper
+from bmcgo import misc
+
+log = Logger()
+tool = Tools()
+
+cwd_script = os.path.split(os.path.realpath(__file__))[0]
+
+
+class BuildComp():
+    def __init__(self, bconfig: BmcgoConfig, args=None, gen_conanbase=True, service_json="mds/service.json"):
+        self.init_common_params(bconfig)
+        self.info: InfoComp = InfoComp(args, service_json, self.bconfig.partner_mode)
+        self.set_remote_url()
+        self.gen_conanbase(gen_conanbase, service_json)
+        self.gen_log()
+
+    @staticmethod
+    def get_remote_urls():
+        """ Get remote url regardless of the cloned directory """
+        git_cmd = Helper.get_git_path()
+        cmd = [git_cmd, "remote", "-v"]
+        process = subprocess.run(cmd, check=True, capture_output=True)
+        return process.stdout.decode("UTF-8").strip().split("\n")
+
+    def gen_conanbase(self, gen_conanbase, service_json):
+        lookup = TemplateLookup(directories=os.path.join(cwd_script, "template"))
+        if gen_conanbase:
+            template = lookup.get_template("conanbase.py.mako")
+            language = ComponentHelper.get_language(service_json=service_json, allow_non_service_json=True)
+            conanbase = template.render(lookup=lookup, pkg=self.info, remote_url=self.remote_url,
+                                        codegen_version=self.info.codegen_base_version,
+                                        language=language)
+            file_handler = os.fdopen(os.open("conanbase.py", os.O_WRONLY | os.O_CREAT | os.O_TRUNC,
+                                            stat.S_IWUSR | stat.S_IRUSR), 'w')
+            file_handler.write(conanbase)
+            file_handler.close()
+
+    def gen_log(self):
+        self.log_file = os.path.join("/tmp", self.info.name + ".log")
+        file_handler = os.fdopen(os.open(self.log_file, os.O_WRONLY | os.O_CREAT | os.O_TRUNC,
+                                         stat.S_IWUSR | stat.S_IRUSR), 'w')
+        file_handler.close()
+
+    def init_common_params(self, bconfig: BmcgoConfig):
+        self.bconfig = bconfig
+        self.folder = bconfig.component.folder
+        os.chdir(self.folder)
+
+    def set_remote_url(self):
+        # 上传模式必须有一个地址
+        if self.info.upload:
+            self.remote_url = self.get_remote_url(False)
+        else:
+            self.remote_url = self.get_remote_url(True)
+        log.info("仓库地址为: %s", self.remote_url)
+
+    def get_remote_url(self, get_first=True):
+        """ Get remote url regardless of the cloned directory """
+        output_lines = self.get_remote_urls()
+        repos = []
+        for line in output_lines:
+            if line.find("(push)") > 0:
+                repos.append(line)
+        log.debug("获取仓库列表:")
+        log.debug(repos)
+        if len(repos) == 0:
+            return ""
+        repo_id = 0
+        if len(repos) > 1 and not get_first:
+            log.info("仓库列表:")
+            for repo in repos:
+                chunk = repo.split(maxsplit=1)
+                log.info("仓库基本信息: %s %s %s", repo_id, chunk[0], chunk[1])
+                repo_id += 1
+            message = input("请选择要使用的仓库地址:")
+            repo_id = int(message, 10)
+            if repo_id > len(repos):
+                raise OSError("未知的仓库, 退出, 请确认仓库!")
+
+        http_proto = "https://"
+        repo = repos[repo_id]
+        url = repo.split()[1]
+        # 如果以https://开头，直接返回
+        if url.startswith(http_proto):
+            return url
+        # 去掉URL的协议部分，转换为https
+        url = url.split("@", 1)[1]
+        # 无端口的，直接转为https://
+        if not url.find(":") > 0:
+            return http_proto + url
+        chunk = url.split(":", 1)
+        # 如果以端口启始的，删除2222端口号
+        if chunk[1].startswith("2222/"):
+            return http_proto + chunk[0] + "/" + chunk[1].split("/", 1)[1]
+        if chunk[1].startswith("/"):
+            return http_proto + chunk[0] + chunk[1]
+        return http_proto + chunk[0] + "/" + chunk[1]
+
+    def install_luac(self):
+        conan_bin = os.path.join(os.path.expanduser('~'), ".conan", "bin")
+        # 设置PLD_LIBRARY_PATH环境变量，luajit运行时需要加载so动态库
+        ld_library_path = conan_bin + ":" + os.environ.get("LD_LIBRARY_PATH", "")
+        os.environ["LD_LIBRARY_PATH"] = ld_library_path
+        # 设置PATH环境变量，luajit无需指定全路径
+        path = conan_bin + ":" + os.environ.get("PATH", "")
+        os.environ["PATH"] = path
+        os.environ["LUA_PATH"] = f"{conan_bin}/?.lua"
+
+        # 待安装的luajit版本
+        channel = f"@{Tools().conan_user}/{misc.StageEnum.STAGE_STABLE.value}"
+        luajit_pkg = f"luajit/2.1.0.B012{channel}"
+        luajit_flag = luajit_pkg.split("@")[0].replace("/", "_")
+        luajit_flag = os.path.join(conan_bin, luajit_flag)
+
+        # 使能luajit时需要安装luajit
+        luac_path = os.path.join(conan_bin, "luajit")
+        # luajit版本一致且luac/luajit存在时赋权即可
+        if os.path.isfile(luajit_flag) and os.path.exists(luac_path):
+            os.chmod(luac_path, stat.S_IRWXU)
+            return
+        Tools.clean_conan_bin(conan_bin)
+        # 其它情况都尝试安装luajit
+        cmd = [misc.CONAN, "install", luajit_pkg]
+        cmd += ("-pr profile.dt.ini -if=temp/.deploy -g deploy").split()
+        if self.info.remote:
+            cmd += ["-r", self.info.remote]
+        Helper.run(cmd)
+        cmd = ["cp", "temp/.deploy/luajit/usr/bin/luajit", f"{conan_bin}"]
+        Helper.run(cmd)
+        cmd = ["cp", "temp/.deploy/luajit/usr/lib64/liblua.so", f"{conan_bin}"]
+        Helper.run(cmd)
+        cmd = ["cp", "-r", "temp/.deploy/luajit/usr/bin/jit", f"{conan_bin}"]
+        Helper.run(cmd)
+        os.chmod(luac_path, stat.S_IRWXU)
+        luajit2luac = shutil.which("luajit2luac.sh")
+        cmd = ["cp", luajit2luac, f"{conan_bin}/luac"]
+        Helper.run(cmd)
+        pathlib.Path(luajit_flag).touch(exist_ok=True)
+
+    def check_conan_profile(self):
+        profile = os.path.join(tool.conan_profiles_dir, self.info.profile)
+        luajit_profile = os.path.join(tool.conan_profiles_dir, "profile.luajit.ini")
+        if not os.path.isfile(profile):
+            raise BmcGoException(f"Profile文件{profile} 不存在，系统可能未初始化，" +
+                                 "请在manifest仓执行bingo build安装产品配套构建工具")
+        if self.info.enable_luajit and not os.path.isfile(luajit_profile):
+            raise BmcGoException(f"Profile文件{luajit_profile} 不存在，系统可能未初始化，" +
+                                "请在manifest仓(2024.07.04之后的版本)执行bingo build安装产品配套构建工具")
+
+    def upload(self):
+        if not self.info.upload:
+            return
+        pkg = "%s/%s%s" % (self.info.name, self.info.version, self.info.channel)
+        cmd = [misc.CONAN, "info"]
+        cmd += ("%s %s -s build_type=%s -j" % (pkg, self.info.full_profile, self.info.build_type.capitalize())).split()
+        lines = subprocess.run(cmd, capture_output=True, check=True).stdout.decode("utf-8").split("\n")
+        conan_info = None
+        for line in lines:
+            if line.startswith("[{"):
+                conan_info = json.loads(line)
+                break
+        pkg_id = None
+        for item in conan_info:
+            if item["reference"] == pkg:
+                pkg_id = item["id"]
+                break
+        if pkg_id is None:
+            raise OSError(f"获取包版本配置无效, 包名: {pkg}")
+        cmd = [misc.CONAN, "upload"]
+        cmd += ("%s:%s -r %s --all" % (pkg, pkg_id, self.info.remote)).split()
+        tool.run_command(cmd, show_log=True)
+
+    def run(self):
+        self.check_conan_profile()
+        self.install_luac()
+        tool.clean_locks()
+        from_source = "--build=missing"
+        if self.info.from_source:
+            from_source = "--build"
+        cache_dir = os.path.join(os.path.expanduser("~/.conan/data"), self.info.package.replace("@", "/"))
+        if self.info.no_cache:
+            shutil.rmtree(cache_dir, ignore_errors=True)
+        # 构建当前组件
+        append = "%s %s -tf None" % (self.info.cmd_base, from_source)
+        cmd = [misc.CONAN, "create"]
+        cmd += append.split()
+        tool.run_command(cmd, show_log=True)
+        self.upload()
+
+    def test(self):
+        if os.path.isdir("test_package"):
+            cmd = [misc.CONAN, "create"]
+            cmd += self.info.cmd_base.split()
+            cmd += ["-tf", "test_package"]
+            Helper.run(cmd)

bmcgo/component/component_dt_version_parse.py

@@ -0,0 +1,348 @@
+#!/usr/bin/env python3
+# -*- 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.
+# descritption: 解析service.json配置文件，生成不同的组件版本service.json配置文件
+import os
+import json
+import logging
+import stat
+import re
+import argparse
+
+from bmcgo.component.package_info import InfoComp
+from bmcgo.component.component_helper import ComponentHelper
+from bmcgo.logger import Logger
+from bmcgo import misc
+
+log = Logger("ComponentDtVersionParse", logging.INFO)
+
+
+class Function:
+    """这边只提供功能模块，做单一解析
+    """
+    @classmethod
+    def is_opensource(cls, version_str: str):
+        """检查组件是否是开源软件
+
+        Args:
+            version_str (str): 配置的组件conan版本
+
+        Returns:
+            bool: 是开源软件返回True
+        """
+        version_str_list = re.split('/|@', version_str)
+        # 如果没有方括号，那么则是静态或者开源
+        if '[' not in version_str_list[1]:
+            # 如果没有查到数字三段, 则认为为开源
+            if re.fullmatch("\d+\.\d+\.\d", version_str_list[1]) is None:
+                return True
+            # 是三段式, 判定为自研
+            else:
+                return False
+        # 有方括号一律认定为自研
+        else:
+            return False
+
+    @classmethod
+    def get_key_value(cls, search_dict: dict, key: str):
+        """获取字典的键的值
+
+        Args:
+            key (str): 使用"a/b/c"形式可逐级取值, 失败则返回None
+
+        Returns:
+            _type_: 返回值为键的值
+        """
+        if search_dict is None:
+            return search_dict
+        value = search_dict
+        for sub_key in key.split("/"):
+            value = value.get(sub_key, None)
+            if value is None:
+                return value
+        return value
+
+    @classmethod
+    def limit_check(cls, str_input: str):
+        """检查字符串是否有上下限
+
+        Args:
+            str_input (str): 被检查字符串
+
+        Returns:
+            bool: 是否匹配上
+        """
+        if '<' not in str_input and '>' not in str_input:
+            return True, "为静态版本或者开源软件"
+        elif '<' not in str_input:
+            return False, "没有上限"
+        elif '>' not in str_input:
+            return False, "没有下限"
+        else:
+            return True, "上下限均已配置"
+
+    @classmethod
+    def get_minimum_version(cls, component_conf_str: str):
+        """
+        获取组件最低的版本配置
+
+        Args:
+            component_conf_str (str): 组件版本配置字符串
+
+        Returns:
+            str: 组件最低版本配置字符串
+        """
+        if cls.is_opensource(component_conf_str) is False:
+            component_conf_list = re.split('/|@', component_conf_str)
+            version_conf_list = component_conf_list[1].strip('[]').split(',')
+            version = []
+            for version_conf in version_conf_list:
+                if ">=" in version_conf:
+                    # 去掉下限的范围符号, 只保留固定版本号
+                    version.append(version_conf.strip(' >='))
+                elif "<=" in version_conf:
+                    continue
+                else:
+                    # 其他内容保留
+                    version.append(version_conf)
+            component_conf_list[1] = ','.join(version)
+            # 有些除了版本, 还有其他配置的, 外面的方括号加回去
+            if len(version) > 1:
+                component_conf_list[1] = f"[{component_conf_list[1]}]"
+            # 由于之前将所有的符号给拆了，这里将符号加上
+            k = 1
+            for i in range(len(component_conf_list) - 1):
+                component_conf_list[i + k:i + k] = ['/', '@', '/'][i]
+                k = k + 1
+            component_conf_str = ''.join(component_conf_list)
+        return component_conf_str
+
+    @classmethod
+    def get_version_replace(cls, component_service: str, manifest_subsys: str, use_patch_range=False):
+        """使用manifest_subsys的静态组件版本 替换掉 组件配置的组件版本
+
+        Args:
+            component_service (str): 组件配置的组件版本
+            manifest_subsys (str): manifest仓配置的组件版本
+
+        Returns:
+            _type_: 返回替换完成的组件版本
+        """
+        service_version_list = re.split('/|@', component_service)
+        manifest_version = re.split('/|@', manifest_subsys)[1]
+
+        if use_patch_range and not Function.is_opensource(manifest_subsys):
+            # 三段式版本组件修改为补丁范围版本 [>=x.y.z <x.y+1.0]
+            major, minor, _ = manifest_version.split(".")
+            uppper_verison = f"{major}.{int(minor) + 1}.0"
+
+            service_version_list[1] = f"[>={manifest_version} <{uppper_verison}]"
+        else:
+            service_version_list[1] = manifest_version
+        # 由于之前将所有的符号给拆了，这里将符号加上
+        k = 1
+        for i in range(len(service_version_list) - 1):
+            service_version_list[i + k:i + k] = ['/', '@', '/'][i]
+            k = k + 1
+        return ''.join(service_version_list)
+
+    @classmethod
+    def find_key(cls, key, dictionary):
+        """在字典中查找相同key值并返回key值组成的列表
+
+        Args:
+            key (_type_): 要查找的key值
+            dictionary (_type_): 被查找的字典
+
+        Returns:
+            _type_: key的值组成的列表
+        """
+        results = []
+        for k, v in dictionary.items():
+            if k == key:
+                results.append(v)
+            elif isinstance(v, dict):
+                results.extend(cls.find_key(key, v))
+        return results
+
+
+class ManifestConfigParse:
+    """获取 manifest 目录下的所有组件版本配置
+    """
+    def __init__(self, package_info_file: str):
+        """初始化 package_info 仓路径
+
+        Args:
+            package_info_file (str): package_info 路径
+        """
+        self.package_info_file = package_info_file
+
+    def get_version_dict(self):
+        """获取主干仓的 package_info 所有组件版本配置
+
+        Returns:
+            dict: 返回所有组件配置的字典
+        """
+        with open(self.package_info_file, mode="r") as fp:
+            package_info_list = fp.readlines()
+            package_info_dict = {package.strip('\n').split('/')[0]:package.strip('\n') for package in package_info_list}
+        return package_info_dict
+
+
+class ComponentDtVersionParse:
+    """分析组件 dt 的依赖组件版本, 实现自动配置 service.json 文件, 达成 dt 构建门禁
+    """
+    def __init__(self, parser=None, serv_file="mds/service.json", args=None):
+        """初始化，读取配置
+
+        Args:
+            serv_file (str): 配置文件路径
+        """
+        if not parser:
+            parser = argparse.ArgumentParser(description="component dt different version")
+        parser.add_argument("--minimum", "-m", action=misc.STORE_TRUE, help="获取dt构建的最小版本")
+        parser.add_argument("--package_info", "-pi", default=None, help="package_info 文件路径, 使用manifest配套版本dt构建, \
+            此文件在manifest构建时会在inner目录生成")
+        parsed_args, _ = parser.parse_known_args(args)
+        self.minimum = parsed_args.minimum
+        self.package_info = parsed_args.package_info
+
+        # 读取service.json配置文件
+        self.serv_file = serv_file
+        with open(self.serv_file, "r") as mds_conf_fp:
+            self.mds_conf = json.load(mds_conf_fp)
+            mds_conf_fp.close()
+        # 生成dt与build的依赖列表, 检查时如果发现问题, 直接报出组件名, 不分类
+        conan_dt_list = Function.get_key_value(self.mds_conf, "dependencies/test") or []
+        conan_build_list = Function.get_key_value(self.mds_conf, "dependencies/build") or []
+        # 根据配置文件，已确定为列表，有告警，无需使用list转化，影响效率
+        self.conan_list = conan_dt_list + conan_build_list
+
+    def write_to_serv_file(self):
+        """写入到对象的 service.json 文件
+        """
+        with os.fdopen(os.open(self.serv_file, flags=os.O_WRONLY, \
+                mode=stat.S_IRUSR | stat.S_IWUSR | stat.S_IRGRP | stat.S_IROTH), "w") as mds_conf_fp:
+            mds_conf_fp.seek(0)
+            mds_conf_fp.truncate()
+            json.dump(self.mds_conf, mds_conf_fp, indent=4, ensure_ascii=False)
+            mds_conf_fp.close()
+
+    def component_limit_check(self):
+        """上下限检查
+
+        Args:
+            check_char (str): '>'表示检查下限, '<'表示检查上限
+
+        Raises:
+            AttributeError: 配置错误
+        """
+        # 默认情况下, 检查通过
+        log.info("开始上下限检查")
+        check_result = True
+        for conan in self.conan_list:
+            check, msg = Function.limit_check(conan[misc.CONAN])
+            if check is False:
+                log.error(f"组件 {conan[misc.CONAN]} {msg}")
+                check_result = False
+            else:
+                log.debug(f"组件 {conan[misc.CONAN]} {msg}")
+        # 检查失败, 报错
+        if check_result is False:
+            raise AttributeError("上下限检查失败")
+        else:
+            log.info("上下限检查通过")
+
+    def minimum_version_config(self):
+        """获取 service.json 的最小配置版本
+        """
+        # 列表逐个取最小版本
+        for version_conf in self.conan_list:
+            version_conf[misc.CONAN] = Function.get_minimum_version(version_conf[misc.CONAN])
+        self.write_to_serv_file()
+
+    def manifest_version_revise(self, package_info_file: str, use_patch_range=False):
+        """将 package_info 的组件版本配置到 service.json 文件中
+
+        Args:
+            package_info (str): package_info 路径
+        """
+        manifest_config_dict = ManifestConfigParse(package_info_file).get_version_dict()
+        check_fail_list = []
+        test_component = ["dtframeforlua", "test_data"]
+        for component in self.conan_list:
+            component_name = component[misc.CONAN].split('/')[0]
+            component_version = component[misc.CONAN]
+            if component_name in manifest_config_dict:
+                component[misc.CONAN] = Function.get_version_replace(
+                    component_version,
+                    manifest_config_dict[component_name],
+                    use_patch_range,
+                )
+            elif component_name in test_component:
+                continue
+            else:
+                check_fail_list.append(component_name)
+        if len(check_fail_list) > 0:
+            raise AttributeError(f"组件 {check_fail_list} 不在 manifest 仓的 subsys 配置中")
+        self.write_to_serv_file()
+
+    def manifest_full_version_dt(self, comp_info: InfoComp, package_info_file: str):
+        """将service.json的依赖组件的所有间接依赖组件根据package_info的组件版本也配置到service.json文件中"""
+        manifest_config_dict = ManifestConfigParse(package_info_file).get_version_dict()
+
+        def get_full_pkg_dependencies(mds_conan_list, root_dependencies):
+            # 获取当前组件service.json中的组件及版本
+            mds_conan_dependencies = [dep[misc.CONAN] for dep in mds_conan_list]
+            mds_pkgs = [dep.split("/")[0] for dep in mds_conan_dependencies]
+            # 通过当前组件的依赖组件完整路径xx/v@user/channel获取间接依赖
+            all_dependencies = ComponentHelper.get_all_dependencies(root_dependencies, comp_info.remote)
+            dependencies = set(root_dependencies)
+            for dependency in all_dependencies:
+                component_name = dependency.split("/")[0]
+                comp = manifest_config_dict.get(component_name, None)
+                if comp and component_name not in mds_pkgs:
+                    dependencies.add(comp)
+
+            full_pkg_dependencies = []
+            for package in dependencies:
+                if not (package.endswith(f"/{misc.StageEnum.STAGE_STABLE.value}") \
+                        or (package in mds_conan_dependencies)):
+                    package = package.split("@")[0]
+                full_pkg_dependencies.append({misc.CONAN: package})
+            return full_pkg_dependencies
+
+        conan_build_list = Function.get_key_value(self.mds_conf, "dependencies/build") or []
+        mds_conf_build = get_full_pkg_dependencies(conan_build_list, comp_info.build_dependencies)
+        self.mds_conf["dependencies"]["build"] = mds_conf_build
+
+        conan_test_list = Function.get_key_value(self.mds_conf, "dependencies/test") or []
+        mds_conf_test = get_full_pkg_dependencies(conan_test_list, comp_info.test_dependencies)
+        self.mds_conf["dependencies"]["test"] = mds_conf_test
+        self.write_to_serv_file()
+
+    def chose_dt_mode(self):
+        if self.minimum is True:
+            self.minimum_version_config()
+        elif self.package_info is not None:
+            self.manifest_version_revise(self.package_info)
+            comp_info = InfoComp([], self.serv_file)
+            self.manifest_full_version_dt(comp_info, self.package_info)
+        else:
+            log.info("没有启动组件版本分析")
+
+
+if __name__ == "__main__":
+    _parser = argparse.ArgumentParser()
+    _parser.add_argument("--service_json")
+    _parsed_args, argv = _parser.parse_known_args()
+    self_test = ComponentDtVersionParse(serv_file=_parsed_args.service_json, args=argv)
+    self_test.chose_dt_mode()

bmcgo/component/component_helper.py

@@ -0,0 +1,114 @@
+#!/usr/bin/env python3
+# 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.
+import os
+import time
+import json
+import re
+from typing import List
+from multiprocessing import Process
+from tempfile import NamedTemporaryFile
+
+from bmcgo.utils.tools import Tools
+from bmcgo.bmcgo_config import misc
+from bmcgo.errors import BmcGoException
+
+STAGE_DEV = "dev"
+STAGE_PRE = "pre"
+STAGE_RC = "rc"
+STAGE_STABLE = "stable"
+
+BUILD_TYPE_DT = "DT"
+BUILD_TYPE_DEBUG = "Debug"
+BUILD_TYPE_RELEASE = "Release"
+
+
+class DownloadComponentRecipe(Process):
+    def __init__(self, tools: Tools, comp, remote_list: list):
+        super().__init__()
+        self.comp = comp
+        self.tools = tools
+        self.remote_list = remote_list
+
+    def run(self):
+        dep_path = os.path.join(self.tools.conan_data, self.comp.replace("@", "/"))
+        if os.path.isdir(dep_path):
+            return
+        self.tools.download_conan_recipes(self.comp, self.remote_list)
+
+
+class ComponentHelper:
+    CONAN_PAKCAGE_RE = r"^[^@|/]+/[^@|/]+@[^@|/]+/(rc|stable|dev)$"
+
+    @staticmethod
+    def get_language(service_json="mds/service.json", allow_non_service_json=False):
+        if not os.path.isfile(service_json):
+            if allow_non_service_json:
+                return "lua"
+            raise RuntimeError(f"{service_json}文件不存在")
+        with open(service_json, "r", encoding="UTF-8") as service_fp:
+            content = json.load(service_fp)
+        return content.get("language", "lua")
+
+    @staticmethod
+    def get_config_value(json_data, key: str, default=None):
+        for sub_key in key.split("/"):
+            json_data = json_data.get(sub_key, None)
+            if json_data is None:
+                return default
+        return json_data
+
+    @staticmethod
+    def download_recipes(depdencies: List[str], tools: Tools, remote_list):
+        pools = []
+        for dep in depdencies:
+            task = DownloadComponentRecipe(tools, dep, remote_list)
+            task.start()
+            pools.append(task)
+
+        while pools:
+            time.sleep(0.1)
+            for pool in pools.copy():
+                if pool.is_alive():
+                    continue
+                if pool.exitcode is not None and pool.exitcode != 0:
+                    raise BmcGoException(f"下载组件 ({pool.comp}) 的构建配方(recipe)失败, 退出码: {pool.exitcode}")
+                pools.remove(pool)
+
+    @staticmethod
+    def get_all_dependencies(components: List[str], remote) -> List[str]:
+        """获取给定的多个组件com/x.yz@user/channel的直接及间接依赖的所有组件及版本。"""
+        tools = Tools()
+        dependencies = set()
+        tempfile = NamedTemporaryFile()
+        for comp in components:
+            if not re.match(ComponentHelper.CONAN_PAKCAGE_RE, comp):
+                raise BmcGoException(f"组件 {comp} 不符合正则 {ComponentHelper.CONAN_PAKCAGE_RE}")
+            cmd = f'conan info "{comp}" --remote {remote} --json {tempfile.name}'
+            tools.run_command(cmd)
+
+            file_handler = open(tempfile.name, "r")
+            conan_comps = json.load(file_handler)
+            for conan_comp in conan_comps:
+                comp_ref = conan_comp.get("reference", "")
+                if not comp_ref or comp_ref == comp:
+                    continue
+                dependencies.add(comp_ref)
+            file_handler.close()
+
+        return list(dependencies)
+
+    @staticmethod
+    def get_user_channel(stage: str):
+        if stage == misc.StageEnum.STAGE_DEV.value:
+            stage = misc.StageEnum.STAGE_RC.value
+        user_channel = f"@{Tools().conan_user}/{stage}"
+        return user_channel