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

bmcgo/utils/config.py

@@ -13,6 +13,7 @@
 import json
 import os
 import sys
+import re
 import copy
 import hashlib
 import stat
@@ -40,6 +41,7 @@ log = Logger("config")
 VERSION = "Version"
 BUILD_NUMBER = "BuildNum"
 VERSION_LEN = 5
+BMCSDKVERSION = "BMCSDKVersion"
 
 
 class Config:
@@ -63,11 +65,11 @@ class Config:
     _profile = ""
     conan_index_options = []
     _manifest_data = {}
-    schema_file = f"{misc.SCHEMA_FILE_PATH}/manifest.schema.json"
+    schema_file = f"{misc.schema_path()}/manifest.schema.json"
     schema_need_validate = False # 由frame.py或target文件配置是否启用
     enable_debug_model = False # # 是否启用调测模式，默认为false，个人构建启用
 
-    def __init__(self, bconfig: BmcgoConfig, board_name="openUBMC", target="target_personal"):
+    def __init__(self, bconfig: BmcgoConfig, board_name=misc.boardname_default(), target="target_personal"):
         self.bconfig = bconfig
 
         # 单板名
@@ -130,15 +132,20 @@ class Config:
         self.docker_tag = None
         # 伙伴/开源远端相关
         self.open_remote = None
+        self.platform_package = None
 
     @property
     def partner_mode(self):
         """是否是伙伴模式"""
         return self.bconfig.partner_mode
 
+    @property
+    def rtos_path(self):
+        return f"/opt/{self.rtos_offering}/{self.rtos_version}"
+
     @property
     def sysroot(self):
-        return f"/opt/{self.rtos_offering}/{self.rtos_version}/arm64le_{self.rtos_kernel}/sdk"
+        return f"{self.rtos_path}/arm64le_{self.rtos_kernel}/sdk"
 
     @property
     def self_sign(self):
@@ -207,15 +214,16 @@ class Config:
 
     @staticmethod
     def argparser(code_path, partner_mode=False):
-        parser = argparse.ArgumentParser(description="构建openUBMC", formatter_class=argparse.RawTextHelpFormatter)
+        parser = argparse.ArgumentParser(description="构建" + misc.boardname_default(),
+                                         formatter_class=argparse.RawTextHelpFormatter)
         boards = Config.get_all_board(code_path)
-        help_txt = "单板包，可选值为build/product/<Kunpeng|...>/下的目录名\n默认：openUBMC"
+        help_txt = "单板包，可选值为build/product/<Kunpeng|...>/下的目录名\n默认：" + misc.boardname_default()
         help_txt += "\n支持的单板列表："
         for board, _ in boards.items():
             help_txt += "\n" + board
