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

bmcgo/functional/conan_index_build.py

@@ -11,11 +11,9 @@
 # MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
 # See the Mulan PSL v2 for more details.
 import os
-import pathlib
 import subprocess
-import shutil
-import stat
 import json
+import re
 import yaml
 
 from bmcgo import errors
@@ -68,21 +66,31 @@ class BmcgoCommand:
     def __init__(self, bconfig: BmcgoConfig, *args):
         self.bconfig = bconfig
         parser = tool.create_common_parser("Conan Index Build")
+        parser.add_argument("--conan2", help="是否构建conan2.x版本的组件包", action=misc.STORE_TRUE)
         self.args, _ = parser.parse_known_args(*args)
+        self.conan2 = self.args.conan2
         self.path = ""
         self.version = ""
+        self.name = ""
+        self.user = ""
+        self.channel = ""
         self.conan_package = ""
         self.upload = False
         self.remote = None
         self.options = []
-        self.stage = misc.StageEnum.STAGE_DEV.value
+        self.stage = self.args.stage
         self.enable_luajit = False
         self.from_source = False
         self.build_type = 'debug'
         self.asan = False
         self.profile = ''
+        self.recipe_folder = self.bconfig.conan_index.folder
+        if misc.conan_v2():
+            recipes2_folder = os.path.join(self.bconfig.conan_index.folder, "..", "recipes2")
+            recipes2_folder = os.path.realpath(recipes2_folder)
+            if os.path.isdir(recipes2_folder):
+                self.recipe_folder = recipes2_folder
         self.initialize()
-        self.channel = f"@{misc.ConanUserEnum.CONAN_USER_DEV.value}/{self.stage}"
 
     @staticmethod
     def run_command(command, ignore_error=False, sudo=False, **kwargs):
@@ -109,13 +117,15 @@ class BmcgoCommand:
         os.environ["LUA_PATH"] = f"{conan_bin}/?.lua"
 
     def initialize(self):
+        if not self.args.conan_package:
+            msg = "构建参数错误，请指定有效的-cp参数，例：kmc/1.0.1 或 kmc/1.0.1@openubmc/stable"
+            raise errors.BmcGoException(msg)
         self.set_package(self.args.conan_package)
         self.upload = self.args.upload_package
         if self.args.remote:
             self.remote = self.args.remote
         if self.args.options:
             self.options = self.args.options
-        self.stage = self.args.stage
         self.enable_luajit = self.args.enable_luajit
         self.from_source = self.args.from_source
         self.build_type = self.args.build_type
@@ -126,15 +136,25 @@ class BmcgoCommand:
 
     # 入参可以是huawei_secure_c/1.0.0样式
     def set_package(self, path: str):
-        os.chdir(self.bconfig.conan_index.folder)
-        split = path.split("/")
-        if len(split) != 2:
-            raise errors.BmcGoException(f"包名称({path})错误，例：kmc/1.0.1")
+        os.chdir(self.recipe_folder)
+        split = re.split('/|@', path)
+        if len(split) != 2 and len(split) != 4:
+            raise errors.BmcGoException(f"包名称({path})错误，例：kmc/1.0.1 或 kmc/1.0.1@openubmc/stable")
+        self.name = split[0].lower()
+        if len(split) == 2:
+            if self.stage == "dev":
+                self.user = misc.conan_user_dev()
+            else:
+                self.user = misc.conan_user()
+            self.channel = self.stage
+        else:
+            self.user = split[2]
+            self.channel = split[3]
 
         if not os.path.isdir(split[0]):
             raise errors.BmcGoException(f"包路径({split[0]})不存在，或不是文件夹")
 
-        config_yaml = os.path.join(self.bconfig.conan_index.folder, split[0], "config.yml")
+        config_yaml = os.path.join(self.recipe_folder, split[0], "config.yml")
         with open(config_yaml) as f:
             config_data = yaml.safe_load(f)
             config_data = config_data.get('versions', None)
