openubmc-bingo 0.5.240__py3-none-any.whl

bmcgo/functional/fetch.py

@@ -0,0 +1,235 @@
+#!/usr/bin/env python3
+# encoding=utf-8
+# 描述：拉取当前minifest快照下的全量代码
+# 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 re
+import argparse
+from multiprocessing import Pool
+import yaml
+from git import Repo
+from bmcgo.codegen.c.helper import Helper
+from bmcgo.logger import Logger
+from bmcgo.bmcgo_config import BmcgoConfig
+from bmcgo.utils.tools import Tools
+from bmcgo import misc
+from bmcgo.errors import ParameterException
+from bmcgo.utils.fetch_component_code import FetchComponentCode
+
+tools = Tools()
+log = Logger()
+
+command_info: misc.CommandInfo = misc.CommandInfo(
+    group=misc.GRP_MISC,
+    name="fetch",
+    description=["基于参数指定的单个、部分、全量组件版本拉取源代码"],
+    hidden=False
+)
+
+
+def if_available(bconfig: BmcgoConfig):
+    if bconfig.component:
+        return False
+    return True
+
+
+def process_err_cb(err):
+    log.error("进程运行失败, 错误: %s", err)
+
+
+_PACKAGE_INFO_HELP = """
+1. 通过组件包名及版本拉取单个组件源码，格式：package/version@user/channel
+2. 通过配置文件拉取部分指定版本的组件源码。支持以下2种配置文件：
+  a. yml格式
+    dependencies:
+    - conan: "package/version@user/channel"
+  b. 文本格式
+    package/version@user/channel
+"""
+
+
+class BmcgoCommand:
+    conan_package_re = r"^[^@|/]+/[^@|/]+@[^@|/]+/(rc|stable|dev)$"
+
+    def __init__(self, bconfig: BmcgoConfig, *args):
+        self.bconfig = bconfig
+        parser = argparse.ArgumentParser(prog="bingo fetch", description="BMC source code fetch", add_help=True,
+                                         formatter_class=argparse.RawTextHelpFormatter)
+        if self.bconfig.manifest:
+            manifest_exclusive_group = parser.add_mutually_exclusive_group()
+            manifest_exclusive_group.add_argument(
+                "-b",
+                "--board_name",
+                help="指定单板获取配套全量源码，可选值为build/product目录下的单板名\n默认：openUBMC",
+                default="openUBMC",
+            )
+            manifest_exclusive_group.add_argument("--manifest_yml", help="指定manifest.yml文件获取源码", default=None)
+            manifest_exclusive_group.add_argument("-pi", "--package_info", help=_PACKAGE_INFO_HELP, default=None)
+            manifest_exclusive_group.add_argument("-sys", "--subsystem", help="根据平台获取源码，可选平台包括（opensource、public、\
+framework、bmc_core、security、hardware、ras、energy、om、interface、product_extension、customer_extension）", default=None)
+            parser.add_argument("--stage", help="包类型，可选值为: rc（预发布包）, stable（发布包）\n默认：stable", default='stable')
+            parser.add_argument("-a", "--all", help="拉取全部conan代码", action=misc.STORE_TRUE)
+        else:
+            parser.add_argument("-pi", "--package_info", help=_PACKAGE_INFO_HELP, required=True)
+
+        parser.add_argument("-p", "--path", help="指定拉取源代码的存放路径\n默认：./source_code", default="./source_code")
+
+        parser.add_argument("-r", "--remote", help=f"conan仓别名，请检查conan remote list查看已配置的conan仓")
+
+        parsed_args, _ = parser.parse_known_args(*args)
+        self.component_ver = {}
+        self.remote = parsed_args.remote
+        self.code_path = os.path.realpath(os.path.join(os.getcwd(), parsed_args.path))
+        self.package_info = parsed_args.package_info
+        if self.bconfig.manifest:
+            self.stage = parsed_args.stage
+            self.board_name = parsed_args.board_name
+            self.manifest_yml_path = parsed_args.manifest_yml
+            self.manifest_build_dir = os.path.join(self.bconfig.manifest.folder, "build")
+            self.fetch_all = parsed_args.all
+            self.subsystem = parsed_args.subsystem
+            self.script_dir = os.path.join(os.path.dirname(os.path.split(os.path.realpath(__file__))[0]), 
+            "component/analysis/dep-rules.json")
+
+    def get_subsys_file_components(self, stage):
+        components = {}
+        version_config_dir = os.path.join(self.manifest_build_dir, "subsys", stage)
+        for file_name in os.listdir(version_config_dir):
+            with open(os.path.join(version_config_dir, file_name)) as f_:
+                ver_descp = yaml.safe_load(f_).get(misc.CONAN_DEPDENCIES_KEY)
+                for ver in ver_descp:
+                    components[ver[misc.CONAN].split('/')[0]] = ver[misc.CONAN]
+        return components
+
+    def run(self):
+        if self.package_info:
+            self.__parse_package_info()
+        # 增加判断情况，使用提取的方法和平台组件对比
+        elif self.subsystem:
+            log.info("====== 开始更新源码, 平台名: %s 代码路径: %s ======",
+                self.subsystem, self.code_path)
+
+            self.__load_config_json(self.stage)
+
+        else:
+            os.chdir(self.manifest_build_dir)
+            log.info("====== 开始更新源码, 单板名: %s 代码路径: %s ======",
+                self.board_name, self.code_path)
+
+            self.__update_manifest_path()
+
+            self.__load_config_yml(self.stage)
+
+        if not os.path.exists(self.code_path):
+            os.makedirs(self.code_path)
+        FetchComponentCode(self.component_ver, self.code_path, self.remote).run()
+        return 0
+
+    def __update_manifest_path(self):
+        if self.manifest_yml_path:
+            return
+        for root, _, files in os.walk(os.path.join(self.manifest_build_dir, "product")):
+            if "manifest.yml" in files and root.endswith(self.board_name):
+                self.manifest_yml_path = os.path.join(root, "manifest.yml")
+                return
+
+        raise RuntimeError("在单板配置目录下, 无法找到 manifest.yml 文件")
+
+    def __update_component_ver(self, comp, subsys_file_components):
+        component = comp if self.subsystem else comp[misc.CONAN]
+        # 此处判断manifest.yml中组件是否已指定版本
+        is_comfirm = component.find("/") > 0
+        component_name = component.split('/')[0]
+        if not self.fetch_all and component_name in self.bconfig.conan_blacklist:
+            return
+        if is_comfirm:
+            self.component_ver[component_name] = comp[misc.CONAN]
+        else:
+            self.component_ver[component_name] = subsys_file_components[component_name]
+        self._fix_com_package(self.component_ver, component_name)
+
+    def _fix_com_package(self, com_package, index):
+        com_package_split = com_package[index].split("/")
+        if len(com_package_split) == 2:
+            stage = self.stage
+            if stage != misc.StageEnum.STAGE_STABLE.value:
+                stage = misc.StageEnum.STAGE_RC.value
+            user_channel = f"@{tools.conan_user}/{stage}"
+            com_package[index] += user_channel
+
+    def __load_config_json(self, stage):
+        if not os.path.exists(self.script_dir):
+            raise RuntimeError("json 文件不存在")
+        with open(self.script_dir, 'r') as f_:
+            subsystems = json.load(f_)["Subsystems"]
+        if self.subsystem not in subsystems:
+            raise AttributeError(f"平台 {self.subsystem} 不存在于 {subsystems.keys()}")
+        subsys_file_components = self.get_subsys_file_components(self.manifest_build_dir, stage)
+        for items in subsystems[self.subsystem]:
+            if items == "Level":
+                continue
+            components = subsystems[self.subsystem].get(items, [])
+            for component in components:
+                self.__update_component_ver(component, subsys_file_components)
+        if len(self.component_ver) == 0:
+            raise RuntimeError(f"平台 {self.subsystem} 没有任何组件信息")
+
+    def __load_config_yml(self, stage):
+        if not os.path.exists(self.manifest_yml_path):
+            raise RuntimeError("manifest 文件不存在")
+        components = tools.get_manifest_dependencies(
+            self.manifest_build_dir, self.manifest_yml_path, self.stage, self.remote
+        )
+        subsys_file_components = self.get_subsys_file_components(stage)
+        for component in components:
+            self.__update_component_ver(component, subsys_file_components)
+
+    def __load_version_yml(self, package_info):
+        try:
+            with open(package_info) as f_:
+                ver_descp = yaml.safe_load(f_).get(misc.CONAN_DEPDENCIES_KEY)
+                for v in ver_descp:
+                    ver = v[misc.CONAN]
+                    comp_name = ver.split('/')[0]
+                    self.component_ver[comp_name] = ver
+            return True
+        except Exception as exp:
+            log.warning("尝试以yml格式解析配置文件(%s)失败, 错误信息: %s", self.package_info, exp)
+            return False
+
+    def __load_version_file(self, package_info):
+        with open(package_info, encoding="UTF-8") as fp:
+            for line_num, line in enumerate(fp.readlines()):
+                package = line.strip()
+                if re.match(self.conan_package_re, package):
+                    comp_name = package.split('/')[0]
+                    self.component_ver[comp_name] = package
+                elif package != "":
+                    log.error(f"第{line_num + 1}行不满足conan包格式要求, 跳过: {package}")
+
+    def __parse_package_info(self):
+        log.info("====== 开始获取组件包信息: %s ======", self.package_info)
+        package_match = re.match(self.conan_package_re, self.package_info)
+        package_info_path = os.path.relpath(os.path.join(self.bconfig.cwd, self.package_info))
+        if not (package_match or os.path.isfile(package_info_path)):
+            raise ParameterException(f"{self.package_info}文件不存在 或 不满足conan包格式要求。")
+
+        if package_match:
+            comp_name = self.package_info.split('/')[0]
+            self.component_ver[comp_name] = self.package_info
+            return
+
+        log.info("按照 yml 格式解析配置文件.")
+        ret = self.__load_version_yml(package_info_path)
+        if not ret:
+            log.info("按照 /etc/package_info 格式解析配置文件.")
+            self.__load_version_file(package_info_path)

bmcgo/functional/full_component.py

@@ -0,0 +1,391 @@
+#!/usr/bin/env python3
+# 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 itertools
+import json
+import sys
+import re
+import stat
+import shutil
+import argparse
+import importlib
+import inspect
+import functools
+import random
+from concurrent.futures import ProcessPoolExecutor, Future
+from typing import List
+
+from conans.model.manifest import FileTreeManifest
+import yaml
+
+from bmcgo import misc
+from bmcgo.utils.fetch_component_code import FetchComponentCode
+from bmcgo.component.component_dt_version_parse import ComponentDtVersionParse
+from bmcgo.component.component_helper import (
+    ComponentHelper,
+    STAGE_DEV,
+    STAGE_STABLE,
+    STAGE_RC,
+    BUILD_TYPE_DT,
+    BUILD_TYPE_DEBUG,
+    BUILD_TYPE_RELEASE,
+)
+from bmcgo.misc import CommandInfo, CONAN_USER
+from bmcgo.utils.tools import Tools
+from bmcgo.bmcgo_config import BmcgoConfig
+from bmcgo.component.build import BuildComp
+from bmcgo.errors import BmcGoException
+from bmcgo.tasks.misc import MODULE_SYMVERS, SDK_PATH
+
+tool = Tools("build_full")
+log = tool.log
+command_info: CommandInfo = CommandInfo(
+    group="Misc commands",
+    name="build_full",
+    description=["获取组件源码并构建出组件的全量二进制"],
+    hidden=True,
+)
+
+
+def if_available(bconfig: BmcgoConfig):
+    if bconfig.conan_index:
+        return False
+    return True
+
+
+class BuildComponent:
+    def __init__(
+        self,
+        comp,
+        profile: str,
+        stage: str,
+        build_type: str,
+        options: dict,
+        code_path: str,
+        remote=misc.CONAN_REPO,
+        service_json="mds/service.json",
+        upload=False,
+    ):
+        self.bconfig = BmcgoConfig()
+        self.comp_name, self.comp_version, *_ = re.split("@|/", comp)
+        self.profile = profile
+        self.stage = stage
+        self.build_type = build_type
+        self.options = options
+        self.code_path = code_path
+        self.option_cmd = ""
+        self.remote = remote
+        self.upload = upload
+        self.service_json = service_json
+
+    def run(self):
+        os.chdir(os.path.join(self.code_path, self.comp_name))
+        for key, value in self.options.items():
+            self.option_cmd = self.option_cmd + f" -o {self.comp_name}:{key}={value}"
+        command = (
+            f"--remote {self.remote} -nc --stage {self.stage} --build_type {self.build_type.lower()}"
+            f" --profile {self.profile} {self.option_cmd}"
+        )
+        log.info(f"执行构建命令bingo build {command}")
+        args = command.split()
+        build = BuildComp(self.bconfig, args, service_json=self.service_json)
+        # 恢复工作区为clean状态, 保证conan export时scm信息准确
+        tool.run_command("git restore .")
+        tool.run_command("git clean -fd")
+        build.run()
+        log.success("组件{}构建成功".format(self.comp_name))
+        if self.upload:
+            log.info("上传组件包至conan仓......")
+            tool.run_command(f'conan upload "*" --all --remote {self.remote} -c --no-overwrite')
+
+
+class BmcgoCommand:
+    def __init__(self, bconfig: BmcgoConfig, *args):
+        parser = argparse.ArgumentParser(description="Fetch component source code and build all binaries.")
+        parser.add_argument("-comp", "--component", help="软件包名, 示例: oms/1.2.6", required=True)
+        parser.add_argument("-r", "--remote", help="远端仓库名称", default=misc.CONAN_REPO)
+        parser.add_argument(
+            "-p",
+            "--path",
+            help="指定拉取源代码的存放路径\n默认：./temp/source_code",
+            default="./temp/source_code",
+        )
+        parser.add_argument("-pi", "--package_info", help="package_info文件路径", required=True)
+        parser.add_argument("-u", "--upload", action=misc.STORE_TRUE, help="上传组件包到conan仓")
+        parser.add_argument("--config_file", help="全量二进制配置文件")
+        parser.add_argument("--skip_fetch", action=misc.STORE_TRUE, help="跳过fetch")
+        parser.add_argument("--build_type", action="append", help="构建类型")
+
+        parsed_args, _ = parser.parse_known_args(*args)
+        self.bconfig = bconfig
+        self.comp = parsed_args.component
+        self.comp_name, self.comp_version, *_ = re.split("@|/", self.comp)
+        self.code_path = os.path.realpath(os.path.join(bconfig.cwd, parsed_args.path))
+        self.comp_path = os.path.join(self.code_path, self.comp_name)
+        self.remote = parsed_args.remote
+        self.package_info_path = os.path.realpath(os.path.join(bconfig.cwd, parsed_args.package_info))
+        self.upload = parsed_args.upload
+        self.config_file = parsed_args.config_file
+        self.skip_fetch = parsed_args.skip_fetch
+        self.profile_list = ["profile.dt.ini", "profile.luajit.ini"]
+        self.stage_list = [STAGE_STABLE]
+        self.built_type_list = [BUILD_TYPE_DT, BUILD_TYPE_DEBUG, BUILD_TYPE_RELEASE]
+        if parsed_args.build_type:
+            self.built_type_list = parsed_args.build_type
+        self.options_dict = {}
+
+    @staticmethod
+    def get_conan_file_cls(comp_path):
+        os.chdir(comp_path)
+        # 先生成conanbase.py文件
+        BuildComp(BmcgoConfig(), gen_conanbase=True)
+        # 去除ConanFile, Conanbase继承, 用于方便区分
+        tool.run_command("sed -i s/(ConanFile)/()/ conanbase.py")
+        tool.run_command("sed -i s/(ConanBase)/()/ conanfile.py")
+        # 动态导入conanfile.py模块
+        sys.path.append(comp_path)
+        conan_file_module = importlib.import_module("conanfile")
+        conan_base_cls = conan_file_module.ConanBase
+        cls_in_module = [member[1] for member in inspect.getmembers(conan_file_module) if inspect.isclass(member[1])]
+
+        # 删除导入的conanbase和conanfile, 保证后续组件的导入是最新的conanbase和conanfile模块
+        sys.modules.pop("conanbase")
+        sys.modules.pop("conanfile")
+        sys.path.pop()
+        # 清空编译的conanbase缓存, 防止后续构建时使用了缓存的conanbase（未继承ConanFile版本)
+        tool.run_command("rm -rf __pycache__")
+        # 恢复工作区为clean状态, 保证conan export时scm信息准确
+        tool.run_command("git restore .")
+        tool.run_command("git clean -fd")
+
+        conan_file_cls = None
+        for conan_cls in cls_in_module:
+            if conan_cls != conan_base_cls:
+                conan_file_cls = conan_cls
+                break
+        if hasattr(conan_file_cls, "options"):
+            return conan_file_cls
+
+        return conan_base_cls
+
+    @staticmethod
+    def get_build_options(conan_file_cls, config_file):
+        options_dict = {}
+        if hasattr(conan_file_cls, "options"):
+            options_dict = conan_file_cls.options
+
+        # 添加module_symver选项
+        module_symvers_path = os.path.join(SDK_PATH, MODULE_SYMVERS)
+        module_symver_key, module_symver_value = tool.get_module_symver_option(module_symvers_path)
+        if module_symver_key in options_dict:
+            options_dict[module_symver_key] = [module_symver_value]
+        if config_file:
+            with open(config_file, "r") as yaml_fp:
+                obj = yaml.safe_load(yaml_fp)
+            BmcgoCommand.exclude_com_options(conan_file_cls, obj, options_dict)
+            BmcgoCommand.exclude_all_options(obj, options_dict)
+        tool.log.info(f"组件全量options选项为: {options_dict}")
+        return options_dict
+
+    @staticmethod
+    def exclude_com_options(conan_file_cls, obj, options_dict):
+        if conan_file_cls.name in obj:
+            for exclude_option in obj[conan_file_cls.name]["exclude_options"]:
+                del options_dict[exclude_option]
+
+    @staticmethod
+    def exclude_all_options(obj, options_dict):
+        if obj.get("all", {}):
+            for exclude_option in obj["all"]["exclude_options"]: 
+                if exclude_option in options_dict:
+                    del options_dict[exclude_option]
+
+    @staticmethod
+    def copy_stable2rc(comp: str):
+        com_folder = os.path.join(tool.conan_data, comp)
+        for version in os.listdir(com_folder):
+            pkg = f"{comp}/{version}@{CONAN_USER}/{STAGE_STABLE}"
+            if not os.path.exists(os.path.join(tool.conan_data, pkg.replace("@", "/"))):
+                continue
+            tool.run_command(f"conan copy {pkg} {CONAN_USER}.release/{STAGE_RC} --all --force")
+
+    @staticmethod
+    def copy_all_stable2rc(tools: Tools):
+        comps = os.listdir(tools.conan_data)
+        tools.log.info(f"创建多进程获取复制conan data下所有组件的stable到rc版本...")
+        pool = ProcessPoolExecutor()
+        future_tasks: List[Future] = []
+        for comp in comps:
+            task = pool.submit(BmcgoCommand.copy_stable2rc, comp)
+            future_tasks.append(task)
+
+        pool.shutdown()
+        for task in future_tasks:
+            task_exception = task.exception()
+            if task_exception is not None:
+                raise task_exception
+
+    @staticmethod
+    def _replace_dev_version(temp_service_json: str):
+        version_parse = ComponentDtVersionParse(serv_file=temp_service_json)
+        for pkg in version_parse.conan_list:
+            component = pkg[misc.CONAN]
+            if "@" not in component:
+                continue
+            comp_version, user_channel = component.split("@")
+            if user_channel.endswith(STAGE_DEV):
+                pkg[misc.CONAN] = f"{comp_version}{ComponentHelper.get_user_channel(STAGE_DEV)}"
+
+        version_parse.write_to_serv_file()
+
+    @functools.cached_property
+    def _full_reference(self) -> str:
+        comp_pkg = self.comp if "@" in self.comp else f"{self.comp}@{CONAN_USER}.release/{STAGE_STABLE}"
+        return comp_pkg
+
+    @functools.cached_property
+    def _is_self_developed(self) -> bool:
+        tool.run_command(f"conan download {self._full_reference} --recipe -r {self.remote}")
+        comp_package_path = os.path.join(tool.conan_data, self.comp_name)
+        ret = tool.run_command(f"find {comp_package_path} -name 'conanbase.py'", capture_output=True)
+        return bool(ret.stdout)
+
+    def fetch_code(self):
+        conan_path = os.path.join(tool.conan_data, self.comp_name)
+        if os.path.isdir(conan_path):
+            shutil.rmtree(conan_path)
+        if os.path.isdir(self.code_path):
+            shutil.rmtree(self.code_path)
+        os.makedirs(self.code_path)
+        packages = {self.comp_name: self._full_reference}
+        FetchComponentCode(packages, self.code_path, self.remote).run()
+
+    def revise_comp_version(self, service_json: str):
+        """修订version为当前指定的版本, 以支持x.y.z-build.x格式的补丁版本
+
+        Args:
+            service_json (str): service.json文件路径
+        """
+        os.chdir(self.comp_path)
+        file_open_mode = stat.S_IRUSR | stat.S_IWUSR | stat.S_IRGRP | stat.S_IROTH
+        with os.fdopen(os.open(service_json, flags=os.O_RDWR, mode=file_open_mode), "w+") as file_handler:
+            service_json_data = json.load(file_handler)
+            service_json_data["version"] = self.comp_version
+            file_handler.seek(0)
+            file_handler.truncate()
+            json.dump(service_json_data, file_handler, indent=4, ensure_ascii=False)
+            file_handler.close()
+
+    def revise_service_dependencies(self, service_json: str):
+        """修订build/test的依赖组件的版本为patch范围版本
+
+        Args:
+            service_json (str): service.json文件路径
+        """
+        os.chdir(self.comp_path)
+        with open(service_json, "r", encoding="UTF-8") as file_handler:
+            service_json_data = json.load(file_handler)
+        dependencies = service_json_data.get(misc.CONAN_DEPDENCIES_KEY, {})
+        if not dependencies:
+            # service.json中没有依赖，可直接构建
+            return
+        ComponentDtVersionParse(serv_file=service_json).manifest_version_revise(
+            self.package_info_path, use_patch_range=True
+        )
+        self._replace_dev_version(service_json)
+
+    def run(self):
+        if not self.skip_fetch:
+            if not self._is_self_developed:
+                tool.log.warning(f"非自研组件{self.comp}不支持该功能。")
+                return
+            self.fetch_code()
+        self._package_docs_from_source()
+        conan_file_cls = self.get_conan_file_cls(self.comp_path)
+        self.options_dict = self.get_build_options(conan_file_cls, self.config_file)
+        service_json = self._create_temp_service_json()
+        self.revise_comp_version(service_json)
+        self.revise_service_dependencies(service_json)
+        self.build_all_packages(service_json)
+        self.copy_all_stable2rc(tool)
+        if self.upload:
+            log.info("上传组件包至conan仓......")
+            tool.run_command(f'conan upload "*" --all --remote {self.remote} -c --no-overwrite')
+
+    def build_all_packages(self, service_json: str):
+        """构建出组件所有组合的package包
+
+        Args:
+            service_json (str): 显式指定用于生成conanbase.py依赖的service.json路径
+        """
+
+        all_attributes = {
+            "profile": self.profile_list,
+            "stage": self.stage_list,
+            "build_type": self.built_type_list,
+        }
+        # 不参与构建二进制的选项
+        block_options = ["asan", "gcov"]
+        options_dict = self.options_dict
+        for block in block_options:
+            options_dict.pop(block, None)
+
+        all_attributes = {**all_attributes, **options_dict}
+        # 设置变量让所有场景（包括DT）构建lua代码时都进行编译
+        os.environ["TRANSTOBIN"] = "true"
+        log.info(f"构建组件{self.comp}的全量二进制, 选项包含：{options_dict}")
+        all_build_params = list(itertools.product(*all_attributes.values()))
+        if not self.skip_fetch:
+            random.shuffle(all_build_params)
+        for build_args in all_build_params:
+            profile, stage, build_type, *option_values = build_args
+            if profile == "profile.dt.ini" and build_type.lower() != BUILD_TYPE_DT.lower():
+                continue
+            if profile != "profile.dt.ini" and build_type.lower() == BUILD_TYPE_DT.lower():
+                continue
+            build_options = dict(zip(options_dict.keys(), option_values))
+            task = BuildComponent(
+                self.comp,
+                profile,
+                stage,
+                build_type,
+                build_options,
+                self.code_path,
+                remote=self.remote,
+                service_json=service_json,
+                upload=self.upload,
+            )
+            task.run()
+
+    def _create_temp_service_json(self):
+        temp_path = os.path.join(self.comp_path, "temp")
+        os.makedirs(temp_path, exist_ok=True)
+        temp_service_json = os.path.join(temp_path, "service.json")
+        if not os.path.isfile(temp_service_json):
+            tool.copy(os.path.join(self.comp_path, "mds/service.json"), temp_service_json)
+        return temp_service_json
+
+    def _package_docs_from_source(self):
+        os.chdir(self.comp_path)
+        current_path = os.getcwd()
+        package_folder = []
+        for entry in os.listdir(current_path):
+            entry_l = entry.lower()
+            if entry_l == "mds" or entry_l == "docs":
+                package_folder.append(entry)
+            elif "changelog" in entry_l or entry_l.endswith(".md"):
+                package_folder.append(entry)
+        if not package_folder:
+            tool.log.info("无docs文档, 跳过文档打包。")
+            return
+        tar_cmd = ["tar", "-czvf", f"{self.code_path}/{self.comp_name}_docs.tar.gz"] + package_folder
+        tool.run_command(tar_cmd)