openubmc-bingo 0.5.240__py3-none-any.whl

bmcgo/tasks/task_prepare.py

@@ -0,0 +1,105 @@
+#!/usr/bin/env python
+# 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.
+
+"""
+文件名：envir_prepare.py
+功能：打包目录形成
+版权信息：华为技术有限公司，版本所有(C) 2020-2021
+"""
+import os
+import json
+import shutil
+import jsonschema
+import yaml
+from bmcgo.tasks.task import Task
+from bmcgo import misc
+from bmcgo import errors
+
+
+class TaskClass(Task):
+    # 构建AdaptiveLM依赖xmllint
+    def check_xmllint(self):
+        ret = self.run_command("xmllint --version", ignore_error=True)
+        if ret.returncode != 0:
+            self.run_command("apt install -y libxml2-utils", sudo=True)
+        ret = self.run_command("ls /usr/bin/tclsh", ignore_error=True)
+        if ret.returncode != 0:
+            self.run_command("apt install -y tclsh", sudo=True)
+        ret = self.run_command("ls /usr/bin/w3m", ignore_error=True)
+        if ret.returncode != 0:
+            self.run_command("apt install -y w3m", sudo=True)
+
+    def build_config_check(self):
+        # 不支持生产装备出包
+        if self.config.manufacture_code is None:
+            key = f"tosupporte/{self.config.tosupporte_code}"
+            supporte_cfg = self.get_manufacture_config(key)
+            if supporte_cfg is None:
+                raise errors.ConfigException(f"参数 -sc 错误, 配置 (manifest.yml: {key}) 错误 !!!!")
+            key += "/package_name"
+            package_name = self.get_manufacture_config(key)
+            if package_name is None:
+                raise errors.ConfigException(f"获取包名错误, 配置 (manifest.yml: {key}) 错误 !!!!")
+            return
+        manufacture = self.get_manufacture_config("manufacture")
+        if manufacture is None:
+            raise errors.ConfigException("manufacture 编码(-z 编码) 无法被设置")
+
+        codes = list(manufacture.keys())
+        if self.config.manufacture_code not in codes:
+            raise errors.ConfigException("manifest.yml 中 manufacture 错误, 可以被设置为: {}".format(codes))
+
+        pkg_name_key = f"manufacture/{self.config.manufacture_code}/package_name"
+        package_name = self.get_manufacture_config(pkg_name_key)
+        if package_name is None:
+            raise errors.ConfigException("manifest.yml 中 package_name 属性丢失, manufacture: {}".format(package_name))
+
+    def run_signature_prepare(self):
+        self.chdir(self.config.board_path)
+        if self.config.sign_certificates is None:
+            # 复制签名需要使用的文件
+            files = self.get_manufacture_config(f"base/signature/files")
+            if files is None:
+                raise errors.ConfigException("获取manifest.yml中base/signature/files失败, 请检查相关配置或生成是否正确")
+            self.copy_manifest_files(files)
+
+    def schema_subsys_valid(self, stage):
+        for subsys_file in os.listdir(os.path.join(self.config.code_path, "subsys", stage)):
+            file = os.path.join(self.config.code_path, "subsys", stage, subsys_file)
+            self.debug("开始校验 %s", file)
+            if not os.path.isfile(file):
+                continue
+            schema_file = misc.get_decleared_schema_file(file)
+            if schema_file == "":
+                raise errors.BmcGoException(f"schema校验文件{schema_file}未找到，本机绝对路径存储的schema文件且保证文件已存在")
+            with open(schema_file, "rb") as fp:
+                schema = json.load(fp)
+            fp = open(file, "rb")
+            subsys = yaml.safe_load(fp)
+            fp.close()
+            self.debug("开始校验 %s", file)
+            jsonschema.validate(subsys, schema)
+
+    def schema_valid(self):
+        if self.config.target != "publish":
+            return
+        self.schema_subsys_valid("rc")
+        self.schema_subsys_valid("stable")
+
+    def run(self):
+        self.built_type_check()
+        self.prepare_conan()
+        self.check_xmllint()
+        self.build_config_check()
+        self.run_signature_prepare()
+        self.schema_valid()
+        self.config.dump_manifest()

bmcgo/tasks/task_sign_and_pack_hpm.py