@@ -148,18 +168,47 @@ class BmcgoCommand:
                 raise errors.BmcGoException(f"Unkown folder, config.yml path: {config_yaml}, version: {split[1]}")
             self.path = "{}/{}".format(split[0], folder)
             self.version = split[1]
+            if misc.conan_v2():
+                self.version = self.version.lower()
             if self.stage != "dev":
                 self.tag_check()
 
-    def run(self):
+    def run_v2(self):
+        log.info("Start build package")
+        if self.build_type == "debug":
+            setting = "-s build_type=Debug"
+        else:
+            setting = "-s build_type=Release"
+        options = " "
+        if self.asan:
+            options += f"-o {self.name}/*:asan=True"
+        for option in self.options:
+            options += f" -o {option}"
+
+        dt_stat = os.environ.get("BINGO_DT_RUN", "off")
+        show_log = True if dt_stat == "off" else False
+        pkg = self.name + "/" + self.version + "@" + self.user + "/" + self.channel
+        append_cmd = f"-r {self.remote}" if self.remote else ""
+        cmd = "conan create . --name={} --version={} -pr={} {} {} {}".format(
+            self.name, self.version, self.profile, setting, append_cmd, options
+        )
+
+        cmd += " --user={} --channel={}".format(self.user, self.channel)
+        if self.from_source:
+            cmd += " --build=*"
+        else:
+            cmd += f" --build={self.name}/* --build=missing"
+        self.run_command(cmd, show_log=show_log)
+
+        if not self.upload:
+            return
+
+        cmd = "conan upload {} -r {}".format(pkg, self.remote)
+        self.run_command(cmd)
+        log.info("===>>>Upload package successfully, pkg: {}".format(pkg))
+
+    def run_v1(self):
         self.check_luac()
-        if self.path == "" or self.version == "":
-            raise errors.BmcGoException(f"Path({self.path}) or version({self.version}) error")
-        os.chdir(self.bconfig.conan_index.folder)
-        os.chdir(self.path)
-        if self.stage != misc.StageEnum.STAGE_DEV.value:
-            # rc和stable模式
-            self.channel = f"@{tool.conan_user}/{self.stage}"
         log.info("Start build package")
         if self.build_type == "dt":
             setting = "-s build_type=Dt"
@@ -177,7 +226,7 @@ class BmcgoCommand:
 
         dt_stat = os.environ.get("BMCGO_DT_RUN", "off")
         show_log = True if dt_stat == "off" else False
-        pkg = packake_name + "/" + self.version + self.channel
+        pkg = self.name + "/" + self.version + "@" + self.user + "/" + self.channel
         append_cmd = f"-r {self.remote}" if self.remote else ""
         cmd = "conan create . {} -pr={} -pr:b profile.dt.ini {} {} -tf None {}".format(
             pkg, self.profile, setting, append_cmd, options
@@ -206,6 +255,16 @@ class BmcgoCommand:
             self.run_command(cmd)
             log.info("===>>>Upload package successfully, pkg: {}:{}".format(pkg, i["id"]))
 
+    def run(self):
+        if self.path == "" or self.version == "":
+            raise errors.BmcGoException(f"Path({self.path}) or version({self.version}) error")
+
+        os.chdir(self.path)
+        if misc.conan_v1():
+            self.run_v1()
+        else:
+            self.run_v2()
+
     def tag_check(self):
         yaml_file = f"{self.path}/conandata.yml"
         if os.path.exists(yaml_file) is False:

bmcgo/functional/csr_build.py

@@ -46,7 +46,7 @@ cwd = os.getcwd()
 
 SR_UPGRADE = "SRUpgrade"
 TIANCHI = "bmc.dev.Board.TianChi"
-HPM_PACK_PATH = "/usr/share/bmcgo/csr_packet"
+HPM_PACK_PATH = "/usr/share/bingo/csr_packet"
 EEPROM_SIZE_LIMIT_CONFIG = "/usr/share/bmcgo/schema/eepromSizeLimit.json"
 
 JSON_DATA_FORMAT = 0x01

bmcgo/functional/diff.py

@@ -105,7 +105,7 @@ class BmcgoCommand:
         tempfile = NamedTemporaryFile()
         # 过滤只包含scm的信息, 并将其生成为字典对象
         ret = tools.run_command(f"conan info {version} --json {tempfile.name} \
-              -r {misc.CONAN_REPO}", ignore_error=True, command_echo=False, capture_output=True)
+              -r {misc.conan_remote()}", ignore_error=True, command_echo=False, capture_output=True)
         file_handler = open(tempfile.name, "r")
         conan_comps = json.load(file_handler)
         version_msg = ""

bmcgo/functional/fetch.py

@@ -163,7 +163,7 @@ framework、bmc_core、security、hardware、ras、energy、om、interface、pro
             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 __load_config_json(self, stage):

bmcgo/functional/full_component.py

@@ -23,8 +23,6 @@ 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
@@ -71,7 +69,7 @@ class BuildComponent:
         build_type: str,
         options: dict,
         code_path: str,
-        remote=misc.CONAN_REPO,
+        remote=misc.conan_remote(),
         service_json="mds/service.json",
         upload=False,
     ):
