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

bmcgo/component/template_v2/conanbase.py.mako

@@ -0,0 +1,352 @@
+import os
+import urllib3
+import time
+import concurrent.futures
+% if pkg.is_maintain:
+import stat
+import shutil
+% endif
+from conan import ConanFile
+from conan.tools.scm import Git
+from conan.tools.cmake import CMake, CMakeToolchain, cmake_layout
+from conan.tools.files import copy, update_conandata, chdir, rm
+from conan.errors import ConanInvalidConfiguration
+% if language == "c":
+from bmcgo.component.gen import GenComp
+% endif
+% if pkg.is_maintain:
+from conans import tools
+from conans.util.files import mkdir
+from conan.tools.files import patch as apply_patch
+from conans.errors import ConanException
+% endif
+
+urllib3.disable_warnings()
+
+# 构建时由工具自动生成到业务仓，做为conanfile.py的基类参与组件构建
+# 如需要调试，请修改模板文件（目录中存在python版本号、bingo集成开发环境应用名称，请适配）：
+#   ~/.local/lib/python3.8/site-packages/bingo/component/template/conanbase.py.mako
+
+
+class ConanBase(ConanFile):
+    name = "${pkg.name}"
+% if not pkg.is_maintain:
+    version = "${pkg.version}"
+% endif
+    settings = "os", "compiler", "build_type", "arch"
+    license = "Mulan PSL v2"
+    generators = "CMakeDeps", "VirtualBuildEnv", "PkgConfigDeps"
+    language = "${language}"
+    _cmake = None
+    _codegen_version = ${codegen_version}
+    options = {
+        "asan": [True, False],
+        "gcov": [True, False],
+        "test": [True, False],
+        "manufacture": [True, False],
+    % if language == "lua":
+        "enable_luajit": [True, False],
+    % endif
+    % for op, ctx in pkg.design_options.items():
+        "${op}": [${",".join(("\"" + i + "\"") if isinstance(i, str) else str(i) for i in ctx["option"])}],
+    % endfor
+    }
+    default_options = {
+        "asan": False,
+        "gcov": False,
+        "test": False,
+        "manufacture": False,
+    % if language == "lua":
+        "enable_luajit": False,
+    % endif
+    % for op, ctx in pkg.design_options.items():
+        "${op}": ${("\"" + ctx["default"] + "\"") if isinstance(ctx["default"], str) else str(ctx["default"])},
+    % endfor
+    }
+
+% if language == "c":
+    def _codegen(self):
+        args = ["-s", "mds/service.json"]
+        gen = GenComp(args)
+        gen.run(self._codegen_version)
+% endif
+
+    def layout(self):
+        cmake_layout(self, build_folder=".build")
+
+    def requirements(self):
+    % if len(pkg.build_dependencies) > 0:
+        # 编译依赖
+        % for build_dep in pkg.build_dependencies:
+        self.requires("${build_dep}")
+        % endfor
+    % endif
+    %if language == "lua":
+        skynet = self.conf.get("user.tools:skynet")
+        if skynet:
+            self.tool_requires(skynet, options={"tools_only": True})
+        luajit = self.conf.get("user.tools:luajit")
+        if luajit:
+            self.tool_requires(luajit, options={"tools_only": True})
+    % endif
+        pass
+
+    def export(self):
+        copy(self, "conanbase.py", self.recipe_folder, self.export_folder)
+        % if not pkg.is_maintain:
+        git = Git(self, self.recipe_folder)
+        if git.is_dirty():
+            update_conandata(self, {"sources": {self.version: {"branch": None, "url": None, "pwd": os.getcwd(), "timestamp": int(time.time())}}})
+            return
+        url = None
+        commit = git.get_commit()
+        branches = git.run("branch -r --contains {}".format(commit))
+        remotes = git.run("remote")
+        for remote in remotes.splitlines():
+            if "{}/".format(remote) in branches:
+                url = git.get_remote_url(remote)
+                break
+        if not url:
+            update_conandata(self, {"sources": {self.version: {"branch": None, "url": None, "pwd": os.getcwd(), "timestamp": int(time.time())}}})
+            return
+        tag = git.run("tag --points-at HEAD")
+        update_conandata(self, {"sources": {self.version: {"branch": f"refs/tags/{tag}" if tag else commit, "url": url}}})
+        % endif
+    
+    % if pkg.is_maintain:
+    def export_sources(self):
+        patches = self.conan_data.get("patches", {}).get(self.version, [])
+        for patch in patches:
+            patch_file = patch.get("patch_file")
+            if patch_file is None:
+                continue
+            # 与export_conandata_patches方法不同点：所有patches将从recipes_folder/../pacthes读取
+            src = os.path.join(self.recipe_folder, "..", patch_file)
+            dst = os.path.join(self.export_sources_folder, patch_file)
+            mkdir(os.path.dirname(dst))
+            shutil.copy2(src, dst)
+    % endif
+
+    def source(self):
+        git = Git(self)
+        sources = self.conan_data["sources"][self.version]
+        if sources["url"] and sources["branch"]:
+            git.fetch_commit(url=sources["url"], commit=sources["branch"].split("/")[-1])
+        else:
+            copy(self, "*", src=sources["pwd"], dst=".")
+        % if language == "c":
+        self._codegen()
+        % endif
+
+    def _pre_generate(self):
+        tc = CMakeToolchain(self)
+        tc.preprocessor_definitions["_FORTIFY_SOURCE"] = "2"
+
+        tc.variables["BUILD_MANUFACTURE"] = self.options.manufacture
+        % if len(pkg.design_options) > 0:
+            % for op, _ in pkg.design_options.items():
+        tc.variables["CONAN_DEFS_${op.upper()}"] = self.options.${op}
+            % endfor
+        % endif
+    % if language == "lua":
+        if self.options.enable_luajit:
+            tc.variables["CONAN_DEFS_ENABLE_LUAJIT"] = True
+    % endif
+        if self.options.test:
+            tc.variables["ENABLE_TEST"] = True
+            tc.preprocessor_definitions["ENABLE_TEST"] = True
+        # 向CMAKE传递版本号信息
+        version = self.version.split(".")
+        if len(version) >= 1:
+            tc.variables["PACKAGE_VERSION_MAJOR"] = version[0]
+        if len(version) >= 2:
+            tc.variables["PACKAGE_VERSION_MINOR"] = version[1]
+        if len(version) >= 3:
+            tc.variables["PACKAGE_VERSION_REVISION"] = version[2]
+        # 设置额外编译选项或者重定义CFLAGS CXXFLAGS,也可以设置其他开关
+        # 示例: os.environ['CFLAGS'] = f"{os.getenv('CFLAGS')} -fPIE"
+
+        if self.settings.arch in ["armv8", "x86_64"]:
+            tc.variables["CMAKE_INSTALL_LIBDIR"] = "usr/lib64"
+        else:
+            tc.variables["CMAKE_INSTALL_LIBDIR"] = "usr/lib"
+
+        if self.options.get_safe("asan", False):
+            print("Enable asan flags")
+            asan_flags = "-fsanitize=address -fsanitize-recover=address,all -fno-omit-frame-pointer -fno-stack-protector -O0"
+            tc.extra_cflags.append(asan_flags)
+            tc.extra_cxxflags.append(asan_flags)
+            tc.extra_sharedlinkflag.append("LDFLAGS", "-fsanitize=address")
+            tc.extra_exelinkflag.append("LDFLAGS", "-fsanitize=address")
+
+        # GCOV 标志设置
+        if self.options.get_safe("gcov", False):
+            print("Enable gcov flags")
+            gcov_flags = "-ftest-coverage -fprofile-arcs -fprofile-update=atomic"
+            tc.extra_cflags.append(gcov_flags)
+            tc.extra_cxxflags.append(gcov_flags)
+        # 配合generate添加宏定义
+        tc.variables["CMAKE_TOOLCHAIN_FILE"] = "conan_toolchain.cmake"
+        # rpath配置
+        tc.variables["CMAKE_SKIP_BUILD_RPATH"] = True
+        tc.variables["CMAKE_SKIP_RPATH"] = True
+        tc.variables["CMAKE_SKIP_INSTALL_RPATH"] = True
+        tc.variables["CMAKE_BUILD_WITH_INSTALL_RPATH"] = False
+        tc.variables["CMAKE_INSTALL_RPATH_USE_LINK_PATH"] = False
+        return tc
+
+    def generate(self):
+        tc = self._pre_generate()
+        tc.generate()
+
+% if pkg.is_maintain:
+    @staticmethod
+    def _get_patch_changed_files(patch_file):
+        files = {}
+        for line in open(patch_file):
+            if not line.startswith("diff --git"):
+                continue
+            line = line.strip()
+            chunk = line.split()
+            a_file = chunk[-2][2:]
+            b_file = chunk[-1][2:]
+            files[a_file] = b_file
+        return files
+
+    def _revise_renamed_files(self, changed_files):
+        for a_file, b_file in changed_files.items():
+            if a_file != b_file:
+                if a_file != "/dev/null" and b_file != "/dev/null":
+                    os.rename(a_file, b_file)
+                    cmd = f"git rm -f {a_file}"
+                    self.run(cmd)
+                elif a_file != "/dev/null":
+                    cmd = f"git rm -f {a_file}"
+                    self.run(cmd)
+                    continue
+            cmd = f"git add {b_file}"
+            self.run(cmd)
+
+%endif
+    def _configure_cmake(self):
+        if self._cmake is not None:
+            return self._cmake
+        self._cmake = CMake(self)
+        self._cmake.configure()
+        return self._cmake
+
+    def build(self):
+% if pkg.is_maintain:
+        for patch in self.conan_data.get("patches", {}).get(self.version, []):
+            patch_file = patch.get("patch_file")
+            if not patch_file:
+                continue
+            real_path = os.path.join(self.folders.base_source, patch_file)
+            print(f"Start patch file {patch_file}")
+            changed_files = self._get_patch_changed_files(real_path)
+            try:
+                apply_patch(self, patch_file=real_path)
+                self._revise_renamed_files(changed_files)
+                cmd = f"git commit -m \"{patch_file}\""
+                self.run(cmd)
+            except ConanException:
+                # 尝试还原文件修改
+                for a_file, b_file in changed_files.items():
+                    cmd = f"git checkout -- {a_file}"
+                    self.run(cmd, ignore_errors=True)
+                    cmd = f"git checkout -- {b_file}"
+                    self.run(cmd, ignore_errors=True)
+                cmd = "git am " + real_path
+                self.run(cmd)
+% endif
+        cmake = self._configure_cmake()
+        cmake.build()
+
+    def package(self):
+        cmake = self._configure_cmake()
+        cmake.install()
+        files_to_copy = [
+            ("permissions.ini", self.source_folder, self.package_folder),
+            ("model.json", os.path.join(self.source_folder, "mds"), os.path.join(self.package_folder, "include/mds")),
+            ("service.json", os.path.join(self.source_folder, "mds"), os.path.join(self.package_folder, "include/mds")),
+            ("*", os.path.join(self.source_folder, "customization"), os.path.join(self.package_folder, "include")),
+            ("*", os.path.join(self.source_folder, "mds"), os.path.join(self.package_folder, "usr/share/doc/openubmc/${pkg.name}/mds")),
+            ("*", os.path.join(self.source_folder, "docs"), os.path.join(self.package_folder, "usr/share/doc/openubmc/${pkg.name}/docs")),
+            ("*", os.path.join(self.source_folder, "build"), os.path.join(self.package_folder, "include")),
+            ("permissions.ini", os.path.join(self.source_folder, "dist"), self.package_folder),
+            ("*.md", self.source_folder, os.path.join(self.package_folder,"usr/share/doc/openubmc/${pkg.name}/docs")),
+            ("*.MD", self.source_folder, os.path.join(self.package_folder,"usr/share/doc/openubmc/${pkg.name}/docs"))
+        ]
+        for pattern, src, dst in files_to_copy:
+            copy(self, pattern, src=src, dst=dst, keep_path=True)
+
+        # 只有当需要统计覆盖率且TRANSTOBIN环境变量未设置时才不处理lua文件
+        if self.options.gcov and os.getenv("TRANSTOBIN") is None:
+            return
+
+        os.chdir(self.package_folder)
+        with concurrent.futures.ThreadPoolExecutor(max_workers=4) as executor:
+            for root, _, files in os.walk("."):
+                for file in files:
+                    if file.endswith(".lua") and not os.path.islink(os.path.join(root, file)):
+                        file_path = os.path.join(root, file)
+                        if self.options.enable_luajit:
+                            executor.submit(self.compile_file, file_path, True)
+                        else:
+                            executor.submit(self.compile_file, file_path, False)
+        rm(self, "luac.out", self.package_folder)
+
+    def compile_file(self, file_path, enable_luajit):
+        if enable_luajit:
+            self.run(f"luajit -b -g {file_path} {file_path}")
+        else:
+            self.run(f"luac -o {file_path} {file_path}")
+            self.run(f"luac -s {file_path}")
+
+    def package_info(self):
+        app_dir = os.path.join(self.package_folder, "opt/bmc/apps/${pkg.name}")
+        if os.path.isdir(app_dir):
+            self.runenv_info.append("PATH", ':' + app_dir)
+            self.buildenv_info.append("PATH", ':' + app_dir)
+    % if "application" in pkg.package_type and pkg.package_info is not None:
+        % if len(pkg.package_info.get("bindirs", [])) > 0:
+        self.cpp_info.bindirs = [${", ".join("\"" + i + "\"" for i in pkg.package_info["bindirs"])}]
+            % for dir in pkg.package_info["bindirs"]:
+        self.env_info.PATH.append(os.path.join(self.package_folder, "${dir}"))
+            % endfor
+        % endif
+    % endif
+        libs = []
+        dirs = []
+        for root, _, files in os.walk("."):
+            for file in files:
+                if file.endswith(".so") and file.startswith("lib"):
+                    if root.startswith("./"):
+                        dir = root[2:]
+                    else:
+                        dir = root
+                    if dir not in dirs:
+                        dirs.append(dir)
+                    lib = file[3:-3]
+                    libs.append(lib)
+                    continue
+                if file.endswith(".a") and file.startswith("lib"):
+                    if root.startswith("./"):
+                        dir = root[2:]
+                    else:
+                        dir = root
+                    if dir not in dirs:
+                        dirs.append(dir)
+                    libs.append(lib)
+                    continue
+
+        if len(dirs):
+            self.cpp_info.components["${pkg.name}"].set_property("cmake_target_name", "${pkg.name}::${pkg.name}")
+            self.cpp_info.components["${pkg.name}"].set_property("cmake_target_aliass", ["${pkg.name}::${pkg.name}"])
+            self.cpp_info.components["${pkg.name}"].set_property("pkg_config_name", "${pkg.name}")
+            self.cpp_info.components["${pkg.name}"].libs = libs
+            self.cpp_info.components["${pkg.name}"].libdirs = dirs
+            for dir in dirs:
+                self.runenv_info.append("LD_LIBRARY_PATH", os.path.join(self.package_folder, dir))
+                self.buildenv_info.append("LD_LIBRARY_PATH", os.path.join(self.package_folder, dir))
+

