openubmc-bingo 0.5.277__py3-none-any.whl → 0.6.2__py3-none-any.whl

bmcgo/tasks/task_buildgppbin.py

@@ -48,8 +48,14 @@ class TaskClass(Task):
                 raise errors.BmcGoException("获取 manifest.yml 中 gpp/pkg_headers 配置失败, 退出码: -1")
             else:
                 files = []
-                files.append({"file": "/usr/local/bin/hpm_header.config", "dst": "hpm_header.config"})
-                files.append({"file": "/usr/local/bin/emmc_uboot_header.config", "dst": "emmc_uboot_header.config"})
+                src = "/usr/share/bingo/hpm_header.config"
+                if not os.path.isfile(src):
+                    src = "/usr/local/bin/hpm_header.config"
+                files.append({"file": src, "dst": "hpm_header.config"})
+                src = "/usr/share/bingo/emmc_uboot_header.config"
+                if not os.path.isfile(src):
+                    src = "/usr/local/bin/emmc_uboot_header.config"
+                files.append({"file": src, "dst": "emmc_uboot_header.config"})
 
         self.copy_manifest_files(files)
 

bmcgo/tasks/task_download_buildtools.py

@@ -15,7 +15,10 @@
 修改记录：2021-10-11 创建
 '''
 import os
+import tempfile
 import shutil
+from pathlib import Path
+from urllib.parse import urlparse
 
 from bmcgo.tasks.task import Task
 from bmcgo.tasks.misc import BUILD_TOOLS_SHA256_PATH
@@ -72,8 +75,81 @@ class DownloadDefaultBuildtools(Task):
         self.run_command(f"cp -rf {self.config.cross_compile_install_path}/{self.config.cross_prefix}/lib64/" +
                          f" {libstdcpp_install_path}")
         self.run_command("cp -af {} {}".format(self.buildtools_new_sha256, BUILD_TOOLS_SHA256_PATH), sudo=True)
+        self.run_command("chmod a+r {}".format(BUILD_TOOLS_SHA256_PATH), sudo=True)
+
+    def download_sdk(self):
+        downloads = self.get_manufacture_config("sdk/downloads")
+        if downloads is None:
+            self.log.warning("请在 manifest.yml 配置 sdk 字段或更新 manifest 仓库")
+            return
+
+        download_path = Path.home() / "downloads"
+        download_path.mkdir(exist_ok=True, parents=True)
+
+        for item in downloads:
+            self.log.info(f"配置 {item['name']}...")
+
+            curr_file_name = Path(urlparse(item['url']).path).name
+            curr_file = download_path / curr_file_name
+            curr_file_path = curr_file.as_posix()
+
+            need_download = True
+            if curr_file.exists():
+                curr_pkg_sha256 = self.tools.sha256sum(curr_file_path)
+                if curr_pkg_sha256 == item['sha256']:
+                    self.log.info(f"已下载 {item["name"]}, 跳过.")
+                    need_download = False
+
+            if need_download:
+                with tempfile.TemporaryDirectory() as tmp:
+                    self.log.info(f"开始下载 {item['url']}...")
+                    download_pkg_path = os.path.join(tmp, curr_file_name)
+                    self.tools.download_file(item['url'], download_pkg_path)
+                    downloaded_sha256 = self.tools.sha256sum(download_pkg_path)
+
+                    if item['sha256'] != downloaded_sha256:
+                        raise RuntimeError(f"manifest.yml /sdk/downloads/{item['name']} sha256 内容和下载包体不符，请检查配置！")
+
+                    shutil.move(download_pkg_path, curr_file_path)
+
+            if hasattr(self, f"install_{item['name']}"):
+                getattr(self, f"install_{item['name']}")(curr_file_path)
+            
+            self.log.info(f"配置 {item['name']} 完成！")
+
+    def install_bmc_sdk(self, zip_path):
+        with tempfile.TemporaryDirectory() as tmp:
+            self.log.info("安装 bmc_sdk")
+            home_path = Path.home().as_posix()
+            real_path = zip_path
+
+            self.log.debug(f"解压 {real_path} 到 {tmp}")
+            self.run_command(f"unzip {real_path} -d {tmp}")
+            
+            rtos_compiler_path = Path.home() / "rtos_compiler"
+            if rtos_compiler_path.exists():
+                shutil.rmtree(rtos_compiler_path)
+
+            sdk_path = Path.home() / "sdk"
+            if sdk_path.exists():
+                shutil.rmtree(sdk_path)
+
+            self.log.debug(f"move {tmp}/rtos_compiler -> {home_path}")
+            self.run_command(f"mv {tmp}/rtos_compiler/ {home_path}")
+            self.log.debug(f"move {tmp}/sdk -> {home_path}")
+            self.run_command(f"mv {tmp}/sdk/ {home_path}")
+            self.log.debug(f"move {tmp}/lua-format -> /usr/bin")
+            self.run_command(f"chmod +x {tmp}/lua-format")
+            self.run_command(f"mv -f {tmp}/lua-format /usr/bin/", sudo=True)
+
+            self.log.debug(f"copy {tmp}/hpm_tools/. -> {home_path}")
+            self.run_command(f"chmod -R +x {tmp}/hpm_tools")
+            self.run_command(f"cp -rf {tmp}/hpm_tools/. /usr/local/bin/", sudo=True)
+
+            self.log.info(f"安装 bmc_sdk 完成！")
 
     def run(self):
+        self.download_sdk()
         self.download_tools()
         self.info("下载依赖工具结束")
 

bmcgo/tasks/task_download_dependency.py

@@ -64,6 +64,7 @@ class TaskClass(Task):
             self.run_command(f"chown {user_group} {SDK_PATH} -R", sudo=True)
         self.run_command(f"ln -s {SDK_PATH} {old_sdk_dir}", sudo=True)
         self.run_command("cp -af {} {}".format(self.sdk_new_sha256, SDK_SHA256_PATH), sudo=True)
+        self.run_command("chmod a+r {}".format(SDK_SHA256_PATH), sudo=True)
 
     def run(self):
         self.download_dependency()

bmcgo/tasks/task_hpm_envir_prepare.py

@@ -71,7 +71,7 @@ class TaskClass(Task):
 
     def prepare_hpm(self):
         hpm_build_dir = self.config.hpm_build_dir
-        hpm_build_dir_src = f"/usr/share/bmcgo/ipmcimage"
+        hpm_build_dir_src = f"/usr/share/bingo/ipmcimage"
         self.tools.copy_all(hpm_build_dir_src, hpm_build_dir)
 
         self.run_command(f"cp {self.config.board_path}/update_ext4.cfg {hpm_build_dir}/update.cfg")

bmcgo/utils/build_conans.py

@@ -0,0 +1,231 @@
+#!/usr/bin/env python
+# 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 stat
+import subprocess
+import shlex
+import time
+import json
+import tempfile
+from queue import Queue
+from threading import Thread
+from bmcgo.logger import Logger
+from bmcgo import errors
+from bmcgo.utils.tools import Tools
+
+tools = Tools("build_parallel")
+log = tools.log
+
+
+class GraphNode():
+    def __init__(self, node):
+        self.node = node
+        self.host_packages: dict[str, GraphNode] = {}
+        self.build_packages: dict[str, GraphNode] = {}
+        self.ref = node.get("ref")
+        self.name = self.ref.split("/")[0]
+        self.context = node.get("context")
+        self.pkg = self.ref.split("#")[0] + "-" + self.context
+        self.is_host = self.context == "host"
+        self.building = False
+        binary = node.get("binary")
+        self.binary_exist = (binary in ["Cache"])
+        self.builded = False
+
+    @property
+    def package_options(self):
+        return self.node.get("options", {})
+
+    @property
+    def package_setting(self):
+        return self.node.get("settings", {})
+
+    @property
+    def default_options(self):
+        return self.node.get("default_options", {})
+
+    def append_host_package(self, dep):
+        self.host_packages[dep.pkg] = dep
+
+    def append_build_package(self, dep):
+        self.build_packages[dep.pkg] = dep
+
+
+class BuildConans(object):
+    def __init__(self, graphinfo, lockfile, conan_args, force_build, log_dir):
+        self.tools = Tools()
+        self.queue = Queue()
+        self.graphinfo = os.path.realpath(graphinfo)
+        if not os.path.isfile(graphinfo):
+            raise errors.BmcGoException(f"graph file {graphinfo} not exist")
+        self.lockfile = os.path.realpath(lockfile)
+        self.cmd = ""
+        args = conan_args.split()
+        skip = False
+        for arg in args:
+            if skip:
+                skip = False
+                continue
+            if arg in ["--user", "--channel", "--version", "--name"]:
+                skip = True
+                continue
+            self.cmd += f"{arg} "
+        self.exception = None
+        self.force_build = force_build
+        self.log_dir = log_dir
+        if not os.path.isdir(log_dir):
+            os.makedirs(log_dir)
+
+    def build_task(self, node: GraphNode, options):
+        for name, value in node.package_setting.items():
+            options += f" -s {name}={value}"
+
+        cmd = f"conan install --requires={node.ref} {self.cmd} {options}"
+        cmd += f" --build=\"{node.name}/*\" --build=missing -f json --lockfile={self.lockfile}"
+        try:
+            logfile = f"{self.log_dir}/conan_build_{node.name}.log"
+            log.debug(f">>>> {cmd}")
+            log.info(f">>>> build {node.ref} start, logfile: {logfile}")
+            with os.fdopen(os.open(logfile, os.O_RDWR | os.O_CREAT, stat.S_IWUSR | stat.S_IRUSR), "a+") as f:
+                real_cmd = shlex.split(cmd)
+                pipe = subprocess.Popen(real_cmd, stdout=f, stderr=f)
+                start_time = time.time()
+                while True:
+                    if pipe.poll() is not None:
+                        break
+                    # 1800秒超时
+                    if time.time() - start_time > 1800:
+                        pipe.kill()
+                        raise errors.BmcGoException(f"================== {node.name} 构建超时 ==================")
+                    time.sleep(1)
+                if pipe.returncode != 0:
+                    log.error(f"================== {node.name} 构建失败日志起始位置 ==================")
+                    f.seek(0)
+                    conan_log = f.read()
+                    log.error(conan_log)
+                    log.error(f"================== {node.name} 构建失败日志结束位置 ==================")
+                    raise errors.BmcGoException(f"================== {node.name} 构建失败 ==================")
+            log.success(f"<<<< build {node.ref} finished")
+        except Exception as e:
+            self.exception = e
+        self.queue.put(node)
+
+    def build(self):
+        cwd = os.getcwd()
+        tmp = tempfile.TemporaryDirectory()
+        os.chdir(tmp.name)
+        self._build()
+        os.chdir(cwd)
+
+    def _build(self):
+        with open(self.graphinfo, "r") as fp:
+            grapth = json.load(fp)
+        nodes = grapth.get("graph", {}).get("nodes", {})
+        dependencies: dict[str, GraphNode] = {}
+
+        build_tasks = {}
+        for refid, node in nodes.items():
+            if refid == "0":
+                continue
+            cp = GraphNode(node)
+            dependencies[cp.pkg] = cp
+            build_tasks[cp.name] = False
+        for refid, node in nodes.items():
+            if refid == "0":
+                continue
+            ref = node.get("ref")
+            context = node.get("context")
+            cp = dependencies[ref.split("#")[0] + "-" + context]
+            host_packages = node.get("dependencies", {})
+            for _, dep in host_packages.items():
+                dep_ref = dep.get("ref")
+                build = dep.get("build")
+                if build:
+                    build_dep = dependencies[dep_ref + "-build"]
+                    cp.append_build_package(build_dep)
+                    # 存在同名host组件时，将build组件作为host的依赖，避免并发构建
+                    host_dep = dependencies.get(dep_ref + "-host")
+                    if host_dep:
+                        host_dep.append_build_package(build_dep)
+                else:
+                    host_dep = dependencies[dep_ref + "-host"]
+                    cp.append_host_package(host_dep)
+        options = ""
+        for _, cp in dependencies.items():
+            # 跳过build包
+            if not cp.is_host:
+                continue
+            for name, value in cp.package_options.items():
+                if value is None:
+                    continue
+                def_val = cp.default_options.get(name)
+                if name == "enable_luajit":
+                    conan_name = "*"
+                else:
+                    conan_name = cp.pkg.split("@")[0]
+                option = ""
+                if isinstance(def_val, bool):
+                    if def_val and "False" == value:
+                        option = f" -o {conan_name}:{name}={value}"
+                    elif not def_val and "True" == value:
+                        option = f" -o {conan_name}:{name}={value}"
+                elif def_val != value:
+                    option = f" -o {conan_name}:{name}={value}"
+                if option not in options:
+                    options += option
+        tasks_cnt = 0
+        while True:
+            for _, dep in dependencies.items():
+                if tasks_cnt >= 4:
+                    break
+                # 如果是构建工具，不参与构建
+                if not dep.is_host:
+                    continue
+                # 如果还有依赖未构建完成，不参与构建
+                if len(dep.host_packages) != 0:
+                    continue
+                # 相同名称的组件正在构建时不启动新的构建
+                if build_tasks.get(dep.name):
+                    continue
+                if dep.builded:
+                    continue
+                if not dep.binary_exist or self.force_build:
+                    # 当依赖的构建工具存在正在构建的组件时不能构建
+                    skip_build = False
+                    for _, build_dep in dep.build_packages.items():
+                        # 正在构建且未构建出制品时
+                        if build_dep.building and not build_dep.builded:
+                            skip_build = True
+                            break
+                    if skip_build:
+                        continue
+                    # 启动构建前将其依赖的构建工具置为正在构建
+                    for _, build_dep in dep.build_packages.items():
+                        build_dep.building = True
+                    tasks_cnt += 1
+                    thread = Thread(target=self.build_task, args=(dep, options,))
+                    thread.start()
+                build_tasks[dep.name] = True
+            if not tasks_cnt:
+                return
+            dep = self.queue.get()
+            if not dep or self.exception:
+                raise self.exception
+            dep.builded = True
+            build_tasks[dep.name] = False
+            tasks_cnt -= 1
+            for _, sub_cp in dependencies.items():
+                if sub_cp.host_packages.get(dep.pkg):
+                    sub_cp.host_packages.pop(dep.pkg)
+            # 构建完成后，组件的构建依赖工具一定构建完成且制品存在
+            for _, build_dep in dep.build_packages.items():
+                build_dep.builded = True

bmcgo/utils/component_post.py

@@ -20,7 +20,6 @@ import importlib
 import sys
 from inspect import getmembers, isfunction
 
-from conans.model.profile import Profile
 from bmcgo.utils.config import Config
 from bmcgo.utils.tools import Tools
 from bmcgo.logger import Logger
@@ -29,9 +28,12 @@ log = Logger("component_post")
 
 
 class ComponentPost():
-    def __init__(self, config: Config, component_path, profile: Profile):
-        sys.path.insert(0, os.path.dirname(component_path))
-        cust_py = importlib.import_module(f"{os.path.basename(component_path)}.include.customization", "customization")
+    def __init__(self, config: Config, component_path, profile):
+        dir_path = os.path.dirname(component_path)
+        if dir_path not in sys.path:
+            sys.path.append(dir_path)
+        cust_py = importlib.import_module(f"{os.path.basename(component_path)}.include.customization",
+                                          "customization")
         self.cust_cls = getattr(cust_py, "Customization")
         self.config = config
         self.component_path = component_path

bmcgo/utils/component_version_check.py

@@ -15,15 +15,16 @@
 功能: 对比manifest.yml生成的组件清单和自动生成的清单是否一致
 注意: 这个文件名为work, 但不继承 Task 类 !!!!!!
 """
-
+import os
 import json
-
+from pathlib import Path
 import yaml
-
 from bmcgo.logger import Logger
 from bmcgo import misc
+from bmcgo.utils.tools import Tools
 
 log = Logger("component_version_check")
+tools = Tools()
 
 
 class ComponentVersionCheck:
@@ -31,18 +32,70 @@ class ComponentVersionCheck:
        conan 目录的 manifest.yml 文件是由单板目录下的 manifest.yml 自动生成的
     """
 
-    def __init__(self, manifest_yml: str, ibmc_lock: str):
+    def __init__(self, manifest_yml: str, ibmc_lock: str, community_name: str, openubmcsdk: str):
         """读取 manifest.yml(conan目录) 文件与 openubmc.lock 文件
 
         Args:
             manifest_yml (str): manifest.yml文件路径
             ibmc_lock (str): openubmc.lock文件路径
         """
-        with open(manifest_yml, "r") as manifest_fp:
+        self.manifest = ""
+        self.manifest_yml = manifest_yml
+        self.ibmc_lock = ibmc_lock
+        self.manifest_dict = {}
+        self.ibmc_lock_dict = {}
+        self.openubmcsdk_comp = openubmcsdk
+        self.openubmcsdk_dict = self.generate_openubmcsdk_dict(self.openubmcsdk_comp)
+        self.community_name = community_name
+
+    @staticmethod
+    def get_cache_path(component):
+        """根据openubmcsdk的包名获取export文件夹路径
+
+        Returns:
+            str: 返回 openubmcsdk 的export路径
+        """
+        if misc.conan_v1():
+            conan_home = Path(os.environ.get("CONAN_HOME", Path.home() / ".conan/data"))
+            openubmcsdk_file = os.path.join(conan_home, component.replace("@", "/"), "export", "requirements.yml")
+        else:
+            conan_home = f"conan cache path {component}"
+            openubmcsdk_file = os.path.join(
+                Tools().run_command(conan_home, capture_output=True).stdout(),
+                "requirements.yml"
+                )
+        return openubmcsdk_file
+
+    def openubmc_folder(self):
+        with open(self.manifest_yml, "r") as manifest_fp:
             self.manifest = yaml.safe_load(manifest_fp)
-        with open(ibmc_lock, "r") as ibmc_lock_fp:
+        with open(self.ibmc_lock, "r") as ibmc_lock_fp:
             self.ibmc_lock = json.load(ibmc_lock_fp)
 
+    def generate_openubmcsdk_dict(self, component) -> dict:
+        """根据 requirement.yml(conan目录) 配置生成 组件名: 组件配置 的字典
+
+        Returns:
+            dict: 返回 组件名: 组件配置 的字典
+        """
+        # component == ""表示manifest.yml未定义"base/sdk"
+        if component == "":
+            return {}
+        openubmcsdk_file = self.get_cache_path(component)
+        if not os.path.isfile(openubmcsdk_file):
+            tools.download_conan_recipes(component, misc.CONAN_REPO)
+            openubmcsdk_file = self.get_cache_path(component)
+        with open(openubmcsdk_file, "r") as openubmcsdk_fp:
+            self.openubmcsdk = yaml.safe_load(openubmcsdk_fp)
+        dependency_list = self.openubmcsdk[misc.CONAN_DEPDENCIES_KEY]
+        openubmc_dict = {x[misc.CONAN].split('/')[0]: x[misc.CONAN].split('@')[0] for x in dependency_list}
+        return openubmc_dict
+    
+    def get_dict(self):
+        self.openubmc_folder()
+        self.manifest_dict = self.generate_manifest_dict()
+        self.ibmc_lock_dict = self.generate_ibmc_lock_dict()
+
     def generate_manifest_dict(self) -> dict:
         """根据 manifest.yml(conan目录) 配置生成 组件名: 组件配置 的字典
 
@@ -59,25 +112,31 @@ class ComponentVersionCheck:
         Returns:
             dict: 返回 组件名: 组件配置 的字典
         """
-        component_list = self.ibmc_lock["graph_lock"]["nodes"]
-        ibmc_lock_dict = {x["ref"].split('/')[0]: x["ref"].split('@')[0]
-                          for x in [component_conf for _, component_conf in component_list.items()]}
-        ibmc_lock_dict.pop("openubmc")
+        if misc.conan_v1():
+            component_list = self.ibmc_lock["graph_lock"]["nodes"]
+            ibmc_lock_dict = {x["ref"].split('/')[0]: x["ref"].split('@')[0]
+                            for x in [component_conf for _, component_conf in component_list.items()]}
+            ibmc_lock_dict.pop("openubmc")
+        else:
+            component_list = self.ibmc_lock["requires"]
+            ibmc_lock_dict = {x.split('/')[0]: x.split('@')[0] for x in component_list}
         return ibmc_lock_dict
 
     def run(self):
         """检查所有组件是否都在 manifest.yml(单板目录下) 中配置了
         """
-        manifest_dict = self.generate_manifest_dict()
-        ibmc_lock_dict = self.generate_ibmc_lock_dict()
         # 这里使用报错退出, 为防止有多个组件未配置, 报错在方法结束后触发
+        self.get_dict()
         report_error = False
-        for key, version in ibmc_lock_dict.items():
-            if key not in manifest_dict.keys():
+        for key, version in self.ibmc_lock_dict.items():
+            if key not in self.manifest_dict.keys() and key not in self.openubmcsdk_dict.keys():
                 log.error(f"{version} 组件没有在manifest中配置!!!!!!")
                 report_error = True
-            elif version != manifest_dict[key]:
-                log.error(f"{version} 组件版本与manifest中配置{manifest_dict[key]}不匹配!!!!!!")
+            elif key in self.openubmcsdk_dict.keys() and version != self.openubmcsdk_dict.get(key, ""):
+                log.error(f"{version} 组件版本与openubmcsdk中配置{self.openubmcsdk_dict[key]}不匹配!!!!!!")
+                report_error = True
+            elif key in self.manifest_dict.keys() and version != self.manifest_dict.get(key, ""):
+                log.error(f"{version} 组件版本与manifest中配置{self.manifest_dict[key]}不匹配!!!!!!")
                 report_error = True
 
         if report_error is True: