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

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")
             # 开发者测试依赖

bmcgo/component/template/conanbase.py.mako

@@ -5,6 +5,7 @@ import urllib3
 import shutil
 % endif
 from conans import ConanFile, CMake
+from conan.tools.files import copy
 % if pkg.is_maintain:
 from conans import tools
 from conans.util.files import mkdir

bmcgo/component/template_v2/conanbase.py.mako

@@ -0,0 +1,383 @@
+#!/usr/bin/env python
+# coding=utf-8
+# Copyright (c) 2024 Huawei Technologies Co., Ltd.
+# openUBMC is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#         http://license.coscl.org.cn/MulanPSL2
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+import os
+import concurrent.futures
+import urllib3
+% if pkg.is_maintain:
+import time
+% endif
+% 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
+    }
+
+    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 pkg.is_maintain:
+        if sources["url"] and sources["branch"]:
+            git.fetch_commit(url=sources["url"], commit=sources["branch"].split("/")[-1])
+        else:
+            copy(self, "*", src=sources["pwd"], dst=".")
+    % else:
+        git.fetch_commit(url=sources["url"], commit=sources["branch"].split("/")[-1])
+    % endif
+        % if language == "c":
+        self._codegen()
+        % endif
+
+    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
+
+%endif
+    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("."):
+                self.compile_files(root, files, executor)
+        rm(self, "luac.out", self.package_folder)
+
+    def compile_files(self, root, files, executor):
+        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)
+
+    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:
+                dirname, libname = self.find_libraries(root, file)
+                if dirname and dirname not in dirs:
+                    dirs.append(dirname)
+                if libname:
+                    libs.append(libname)
+
+        if 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))
+
+    def find_libraries(self, root, file):
+        if file.endswith(".so") and file.startswith("lib"):
+            if root.startswith("./"):
+                dirname = root[2:]
+            else:
+                dirname = root
+            libname = file[3:-3]
+            return (dirname, libname)
+        if file.endswith(".a") and file.startswith("lib"):
+            if root.startswith("./"):
+                dirname = root[2:]
+            else:
+                dirname = root
+            return (dirname, file)
+        return (None, None)
+
+% if pkg.is_maintain:
+    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
+
+% if language == "c":
+    def _codegen(self):
+        args = ["-s", "mds/service.json"]
+        gen = GenComp(args)
+        gen.run(self._codegen_version)
+
+% 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