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

bmcgo/tasks/task_build_conan.py

@@ -27,10 +27,10 @@ import random
 import pathlib
 from multiprocessing import Process, Queue
 from copy import deepcopy
+from collections import Counter
 
 import yaml
 from colorama import Fore, Back, Style
-from conans.model.profile import Profile
 
 from bmcgo.tasks.task import Task
 from bmcgo.utils.config import Config
@@ -40,6 +40,9 @@ from bmcgo import errors, misc
 from bmcgo.utils.tools import Tools
 from bmcgo.errors import BmcGoException
 from bmcgo.component.component_helper import ComponentHelper
+from bmcgo.utils.build_conans import BuildConans
+from bmcgo.component.deploy import GraphNode
+from bmcgo.tasks.misc import MODULE_SYMVERS, SDK_PATH
 
 IBMC_LOCK_FILE = "openubmc.lock"
 SDK_ROOT = "/opt/hi1711sdk"
@@ -56,14 +59,30 @@ PERSIST_TYPES = {
 PRIMARY_KEYS = "PrimaryKeys"
 tools = Tools()
 
+PERSIST_TYPES = {
+    "TemporaryPer": "TemporaryPer",
+    "TemporaryPerRetain": "TemporaryPer",
+    "ResetPer": "ResetPer",
+    "ResetPerRetain": "ResetPer",
+    "PoweroffPer": "PoweroffPer",
+    "PoweroffPerRetain": "PoweroffPer",
+    "PermanentPer": "PermanentPer"
+}
+
+PRIMARY_KEYS = "PrimaryKeys"
+
+cwd_dir = os.path.dirname(os.path.realpath(__file__))
+
 
 class CopyComponent(Process):
-    def __init__(self, work: Task, comp: str, profile: Profile):
+    def __init__(self, work: Task, comp: str, package_folder: str, profile):
         super().__init__()
         self.work = work
         self.config = self.work.config
         self.comp = comp
+        self.package_folder = package_folder
         self.profile = profile
+        self.graphfile = None
 
     def link_recursive_deal(self, file_name, ownership):
         self.work.run_command(f"chown -h {ownership} {file_name}", sudo=True)
@@ -74,16 +93,16 @@ class CopyComponent(Process):
         self.work.work_name = self.comp
         # 复制组件文件到rootfs中
         # rc.sysinit脚本只允许使用rootfs_user仓库的
-        rc_sysinit_path = os.path.join(self.comp, "etc/rc.d/rc.sysinit")
+        rc_sysinit_path = os.path.join(self.package_folder, "etc/rc.d/rc.sysinit")
         if self.comp != "rootfs_user" and os.path.isfile(rc_sysinit_path):
             shutil.rmtree(rc_sysinit_path, ignore_errors=True)
         # 由于复制时有很多同名路径，cp命令有概率失败，10次复制尝试
         self._copy_files()
 
         # 执行权限控制逻辑
-        per_cfg = os.path.join(self.comp, "permissions.ini")
+        per_cfg = os.path.join(self.package_folder, "permissions.ini")
         if not os.path.isfile(per_cfg):
-            self.work.warning("权限文件 {} 不存在, 所以无法设置组件 {} 的权限".format(per_cfg, self.comp))
+            self.work.warning("权限文件 {} 不存在, 所以无法设置组件 {} 的权限".format(per_cfg, self.package_folder))
             return
         self.work.info("依据配置文件: {}, 修改权限".format(per_cfg))
         # NOTE 这里的配置时间, 偶发复制未完成, 就开始修改权限
@@ -130,7 +149,7 @@ class CopyComponent(Process):
 
     def _copy_files(self):
         # 由于复制时有很多同名路径，cp命令有概率失败，10次复制尝试
-        cmd = "sudo cp -dfr {}/. {}".format(self.comp, self.config.rootfs_path)
+        cmd = "sudo cp -dfr {}/. {}".format(self.package_folder, self.config.rootfs_path)
         for _ in range(0, 10):
             try:
                 # 尝试复制到目标目录，成功则break退出循环
@@ -165,22 +184,33 @@ class ConanLockParse:
         self._process_list = []
 
     def conan_install(self, cmd, com):
-        real_cmd = shlex.split(cmd)
-        pipe = subprocess.Popen(real_cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
-        # 超时时长1800s
-        out, _ = pipe.communicate(timeout=1800)
-        if pipe.returncode != 0:
-            self.work.error(f"================== {com} 构建失败日志起始位置 ==================")
-            self.work.info(out.decode())
-            self.work.error(f"================== {com} 构建失败日志结束位置 ==================")
-            self._queue.put(self.error_str)
-            self._queue.put(self.error_str)
-            self._queue.put(self.error_str)
-            return
-        self._queue.put(com)
-        self._queue.put(com)
-        self._queue.put(com)
-        self.work.info(f"命令 {cmd} " + Fore.GREEN + "执行完成" + Style.RESET_ALL)
+        com_name = com[:com.index("/")]
+        com_install_log = os.path.join(self.work.config.temp_path, f"log/conan_install/{com_name}.log")
+        with os.fdopen(os.open(com_install_log, os.O_RDWR | os.O_CREAT, stat.S_IWUSR | stat.S_IRUSR), "a+") as f:
+            self.work.info(f"命令 {cmd} " + Fore.GREEN + "开始" + Style.RESET_ALL)
+            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()
+                    self.work.error(f"================== {com} 构建超时 ==================")
+                    self._queue.put(self.error_str)
+                    return
+                time.sleep(1)
+            if pipe.returncode != 0:
+                self.work.error(f"================== {com} 构建失败日志起始位置 ==================")
+                f.seek(0)
+                conan_log = f.read()
+                self.work.info(conan_log)
+                self.work.error(f"================== {com} 构建失败日志结束位置 ==================")
+                self._queue.put(self.error_str)
+                return
+            self._queue.put(com)
+            self.work.info(f"命令 {cmd} " + Fore.GREEN + "执行完成" + Style.RESET_ALL)
 
     def wait_task_finished(self):
         # 所有入度为0任务拉起后等待完成消息
@@ -210,6 +240,9 @@ class ConanLockParse:
         self._degree = {x: len(self._bundle[x].get('requires')) if self._bundle[x].get('requires') is not None else 0
                              for x in self._bundle.keys()}
 
+        conan_log_path = os.path.join(self.work.config.temp_path, "log/conan_install")
+        os.makedirs(conan_log_path, exist_ok=True)
+
         self.work.success(">>>>>>>>>>>>>>>>> 开始构建所有组件 <<<<<<<<<<<<<<<<")
         self.work.info("这些进程将要花费几分钟(2-3分钟), 请耐心等待")
         while self._degree:
@@ -226,7 +259,6 @@ class ConanLockParse:
                 t = Process(target=self.conan_install, args=(cmd_tmp, com))
                 t.start()
                 self._process_list.append(t)
-                self.work.info(f"命令 {cmd_tmp} " + Fore.GREEN + "开始" + Style.RESET_ALL)
                 # 入度为0的任务构建拉起后弹出
                 self._degree.pop(com)
             else:
@@ -243,7 +275,12 @@ class TaskClass(Task):
 
     def __init__(self, config: Config, work_name=""):
         super(TaskClass, self).__init__(config, work_name)
+        self.skip_install_comp = False
+        self.only_manifest_yml = False
         self.update_path()
+        self.component_check = ""
+        # 记录每个组件的GraphNode信息
+        self.package_info = os.path.join(self.config.rootfs_path, "package_info")
 
     @property
     def subsys_dir(self):
@@ -261,6 +298,13 @@ class TaskClass(Task):
                 return PERSIST_TYPES[item]
         return None
 
+    @staticmethod
+    def match_persist_type(usage):
+        for item in usage:
+            if item in PERSIST_TYPES:
+                return PERSIST_TYPES[item]
+        return None
+
     def find_conan_package_and_write(self, search, comps, file_handler, stage):
         if search.find("/") < 0:
             search += "/"
@@ -273,18 +317,25 @@ class TaskClass(Task):
                 if stage != misc.StageEnum.STAGE_DEV.value and comp.endswith(f"/{misc.StageEnum.STAGE_DEV.value}"):
                     err_msg = f"组件包 {comp} user/channel 配置错误, 必须以 \"{stage}\" 作为结尾, 终止构建"
                     raise errors.BmcGoException(err_msg)
+                if misc.conan_v2():
+                    comp = comp.lower()
                 self.add_new_dependencies(comp, file_handler)
                 return
+        # 判断组件是否在openubmcsdk中定义
+        if search[:-1] in self.component_check.openubmcsdk_dict.keys():
+            if misc.conan_v2():
+                comp = comp.lower()
+            self.add_new_dependencies(comp, file_handler)
+            return
         raise errors.ConfigException(f"未知组件: {search}, 请检查配置 !!!")
 
     def update_path(self):
         # conan source folder
-        self.conan_source = os.path.join(self.config.temp_path,
-                                         f"conan_source_{self.config.build_type}_{self.config.stage}/openubmc")
+        self.conan_source = os.path.join(self.config.build_path, misc.community_name())
         # conan install folder
         self.conan_install = os.path.join(self.config.build_path, "conan_install")
         # openubmc install folder
-        self.openubmc_ins_dir = os.path.join(self.conan_install, "openubmc")
+        self.openubmc_ins_dir = os.path.join(self.conan_install, misc.community_name())
         # openubmc top rootfs folder
         self.top_rootfs_dir = os.path.join(self.conan_install, "rootfs")
         self.board_option = ""
@@ -320,6 +371,18 @@ class TaskClass(Task):
         else:
             self.skip_package = False
 
+    def set_skip_install_comp(self, value):
+        if value:
+            self.skip_install_comp = True
+        else:
+            self.skip_install_comp = False
+
+    def set_only_manifest_yml(self, value):
+        if value:
+            self.only_manifest_yml = True
+        else:
+            self.only_manifest_yml = False
+
     def package_dependencies_parse(self, default_component: list):
         """解析manufacture或者tosupporte配置，不同的包设置不同组件的不同编译选项
         参数:
@@ -346,6 +409,68 @@ class TaskClass(Task):
         self.success(f"获取到依赖: {conan}")
         self.depdencies.append(conan)
 
+    def merge_manifest_v2(self):
+        comps = []
+        for f in os.listdir(self.subsys_dir):
+            with open(os.path.join(self.subsys_dir, f)) as fp:
+                yml = yaml.safe_load(fp)
+            deps = yml.get('dependencies')
+            for dep in deps:
+                conan = dep.get(misc.CONAN)
+                if conan:
+                    comps.append(conan)
+        self.debug("依赖列表: {}".format(comps))
+        # 重建新的依赖关系
+        # 从单板目录manifest.yml，与subsys/<stage>目录下的组件合并
+        new_fd = os.fdopen(os.open("manifest.yml", os.O_WRONLY | os.O_CREAT,
+                            stat.S_IWUSR | stat.S_IRUSR), 'w')
+        new_fd.write("base:\n")
+        ver = self.get_manufacture_config("base/version")
+
+        new_fd.write(f"  version: \"{ver}\"\n")
+        self.info(f"包版本号: {ver}")
+
+        new_fd.write("dependencies:\n")
+        deps = self._get_dependencies_pkg()
+
+        # 如果是打包，依赖信息调整
+        deps = self.package_dependencies_parse(deps)
+        # 由于manifest.yml当中有对于此的新的配置，此处将配置读出，并重新分配
+        skynet_with_enable_luajit = False
+        # 获取manifest.yml中"base/sdk"字段值
+        openubmcsdk = self.get_manufacture_config("base/sdk", "")
+        if openubmcsdk:
+            self.add_new_dependencies(openubmcsdk, new_fd)
+        self.component_check = ComponentVersionCheck(
+            manifest_yml="manifest.yml",
+            ibmc_lock=IBMC_LOCK_FILE,
+            community_name="openubmc",
+            openubmcsdk=openubmcsdk
+            )
+        for dep in deps:
+            conan = dep.get(misc.CONAN)
+            if not conan:
+                continue
+            if conan.find("@") > 0:
+                self.add_new_dependencies(conan.lower(), new_fd)
+            else:
+                self.find_conan_package_and_write(conan, comps, new_fd, self.config.stage)
+            options = dep.get("options", {})
+            name = conan.split("/")[0]
+            for key, val in options.items():
+                # skynet特殊处理：manifest.yml指定enable_luajit特性时需要覆盖用户输入
+                if name == "skynet" and key == "enable_luajit":
+                    self.warning(f"根据manifest.yml配置，当前产品的enable_luajit配置为{val}，忽略命令行指定的-jit参数")
+                    skynet_with_enable_luajit = True
+                    self.config.set_enable_luajit(val)
+                    self.board_option = self.board_option + " -o */*:{}={}".format(key, val)
+                else:
+                    self.board_option = self.board_option + " -o {}/*:{}={}".format(name, key, val)
+        # 当使能Luajit又未向skynet传递enable_luajit配置项时需要添加使能参数
+        if not skynet_with_enable_luajit and self.config.enable_luajit:
+            self.board_option += f" -o */*:enable_luajit={self.config.enable_luajit}"
+        new_fd.close()
+
     def merge_manifest(self):
         comps = []
         for f in os.listdir(self.subsys_dir):
@@ -364,7 +489,7 @@ class TaskClass(Task):
         new_fd.write("base:\n")
         ver = self.get_manufacture_config("base/version")
 
-        new_fd.write(f"  version: \"{ver}@{tools.conan_user}/{misc.StageEnum.STAGE_RC.value}\"\n")
+        new_fd.write(f"  version: \"{ver}@{misc.conan_user()}/{misc.StageEnum.STAGE_RC.value}\"\n")
         self.info(f"包版本号: {ver}")
 
         new_fd.write("dependencies:\n")
@@ -374,6 +499,16 @@ class TaskClass(Task):
         deps = self.package_dependencies_parse(deps)
         # 由于manifest.yml当中有对于此的新的配置，此处将配置读出，并重新分配
         skynet_with_enable_luajit = False
+        # 获取manifest.yml中定义"base/sdk"字段值
+        openubmcsdk = self.get_manufacture_config("base/sdk", "")
+        if openubmcsdk:
+            self.add_new_dependencies(openubmcsdk, new_fd)
+        self.component_check = ComponentVersionCheck(
+            manifest_yml="manifest.yml",
+            ibmc_lock=IBMC_LOCK_FILE,
+            community_name="openubmc",
+            openubmcsdk=openubmcsdk
+            )
         for dep in deps:
             conan = dep.get(misc.CONAN)
             if not conan:
@@ -384,7 +519,7 @@ class TaskClass(Task):
                 stage = self.config.stage
                 if stage != misc.StageEnum.STAGE_STABLE.value:
                     stage = misc.StageEnum.STAGE_RC.value
-                conan += f"@{tools.conan_user}/{stage}"
+                conan += f"@{misc.conan_user()}/{stage}"
                 self.add_new_dependencies(conan, new_fd)
             else:
                 self.find_conan_package_and_write(conan, comps, new_fd, self.config.stage)
@@ -400,17 +535,26 @@ class TaskClass(Task):
         # 当使能Luajit又未向skynet传递enable_luajit配置项时需要添加使能参数
         if not skynet_with_enable_luajit and self.config.enable_luajit:
             self.board_option += f" -o skynet:enable_luajit={self.config.enable_luajit}"
-        self.merge_0502_default_options()
         sha256 = Tools.sha256sum(SDK_ROOT_MODULE_SYMVERS)
         self.board_option += " -o *:module_symvers={}".format(sha256)
         new_fd.close()
 
+    def merge_dep_options(self):
+        self.merge_0502_default_options()
+
     def merge_0502_default_options(self):
+        if misc.conan_v1():
+            prefix = "*"
+        else:
+            prefix = "*/*"
         if self.config.manufacture_code:
             default_options_path = f"manufacture/{self.config.manufacture_code}/default_options"
             default_options = self.get_manufacture_config(default_options_path, {})
             for key, val in default_options.items():
-                self.board_option += f" -o *:{key}={val}"
+                self.board_option += f" -o {prefix}:{key}={val}"
+        module_symvers_path = os.path.join(SDK_PATH, MODULE_SYMVERS)
+        option, value = self.tools.get_hi171x_module_symver_option(module_symvers_path)
+        self.board_option += f" -o {prefix}:{option}={value}"
 
     def package_info_gen(self, bundle_file, dst_file):
         with open(bundle_file, "r") as fp:
@@ -419,8 +563,8 @@ class TaskClass(Task):
         list.sort(require_list)
         package_info_list = deepcopy(require_list)
         self.run_command(f"rm -rf {dst_file}", sudo=True)
-        temp_dst_file = f"{self.config.rootfs_path}/{os.path.basename(dst_file)}"
-        with os.fdopen(os.open(temp_dst_file, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, stat.S_IWUSR | stat.S_IRUSR |
+        self.package_info = f"{self.config.rootfs_path}/{os.path.basename(dst_file)}"
+        with os.fdopen(os.open(self.package_info, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, stat.S_IWUSR | stat.S_IRUSR |
                                stat.S_IWGRP | stat.S_IRGRP | stat.S_IWOTH | stat.S_IROTH), 'w') as fp:
             for package in require_list:
                 if "openubmc/" not in package:
@@ -428,8 +572,7 @@ class TaskClass(Task):
                 else:
                     package_info_list.remove(package)
             fp.close()
-        self.run_command(f"cp -df {temp_dst_file} {dst_file}", sudo=True)
-        self.run_command(f"rm -rf {temp_dst_file}", sudo=True)
+        self.run_command(f"cp -df {self.package_info} {dst_file}", sudo=True)
 
     def sensitive_data_conf_gen(self, comps, dst_file):
         self.run_command(f"rm -rf {dst_file}", sudo=True)
@@ -500,6 +643,78 @@ class TaskClass(Task):
             options += " -o *:gcov=True"
         return options
 
+    def proc_sensitive_v2(self, table_type, props, table_name, output):
+        for prop_name, prop_data in props.items():
+            if prop_data.get("primaryKey"):
+                output[PRIMARY_KEYS][table_name] = output[PRIMARY_KEYS].get(table_name, {})
+                output[PRIMARY_KEYS][table_name][prop_name] = prop_data.get("sensitive", False)
+                continue
+            per_type = self.match_persist_type(prop_data.get("usage", [])) or table_type
+            if not per_type:
+                continue
+            output[per_type][table_name] = output[per_type].get(table_name, {})
+            output[per_type][table_name][prop_name] = prop_data.get("sensitive", False)
+        return output
+
+    def proc_comp_v2(self, package_folder, output):
+        model_file = os.path.join(package_folder, "include", "mds", "model.json")
+        if not os.path.isfile(model_file):
+            return output
+        with open(model_file, "r") as fp:
+            content = json.load(fp)
+        for class_data in content.values():
+            table_type = PERSIST_TYPES.get(class_data.get("tableType", ""))
+            table_name = class_data.get("tableName", "")
+            if not table_name or class_data.get("tableLocation") == "Local":
+                continue
+            class_props = [class_data.get("properties", {})]
+            for intf_data in class_data.get("interfaces", {}).values():
+                class_props.append(intf_data.get("properties", {}))
+            for props in class_props:
+                output = self.proc_sensitive_v2(table_type, props, table_name, output)
+        return output
+
+    def calc_options_v2(self):
+        if self.config.build_type == "debug":
+            options = "-s build_type=Debug"
+        else:
+            options = "-s build_type=Release"
+
+        if self.config.enable_arm_gcov:
+            options += " -o */*:gcov=True"
+        return options
+
+    def install_openubmc_v2(self):
+        profile_file = os.path.join(self.tools.conan_profiles_dir, self.config.profile)
+        if not os.path.isfile(profile_file):
+            raise BmcGoException(f"{profile_file} 文件不存在")
+
+        options = self.calc_options_v2()
+        append_cmd = f"-r {self.config.remote}" if self.config.remote else ""
+        # 依据选项生成openubmc.lock和openubmc.bundle文件
+        base_cmd = f"-pr={self.config.profile} "
+        base_cmd += f"-pr:b profile.dt.ini {append_cmd} {options} {self.board_option}"
+        lockfile = os.path.join(self.config.build_path, "conan.lock")
+        graphfile = os.path.join(self.config.build_path, "graph.info")
+        lock_cmd = f"conan lock create . {base_cmd} --lockfile-out={lockfile}"
+        self.run_command(lock_cmd, capture_output=False)
+        graph_cmd = f"conan graph info . {base_cmd} -f json --lockfile={lockfile} --out-file={graphfile}"
+        self.run_command(graph_cmd)
+        self.success(f"start build dependency packages of {self.config.board_name}")
+        bcp = BuildConans(graphfile, lockfile, base_cmd, self.config.from_source, self.config.log_path)
+        bcp.build()
+
+        cmd = f"conan create . {base_cmd} --build=missing"
+        self.info(f"start build {self.config.board_name}: {cmd}")
+        self.run_command(cmd, capture_output=False)
+
+        self.graphfile = graphfile
+
+        shutil.copyfile(lockfile, f"{self.conan_install}/conan.lock")
+        # 检查使用到的组件是否都在单板目录 manifest.yml 中配置了
+        self.component_check.run()
+        self.clean_luac_out()
+
     def install_ibmc(self):
         profile_file = os.path.join(self.tools.conan_profiles_dir, self.config.profile)
         if not os.path.isfile(profile_file):
@@ -539,21 +754,29 @@ class TaskClass(Task):
             self.run_command(install_cmd, command_echo=True)
         shutil.copyfile(IBMC_LOCK_FILE, f"{self.conan_install}/conan.lock")
         # 检查使用到的组件是否都在单板目录 manifest.yml 中配置了
-        component_check = ComponentVersionCheck(manifest_yml="manifest.yml", ibmc_lock=IBMC_LOCK_FILE)
-        component_check.run()
+        self.component_check.run()
         self.clean_luac_out()
 
     def deploy(self):
-        src = os.path.join(self.config.code_path, "conan_index/openubmc")
-        shutil.copytree(src, self.conan_source, dirs_exist_ok=True)
+        conanfile_dir = os.path.join(cwd_dir, "conan")
         openubmc_dir = os.path.join(self.conan_source, "all")
+        os.makedirs(openubmc_dir, exist_ok=True)
+        shutil.copytree(conanfile_dir, openubmc_dir, dirs_exist_ok=True)
         self.chdir(openubmc_dir)
         # 复制manifest.yml文件
-        self.merge_manifest()
+        if misc.conan_v2():
+            self.merge_manifest_v2()
+        else:
+            self.merge_manifest()
+        if self.only_manifest_yml:
+            return
+        if not self.skip_install_comp:
+            self.merge_dep_options()
         # 下载组件构建脚本
         ComponentHelper.download_recipes(self.depdencies, self.tools, self.config.remote_list)
         # 下载skynet
-        self.install_luac_or_luajit()
+        if misc.conan_v1():
+            self.install_luac_or_luajit()
 
         # 复制全局定制rootfs到conan install目录
         top_rootfs = os.path.join(self.config.code_path, "rootfs")
@@ -578,7 +801,10 @@ class TaskClass(Task):
         if os.path.isfile(per_file):
             shutil.copy(per_file, self.openubmc_ins_dir)
 
-        self.install_ibmc()
+        if misc.conan_v2():
+            self.install_openubmc_v2()
+        else:
+            self.install_ibmc()
 
     def clean_luac_out(self):
         # 清理冗余文件luac.out
@@ -600,15 +826,15 @@ class TaskClass(Task):
         self.run_command(f'cp -f conan.lock {os.path.join(inner_path, f"package_{self.config.board_name}.lock")}')
         self.run_command(f'cp -f conan.lock {os.path.join(self.config.output_path, f"package.lock")}')
 
-    def copy_components(self, comps: list, profile: Profile):
+    def copy_components(self, comps: list, profile):
         # 优先处理rootfs
-        p = CopyComponent(self, "rootfs", profile)
+        p = CopyComponent(self, "rootfs", os.path.join(self.conan_install, "rootfs"), profile)
         p.run()
         # 打印组件清单
         self.info(f"组件列表: {comps}")
         pools = []
         for comp in comps:
-            p = CopyComponent(self, comp, profile)
+            p = CopyComponent(self, comp, os.path.join(self.conan_install, comp), profile)
             p.start()
             pools.append(p)
 
@@ -621,11 +847,161 @@ class TaskClass(Task):
                     raise errors.BmcGoException(f"复制组件 ({p.comp}) 失败, 退出码: {p.exitcode}")
                 pools.remove(p)
         # 最后处理openubmc
-        p = CopyComponent(self, "openubmc", profile)
+        p = CopyComponent(self, misc.community_name(), os.path.join(self.conan_install, misc.community_name()), profile)
+        p.run()
+
+    def package_info_gen_v2(self, bmc_lock, dst_file):
+        with open(bmc_lock, "r") as bmc_lock_fp:
+            lock_info = json.load(bmc_lock_fp)
+        require_list = lock_info.get("requires")
+        self.run_command(f"rm -rf {dst_file}", sudo=True)
+        self.package_info = f"{self.config.rootfs_path}/{os.path.basename(dst_file)}"
+        with os.fdopen(os.open(self.package_info, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, stat.S_IWUSR | stat.S_IRUSR |
+                               stat.S_IWGRP | stat.S_IRGRP | stat.S_IWOTH | stat.S_IROTH), 'w') as fp:
+            for package in require_list:
+                fp.write(f"{package}\n")
+            fp.close()
+        self.run_command(f"cp -df {self.package_info} {dst_file}", sudo=True)
+
+    def sensitive_data_conf_gen_v2(self, dst_file):
+        self.run_command(f"rm -rf {dst_file}", sudo=True)
+        temp_dst_file = f"{self.config.rootfs_path}/{os.path.basename(dst_file)}"
+        output = {
+            "TemporaryPer": {},
+            "ResetPer": {},
+            "PoweroffPer": {},
+            "PermanentPer": {},
+            "PrimaryKeys": {}
+        }
+        for name, node in self.graph_nodes.items():
+            try:
+                output = self.proc_comp_v2(node.package_folder, output)
+            except Exception as e:
+                raise errors.BmcGoException(f"分析组件 {name} 的 model.json 失败, 失败信息:{e}")
+
+        with os.fdopen(os.open(temp_dst_file, os.O_WRONLY | os.O_CREAT | os.O_TRUNC,
+                               stat.S_IWUSR | stat.S_IRUSR), 'w') as fp:
+            json.dump(output, fp, sort_keys=True)
+        self.run_command(f"mkdir -p {os.path.dirname(dst_file)}", sudo=True)
+        self.run_command(f"cp -df {temp_dst_file} {dst_file}", sudo=True)
+        self.run_command(f"rm -rf {temp_dst_file}", sudo=True)
+
+    def get_all_subdirectories(self, dirpath):
+        exclude_files = ["permissions.ini", "conaninfo.txt", "conanmanifest.txt"]
+        out = []
+        for root, _, files in os.walk(dirpath):
+            for file in files:
+                file = os.path.join(root, file)
+                relative_path = os.path.relpath(file, dirpath)
+                if not relative_path.startswith("include") and relative_path not in exclude_files:
+                    out.append(relative_path)
+        return out
+
+    def print_dup_files(self, comps, paths):
+        dup_paths = {}
+        for comp, files in comps.items():
+            for path in paths:
+                if path in files:
+                    dup_paths.setdefault(path, []).append(comp)
+
+        for path, comp in dup_paths.items():
+            self.error(f"{comp} 存在重复文件 {path}")
+
+    def copy_components_v2(self, profile):
+        # 优先处理rootfs
+        p = CopyComponent(self, "rootfs", os.path.join(self.conan_install, "rootfs"), profile)
+        p.run()
+        # 打印组件清单
+        self.info(f"组件列表: {self.graph_nodes.keys()}")
+        pools = []
+        # 记录全部的文件信息
+        all_path = []
+        # 记录组件有哪些文件
+        comp_path = {}
+        for name, node in self.graph_nodes.items():
+            if name in ["rootfs", misc.community_name()]:
+                continue
+            file_paths = self.get_all_subdirectories(node.package_folder)
+            all_path.extend(file_paths)
+            comp_path[name] = file_paths
+            p = CopyComponent(self, node.name, node.package_folder, profile)
+            p.start()
+            pools.append(p)
+
+        while pools:
+            time.sleep(0.01)
+            for p in pools:
+                if p.is_alive():
+                    continue
+                if p.exitcode is not None and p.exitcode != 0:
+                    raise errors.BmcGoException(f"复制组件 ({p.name}) 失败, 退出码: {p.exitcode}")
+                pools.remove(p)
+        counter = Counter(all_path)
+        duplicates = {path for path, count in counter.items() if count > 1}
+        if len(duplicates):
+            self.print_dup_files(comp_path, duplicates)
+            raise errors.BmcGoException("请检查组件的打包逻辑，检测到重复文件： " + ".".join(duplicates))
+        # 最后处理openubmc
+        p = CopyComponent(self, misc.community_name(), os.path.join(self.conan_install, misc.community_name()), profile)
         p.run()
+        self.run_command(f"sudo rm -f {self.config.rootfs_path}/conaninfo.txt")
+        self.run_command(f"sudo rm -f {self.config.rootfs_path}/conanmanifest.txt")
+
+    def update_graph_nodes(self):
+        rootfs = GraphNode(None)
+        rootfs.name = "rootfs"
+        rootfs.package_folder = os.path.join(self.conan_install, "rootfs")
+        self.graph_nodes["rootfs"] = rootfs
+
+        with open(self.graphfile, "r") as fp:
+            graph = json.load(fp)
+        nodes = graph.get("graph", {}).get("nodes", {})
+        for _, info in nodes.items():
+            node = GraphNode(info)
+            context = info.get("context")
+            if context != "host":
+                continue
+            cmd = f"conan cache path {node.ref}:{node.package_id}"
+            node.package_folder = tools.run_command(cmd, capture_output=True).stdout.strip()
+            self.graph_nodes[node.name] = node
+
+        rootfs = GraphNode(None)
+        rootfs.name = misc.community_name()
+        rootfs.package_folder = os.path.join(self.conan_install, misc.community_name())
+        self.graph_nodes[misc.community_name()] = rootfs
+
+    def make_customization_symlinks(self):
+        if os.path.isdir(self.customization_dir):
+            self.run_command(f"rm -rf {self.customization_dir}")
+        self.run_command(f"mkdir -p {self.customization_dir}")
+        for name, node in self.graph_nodes.items():
+            cust = os.path.join(node.package_folder, "include", "customization.py")
+            if not os.path.isfile(cust):
+                continue
+            os.symlink(node.package_folder, os.path.join(self.customization_dir, name))
+
+    def package_v2(self):
+        self.update_graph_nodes()
+        self.make_customization_symlinks()
+        self.run_command(f"sudo rm -rf {self.config.rootfs_path}")
+        os.makedirs(self.config.rootfs_path)
+        profile, _ = self.get_profile_config()
+        self.copy_components_v2(profile)
+
+        self.chdir(self.config.rootfs_path)
+        self._component_cust_action("post_image")
+
+        self.chdir(self.config.rootfs_path)
+        self.package_info_gen_v2(f"{self.conan_install}/conan.lock", "etc/package_info")
+        self.sensitive_data_conf_gen_v2("opt/bmc/trust/sensitive_data.json")
+        if os.path.isfile("permissions.ini"):
+            os.unlink("permissions.ini")
 
     def package(self):
         self.chdir(self.conan_install)
+        if misc.conan_v2():
+            self.package_v2()
+            return
         self.run_command(f"sudo rm -rf {self.config.rootfs_path}")
         os.makedirs(self.config.rootfs_path)
         profile, _ = self.get_profile_config()
@@ -638,14 +1014,8 @@ class TaskClass(Task):
         
         self.copy_components(comps, profile)
 
-        # 运行组件定制化文件
-        for comp in comps:
-            cust = os.path.join(self.conan_install, comp, "include", "customization.py")
-            if not os.path.isfile(cust):
-                continue
-            self.info(f"开始执行 {comp}/include/customization.py")
-            post = ComponentPost(self.config, os.path.join(self.conan_install, comp), profile)
-            post.post_work(self.config.rootfs_path, "post_image")
+        self.chdir(self.config.rootfs_path)
+        self._component_cust_action("post_image")
 
         self.chdir(self.config.rootfs_path)
         self.package_info_gen(f"{self.conan_source}/all/openubmc.bundle", "etc/package_info")
@@ -721,6 +1091,8 @@ class TaskClass(Task):
         self.mkdir_work_path()
         self.tools.clean_locks()
         self.deploy()
+        if self.only_manifest_yml:
+            return
         self.package_lock()
         if not self.skip_package:
             self.package()