@@ -0,0 +1,42 @@
+#!/usr/bin/env python
+# 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
+from bmcgo.tasks.task import Task
+
+
+class TaskClass(Task):
+    def sign_hpms(self):
+        self.chdir(self.config.work_out)
+        if self.config.sign_certificates is not None:
+            self.chdir(self.config.work_out)
+            # 复制预置的ca, crl作为签名文件，并复制cms
+            self.signature(f"rootfs_{self.config.board_name}.filelist",
+                           f"rootfs_{self.config.board_name}.filelist.cms",
+                           "cms.crl", "rootca.der")
+        else:
+            self.run_command(f"touch {self.config.work_out}/rootfs_{self.config.board_name}.filelist.cms")
+            self.run_command(f"cp {self.config.board_path}/cms.crl {self.config.work_out}/cms.crl")
+            self.chdir(self.config.work_out)
+        
+        # 生成的文件为rootfs_{board_name}.hpm.signed
+        self.info(f"给 hpm 包 rootfs_{self.config.board_name}.hpm 签名")
+        self.run_command(f"cms_sign_hpm.sh 2 rootfs_{self.config.board_name}.hpm")
+        if self.config.enable_arm_gcov:
+            self.link(f"rootfs_{self.config.board_name}.hpm.signed", os.path.join(
+                self.config.inner_path, f"{self.config.board_name}_gcov.hpm"))
+        else:
+            self.link(f"rootfs_{self.config.board_name}.hpm.signed", os.path.join(
+                self.config.output_path, f"rootfs_{self.config.board_name}.hpm"))
+
+    def run(self):
+        self.sign_hpms()

bmcgo/utils/__init__.py

@@ -0,0 +1,10 @@
+# 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.

bmcgo/utils/buffer.py