-        parser.add_argument("-b", "--board_name", help=help_txt, default="openUBMC")
-        parser.add_argument("-bt", "--build_type", 
-                            help="构建类型，可选：debug（调试包）, release（正式包）, dt（开发者测试包）", default="debug")
+        parser.add_argument("-b", "--board_name", help=help_txt, default=misc.boardname_default())
+        parser.add_argument("-bt", "--build_type",
+                            help="构建类型，可选：debug（调试包）, release（正式包）", default="debug")
         parser.add_argument(
             "-s",
             "--from_source",
@@ -329,6 +337,14 @@ class Config:
         template_sha256 = template_hash.hexdigest()
         return sha256 + template_sha256
 
+    @staticmethod
+    def _get_number_version(version):
+        if "B" in version:
+            version = version.rsplit(".", 1)[0]
+        elif "b" in version:
+            version = version.rsplit(".", 1)[0]
+        return version
+
     @functools.cached_property
     def rtos_offering(self):
         return self.get_manufacture_config("base/rtos_offering", "RTOS")
@@ -406,7 +422,7 @@ class Config:
         """
         if self.version == "":
             return self.version
-        version = self.version.rsplit(".", 1)[0] if "B" in self.version else self.version
+        version = self._get_number_version(self.version)
         correction_version = str(int(version.rsplit(".", 1)[-1]) + 1)
         version = "{}.{}".format(version.rsplit(".", 1)[0], correction_version.zfill(2))
         return version
@@ -420,7 +436,7 @@ class Config:
 
     # 模板化，manifest.yml替换时使用
     def get_template(self) -> dict:
-        version = self.version.rsplit(".", 1)[0] if "B" in self.version else self.version
+        version = self._get_number_version(self.version)
         template = {
             "code_root": self.code_root,
             "product": f"{self.code_path}/product",
@@ -554,12 +570,12 @@ class Config:
     def set_build_type(self, arg_build_type="debug"):
         '''
         这只编译app的cmake编译选项
-        参数：arg_build_type 可选值："debug";"release";"dt"
+        参数：arg_build_type 可选值："debug";"release"
         '''
         # 可以编译的版本
-        build_type_turple = ("debug", "release", "dt")
+        build_type_turple = misc.build_type()
         if arg_build_type not in build_type_turple:
-            log.info("不支持的构建类型, 请从以下构建类型中输入: [debug release dt]")
+            log.info(f"不支持的构建类型, 请从以下构建类型中输入: [{misc.build_type_str()}]")
             return
 
         self.build_type = arg_build_type
@@ -599,7 +615,7 @@ class Config:
 
     def set_common_params(self):
         # conan仓
-        self.remote = None
+        self.remote = misc.conan_remote()
         self.remote_list = []
         self.temp_platform_dir_name = f"temp/board_{self.board_name}_platform"
         self.temp_platform_build_dir = os.path.join(self.code_path, self.temp_platform_dir_name)
@@ -632,6 +648,8 @@ class Config:
         boards = self.get_all_board(self.code_path)
         # 单板配置路径
         self.ori_board_path = boards.get(self.board_name)
+        if not self.ori_board_path:
+            raise errors.ConfigException(f"未知的单板 {self.board_name}，请检查参数配置是否正确")
         log.info(f"单板源配置路径: {self.ori_board_path}")
         # openUBMC get Kunpeng
         self.productline = os.path.abspath(self.ori_board_path).split('/')[-2]
@@ -646,7 +664,7 @@ class Config:
         tools.run_command(f"cp -rf {self.ori_board_path} {self.board_path}")
 
     def set_enable_luajit(self, enable):
-        if self.build_type == "Dt":
+        if misc.conan_v1() and self.build_type == "Dt":
             self.enable_luajit = False
         self.enable_luajit = enable
 
@@ -671,7 +689,10 @@ class Config:
         self.enable_qemu = True if enable_qemu is True else self.enable_qemu
 
     def set_stage(self, stage: str):
-        in_stage = [member.value for member in misc.StageEnum if member is not misc.StageEnum.STAGE_PRE]
+        if misc.conan_v2():
+            in_stage = [member.value for member in misc.StageEnum]
+        else:
+            in_stage = [member.value for member in misc.StageEnum if member is not misc.StageEnum.STAGE_PRE]
         if stage not in in_stage:
             raise errors.ConfigException(f"stage 参数错误, 可用选项为: {in_stage}, 请检查参数")
         self.stage = stage
@@ -761,11 +782,11 @@ class Config:
         com_package_split = com_package[index].split("/")
         if len(com_package_split) == 1:
             com_package[index] = sub_name
-        elif len(com_package_split) == 2:
+        elif len(com_package_split) == 2 and "@" not in com_package[index]:
             stage = self.stage
             if stage != misc.StageEnum.STAGE_STABLE.value:
                 stage = misc.StageEnum.STAGE_RC.value
-            user_channel = f"@{tools.conan_user}/{stage}"
+            user_channel = f"@{misc.conan_user()}/{stage}"
             com_package[index] += user_channel
 
     def get_subsys_coms(self):
@@ -781,7 +802,10 @@ class Config:
         return comps
 
     def load_platform_manifest(self, package):
-        package_conan_dir = tools.install_platform(package, self.stage, self.remote)
+        self.platform_package = package[misc.CONAN]
+        if misc.conan_v2():
+            self.platform_package = self.platform_package.lower()
+        package_conan_dir = tools.install_platform(package, self.stage, self.remote, self.update_conan_cache)
         if os.path.isdir(self.temp_platform_build_dir):
             shutil.rmtree(self.temp_platform_build_dir)
         os.makedirs(os.path.join(self.code_path, "temp"), exist_ok=True)
@@ -850,6 +874,11 @@ class Config:
         if template is None:
             template = self.get_template()
         mani = self._load_manifest_with_template(filename, template)
+        schema_file = mani.get("schema", "")
+        if schema_file:
+            self.schema_file = schema_file
+        else:
+            self.schema_file = misc.get_decleared_schema_file(filename)
         inc_filename = mani.get("include")
         if not inc_filename:
             return mani
@@ -865,17 +894,13 @@ class Config:
         mani_inc = self.load_manifest_yml(inc_filename, template)
         self.merge_manifest_yml(mani, mani_inc, "")
         if top_manifest and self.schema_need_validate:
-            schema_file = mani.get("schema", self.schema_file)
-            if not schema_file:
-                schema_file = misc.get_decleared_schema_file(filename)
-                # 获取产品配置的schema，已通过schema校验，必然存在
-            if schema_file is None:
+            # 获取产品配置的schema，已通过schema校验，必然存在
+            if self.schema_file is None:
                 raise errors.BmcGoException("未找到应该遵循的manifest规范，无法校验manifest.yml文件正确性，" +
                                             "请检查配置项yaml-language-server或schema配置项是否正确")
-            if not os.path.isfile(schema_file):
-                raise errors.BmcGoException(f"产品配置了一个不存在的manifest规范文件{schema_file}，" +
-                                            "无法校验manifest.yml文件正确性，请检查bingo是否正确安装")
-            self.schema_file = schema_file
+            if not os.path.isfile(self.schema_file):
+                raise errors.BmcGoException(f"产品配置了一个不存在的manifest规范文件{self.schema_file}，" +
+                                            f"无法校验manifest.yml文件正确性，请检查{misc.tool_name()}是否正确安装")
             with open(self.schema_file, "rb") as fp:
                 schema = json.load(fp)
             log.debug(f"使用规范配置文件{self.schema_file}校验{filename}配置项")
@@ -886,7 +911,7 @@ class Config:
         self.archive_conf = self.get_manufacture_config("archive")
         self.archive_path = self.get_manufacture_config("archive/archive_path")
         if self.target == "docker_build":
-            self.archive_path = "openUBMC/ToCommunity"
+            self.archive_path = f"{misc.logo()}/ToCommunity"
         self.partner_docker = self.get_manufacture_config("archive/partner_docker")
 
     def version_split(self):
@@ -922,7 +947,9 @@ class Config:
         with open(manifest_file, "r", encoding="utf-8") as fp:
             mani = yaml.safe_load(fp)
         mani["base"]["version"] = self.version
-        schema_file = misc.get_decleared_schema_file(manifest_file)
+        schema_file = mani.get("schema", "")
+        if not schema_file:
+            schema_file = misc.get_decleared_schema_file(manifest_file)
         with os.fdopen(os.open(manifest_file, os.O_WRONLY | os.O_CREAT | os.O_TRUNC,
                                stat.S_IWUSR | stat.S_IRUSR), 'w+') as file_handler:
             if schema_file != "":
@@ -961,6 +988,9 @@ class Config:
 
         with open(dest_file, "r") as dst:
             ver_dst_data = json.load(dst)
+            if self.platform_package:
+                version_temp = re.split("/|@", self.platform_package)[1].split(".")[:4]
+                ver_dst_data[BMCSDKVERSION] = ".".join(version_temp)
             # 大版本字段为空，自动填充
             if ver_dst_data[VERSION] == "":
                 real_version = ""
@@ -968,7 +998,10 @@ class Config:
                     real_version = fixed_version
                 else:
                     real_version = version
-                ver_dst_data[VERSION] = real_version.rsplit(".", 1)[0] if "B" in real_version else real_version
+                if misc.conan_v2():
+                    ver_dst_data[VERSION] = self._get_number_version(real_version)
+                else:
+                    ver_dst_data[VERSION] = real_version.rsplit(".", 1)[0] if "B" in real_version else real_version
                 # 如果包名中有manufacture字段，则自动加1
                 if "manufacture" in package_name:
                     version_list = ver_dst_data[VERSION].rsplit(".", 1)
@@ -976,10 +1009,10 @@ class Config:
 
             # 小版本为空，则填充
             if ver_dst_data[BUILD_NUMBER] == "":
-                if fixed_version is not None and "B" in fixed_version:
-                    ver_dst_data[BUILD_NUMBER] = fixed_version.rsplit(".", 1)[1].strip("B")
+                if fixed_version is not None and ("B" in fixed_version or "b" in fixed_version):
+                    ver_dst_data[BUILD_NUMBER] = fixed_version.rsplit(".", 1)[1].strip("B").strip("b")
                 else:
-                    ver_dst_data[BUILD_NUMBER] = version.rsplit(".", 1)[1].strip("B")
+                    ver_dst_data[BUILD_NUMBER] = version.rsplit(".", 1)[1].strip("B").strip("b")
 
             # 填充构建日期
             if ver_dst_data['ReleaseDate'] == "":
@@ -1027,9 +1060,6 @@ class Config:
         self.set_build_type(args.build_type)
         self.set_stage(args.stage)
         self.set_board_name(args.board_name)
-        self.asan = args.asan
-        self.remote = args.remote
-        self.remote_list = tools.get_conan_remote_list(self.remote)
         self.verbose = args.verbose
         if os.environ.get("LOG"):
             self.verbose = True
@@ -1041,19 +1071,25 @@ class Config:
         self.set_enable_arm_gcov(args.coverage)
         self.set_enable_luajit(args.enable_luajit)
         self.set_show_version()
+        self.asan = args.asan
+        self.remote = args.remote
+        self.remote_list = tools.get_conan_remote_list(self.remote)
         self.get_archive()
         self.init_conan_profile(args.profile)
 
         # 构建阶段检查
-        bt = ["dt", "debug", "release"]
+        bt = misc.build_type()
         if args.build_type not in bt:
-            raise errors.ConfigException("构建类型 build_type 错误, 可用选项为: [debug, release, dt], 请检查参数")
+            raise errors.ConfigException(f"构建类型 build_type 错误, 可用选项为: {misc.build_type_str()}, 请检查参数")
 
         hpm_encrypt = self.bconfig.hpm_encrypt
-        if hpm_encrypt and hpm_encrypt.need_encrypt:
+        if misc.need_encrypt_hpm() or (hpm_encrypt and hpm_encrypt.need_encrypt):
             if not shutil.which("crypto_tool"):
                 raise errors.BmcGoException(f"开启了hpm加密配置, 在环境中未找到 'crypto_tool', 请确认环境配置是否正确.")
             os.environ["HPM_ENCRYPT"] = "true"
+        else:
+            log.info(f"未开启hpm加密配置")
+
 
     def _load_manifest_with_template(self, filename, template):
         try:

bmcgo/utils/fetch_component_code.py

@@ -19,7 +19,7 @@ import patch_ng
 import yaml
 from git import Repo
 
-from bmcgo.misc import errors
+from bmcgo import errors
 from bmcgo import misc
 from bmcgo.utils.tools import Tools
 
@@ -44,7 +44,7 @@ class FetchComponentCode:
     @staticmethod
     def resolve_version_range(component_name, version_range):
         cmd = f"conan info '{version_range}' --package-filter={component_name}/*" \
-             f" -r {misc.CONAN_REPO} --only None 2>/dev/null"
+             f" -r {misc.conan_remote()} --only None 2>/dev/null"
         ret, output = subprocess.getstatusoutput(cmd)
         output = output.strip()
         if ret != 0 or not output:
@@ -93,7 +93,10 @@ class FetchComponentCode:
     @staticmethod
     def __apply_patches(conandata_file, patches, code_dir):
         cwd = os.getcwd()
-        recipe_folder = os.path.join(os.path.dirname(conandata_file), "..", "export_source")
+        if misc.conan_v1():
+            recipe_folder = os.path.join(os.path.dirname(conandata_file), "..", "export_source")
+        else:
+            recipe_folder = os.path.join(os.path.dirname(conandata_file), "..", "es")
         recipe_folder = os.path.realpath(recipe_folder)
         os.chdir(os.path.join(cwd, code_dir))
         for patch in patches:
@@ -136,17 +139,20 @@ class FetchComponentCode:
     @staticmethod
     def __update_code_by_branch(code_dir, deps):
         url = deps['url']
-        branch = deps['branch'].split('/')[-1]
-
+        branch = deps.get("branch", "").split('/')[-1] or deps.get("commit", "")
         if os.path.exists(code_dir):
             repo = Repo(code_dir)
-            repo.git.fetch('origin', branch)
-            repo.git.pull('origin', branch)
-            repo.git.checkout(branch)
+            repo.git.fetch('origin')
         else:
-            Repo.clone_from(url, to_path=code_dir, branch=branch)
+            Repo.clone_from(url, to_path=code_dir)
             repo = Repo(code_dir)
-        log.info("更新代码(组件: %s, 地址: %s, 分支: %s)", code_dir, url, branch)
+        if re.match(r"^[0-9a-f]{40}$", branch):
+            repo.head.reset(branch, working_tree=True)
+        elif branch.startswith("refs/tags/"):
+            repo.head.reset(branch[len("refs/tags/"):], working_tree=True)
+        else:
+            repo.git.checkout(branch)
+        log.info("更新代码(组件: %s, 地址: %s, 节点: %s)", code_dir, url, branch)
 
     @staticmethod
     def __update_component_code_by_conandata(name, version, conandata_file):
@@ -207,26 +213,39 @@ class FetchComponentCode:
         try:
             os.chdir(self.target_dir)
             log.info("更新 %s 组件代码到 %s 开始", component_name, conan_version)
-
-            version_split = re.split(r'[/, @]', conan_version)
-            conan_dir = os.path.join(os.path.expanduser('~'), '.conan/data/', *version_split, 'export')
-            conandata = os.path.join(conan_dir, 'conandata.yml')
-            if not os.path.exists(conan_dir):
+            if misc.conan_v1():
+                version_split = re.split(r'[/, @]', conan_version)
+                conan_dir = os.path.join(os.path.expanduser('~'), '.conan/data/', *version_split, 'export')
+                conandata = os.path.join(conan_dir, 'conandata.yml')
+                if not os.path.exists(conan_dir):
+                    conan_remote_list = tools.get_conan_remote_list(self.remote)
+                    tools.download_conan_recipes(conan_version, conan_remote_list)
+                if os.path.exists(conandata):
+                    self.__update_component_code_by_conandata(version_split[0], version_split[1], conandata)
+                    return
+
+                conanfile = os.path.join(conan_dir, 'conanfile.py')
+                if os.path.exists(conanfile):
+                    revision, url = self.__getinfo_from_conanfile(conanfile)
+                    self.__update_code_by_commit_id(component_name, url, revision)
+                    return
+                log.error("conandata(%s) 和 conanfile(%s) 都没有找到", conandata, conanfile)
+            else:
                 conan_remote_list = tools.get_conan_remote_list(self.remote)
                 tools.download_conan_recipes(conan_version, conan_remote_list)
-            if os.path.exists(conandata):
-                FetchComponentCode.__update_component_code_by_conandata(version_split[0], version_split[1], conandata)
-                return
+                path_cmd = f"conan cache path {conan_version}"
+                path_cmd_info = Tools().run_command(path_cmd, capture_output=True)
 
-            conanfile = os.path.join(conan_dir, 'conanfile.py')
-            if os.path.exists(conanfile):
-                revision, url = FetchComponentCode.__getinfo_from_conanfile(conanfile)
-                FetchComponentCode.__update_code_by_commit_id(component_name, url, revision)
-                return
+                version_split = re.split(r'[/, @]', conan_version)
+                conan_dir = path_cmd_info.stdout.strip()
+                conandata = os.path.join(conan_dir, 'conandata.yml')
+                if os.path.exists(conandata):
+                    self.__update_component_code_by_conandata(version_split[0], version_split[1], conandata)
+                    return
 
-            log.error("conandata(%s) 和 conanfile(%s) 都没有找到", conandata, conanfile)
+                log.error("conandata(%s) 没有找到", conandata)
             log.info("更新组件 %s 代码到 %s 失败, 无法获取到 conan 信息", component_name,
                      conan_version)
         except Exception as exp:
             log.error("工作状态错误: %s", exp)
-            log.error("更新组件代码到 %s 失败", conan_version)
+            log.error("更新组件代码到 %s 失败", conan_version)