bmcgo/component/template_v2/conanfile.deploy.py.mako

@@ -0,0 +1,26 @@
+from conan import ConanFile
+
+
+class DeployConan(ConanFile):
+    name = "${pkg.name}-deploy"
+    version = "0.0.1"
+    settings = "os", "compiler", "build_type", "arch"
+    license = "Mulan PSL v2"
+    requires = []
+
+    def export(self):
+        self.copy("manifest.yaml")
+
+    def requirements(self):
+        % for build_dep in dependencies:
+        self.requires("${build_dep}")
+        % endfor
+
+    def build(self):
+        pass
+
+    def package(self):
+        pass
+
+    def package_info(self):
+        pass

bmcgo/component/test.py

@@ -58,19 +58,27 @@ class TestComp():
         # 参数检查
         dt_parser = ComponentDtVersionParse(parser=parser, args=args, serv_file=self.temp_service_json)
         dt_parser.chose_dt_mode()
-        self.args, self.build_args = parser.parse_known_args(args)
+        if misc.conan_v1():
+            self.args, self.build_args = parser.parse_known_args(args)
+            self.build_args.append("-bt")
+            self.build_args.append("dt")
+            self.build_args.append("-r")
+            self.build_args.append(self.args.remote)
+        else:
+            self.args, _ = parser.parse_known_args(args)
+            self.build_args = args
+            self.build_args.append("-pr")
+            self.build_args.append("profile.dt.ini")
+        self.build_args.append("-test")
         if self.args.enable_luajit:
             self.build_args.append("-jit")