@@ -0,0 +1,128 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Copyright © Huawei Technologies Co., Ltd. 2025. All rights reserved.
+
+MAX_BUFFER_LENGTH = 4 * 1024 * 1024 * 1024
+
+
+class BufferOverflowException(Exception):
+    def __init__(self, message="The data to be input to buffer is out of range."):
+        super().__init__(message)
+
+    def get_class_name(self):
+        return "BufferOverflowException"
+
+
+class Buffer:
+    def __init__(self, buf_len: int, little_endian: bool = True):
+        if buf_len > MAX_BUFFER_LENGTH:
+            self.buf = bytearray(MAX_BUFFER_LENGTH)
+        elif buf_len > 0:
+            self.buf = bytearray(buf_len)
+        else:
+            raise ValueError(f"Invalid buffer length: buf_len={buf_len}")
+        self.size = len(self.buf)
+        self.pos = 0
+        self.marker = -1
+        self.bo = little_endian
+
+    def capacity(self):
+        # 字节缓冲区容量
+        return self.size
+
+    def position(self):
+        # 此缓冲区当前输入位置
+        return self.pos
+
+    def set_position(self, new_pos: int):
+        # 设置此缓冲区输入位置
+        if new_pos > self.size or new_pos < 0:
+            raise ValueError("Position out of range")
+        self.pos = new_pos
+
+    def put(self, b: bytearray):
+        # 将字节数组写入当前位置的缓冲区并递增位置
+        if len(b) > self.size - self.pos:
+            raise BufferOverflowException()
+        if self.bo:
+            self.buf[self.pos:self.pos + len(b)] = b
+        else:
+            self.buf[self.pos:self.pos + len(b)] = b[::-1]
+        self.pos += len(b)
+
+    def put_uint8(self, v: int):
+        # 按当前字节顺序将1字节无符号整数写入此缓冲区，位置递增1
+        if self.size - self.pos < 1:
+            raise BufferOverflowException()
+        self.buf[self.pos] = v
+        self.pos += 1
+
+    def put_uint16(self, v: int):
+        # 按当前字节顺序将一个2字节无符号整数写入此缓冲区，位置递增2
+        if self.size - self.pos < 2:
+            raise BufferOverflowException()
+        n = v
+        start = self.pos
+        for i in range(2):
+            if self.bo:
+                self.buf[self.pos] = n & 0xFF
+            else:
+                self.buf[start + 1 - i] = n & 0xFF
+            n >>= 8
+            self.pos += 1
+
+    def put_uint32(self, v: int):
+        #按当前字节顺序将一个4字节无符号整数写入此缓冲区，位置递增4
+        if self.size - self.pos < 4:
+            raise BufferOverflowException()
+        n = v
+        start = self.pos
+        for i in range(4):
+            if self.bo:
+                self.buf[self.pos] = n & 0xFF
+            else:
+                self.buf[start + 3 - i] = n & 0xFF
+            n >>= 8
+            self.pos += 1
+
+    def put_uint64(self, v: int):
+        # 按当前字节顺序将一个8字节无符号整数写入此缓冲区，位置递增8
+        if self.size - self.pos < 8:
+            raise BufferOverflowException()
+        n = v
+        if self.bo:
+            self.put_uint32(n & 0xFFFFFFFF)
+            self.put_uint32(n >> 32) 
+        else:
+            start = self.pos
+            for i in range(8):
+                self.buf[start + 7 - i] = n & 0xFF
+                n >>= 8
+                self.pos += 1
+
+    def mark(self):
+        # 将此缓冲区的标记设置在其位置
+        self.marker = self.pos
+        return self
+
+    def reset(self):
+        # 将此缓冲区的位置重置为先前标记的位置
+        if self.marker < 0:
+            raise BufferOverflowException("The marker of buffer is invalid.")
+        self.pos = self.marker
+        return self
+    
+    def clean(self):
+        # 重置此缓冲区位置及标志位
+        self.pos = 0
+        self.marker = -1
+        return self
+
+    def array(self):
+        # 返回缓冲区的字节数组
+        return self.buf 
+
+
+def round_up_data_size(data_size: int) -> int:
+    # 对齐数据字节量为8的倍数
+    return ((data_size + 7) // 8) * 8

bmcgo/utils/combine_json_schemas.py

@@ -0,0 +1,170 @@
+#!/usr/bin/env python
+# -*- 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 json
+import stat
+from collections import OrderedDict
+from bmcgo.tasks.task import Task
+from bmcgo.logger import Logger
+
+log = Logger("combine_json_schemas")
+
+
+class CombineJsonSchemas(Task):
+    '''
+    用途: 支持产品定制差异化json schema文件, 用于产品扩展装备定制化的默认值和属性
+    说明:
+        1、该脚本在构建阶段整合组件原始schema和产品差异化schema文件, 同时生成装备定制化默认配置default_settings.json
+        2、json schema文件来自装备定制化定义的schema文件(复用配置导入导出schema文件)
+        3、该脚本属于装备定制化处理产品差异的通用机制, 虽然与产品有关, 但是脚本本身不处理产品差异(由一级流水线完成产品差异处理)
+    '''
+    def __init__(self, config, schema_path, work_name=""):
+        super(CombineJsonSchemas, self).__init__(config, work_name)
+        self.schema_path = schema_path
+        self.custom_path_name = "custom"
+        self.default_settings = "default_settings.json"
+        self.config = config
+        self.schema_tmp = os.path.join(config.build_path, "profile_schema")
+
+    def handle_type_change(self, dict1, dict2):
+        # 键值相同，但是类型由object变化为array
+        if "type" in dict1 and dict1["type"] == "object" and dict2["type"] == "array":
+            dict1.pop("properties")
+        # 键值相同，但是类型由array变化为object
+        if "type" in dict1 and dict1["type"] == "array" and dict2["type"] == "object":
+            dict1.pop("items")
+
+    # 将dict2合并到dict1
+    def merge_dicts(self, dict1, dict2):
+        for key, value in dict2.items():
+            if key in dict1 and isinstance(dict1[key], dict) and isinstance(value, dict):
+                # 处理键值相同，但是类型发生变化的情况
+                self.handle_type_change(dict1[key], value)
+                self.merge_dicts(dict1[key], value)
+            else:
+                dict1[key] = value
+
+    def has_key(self, dict_ins, key_str):
+        if not dict_ins:
+            return False
+
+        if not isinstance(dict_ins, dict):
+            return False
+
+        return key_str in dict_ins.keys()
+
+    # 递归解析schema内部结构
+    def rec_parse(self, data):
+        if data['type'] == 'array':    # 定制数据是明确的条目，配置不存在于数组中
+            return {}
+
+        if data['type'] == 'object':
+            sub_objs = data['properties']
+            ret_data = OrderedDict()
+            for key in sub_objs:
+                tmp = self.rec_parse(sub_objs[key])
+                if tmp != {}:
+                    ret_data[key] = tmp
+
+            return ret_data
+
+        if self.has_key(data, 'CustomDefault'):
+            return {'AttributeType':'ImportAndExport', 'Import': True, 'Value': data['CustomDefault']}
+
+        return {}
+
+    def load_schema(self, path, product_schema_path, com_obj):
+        # 临时的产品schema路径下无需求处理
+        if product_schema_path == os.path.dirname(path):
+            return
+        with open(path, 'r') as handle:
+            data = json.load(handle, object_pairs_hook=OrderedDict)
+            tmp = self.rec_parse(data['properties']['ConfigData'])
+            if tmp != {}:
+                com_obj['ConfigData'] = tmp
+
+    def load_json_file(self, json_file):
+        with open(json_file) as f:
+            return json.load(f, object_pairs_hook=OrderedDict)
+
+    def save_json_file(self, json_file, mode, json_dict):
+        log.info(f"保存 json 文件: {json_file}")
+        with os.fdopen(os.open(json_file, os.O_WRONLY | os.O_CREAT | os.O_TRUNC,
+                               stat.S_IWUSR | stat.S_IRUSR), 'w') as fp:
+            json.dump(json_dict, fp, indent=4)
+        self.run_command(f"chmod {mode} {json_file}")
+
+    # 将原始schema文件和产品差异化schema文件结合后生成组件新的schema文件
+    def regenerate_schema(self, path, product_schema_path, origin_schema):
+        # 不存在产品差异化schema时则无需处理; 临时的产品schema路径下无需求处理
+        if not os.path.exists(product_schema_path) or product_schema_path == os.path.dirname(path):
+            return
+        product_schemas = sorted(os.listdir(product_schema_path))
+        # 存在与原始schema名称一致的产品差异化schema文件时，合并schema文件
+        if origin_schema in product_schemas:
+            origin_dict = self.load_json_file(os.path.join(path, origin_schema))
+            product_dict = self.load_json_file(os.path.join(product_schema_path, origin_schema))
+            self.merge_dicts(origin_dict, product_dict)
+            self.save_json_file(os.path.join(path, origin_schema), 440, origin_dict)
+
+    # 遍历所有schema文件
+    def walk_schema(self, path, product_schema_path, com_objs):
+        files = sorted(os.listdir(path))
+        for file in files:
+            sub_path = os.path.join(path, file)
+            if os.path.isdir(sub_path):
+                self.walk_schema(sub_path, product_schema_path, com_objs)
+            else:
+                seps = file.split('.')
+                if seps[1] != 'json':
+                    continue
+                self.regenerate_schema(path, product_schema_path, file)
+                app_name = seps[0]
+                if not self.has_key(com_objs, app_name):
+                    com_objs[app_name] = {}
+
+                self.load_schema(sub_path, product_schema_path, com_objs[app_name])
+
+    def gen_default_settings(self):
+        log.info(f"开始生成配置: {self.default_settings}")
+        if not os.path.isdir(self.schema_path):
+            raise Exception('schema 文件的目标必须为文件夹')
+
+        # 1.准备临时目录，支持非root构建
+        # 清理临时schema路径, 防止上次构建失败导致路径残留
+        if os.path.exists(self.schema_tmp):
+            self.run_command(f"rm -rf {self.schema_tmp}", sudo=True)
+        # 拷贝schema路径到构建临时路径
+        self.run_command(f"cp -r {self.schema_path} {self.config.build_path}", sudo=True)
+        # 修改权限为当前用户
+        user_group = f"{os.getuid()}:{os.getgid()}"
+        self.run_command(f"chown -R {user_group} {self.schema_tmp}", sudo=True)
+        self.run_command(f"chmod -R 750 {self.schema_tmp}", sudo=True) # 增加写权限, 防止创建子目录失败
+        # 创建custom路径存放默认配置
+        custom_tmp = os.path.join(self.schema_tmp, self.custom_path_name)
+        if not os.path.exists(custom_tmp):
+            self.run_command(f"mkdir {custom_tmp}")
+        self.run_command(f"chmod +w {custom_tmp}") # 增加写权限, 保存default_settings.json
+
+        # 2.整合schema文件
+        product_schema_tmp = os.path.join(self.schema_tmp, "product")
+        com_objs = OrderedDict()
+        ret_data = {'Components': com_objs}
+        self.walk_schema(self.schema_tmp, product_schema_tmp, com_objs)
+        self.save_json_file(os.path.join(custom_tmp, self.default_settings), 440, ret_data)
+
+        # 3.拷贝整合后的schema文件到源目录
+        self.run_command(f"cp -rf {self.schema_tmp}/. {self.schema_path}", sudo=True)
+        self.run_command(f"chmod 550 {os.path.join(self.schema_path, self.custom_path_name)}", sudo=True)
+        # 4.清理临时目录
+        self.run_command(f"rm -rf {self.schema_tmp}", sudo=True)

bmcgo/utils/component_post.py

@@ -0,0 +1,54 @@
+#!/usr/bin/env python
+# 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.
+
+"""
+文件名：component_post.py
+功能：获取对应路径下的python脚本，并执行其中的方法
+"""
+
+import os
+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
+
+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")
+        self.cust_cls = getattr(cust_py, "Customization")
+        self.config = config
+        self.component_path = component_path
+        self.profile = profile
+
+    def post_work(self, work_path, func_name):
+        if Tools.has_kwargs(self.cust_cls.__init__):
+            # 支持组件新的Customization的__init__(board_name, rootfs_path, **kwargs)
+            real_post = self.cust_cls(self.config.board_name, work_path, profile=self.profile)
+        else:
+            # 兼容之前组件Customization的__init__(board_name, rootfs_path)
+            real_post = self.cust_cls(self.config.board_name, work_path)
+        func_tuple_list = getmembers(self.cust_cls, isfunction)
+        func_list = [func_tuple_list[i][0] for i in range(len(func_tuple_list))]
+        if func_name not in func_list:
+            log.info(f"组件 {os.path.basename(self.component_path)} 中没有 {func_name} 方法")
+        else:
+            getattr(real_post, func_name)()
+            log.info(f"组件 {os.path.basename(self.component_path)} {func_name} 执行完成")
+        sys.path.pop(0)

bmcgo/utils/component_version_check.py

@@ -0,0 +1,86 @@
+#!/usr/bin/env python
+# 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.
+
+"""
+文件名: work_component_version_check.py
+功能: 对比manifest.yml生成的组件清单和自动生成的清单是否一致
+注意: 这个文件名为work, 但不继承 Task 类 !!!!!!
+"""
+
+import json
+
+import yaml
+
+from bmcgo.logger import Logger
+from bmcgo import misc
+
+log = Logger("component_version_check")
+
+
+class ComponentVersionCheck:
+    """类方法中的 manifest.yml 是有两个含义, conan 目录和单板目录, 均已注明
+       conan 目录的 manifest.yml 文件是由单板目录下的 manifest.yml 自动生成的
+    """
+
+    def __init__(self, manifest_yml: str, ibmc_lock: 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 = yaml.safe_load(manifest_fp)
+        with open(ibmc_lock, "r") as ibmc_lock_fp:
+            self.ibmc_lock = json.load(ibmc_lock_fp)
+
+    def generate_manifest_dict(self) -> dict:
+        """根据 manifest.yml(conan目录) 配置生成 组件名: 组件配置 的字典
+
+        Returns:
+            dict: 返回 组件名: 组件配置 的字典
+        """
+        dependency_list = self.manifest[misc.CONAN_DEPDENCIES_KEY]
+        manifest_dict = {x[misc.CONAN].split('/')[0]: x[misc.CONAN].split('@')[0] for x in dependency_list}
+        return manifest_dict
+
+    def generate_ibmc_lock_dict(self) -> dict:
+        """根据 ibmc.lock 配置生成 组件名: 组件配置 的字典
+
+        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")
+        return ibmc_lock_dict
+
+    def run(self):
+        """检查所有组件是否都在 manifest.yml(单板目录下) 中配置了
+        """
+        manifest_dict = self.generate_manifest_dict()
+        ibmc_lock_dict = self.generate_ibmc_lock_dict()
+        # 这里使用报错退出, 为防止有多个组件未配置, 报错在方法结束后触发
+        report_error = False
+        for key, version in ibmc_lock_dict.items():
+            if key not in manifest_dict.keys():
+                log.error(f"{version} 组件没有在manifest中配置!!!!!!")
+                report_error = True
+            elif version != manifest_dict[key]:
+                log.error(f"{version} 组件版本与manifest中配置{manifest_dict[key]}不匹配!!!!!!")
+                report_error = True
+
+        if report_error is True:
+            raise AttributeError
+        else:
+            log.info("所有组件均已在manifest中配置")