openubmc-bingo 0.5.275__py3-none-any.whl → 0.6.0__py3-none-any.whl

bmcgo/component/component_dt_version_parse.py

@@ -200,7 +200,7 @@ class ManifestConfigParse:
 class ComponentDtVersionParse:
     """分析组件 dt 的依赖组件版本, 实现自动配置 service.json 文件, 达成 dt 构建门禁
     """
-    def __init__(self, parser=None, serv_file="mds/service.json", args=None):
+    def __init__(self, parser=None, serv_file="mds/service.json", args=None, exclude_dt=False):
         """初始化，读取配置
 
         Args:
@@ -221,7 +221,8 @@ class ComponentDtVersionParse:
             self.mds_conf = json.load(mds_conf_fp)
             mds_conf_fp.close()
         # 生成dt与build的依赖列表, 检查时如果发现问题, 直接报出组件名, 不分类
-        conan_dt_list = Function.get_key_value(self.mds_conf, "dependencies/test") or []
+        if not exclude_dt:
+            conan_dt_list = Function.get_key_value(self.mds_conf, "dependencies/test") or []
         conan_build_list = Function.get_key_value(self.mds_conf, "dependencies/build") or []
         # 根据配置文件，已确定为列表，有告警，无需使用list转化，影响效率
         self.conan_list = conan_dt_list + conan_build_list

bmcgo/component/component_helper.py

@@ -19,7 +19,7 @@ from tempfile import NamedTemporaryFile
 from packaging import version
 
 from bmcgo.utils.tools import Tools
-from bmcgo.bmcgo_config import misc
+from bmcgo import misc
 from bmcgo.errors import BmcGoException
 
 STAGE_DEV = "dev"
@@ -40,9 +40,15 @@ class DownloadComponentRecipe(Process):
         self.remote_list = remote_list
 
     def run(self):
-        dep_path = os.path.join(self.tools.conan_data, self.comp.replace("@", "/"))
-        if os.path.isdir(dep_path):
-            return
+        if misc.conan_v1():
+            dep_path = os.path.join(self.tools.conan_data, self.comp.replace("@", "/"))
+            if os.path.isdir(dep_path):
+                return
+        else:
+            cmd = f"conan cache path {self.comp}"
+            ret = self.tools.run_command(cmd, capture_output=True, ignore_error=True)
+            if ret.returncode == 0:
+                return
         self.tools.download_conan_recipes(self.comp, self.remote_list)
 
 
@@ -123,17 +129,26 @@ class ComponentHelper:
     @staticmethod
     def download_recipes(depdencies: List[str], tools: Tools, remote_list):
         pools = []
+        ignore_error = os.getenv("CLOUD_BUILD_IGNORE_ERROR")
         for dep in depdencies:
             task = DownloadComponentRecipe(tools, dep, remote_list)
             task.start()
             pools.append(task)
-
+            # 减少并发数，避免CI场景连接过多导致服务器无法处理导致的失败
+            while len(pools) > 4:
+                time.sleep(0.1)
+                for pool in pools.copy():
+                    if pool.is_alive():
+                        continue
+                    if pool.exitcode is not None and pool.exitcode != 0 and not ignore_error:
+                        tools.log.warning(f"下载组件 ({pool.comp}) 的构建配方(recipe)失败, 退出码: {pool.exitcode}")
+                    pools.remove(pool)
         while pools:
             time.sleep(0.1)
             for pool in pools.copy():
                 if pool.is_alive():
                     continue
-                if pool.exitcode is not None and pool.exitcode != 0:
+                if pool.exitcode is not None and pool.exitcode != 0 and not ignore_error:
                     raise BmcGoException(f"下载组件 ({pool.comp}) 的构建配方(recipe)失败, 退出码: {pool.exitcode}")
                 pools.remove(pool)
 
@@ -144,18 +159,31 @@ class ComponentHelper:
         dependencies = set()
         tempfile = NamedTemporaryFile()
         for comp in components:
-            if not re.match(ComponentHelper.CONAN_PAKCAGE_RE, comp):
-                raise BmcGoException(f"组件 {comp} 不符合正则 {ComponentHelper.CONAN_PAKCAGE_RE}")
-            cmd = f'conan info "{comp}" --remote {remote} --json {tempfile.name}'
+            if misc.conan_v1():
+                if not re.match(ComponentHelper.CONAN_PAKCAGE_RE, comp):
+                    raise BmcGoException(f"组件 {comp} 不符合正则 {ComponentHelper.CONAN_PAKCAGE_RE}")
+                cmd = f'conan info "{comp}" --remote {remote} --json {tempfile.name}'
+            else:
+                if not misc.conan_package_match(comp):
+                    raise BmcGoException(f"组件 {comp} 不符合正则 {misc.CONAN_NAME_RESTR}")
+                cmd = f'conan graph info --requires="{comp}" --remote {remote} -f json --out-file={tempfile.name}'
             tools.run_command(cmd)
 
             file_handler = open(tempfile.name, "r")
             conan_comps = json.load(file_handler)
-            for conan_comp in conan_comps:
-                comp_ref = conan_comp.get("reference", "")
-                if not comp_ref or comp_ref == comp:
-                    continue
-                dependencies.add(comp_ref)
+            if misc.conan_v1():
+                for conan_comp in conan_comps:
+                    comp_ref = conan_comp.get("reference", "")
+                    if not comp_ref or comp_ref == comp:
+                        continue
+                    dependencies.add(comp_ref)
+            else:
+                deps = conan_comps.get("graph", {}).get("nodes", {}).get("0", {}).get("dependencies", {})
+                for _, conan_comp in deps.items():
+                    comp_ref = conan_comp.get("ref", "")
+                    if not comp_ref or comp_ref == comp:
+                        continue
+                    dependencies.add(comp_ref)
             file_handler.close()
 
         return list(dependencies)
@@ -164,5 +192,5 @@ class ComponentHelper:
     def get_user_channel(stage: str):
         if stage == misc.StageEnum.STAGE_DEV.value:
             stage = misc.StageEnum.STAGE_RC.value
-        user_channel = f"@{Tools().conan_user}/{stage}"
+        user_channel = f"@{misc.conan_user()}/{stage}"
         return user_channel

bmcgo/component/coverage/incremental_cov.py

@@ -85,9 +85,9 @@ class GcovHTMLParser(HTMLParser):
             for a in attrs:
                 if a == ("class", "lineNum"):
                     self.is_line_num = True
-                if a == ("class", "lineNoCov"):
+                if a == ("class", "lineNoCov") or a == ("class", "tlaUNC"):
                     self.uncovers.append(self.line_num)
-                if a == ("class", "lineCov"):
+                if a == ("class", "lineCov") or a == ("class", "tlaGNC"):
                     self.covers.append(self.line_num)
 
     def handle_data(self, data):

bmcgo/component/deploy.py

@@ -12,6 +12,7 @@
 import os
 import shutil
 import stat
+import json
 import yaml
 
 from mako.lookup import TemplateLookup
@@ -28,6 +29,24 @@ log = Logger("deploy")
 cwd_script = os.path.split(os.path.realpath(__file__))[0]
 
 
+class GraphNode:
+    def __init__(self, node):
+        if not node:
+            self.name = None
+            self.package_folder = None
+            self.recipe_folder = None
+            self.package_id = None
+            self.ref = None
+            self.node = node
+            return
+        self.name = node.get("name")
+        self.package_folder = node.get("package_folder")
+        self.recipe_folder = node.get("recipe_folder")
+        self.package_id = node.get("package_id")
+        self.ref = node.get("ref")
+        self.node = node
+
+
 class DeployComp():
     def __init__(self, bconfig: BmcgoConfig, info: InfoComp = None):
         self.info: InfoComp = info
@@ -35,6 +54,19 @@ class DeployComp():
         self.folder = bconfig.component.folder
         os.chdir(self.folder)
         self.temp_path = os.path.join(self.folder, "temp")
+        self.graph_nodes: dict[str, GraphNode] = {}
+
+    @staticmethod
+    def copy_packages_v1(install_path, rootfs_path):
+        for sub_dir in os.listdir(install_path):
+            dir_path = os.path.join(install_path, sub_dir)
+            if os.path.isfile(dir_path):
+                os.unlink(dir_path)
+                continue
+            for file in os.listdir(dir_path):
+                source = os.path.join(dir_path, file)
+                cmd = ["/usr/bin/cp", "-arf", source, rootfs_path]
+                Helper.run(cmd)
 
     def get_dt_dependencies(self):
         user_channel = ComponentHelper.get_user_channel(self.info.stage)
@@ -61,12 +93,15 @@ class DeployComp():
         return dependencies
 
     def gen_conanfile(self):
-        dependencies = [f"{self.info.name}/{self.info.version}{self.info.channel}"]
-        if self.info.build_type == "dt":
+        dependencies = self.info.package
+        if self.info.test:
             dependencies += self.get_dt_dependencies()
 
         # 构建虚拟deploy组件，生成conanfile.py文件
-        lookup = TemplateLookup(directories=os.path.join(cwd_script, "template"))
+        if misc.conan_v1():
+            lookup = TemplateLookup(directories=os.path.join(cwd_script, "template"))
+        else:
+            lookup = TemplateLookup(directories=os.path.join(cwd_script, "template_v2"))
         template = lookup.get_template("conanfile.deploy.py.mako")
         conanfile = template.render(lookup=lookup, pkg=self.info, dependencies=dependencies)
         file_handler = os.fdopen(os.open("conanfile.py", os.O_WRONLY | os.O_CREAT | os.O_TRUNC,
@@ -74,6 +109,25 @@ class DeployComp():
         file_handler.write(conanfile)
         file_handler.close()
 
+    def copy_packages_v2(self, graph_file, rootfs_path=None):
+        if not rootfs_path:
+            rootfs_path = self.temp_path
+        with open(graph_file, "r") as file_handler:
+            package_info = json.load(file_handler)
+        nodes: dict[str, dict] = package_info.get("graph", {}).get("nodes", {})
+        self.graph_nodes = {}
+        for _, node in nodes.items():
+            if node.get("context") != "host":
+                continue
+            gn = GraphNode(node)
+            self.graph_nodes[gn.name] = gn
+            if not gn.package_folder:
+                continue
+            for file in os.listdir(gn.package_folder):
+                source = os.path.join(gn.package_folder, file)
+                cmd = ["/usr/bin/cp", "-arf", source, rootfs_path]
+                Helper.run(cmd)
+
     def run(self):
         # 生成虚拟deploy组件，仅用于安装
         deploy_conan = os.path.join(self.temp_path, ".deploy")
@@ -86,8 +140,13 @@ class DeployComp():
         log.info("安装所有依赖到目录 %s", install_path)
         shutil.rmtree(install_path, ignore_errors=True)
         cmd = [misc.CONAN, "install"]
-        append_cmd = ("%s -if=%s -g deploy" % (self.info.cmd_base, install_path))
-        append_cmd = append_cmd.replace(self.info.package, self.info.channel)
+        graph_file = "package.info.json"
+        if misc.conan_v2():
+            append_cmd = ("%s -of=%s -d=full_deploy -f json --out-file=%s" %
+                          (self.info.cmd_base, install_path, graph_file))
+        else:
+            append_cmd = ("%s -if=%s -g deploy" % (self.info.cmd_base, install_path))
+            append_cmd = append_cmd.replace(self.info.package, self.info.channel)
         cmd += append_cmd.split()
         cmd.append("--build=missing")
         log.success("运行部署命令: %s", " ".join(cmd))
@@ -96,13 +155,8 @@ class DeployComp():
         rootfs_path = self.temp_path
         log.info("复制所有依赖到目录 %s", rootfs_path)
         os.makedirs(rootfs_path, exist_ok=True)
-        for sub_dir in os.listdir(install_path):
-            dir_path = os.path.join(install_path, sub_dir)
-            if os.path.isfile(dir_path):
-                os.unlink(dir_path)
-                continue
-            for file in os.listdir(dir_path):
-                source = os.path.join(dir_path, file)
-                cmd = ["/usr/bin/cp", "-arf", source, rootfs_path]
-                Helper.run(cmd)
+        if misc.conan_v2():
+            self.copy_packages_v2(graph_file, rootfs_path)
+        else:
+            self.copy_packages_v1(install_path, rootfs_path)
         shutil.rmtree(install_path, ignore_errors=True)

bmcgo/component/gen.py

@@ -107,7 +107,7 @@ class GenComp():
     def run(self, base_version=-1):
         language = ComponentHelper.get_language().lower()
         parser = argparse.ArgumentParser(description="代码自动生成.",
-                                         prog="bingo gen/当前只支持C和lua语言代码生成",
+                                         prog=f"{misc.tool_name()} gen/当前只支持C和lua语言代码生成",
                                          formatter_class=SmartFormatter)
         parser.add_argument("-v", "--version", help="use specified version", type=int, default=-1)
         parser.add_argument("-r", "--remote", help="conan remote, 如不设置则默认读取本地conan配置")

bmcgo/component/package_info.py

@@ -22,9 +22,11 @@ from bmcgo.codegen import __version__ as codegen_version
 from bmcgo.logger import Logger
 from bmcgo.utils.tools import Tools
 from bmcgo import misc
+from bmcgo import errors
 from bmcgo.component.component_helper import ComponentHelper
 
 global log
+tools = Tools()
 log = Logger()
 
 cwd = os.getcwd()
@@ -40,22 +42,28 @@ class CodegenPolicyError(OSError):
 
 
 class InfoComp():
-    def __init__(self, args=None, service_json="mds/service.json", partner_mode=False):
-        parser = self.arg_parser(True, partner_mode)
+    def __init__(self, args=None, service_json="mds/service.json", partner_mode=False, enable_upload=True):
+        self.enable_upload = enable_upload
+        self.package = ""
+        self.setting = ""
+        self.full_profile = ""
+        self.cmd_base = ""
+        parser = self.arg_parser(True, partner_mode, enable_upload)
         self.parse_args(parser, args, service_json)
 
     @staticmethod
-    def arg_parser(add_help=False, partner_mode=False):
+    def arg_parser(add_help=False, partner_mode=False, enable_upload=True):
         stage_values = [member.value for member in misc.StageEnum]
-        parser = argparse.ArgumentParser(prog="bingo build", description="Build conan", add_help=add_help,
+        parser = argparse.ArgumentParser(prog=f"{misc.tool_name()} build", description="Build conan", add_help=add_help,
                                          formatter_class=argparse.RawTextHelpFormatter)
-        parser.add_argument("-bt", "--build_type", default="debug", help="构建类型，可选：dt,debug,release\n默认：debug")
+        parser.add_argument("-bt", "--build_type", default="debug", help=f"构建类型，可选：{misc.build_type_str()}\n默认：debug")
         parser.add_argument(
-            "--stage", 
-            help=f"组件包发布阶段, 可选: {stage_values}\n默认：{misc.StageEnum.STAGE_DEV.value}", 
+            "--stage",
+            help=f"组件包发布阶段, 可选: {stage_values}\n默认：{misc.StageEnum.STAGE_DEV.value}",
             default=misc.StageEnum.STAGE_DEV.value
         )
-        parser.add_argument("-u", "--upload", action=misc.STORE_TRUE, help="上传组件包到conan仓")
+        if enable_upload:
+            parser.add_argument("-u", "--upload", action=misc.STORE_TRUE, help="上传组件包到conan仓")
         parser.add_argument(
             "-r", "--remote", help=f"conan仓别名，请检查conan remote list查看已配置的conan仓"
         )
@@ -71,14 +79,19 @@ class InfoComp():
         )
         parser.add_argument("-nc", "--no_cache",
                             help="不使用~/.conan/data目录下的缓存包(构建前删除缓存)", action=misc.STORE_FALSE)
-        parser.add_argument("-o", "--options", help="Define options values (host machine), e.g.: -o Pkg:with_qt=true",
-                            action='append', default=[])
+        if misc.conan_v2():
+            parser.add_argument("-o", "--options", action='append', default=[],
+                                help="Define options values (host machine), e.g.: -o Pkg/*:with_qt=True")
+        else:
+            parser.add_argument("-o", "--options", action='append', default=[],
+                                help="Define options values (host machine), e.g.: -o Pkg:with_qt=True")
         parser.add_argument(
             "--user",
-            help=f"指定conan包的user字段，尝试从{misc.GLOBAL_CFG_FILE}文件读取conan.user字段，否则由程序管理",
+            help=f"指定conan包的user字段，未指定时依次尝试读取mds/service.json的user字段，都未指定时使用'{misc.conan_user()}'",
             default=None
         )
         parser.add_argument("-cov", "--coverage", help=argparse.SUPPRESS, action=misc.STORE_TRUE)
+        parser.add_argument("-test", "--test", help=argparse.SUPPRESS, action=misc.STORE_TRUE)
         parser.add_argument(
             "-as",
             "--asan",
@@ -92,11 +105,14 @@ class InfoComp():
             help=argparse.SUPPRESS if partner_mode else Tools.get_profile_arg_help(),
             default="",
         )
+        profile_name = tools.get_conan_profile("", "", True)
+        profile_file = os.path.join(tools.conan_profiles_dir, profile_name)
+        default_enable_luajit = partner_mode and os.path.isfile(profile_file)
         parser.add_argument(
             "-jit",
             "--enable_luajit",
-            help=argparse.SUPPRESS if partner_mode else "Enable luajit",
-            action=misc.STORE_FALSE if partner_mode else misc.STORE_TRUE,
+            help=argparse.SUPPRESS if default_enable_luajit else "Enable luajit",
+            action=misc.STORE_FALSE if default_enable_luajit else misc.STORE_TRUE,
         )
         return parser
 
@@ -104,7 +120,9 @@ class InfoComp():
     def get_codegen_policy(service_data) -> Tuple[str, int]:
         # 代码自动生成工具版本号检查
         policy = ComponentHelper.get_config_value(service_data, "codegen_policy", {})
-        code_version = policy.get("version", ">=0")
+        if "codeGenPolicy" in service_data:
+            policy = ComponentHelper.get_config_value(service_data, "codeGenPolicy", {})
+        code_version = policy.get("version", "3")
         if not isinstance(code_version, str):
             code_version = str(code_version)
         code_language = policy.get("language", "c")
@@ -116,54 +134,80 @@ class InfoComp():
         if code_version.startswith(">="):
             codegen_base_version = int(code_version[2:])
             if codegen_base_version > codegen_version:
-                raise CodegenVersionNotMatchError("代码自动生成要求的版本号大于当前bmcgo工具提供的版本号，建议升级到最新版本")
+                raise CodegenVersionNotMatchError(f"代码自动生成要求的版本号大于当前{misc.tool_name()}工具提供的版本号，建议升级到最新版本")
             codegen_base_version = codegen_version
         else:
             codegen_base_version = int(code_version)
         return code_language, codegen_base_version
 
+    @staticmethod
+    def get_dependencies_v2(service_data, key):
+        dependencies = []
+        user_channel = f"@{misc.conan_user()}/stable"
+        deps = ComponentHelper.get_config_value(service_data, key, [])
+        for dep in deps:
+            conan = dep.get(misc.CONAN)
+            if conan is None:
+                log.info("获取 conan 依赖失败, 跳过未知组件")
+                continue
+            if conan.find("@") < 0:
+                conan += user_channel
+            if not misc.conan_package_match(conan, True):
+                raise errors.BmcGoException(f"未正确定义依赖组件的名称: {conan}")
+            dependencies.append(conan)
+
+        return dependencies
+
     def parse_args(self, parser, args, service_json):
         self.args, _ = parser.parse_known_args(args)
         self.build_type = self.args.build_type
         self.stage = self.args.stage
-        self.upload = self.args.upload
+        if self.enable_upload:
+            self.upload = self.args.upload
+        else:
+            self.upload = False
         self.from_source = self.args.from_source
         self.options = self.args.options
         self.coverage = self.args.coverage
         self.asan = self.args.asan
         self.remote = self.args.remote
+        self.user = self.args.user
+        self.test = self.args.test
         self.no_cache = self.args.no_cache and (not os.getenv('NOT_CLEAN_CONAN_CACHE') == 'True')
         # 是否是维护模式
         self.is_maintain = self.args.maintain
         self.enable_luajit = self.args.enable_luajit
-        self.profile = Tools.get_conan_profile(self.args.profile, self.build_type, self.enable_luajit)
+        self.profile = Tools.get_conan_profile(self.args.profile, self.build_type, self.enable_luajit, self.test)
+        if self.profile == "profile.luajit.ini":
+            self.enable_luajit = True
 
         os.environ["ROOTFS_DIR"] = os.path.join(cwd, "temp")
         stage_values = [member.value for member in misc.StageEnum]
         if self.stage not in stage_values:
             raise OSError(f"参数 stage 错误, 请从 {stage_values} 中选择")
         # 构建阶段检查
-        build_types = ["dt", "debug", "release"]
-        if self.build_type not in build_types:
-            raise OSError("参数 build_type 错误, 请从 [debug, release, dt] 中选择")
+        if self.build_type not in misc.build_type():
+            raise OSError(f"参数 build_type 错误, 请从 {misc.build_type_str()} 中选择")
         if self.upload and not self.remote:
             raise OSError("参数 remote 必填")
 
-        # 只有指定为pre时才增加prerelease编码
-        pre = ""
-        if self.stage == misc.StageEnum.STAGE_PRE:
-            self.stage = misc.StageEnum.STAGE_DEV
-            now = datetime.datetime.utcnow()
-            pre = "-pre." + now.strftime("%Y%m%d%H%M%S")
+        if misc.conan_v1():
+            # 只有指定为pre时才增加prerelease编码
+            pre = ""
+            if self.stage == misc.StageEnum.STAGE_PRE:
+                self.stage = misc.StageEnum.STAGE_DEV
+                now = datetime.datetime.utcnow()
+                pre = "-pre." + now.strftime("%Y%m%d%H%M%S")
 
-        # 尝试从/etc/bmcgo.conf读取user配置
-        user = self._get_package_user()
-        self.channel = f"@{user}/{self.stage}"
-
-        self._parse_service_json(service_json, pre)
+            # 尝试从/etc/bmcgo.conf读取user配置
+            user = self._get_package_user()
+            self.channel = f"@{user}/{self.stage}"
+            self._parse_service_json(service_json, pre)
+        else:
+            self._parse_service_json(service_json)
         self._conan_define()
 
-    def get_dependencies(self, service_data, key):
+    def get_dependencies_v1(self, service_data, key):
         dependencies = []
         user_channel = ComponentHelper.get_user_channel(self.stage)
         deps = ComponentHelper.get_config_value(service_data, key, [])
@@ -178,14 +222,51 @@ class InfoComp():
                 dependencies.append(conan + user_channel)
         return dependencies
 
+    def get_dependencies(self, service_data, key):
+        if misc.conan_v1():
+            return self.get_dependencies_v1(service_data, key)
+        else:
+            return self.get_dependencies_v2(service_data, key)
+
     def _conan_define(self):
+        if misc.conan_v1():
+            self._conan_define_v1()
+        else:
+            self._conan_define_v2()
+
+    def _conan_define_v2(self):
+        self.package = "%s/%s@%s/%s" % (self.name, self.version, self.user, self.stage)
+        profiles = [f"-pr:h {self.profile}"]
+        profiles.append("-pr:b default")
+        if self.enable_luajit:
+            self.options.append("*/*:enable_luajit=True")
+        if self.build_type == "debug":
+            self.setting = "-s:a build_type=Debug"
+        else:
+            self.setting = "-s:a build_type=Release"
+        self.full_profile = " ".join(profiles)
+        self.cmd_base = ". %s %s " % (self.full_profile, self.setting)
+        self.cmd_base += "%s %s " % (f"--user {self.user}", f"--channel {self.stage}")
+        if self.remote:
+            self.cmd_base += "-r %s " % self.remote
+        if self.options:
+            for option in self.options:
+                self.cmd_base += " -o " + option
+        if self.coverage:
+            self.cmd_base += f" -o {self.name}/*:gcov=True"
+        if self.asan:
+            self.cmd_base += f" -o {self.name}/*:asan=True"
+        if self.test:
+            self.cmd_base += f" -o */*:test=True"
+
+    def _conan_define_v1(self):
         self.package = "%s/%s%s" % (self.name, self.version, self.channel)
         profiles = [f"-pr:h {self.profile}"]
         if self.build_type == "dt":
             self.setting = "-s build_type=Dt"
         else:
             profiles.append("-pr:b profile.dt.ini")
-            if self.enable_luajit:
+            if self.enable_luajit or misc.community_name() == "openubmc":
                 self.options.append("skynet:enable_luajit=True")
             if self.build_type == "debug":
                 self.setting = "-s build_type=Debug"
@@ -215,17 +296,26 @@ class InfoComp():
             user = None
         if user is None:
             if self.stage == misc.StageEnum.STAGE_DEV.value:
-                user = misc.ConanUserEnum.CONAN_USER_DEV.value
+                user = misc.conan_user_dev()
             else:
-                user = misc.ConanUserEnum.CONAN_USER_RELEASE.value
+                user = misc.conan_user()
         return user
 
-    def _parse_service_json(self, service_json: str, pre: str):
+    def _parse_service_json(self, service_json: str, pre: str = ""):
         self.language = ComponentHelper.get_language(service_json=service_json)
         with open(service_json, "r", encoding="UTF-8") as file_handler:
             data = json.load(file_handler)
-            self.version = ComponentHelper.get_config_value(data, "version") + pre
-            self.name = data.get("name")
+            if misc.conan_v2():
+                self.language = data.get("language", "lua")
+                if not self.user:
+                    self.user = data.get("user", misc.conan_user()).lower()
+                    if self.stage == "dev":
+                        self.user += ".dev"
+                self.version = ComponentHelper.get_config_value(data, "version").lower()
+                self.name = data.get("name").lower()
+            else:
+                self.version = ComponentHelper.get_config_value(data, "version") + pre
+                self.name = data.get("name")
             # 编译依赖
             self.build_dependencies = self.get_dependencies(data, "dependencies/build")
             # 开发者测试依赖