-        self.build_args.append("-bt")
-        self.build_args.append("dt")
-        self.build_args.append("-r")
         self.build_args.append(self.args.remote)
         if self.args.coverage:
             self.build_args.append("-cov")
         if self.args.asan:
             self.build_args.append("-as")
 
-        self.info = InfoComp(self.build_args, self.temp_service_json)
+        self.info = InfoComp(self.build_args, self.temp_service_json, self.bconfig.partner_mode, False)
         self.unit_test = self.args.unit_test
         self.integration_test = self.args.integration_test
         self.test_filter = self.args.test_filter
@@ -110,13 +118,13 @@ class TestComp():
         self.init_dt_result_dict()
 
         # 构建和部署对象
-        self.build = BuildComp(bconfig, self.build_args, service_json=self.temp_service_json)
+        self.build = BuildComp(bconfig, self.build_args, service_json=self.temp_service_json, enable_upload=False)
         self.deploy = DeployComp(bconfig, self.build.info)
         self.current_app = self.build.info.name
 
     @staticmethod
     def arg_parser(add_help=False):
-        pkg_parser = InfoComp.arg_parser()
+        pkg_parser = InfoComp.arg_parser(False, enable_upload=False)
         parser = argparse.ArgumentParser(description="Test component", parents=[pkg_parser], add_help=add_help)
         parser.add_argument("-ut", "--unit_test", help="Enable unit test", action=misc.STORE_TRUE)
         parser.add_argument("-it", "--integration_test", help="Enable integration test", action=misc.STORE_TRUE)
@@ -264,8 +272,11 @@ class TestComp():
                 log.error("依赖格式错误, 获取到: %s", dep)
             elif not self.is_common_dep(conan, dt_common_deps):
                 # 写入组件配置的非DT公共依赖
-                if "@" not in conan:
-                    write_dep = prefix + '"' + conan + uc_code + '"' + "\n"
+                if misc.conan_v1():
+                    if "@" not in conan:
+                        write_dep = prefix + '"' + conan + uc_code + '"' + "\n"
+                    else:
+                        write_dep = prefix + '"' + conan + '"' + "\n"
                 else:
                     write_dep = prefix + '"' + conan + '"' + "\n"
                 mf_file.write(write_dep)
@@ -275,7 +286,10 @@ class TestComp():
         self.build.run()
         os.chdir(self.folder)
         # 部署被测组件及其依赖到temp/rootfs目录
-        self.deploy.run()
+        if misc.conan_v1():
+            self.deploy.run()
+        else:
+            self.deploy.run()
         os.chdir(self.folder)
 
     def coverage_config(self, project_root, cov_path, app):
@@ -606,17 +620,36 @@ class TestComp():
                                stat.S_IWUSR | stat.S_IRUSR), 'w') as file:
             file.write(self.info.package)
 
+    def get_gcda_path(self, ):
+        package_path = f"{self.info.name}/{self.info.version}@{self.info.user}/{self.info.stage}"
+        ret = self.tools.run_command(f"conan list {package_path}#latest:* -f json", capture_output=True).stdout.strip()
+        revisions_path = json.loads(ret)["Local Cache"][package_path]["revisions"]
+        revisions = next(iter(revisions_path.keys()), None)
+        if not revisions:
+            raise ValueError("No revision IDs found")
+        packages = next(iter(revisions_path[revisions]["packages"].keys()), None)
+        if not packages:
+            raise ValueError("No packages IDs found")
+        build_path = self.tools.run_command(f"conan cache path {package_path}#{revisions}:{packages} --folder build",
+                                            capture_output=True).stdout.strip()
+        return build_path
+
     def generate_gcov(self):
-        if not self.test_by_conan:
-            if not os.path.exists("src/lualib-src"):
-                return
-            package_path = os.path.join(self.temp_path, "package_info")
-            with open(package_path, "r") as file:
-                lines = file.readlines()
-                package_path = lines[0].replace("@", "/")
+        if misc.conan_v1():
+            if not self.test_by_conan:
+                if not os.path.exists("src/lualib-src"):
+                    return
+                package_path = os.path.join(self.temp_path, "package_info")
+                with open(package_path, "r") as file:
+                    lines = file.readlines()
+                    package_path = lines[0].replace("@", "/")
+            else:
+                package_path = self.info.package.replace("@", "/")
+            base_dir = "%s/.conan/data/%s" % (os.path.expanduser('~'), package_path)
+            gcda_dir = base_dir
         else:
-            package_path = self.info.package.replace("@", "/")
-        base_dir = "%s/.conan/data/%s" % (os.path.expanduser('~'), package_path)
+            base_dir = self.folder
+            gcda_dir = self.get_gcda_path()
         gcov_path = os.path.join(self.cov_path, "gcov")
         if not os.path.exists(gcov_path):
             os.makedirs(gcov_path)
@@ -630,7 +663,7 @@ class TestComp():
             "--base-directory",
             base_dir,
             "--directory",