@@ -90,12 +88,15 @@ class BuildComponent:
     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}"
+            if misc.conan_v2():
+                self.option_cmd = self.option_cmd + f" -o {self.comp_name}/*:{key}={value}"
+            else:
+                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}")
+        log.info(f"执行构建命令{misc.tool_name()} build {command}")
         args = command.split()
         build = BuildComp(self.bconfig, args, service_json=self.service_json)
         # 恢复工作区为clean状态, 保证conan export时scm信息准确
@@ -112,7 +113,7 @@ 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("-r", "--remote", help="远端仓库名称", default=misc.conan_remote())
         parser.add_argument(
             "-p",
             "--path",
@@ -136,9 +137,11 @@ class BmcgoCommand:
         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]
+        self.profile_list = ["profile.dt.ini"]
+        if misc.conan_v1():
+            self.profile_list.append("profile.luajit.ini")
+        self.stage_list = [misc.StageEnum.STAGE_STABLE]
+        self.built_type_list = [misc.BuildTypeEnum.DEBUG, misc.BuildTypeEnum.RELEASE]
         if parsed_args.build_type:
             self.built_type_list = parsed_args.build_type
         self.options_dict = {}
@@ -185,7 +188,7 @@ class BmcgoCommand:
 
         # 添加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)
+        module_symver_key, module_symver_value = tool.get_171x_module_symver_option(module_symvers_path)
         if module_symver_key in options_dict:
             options_dict[module_symver_key] = [module_symver_value]
         if config_file:
@@ -237,24 +240,28 @@ class BmcgoCommand:
     @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)}"