-            base_dir,
+            gcda_dir,
             "--capture",
             "--output-file",
             info_file,

bmcgo/frame.py

@@ -135,8 +135,12 @@ class Frame(object):
             parser = argparse.ArgumentParser(description="build target")
             parser.add_argument("-cp", "--conan_package", help="软件包名, 示例: kmc/21.1.2.B001", default="")
             parser.add_argument("-uci", "--upload_package", help="是否上传软件包", action=misc.STORE_TRUE)
-            parser.add_argument("-o", "--options", help="组件特性配置, 示例: -o skynet:enable_luajit=True",
-                                action='append')
+            if misc.conan_v2():
+                parser.add_argument("-o", "--options", help="组件特性配置, 示例: -o skynet/*:enable_luajit=True",
+                                    action='append')
+            else:
+                parser.add_argument("-o", "--options", help="组件特性配置, 示例: -o skynet:enable_luajit=True",
+                                    action='append')
             self.conan_args, unknown_args = parser.parse_known_args(unknown_args)
             if self.conan_args is None or self.conan_args.conan_package == "":
                 raise errors.BmcGoException("软件包选项为空, 请输入软件包选项!")
@@ -216,5 +220,5 @@ class Frame(object):
         shutil.rmtree(misc.CACHE_DIR)
         os.makedirs(misc.CACHE_DIR)
         os.chmod(misc.CACHE_DIR, 0o777)
-        if shutil.which(misc.CONAN) is not None:
+        if shutil.which(misc.CONAN) is not None and misc.conan_v1():
             tool.run_command("conan remove --locks")

bmcgo/functional/analysis.py

@@ -42,7 +42,8 @@ def if_available(bconfig: BmcgoConfig):
 
 class BmcgoCommand:
     def __init__(self, bconfig: BmcgoConfig, *args):
-        parser = argparse.ArgumentParser(prog="bmcgo analysis", description="BMC package analysis", add_help=True,
+        parser = argparse.ArgumentParser(prog=f"{misc.tool_name()} analysis",
+                                         description="BMC package analysis", add_help=True,
             formatter_class=argparse.RawTextHelpFormatter)
         parser.add_argument("-r", "--remote", help="指定conan远端")
         parser.add_argument("--rebuild", dest="rebuild", help="rebuild the package before analysis",
@@ -50,7 +51,7 @@ class BmcgoCommand:
         parser.add_argument("--out_dir", dest="out_dir", help="analysis artifacts directory")
         parser.add_argument("--lock_file", dest="lock_file", help="manifest lock file path")
         parser.add_argument("-b", "--board_name", help="find supported boards in the manifest/build/product directory",
-                            default="openUBMC")
+                            default=misc.boardname_default())
         pre_parsed_args, _ = parser.parse_known_args(*args)
 
         self.bconfig = bconfig

bmcgo/functional/check.py

@@ -59,10 +59,11 @@ def if_available(bconfig: BmcgoConfig):
 class BmcgoCommand:
     def __init__(self, bconfig: BmcgoConfig, *args):
         self.bconfig = bconfig
-        parser = argparse.ArgumentParser(prog="bmcgo check", description="语法正确性与模型一致性检查", add_help=True,
+        parser = argparse.ArgumentParser(prog=f"{misc.tool_name()} check", description="语法正确性与模型一致性检查", add_help=True,
             formatter_class=argparse.RawTextHelpFormatter)
-        parser.add_argument("-b", "--board_name", help="指定单板获取配套全量源码，可选值为build/product目录下的单板名\n默认：openUBMC",
-                            default="openUBMC")
+        parser.add_argument("-b", "--board_name",
+                            help="指定单板获取配套全量源码，可选值为build/product目录下的单板名\n默认：" + misc.boardname_default(),
+                            default=misc.boardname_default())
         parser.add_argument("--stage", help="包类型，可选值为：rc(预发布包), stable(发布包)\n默认: stable", default="stable")
         parser.add_argument("-r", "--remote")
         parser.add_argument("-m", "--model", help=f"检查的模型，可选值为: {', '.join(MODEL_CHOICES)}\n默认: all",
@@ -87,14 +88,14 @@ class BmcgoCommand:
     @staticmethod
     def check_overdue(issue: dict):
         data = issue.get("deadline")
-        if date is None:
+        if data is None:
             return False
         try:
             utc_8 = timezone(timedelta(hours=8))
             deadline = datetime.strptime(data, '%Y/%m/%d').replace(tzinfo=utc_8)
             return datetime.now(tz=utc_8) >= deadline + timedelta(days=1)
         except Exception as e:
-            log.warning("日期 %s 解析失败：%s", date, e)
+            log.warning("日期 %s 解析失败：%s", data, e)
             return False
     
     @staticmethod
@@ -145,7 +146,10 @@ class BmcgoCommand:
             package = dep.get(misc.CONAN, "")
             comp_name = package.split("/")[0]
             if "@" not in package:
-                package += f"@{misc.ConanUserEnum.CONAN_USER_RELEASE.value}/{misc.StageEnum.STAGE_RC.value}"
+                if misc.conan_v1():
+                    package += f"@{misc.conan_user()}/{misc.StageEnum.STAGE_RC.value}"
+                else:
+                    package += f"@{misc.conan_user()}/stable"
             self.packages[comp_name] = package
 
     def run(self):