-
+        if misc.conan_v1():
+            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}"
+        if misc.conan_v1():
+            comp_pkg = self.comp if "@" in self.comp else f"{self.comp}@{CONAN_USER}.release/{STAGE_STABLE}"
+        else:
+            comp_pkg = self.comp if "@" in self.comp else f"{self.comp}@{misc.conan_user()}/{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}")
+        args = "--only-recipe" if misc.conan_v2() else "--recipe"
+        tool.run_command(f"conan download {self._full_reference} {args} -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)
@@ -348,10 +355,11 @@ class BmcgoCommand:
             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
+            if misc.conan_v1():
+                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,

bmcgo/functional/git_history.py

@@ -0,0 +1,220 @@
+#!/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 argparse
+import datetime
+import json
+import os
+import re
+import sys
+from datetime import timezone, timedelta
+from typing import List, Tuple, Dict, Optional, Any
+from git import Repo, Commit, Diff
+from git.exc import InvalidGitRepositoryError, GitCommandError
+from bmcgo import misc
+from bmcgo.utils.tools import Tools
+from bmcgo.bmcgo_config import BmcgoConfig
+from bmcgo import errors
+
+
+tools = Tools()
+log = tools.log
+beijing_timezone = timezone(timedelta(hours=8))
+
+
+command_info: misc.CommandInfo = misc.CommandInfo(
+    group=misc.GRP_COMP,
+    name="git_history",
+    description=["获取指定开始时间与结束时间之间提交信息，并生成release note"],
+    hidden=False
+)
+
+
+def if_available(bconfig: BmcgoConfig):
+    if bconfig.component is None:
+        return False
+    return True
+
+
+class BmcgoCommand:
+    def __init__(self, bconfig: BmcgoConfig, *args):
+        self.bconfig = bconfig
+        parser = argparse.ArgumentParser(prog="bmcgo git_history", description="生成Git仓库的Release Note", add_help=True,
+            formatter_class=argparse.RawTextHelpFormatter)
+        parser.add_argument("--start_date", "-s", help="起始日期YYYY-MM-DD", required=True)
+        parser.add_argument("--end_date", "-e", help="结束日期YYYY-MM-DD，默认为当前日期")
+        args, kwargs = parser.parse_known_args(*args)
+        self.start_date = args.start_date
+        self.end_date = args.end_date
+        self.output_file = f"./{self.start_date}_{self.end_date}_releaseNote.log"
+        self.service_json_path = "mds/service.json"
+        self.repo = Repo(".")
+
+    @staticmethod
+    def validate_date(date_str: str) -> datetime.datetime:
+        try:
+            date = datetime.datetime.strptime(date_str, "%Y-%m-%d")
+        except ValueError as e:
+            raise errors.BmcGoException(f"日期格式不正确: {date_str}，请使用YYYY-MM-DD格式，错误信息{e}")
+        current_date = datetime.datetime.now(beijing_timezone)
+        if date.date() > current_date.date():
+            raise errors.BmcGoException(f"日期 {date_str} 超过当前日期")
+        return date
+
+    @staticmethod
+    def extract_version_from_diff(self, diff: Diff) -> Optional[str]:
+        try:
+            diff_text = diff.diff.decode('utf-8') if diff.diff else str(diff)
+            version_pattern = r'[-+]\s*"version"\s*:\s*"([^"]+)"'
+            matches = re.findall(version_pattern, diff_text)
+            if matches:
+                return matches[-1]
+        except (UnicodeDecodeError, AttributeError):
+            pass
+        return None
+
+    @staticmethod
+    def is_merge_into_main(s):
+        pattern = r'^merge .+ into main$'
+        # 使用re.match进行匹配，忽略大小写
+        match = re.match(pattern, s, re.IGNORECASE)
+        return match is not None
+
+    def get_current_version(self) -> str:
+        try:
+            with open(self.service_json_path, 'r') as f:
+                service_data = json.load(f)
+                return service_data.get('version', 'unknown')
+        except (FileNotFoundError, json.JSONDecodeError) as e:
+            raise errors.BmcGoException(f"无法读取或解析 {self.service_json_path}: {e}")
+
+    def get_commits_in_range(self, start_date: str, end_date: str) -> List[Commit]:
+        start_dt = self.validate_date(start_date)
+        if end_date is None:
+            end_dt = datetime.datetime.now(beijing_timezone)
+        else:
+            try:
+                end_dt = self.validate_date(end_date)
+            except errors.BmcGoException as e:
+                if "超过当前日期" in str(e):
+                    log.warning(f"警告: {e}，将使用当前日期作为结束日期")
+                    end_dt = datetime.datetime.now(beijing_timezone).replace(tzinfo=None)
+                else:
+                    raise
+        if end_dt < start_dt:
+            raise errors.BmcGoException("结束日期不能早于起始日期")
+        since_str = start_dt.strftime("%Y-%m-%d")
+        until_str = end_dt.strftime("%Y-%m-%d")
+        try:
+            commits = list(self.repo.iter_commits(
+                since=since_str,
+                until=until_str
+            ))
+        except GitCommandError as e:
+            raise errors.BmcGoException(f"获取commit记录时出错: {e}")
+        return commits
+
+    def get_version_from_commit(self, commit_hash: str) -> Optional[str]:
+        try:
+            commit = self.repo.commit(commit_hash)
+            try:
+                file_content = (commit.tree / self.service_json_path).data_stream.read().decode('utf-8')
+                data = json.loads(file_content)
+                version = data.get('version')
+                return version
+            except (KeyError, AttributeError):
+                log.error(f"在commit {commit_hash} 中找不到文件: {self.service_json_path}")
+                return None
+            except json.JSONDecodeError:
+                log.error(f"在commit {commit_hash} 中的 {self.service_json_path} 文件不是有效的JSON格式")
+                return None
+        except Exception as e:
+            log.error(f"获取commit {commit_hash} 的版本信息时出错: {e}")
+            return None
+
+    def get_version_info_for_commits(self, commits: List[Commit]) -> Dict[str, Any]:
+        version_info = {
+            'current_version': self.get_current_version(),
+            'commit_versions': {}
+        }
+        # 按时间顺序处理commit（从旧到新）
+        for commit in reversed(commits):
+            try:
+                if not self.is_merge_into_main(str(commit.summary)):
+                    continue
+                modified_version = self.get_version_from_commit(commit.hexsha)
+                message = commit.message.strip()
+                lines = message.splitlines()
+                if len(lines) >= 3:
+                    message = lines[2]
+                version_info['commit_versions'][commit.hexsha] = {
+                        'date': commit.committed_datetime.strftime("%Y-%m-%d"),
+                        'message': message,
+                        'version': modified_version if modified_version else version_info['current_version']
+                    }
+                if modified_version:
+                    version_info['current_version'] = modified_version
+            except Exception as e:
+                log.error(f"处理commit {commit.hexsha} 时出错: {e}")
+                message = commit.message.strip()
+                lines = message.splitlines()
+                if len(lines) >= 3:
+                    message = lines[2]
+                version_info['commit_versions'][commit.hexsha] = {
+                    'date': commit.committed_datetime.strftime("%Y-%m-%d"),
+                    'message': message,
+                    'version': version_info['current_version']
+                }
+        return version_info
+
+    def generate_release_note(self,
+                             start_date: str,
+                             end_date: str,
+                             output_file: str) -> str:
+        release_note = f"从{start_date}至{end_date}特性提交如下：\n"
+        commits = self.get_commits_in_range(start_date, end_date)
+        if not commits:
+            try:
+                release_note += f"无更新\n"
+                with open(output_file, 'w', encoding='utf-8') as f:
+                    f.write(release_note)
+                log.info(f"Release Note已保存到: {output_file}")
+            except IOError as e:
+                log.error(f"保存文件时出错: {e}")
+        version_info = self.get_version_info_for_commits(commits)
+
+        for commit in commits:
+            commit_info = version_info['commit_versions'].get(commit.hexsha, {})
+            if len(commit_info) == 0:
+                continue
+            release_note += f"-commit ID： {commit.hexsha}\n"
+            release_note += f"-修改描述： {commit_info.get('message')}\n"
+            release_note += f"-版本号： {commit_info.get('version')}\n"
+            release_note += f"-发布日期：{commit_info.get('date')}\n\n"
+        if output_file:
+            try:
+                with open(output_file, 'w', encoding='utf-8') as f:
+                    f.write(release_note)
+                log.info(release_note)
+                log.info(f"Release Note已保存到: {output_file}")
+            except IOError as e:
+                log.error(f"保存文件时出错: {e}")
+        return release_note
+
+    def run(self):
+        try:
+            _ = self.generate_release_note(
+                start_date=self.start_date,
+                end_date=self.end_date,
+                output_file=self.output_file
+            )
+        except (ValueError, RuntimeError) as e:
+            log.error(f"错误: {e}")

bmcgo/functional/maintain.py

@@ -26,6 +26,7 @@ from bmcgo.component.build import BuildComp
 from bmcgo import errors
 from bmcgo.bmcgo_config import BmcgoConfig
 from bmcgo import misc
+from bmcgo import errors
 
 tool = Tools("maintain")
 log = tool.log
@@ -89,22 +90,33 @@ class BmcgoCommand:
     def __init__(self, bconfig: BmcgoConfig, *args):
         self.patch_file = []
         self.bconfig = bconfig
-        parser = argparse.ArgumentParser(prog="bmcgo maintain", description="BMC组件的维护管理工具", add_help=True,
-                                         formatter_class=argparse.RawTextHelpFormatter)
-        parser.add_argument("-cp", "--conan_package", help="指定需要维护的组件版本，示例：component/1.2.3", required=True)
+        parser = argparse.ArgumentParser(prog=f"{misc.tool_name()} maintain", description="BMC组件的维护管理工具",
+                                         add_help=True, formatter_class=argparse.RawTextHelpFormatter)
+        if misc.conan_v1():
+            parser.add_argument("-cp", "--conan_package", help="指定需要维护的组件版本，示例：component/1.2.3", required=True)
+        else:
+            parser.add_argument("-cp", "--conan_package",
+                                help="指定需要维护的组件版本，示例：component/1.2.3@{misc.conan_user()}/stable", required=True)
         parser.add_argument("-p", "--patch_file", help="添加patch文件，可指定多个，顺序追加到代码中", action='append')
         parser.add_argument("-b", "--branch", help="用于提取patch的分支，与commit_id配合使用", default="master")
         parser.add_argument("-c", "--commit_id", help="需要生成patch的提交节点，长度不低于8个字符，可指定多个，顺序追加到代码中",
                             action='append')
         parser.add_argument("-v", "--version", help="指定需要生成的组件版本号", default=None)
-        parser.add_argument("-r", "--remote", default=misc.CONAN_REPO,
+        parser.add_argument("-r", "--remote", default=misc.conan_remote(),
                             help="conan远程仓，请检查conan remote list查看已配置的conan仓")
         parsed_args = parser.parse_args(*args)
         cp = parsed_args.conan_package
-        if (not re.match("^[a-zA-Z0-9_-]+/([1-9][0-9]*|[0-9])\.[0-9]+\.[0-9]+$", cp) and
-           not re.match("^[a-zA-Z0-9_-]+/(([1-9][0-9]*|[0-9])\.[0-9]+\.[0-9]+)(-build\.[0-9]+)$", cp) and
-           not re.match("^[a-zA-Z0-9_-]+/(([1-9][0-9]*|[0-9])\.[0-9]+\.[0-9]+)(.p[0-9]+)$" + cp)):
-            raise errors.BmcGoException("-cp参数错误，不满足格式\"<name>/<version>\"要求")
+        if misc.conan_v1():
+            if (not re.match("^[a-zA-Z0-9_-]+/([1-9][0-9]*|[0-9])\.[0-9]+\.[0-9]+$", cp) and
+            not re.match("^[a-zA-Z0-9_-]+/(([1-9][0-9]*|[0-9])\.[0-9]+\.[0-9]+)(-build\.[0-9]+)$", cp) and
+            not re.match("^[a-zA-Z0-9_-]+/(([1-9][0-9]*|[0-9])\.[0-9]+\.[0-9]+)(.p[0-9]+)$" + cp)):
+                raise errors.BmcGoException("-cp参数错误，不满足格式\"<name>/<version>\"要求")
+        else:
+            restr = misc.CONAN_NAME_RESTR
+            if (not re.match(f"^{restr}/([1-9][0-9]*|[0-9])\.[0-9]+\.[0-9]+@{restr}/{restr}$", cp) and
+            not re.match(f"^{restr}/(([1-9][0-9]*|[0-9])\.[0-9]+\.[0-9]+)(-build\.[0-9]+)@{restr}/{restr}$", cp) and
+            not re.match(f"^{restr}/(([1-9][0-9]*|[0-9])\.[0-9]+\.[0-9]+)(.p[0-9]+)@{restr}/{restr}$" + cp)):
+                raise errors.BmcGoException("-cp参数错误，不满足格式\"<name>/<version>@user/channel\"要求")
         self.conan_package = cp
         self.name = self.conan_package.split("/")[0]
         self.base_version = self.conan_package.split("/")[1]
@@ -127,7 +139,7 @@ class BmcgoCommand:
             if re.match(r"^[a-f0-9]{8,40}$", commit) is None:
                 raise errors.ConfigException(f"参数错误, --commit_id({commit}) 格式错误")
         self.patch_description = ""
-        self.dir = tempfile.TemporaryDirectory(prefix="bmcgo_maint")
+        self.dir = tempfile.TemporaryDirectory(prefix="bingo_maint")
         for file in self.patch_file:
             if not os.path.isfile(file):
                 raise errors.BmcGoException(f"补丁文件 {file} 不存在")
@@ -182,11 +194,36 @@ class BmcgoCommand:
         log.success(f"生成维护版本 {self.name}/{self.next_version} 成功")
         return 0
 
-    def _fetch_conan_info(self):
-        user = tool.conan_user
+    def _fetch_conan_info_v2(self):
+        args = "--only-recipe" if misc.conan_v2() else "--recipe"
+        cmd = f"conan download {self.conan_package} -r {self.remote} {args}"
+        tool.run_command(cmd, error_log=f"组件 {self.conan_package} 未找到，请检查网络连接以及该版本是否已发布")
+        cmd = f"conan cache path {self.conan_package}"
+        export_path = tool.run_command(cmd, capture_output=True, shell=True).stdout.strip()
+        conanfile = os.path.join(export_path, "conanfile.py")
+        conandata = os.path.join(export_path, "conandata.yml")
+        if not os.path.isfile(conandata):
+            raise errors.BmcGoException(f"未找到组件 {self.conan_package} 的conandata.yml文件")
+        log.info(f"从 {conandata} 读取源码tag的url")
+        # 尝试从conandata中获取代码仓地址
+        with open(conandata, "r") as fp:
+            data = yaml.safe_load(fp)
+        cfg = data.get("sources", {}).get(self.base_version)
+        if cfg is None:
+            raise RuntimeError(f"${conandata}不存在组件 {self.conan_package} 配置, 请检查是否正确")
+        self.url = cfg.get("url")
+        self.tag = cfg.get("branch")
+        if re.match("^refs/tags/[0-9]+\\.[0-9]+\\.[0-9]+$", self.tag):
+            self.tag = self.tag[len("refs/tags/"):]
+        elif not self.tag:
+            self.tag = self.base_version
+
+    def _fetch_conan_info_v1(self):
+        user = misc.conan_user()
+        args = "--only-recipe" if misc.conan_v2() else "--recipe"
         export_path = os.path.join(tool.conan_data, self.conan_package, f"{user}/stable", "export")
         if not os.path.isdir(export_path):
-            cmd = f"conan download {self.conan_package}@{user}/stable -r {self.remote} -re"
+            cmd = f"conan download {self.conan_package}@{user}/stable -r {self.remote} {args}"
             tool.run_command(cmd, error_log=f"组件 {self.conan_package} 未找到，请检查网络连接以及该版本是否已发布")
         conanfile = os.path.join(export_path, "conanfile.py")
         conandata = os.path.join(export_path, "conandata.yml")
@@ -216,6 +253,12 @@ class BmcgoCommand:
             else:
                 raise RuntimeError("无法找到版本(revision)和地址(url)字段")
 
+    def _fetch_conan_info(self):
+        if misc.conan_v1():
+            self._fetch_conan_info_v1()
+        else:
+            self._fetch_conan_info_v2()
+
     def _update_next_version(self):
         self.next_version = self.arg_special_version
         if not self.next_version: