openubmc-bingo 0.5.240__py3-none-any.whl

bmcgo/component/gen.py

@@ -0,0 +1,169 @@
+#!/usr/bin/python3
+# 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 argparse
+import json
+import os
+import re
+import stat
+from bmcgo.codegen.c.codegen import CodeGen as CodeGenC
+from bmcgo.codegen.lua.codegen import CodeGen as CodeGenLua
+from bmcgo.ipmigen.ipmigen import IpmiGen
+from bmcgo.component.package_info import InfoComp
+from bmcgo.codegen import __version__ as codegen_version
+from bmcgo.logger import Logger
+from bmcgo import misc
+from bmcgo.component.component_helper import ComponentHelper
+
+log = Logger("gen")
+
+cwd = os.getcwd()
+cwd_script = os.path.split(os.path.realpath(__file__))[0]
+
+
+class ParameterError(OSError):
+    """参数错误"""
+
+
+class SmartFormatter(argparse.HelpFormatter):
+    def _fill_text(self, text, width, indent):
+        import textwrap
+        text = textwrap.dedent(text)
+        return ''.join(indent + line for line in text.splitlines(True))
+
+
+class GenComp():
+    def __init__(self, args):
+        self.args = args
+
+    @staticmethod
+    def update_conanbase(gen_version: int):
+        conanbase_path = os.path.join(cwd, "conanbase.py")
+        if not os.path.isfile(conanbase_path):
+            return
+        conanbase_file = os.fdopen(os.open(conanbase_path, os.O_RDWR, stat.S_IWUSR | stat.S_IRUSR), 'w+')
+        content = conanbase_file.read()
+        content = re.sub(r"_codegen_version *= *\S+", f"_codegen_version = {gen_version}", content)
+        conanbase_file.seek(0)
+        conanbase_file.truncate()
+        conanbase_file.write(content)
+        conanbase_file.close()
+
+    @staticmethod
+    def get_codegen_version(args, base_version: int):
+        if base_version != -1:
+            return base_version
+        if args.version != -1:
+            return int(args.version)
+        if not os.path.isfile(args.service_file):
+            return codegen_version
+        file_handler = open(args.service_file, "r")
+        service = json.load(file_handler)
+        file_handler.close()
+        _, version = InfoComp.get_codegen_policy(service)
+        return version
+
+    @staticmethod
+    def _gen_service(service_file, gen_version):
+        """
+        代码自动生成.
+
+        支持自动生成服务端和客户端C代码
+        """
+        file_handler = open(service_file, "r")
+        service = json.load(file_handler)
+        file_handler.close()
+        # 如果默认版本号为-1则使用service.json读取的版本号
+
+        codegen = CodeGenC(gen_version)
+        ipmigen = IpmiGen(gen_version)
+        codegen.gen_mds(service_file)
+        configs = service.get("codegen", [])
+        for cfg in configs:
+            file = cfg.get("file")
+            if file is None:
+                raise OSError("自动代码生成配置不正确, 缺少file元素指定描述文件")
+            if not os.path.isfile(file):
+                raise OSError(f"自动代码生成配置不正确, {file}不是一个文件")
+            tpye = cfg.get("type", "interface_xml")
+            output = cfg.get("output", ".")
+            if tpye == "interface_xml":
+                if not file.endswith(".xml"):
+                    raise OSError(f"接口自动代码生成配置不正确, {file}的文件名不是以.xml结束")
+                codegen.gen(file, output)
+            elif tpye == "ipmi":
+                if not file.endswith(".json"):
+                    raise OSError(f"IPMI自动代码生成配置不正确, {file}的文件名不是以.json结束")
+                ipmigen.gen(file, output)
+
+    def run(self, base_version=-1):
+        language = ComponentHelper.get_language().lower()
+        parser = argparse.ArgumentParser(description="代码自动生成.",
+                                         prog="bingo 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配置")
+
+        if language == "c":
+            self.generate_c_run(parser, base_version)
+        elif language == "lua":
+            self.generate_lua_run(parser, base_version)
+
+    def generate_lua_run(self, parser: argparse.ArgumentParser, base_version):
+        parser.add_argument("-s", "--service_file", help='Service file')
+        parser.add_argument("-w", "--with_template", help="generate with template", action=misc.STORE_TRUE)
+        args, _ = parser.parse_known_args(self.args)
+
+        if args.service_file is not None and not os.path.isfile(args.service_file):
+            raise FileNotFoundError(f"配置文件{args.service_file}不存在")
+        gen_version = self.get_codegen_version(args, base_version)
+        self.update_conanbase(gen_version)
+        codegen = CodeGenLua(cwd, gen_version, remote=args.remote)
+        codegen.gen(args)
+
+    def generate_c_run(self, parser: argparse.ArgumentParser, base_version):
+        group1 = parser.add_mutually_exclusive_group()
+        group1.add_argument("-s", "--service_file", help='Service file')
+        group1.add_argument("-i", "--interface", help='interface name, e.g.: com.kepler.upgrade')
+        group2 = parser.add_mutually_exclusive_group()
+        group2.add_argument("-d", "--directory", help='generate code directory', default=".")
+        parser.add_argument("-f", "--force", help='ignore the version configuration in the service.json file.',
+                            action=misc.STORE_TRUE)
+
+        args, _ = parser.parse_known_args(self.args)
+        gen_version = self.get_codegen_version(args, base_version)
+        self.update_conanbase(gen_version)
+        if args.service_file is not None:
+            if not os.path.isfile(args.service_file):
+                raise FileNotFoundError(f"配置文件{args.service_file}不存在")
+            self._gen_service(args.service_file, gen_version)
+            return 0
+        if args.interface is None:
+            raise ParameterError("需要指定-s或-i参数")
+        xml_file = None
+        file = args.interface
+        if file.endswith("ipmi.json"):
+            ipmigen = IpmiGen(gen_version)
+            ipmigen.gen(file, args.directory)
+            return 0
+        if file.endswith(".xml") and os.path.isfile(file):
+            xml_file = file
+        else:
+            file += ".xml"
+            if os.path.isfile(file):
+                xml_file = file
+        if not xml_file:
+            raise FileNotFoundError(f"接口 {args.interface} 不存在")
+        if not os.path.isdir(args.directory):
+            raise NotADirectoryError(f"文件夹 {args.directory} 不存在")
+        codegen = CodeGenC(gen_version)
+        codegen.gen(xml_file, args.directory)
+        return 0

bmcgo/component/package_info.py

@@ -0,0 +1,236 @@
+#!/usr/bin/python3
+# 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 argparse
+import datetime
+import json
+import os
+import re
+import configparser
+from configparser import NoSectionError, NoOptionError
+from typing import Tuple
+
+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.component.component_helper import ComponentHelper
+
+global log
+log = Logger()
+
+cwd = os.getcwd()
+cwd_script = os.path.split(os.path.realpath(__file__))[0]
+
+
+class CodegenVersionNotMatchError(OSError):
+    """版本号不满足要求"""
+
+
+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)
+        self.parse_args(parser, args, service_json)
+
+    @staticmethod
+    def arg_parser(add_help=False, partner_mode=False):
+        stage_values = [member.value for member in misc.StageEnum]
+        parser = argparse.ArgumentParser(prog="bingo 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(
+            "--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仓")
+        parser.add_argument(
+            "-r", "--remote", help=f"conan仓别名，请检查conan remote list查看已配置的conan仓"
+        )
+        parser.add_argument(
+            "-s",
+            "--from_source",
+            help=(
+                argparse.SUPPRESS
+                if partner_mode
+                else "Build from source, include dependency component"
+            ),
+            action=misc.STORE_TRUE,
+        )
+        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=[])
+        parser.add_argument(
+            "--user",
+            help=f"指定conan包的user字段，尝试从{misc.GLOBAL_CFG_FILE}文件读取conan.user字段，否则由程序管理",
+            default=None
+        )
+        parser.add_argument("-cov", "--coverage", help=argparse.SUPPRESS, action=misc.STORE_TRUE)
+        parser.add_argument(
+            "-as",
+            "--asan",
+            help=argparse.SUPPRESS if partner_mode else "Enable address sanitizer",
+            action=misc.STORE_TRUE,
+        )
+        parser.add_argument("-maint", "--maintain", help=argparse.SUPPRESS, action=misc.STORE_TRUE)
+        parser.add_argument(
+            "-pr",
+            "--profile",
+            help=argparse.SUPPRESS if partner_mode else Tools.get_profile_arg_help(),
+            default="",
+        )
+        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,
+        )
+        return parser
+
+    @staticmethod
+    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 not isinstance(code_version, str):
+            code_version = str(code_version)
+        code_language = policy.get("language", "c")
+        if not re.fullmatch("^(>=)?[0-9]+$", code_version):
+            raise CodegenPolicyError("codegen_policy.version配置错误，需要满足如下要求 ^(>=)?[0-9]+$")
+        if code_language != "c":
+            raise CodegenPolicyError("codegen_policy.language当前只支持C语言$")
+        # 生成代码需要使用的自动生成工具基础版本号
+        if code_version.startswith(">="):
+            codegen_base_version = int(code_version[2:])
+            if codegen_base_version > codegen_version:
+                raise CodegenVersionNotMatchError("代码自动生成要求的版本号大于当前bmcgo工具提供的版本号，建议升级到最新版本")
+            codegen_base_version = codegen_version
+        else:
+            codegen_base_version = int(code_version)
+        return code_language, codegen_base_version
+
+    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
+        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.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)
+
+        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.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")
+
+        # 尝试从/etc/bmcgo.conf读取user配置
+        user = self._get_package_user()
+        self.channel = f"@{user}/{self.stage}"
+
+        self._parse_service_json(service_json, pre)
+        self._conan_define()
+
+    def get_dependencies(self, service_data, key):
+        dependencies = []
+        user_channel = ComponentHelper.get_user_channel(self.stage)
+        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:
+                dependencies.append(conan)
+            else:
+                dependencies.append(conan + user_channel)
+        return dependencies
+
+    def _conan_define(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:
+                self.options.append("skynet:enable_luajit=True")
+            if self.build_type == "debug":
+                self.setting = "-s build_type=Debug"
+            else:
+                self.setting = "-s build_type=Release"
+        self.full_profile = " ".join(profiles)
+        self.cmd_base = ". %s %s %s " % (self.package, self.full_profile, self.setting)
+        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"
+
+    def _get_package_user(self):
+        """ 尝试从/etc/bmcgo.conf读取user配置 """
+        user = self.args.user
+        try:
+            if user is None and os.access(misc.GLOBAL_CFG_FILE, os.R_OK):
+                conf = configparser.ConfigParser()
+                conf.read(misc.GLOBAL_CFG_FILE)
+                user = conf.get(misc.CONAN, "user")
+        except (NoSectionError, NoOptionError):
+            user = None
+        if user is None:
+            if self.stage == misc.StageEnum.STAGE_DEV.value:
+                user = misc.ConanUserEnum.CONAN_USER_DEV.value
+            else:
+                user = misc.ConanUserEnum.CONAN_USER_RELEASE.value
+        return user
+
+    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")
+            # 编译依赖
+            self.build_dependencies = self.get_dependencies(data, "dependencies/build")
+            # 开发者测试依赖
+            self.test_dependencies = self.get_dependencies(data, "dependencies/test")
+            self.design_options = ComponentHelper.get_config_value(data, "options", {})
+            self.package_type = ComponentHelper.get_config_value(data, "type", [])
+            self.package_info = ComponentHelper.get_config_value(data, "package_info")
+            self.code_language, self.codegen_base_version = self.get_codegen_policy(data)

bmcgo/component/template/conanbase.py.mako

@@ -0,0 +1,278 @@
+import os
+import stat
+import urllib3
+% if pkg.is_maintain:
+import shutil
+% endif
+from conans import ConanFile, CMake
+% 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版本号、bmcgo集成开发环境应用名称，请适配）：
+#   ~/.local/lib/python3.8/site-packages/bmcgo/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 = "cmake"
+    language = "${language}"
+    _cmake = None
+    _codegen_version = ${codegen_version}
+% if not pkg.is_maintain:
+    scm = {
+        "type": "git",
+        "url": "${remote_url}",
+        "revision": "auto"
+    }
+% endif
+    options = {
+        "asan": [True, False],
+        "gcov": [True, False],
+        "manufacture": [True, False],
+    % 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,
+        "manufacture": False,
+    % for op, ctx in pkg.design_options.items():
+        "${op}": ${("\"" + ctx["default"] + "\"") if isinstance(ctx["default"], str) else str(ctx["default"])},
+    % endfor
+    }
+
+    def generate(self):
+        file_descriptor = os.open("conan_toolchain.cmake", os.O_RDWR | os.O_CREAT, stat.S_IWUSR | stat.S_IRUSR)
+        file_handler = os.fdopen(file_descriptor, "w")
+        file_handler.write("add_compile_definitions(\"_FORTIFY_SOURCE=2\")\n")
+        file_handler.close()
+
+    @property
+    def _source_subfolder(self):
+        return "source_subfolder"
+
+    @property
+    def _build_subfolder(self):
+        return "build_subfolder"
+
+    def export(self):
+        self.copy("mds/service.json")
+        self.copy("conanbase.py")
+
+% 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)
+
+    def source(self):
+        git = tools.Git(verify_ssl=False)
+        git.clone(**self.conan_data["sources"][self.version])
+% endif
+
+    % if len(pkg.build_dependencies) > 0 or len(pkg.test_dependencies) > 0:
+    def requirements(self):
+        uc = ""
+        if self.user and self.channel:
+            if self.channel == "dev":
+                uc = f"@{self.user}/rc"
+            else:
+                uc = f"@{self.user}/{self.channel}"
+        # 编译依赖
+        % for build_dep in pkg.build_dependencies:
+            % if "@" in build_dep:
+        self.requires("${build_dep}")
+            % else:
+        self.requires(f"${build_dep}{uc}")
+            % endif
+        % endfor
+
+    % endif
+
+    def _codegen(self):
+        from bmcgo.component.gen import GenComp
+        args = ["-s", "mds/service.json"]
+        gen = GenComp(args)
+        gen.run(self._codegen_version)
+
+    def _new_cmake(self):
+        return CMake(self)
+
+    def _configure_cmake(self):
+        if self._cmake:
+            return self._cmake
+        self._cmake = self._new_cmake()
+        self._cmake.definitions["BUILD_MANUFACTURE"] = self.options.manufacture
+        if self.settings.build_type == "Dt":
+            self._cmake.definitions["ENABLE_TEST"] = "ON"
+
+% if len(pkg.design_options) > 0:
+    % for op, _ in pkg.design_options.items():
+        self._cmake.definitions["CONAN_DEFS_${op.upper()}"] = self.options.${op}
+    % endfor
+% endif
+        # 向CMAKE传递版本号信息
+        version = self.version.split(".")
+        if len(version) >= 1:
+            self._cmake.definitions["PACKAGE_VERSION_MAJOR"] = version[0]
+        if len(version) >= 2:
+            self._cmake.definitions["PACKAGE_VERSION_MINOR"] = version[1]
+        if len(version) >= 3:
+            self._cmake.definitions["PACKAGE_VERSION_REVISION"] = version[2]
+        # 设置额外编译选项或者重定义CFLAGS CXXFLAGS,也可以设置其他开关
+        # 示例: os.environ['CFLAGS'] = f"{os.getenv('CFLAGS')} -fPIE"
+
+        if self.settings.arch == "armv8" or self.settings.arch == "x86_64":
+            self._cmake.definitions["CMAKE_INSTALL_LIBDIR"] = "usr/lib64"
+        else:
+            self._cmake.definitions["CMAKE_INSTALL_LIBDIR"] = "usr/lib"
+
+        if self.options.asan:
+            print("Enable asan flags")
+            flag = " -fsanitize=address -fsanitize-recover=address,all -fno-omit-frame-pointer -fno-stack-protector -O0"
+            os.environ['CFLAGS'] = os.getenv('CFLAGS') + flag
+            os.environ['CXXFLAGS'] = os.getenv('CXXFLAGS') + flag
+        if self.options.gcov:
+            print("Enable gcov flags")
+            os.environ['CFLAGS'] = f"{os.getenv('CFLAGS')} -ftest-coverage -fprofile-arcs"
+            os.environ['CXXFLAGS'] = f"{os.getenv('CXXFLAGS')} -ftest-coverage -fprofile-arcs"
+
+        # 配合generate添加宏定义
+        self._cmake.definitions["CMAKE_TOOLCHAIN_FILE"] = "conan_toolchain.cmake"
+        # rpath配置
+        self._cmake.definitions["CMAKE_SKIP_BUILD_RPATH"] = True
+        self._cmake.definitions["CMAKE_SKIP_RPATH"] = True
+        self._cmake.definitions["CMAKE_SKIP_INSTALL_RPATH"] = True
+        self._cmake.definitions["CMAKE_BUILD_WITH_INSTALL_RPATH"] = False
+        self._cmake.definitions["CMAKE_INSTALL_RPATH_USE_LINK_PATH"] = False
+        self._cmake.configure(args=["--no-warn-unused-cli"])
+        return self._cmake
+
+% 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 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
+        if self.language != "c":
+            return
+        self._codegen()
+        cmake = self._configure_cmake()
+        cmake.build()
+
+    def package(self):
+        cmake = self._configure_cmake()
+        cmake.install()
+        if os.path.isfile("permissions.ini"):
+            self.copy("permissions.ini")
+        if os.path.isfile("mds/model.json"):
+           self.copy("model.json", src="mds", dst="include/mds")
+        if os.path.isfile("mds/service.json"):
+           self.copy("service.json", src="mds", dst="include/mds")
+        if os.path.isdir("build"):
+            self.copy("*", src="build", dst="include")
+        if os.path.isdir("mds"):
+            self.copy("*", src="mds", dst="usr/share/doc/openubmc/${pkg.name}/mds")
+        if os.path.isdir("docs"):
+            self.copy("*", src="docs", dst="usr/share/doc/openubmc/${pkg.name}/docs")
+        self.copy("*.md", dst="usr/share/doc/openubmc/${pkg.name}/docs")
+        self.copy("*.MD", dst="usr/share/doc/openubmc/${pkg.name}/docs")
+        if self.settings.build_type in ("Dt", ) and os.getenv('TRANSTOBIN') is None:
+            return
+        os.chdir(self.package_folder)
+        for root, dirs, files in os.walk("."):
+            for file in files:
+                if not file.endswith(".lua") or os.path.islink(file):
+                    continue
+                file_path = os.path.join(root, file)
+                self.run(f"{os.path.expanduser('~')}/.conan/bin/luac -o {file_path} {file_path}")
+                self.run(f"{os.path.expanduser('~')}/.conan/bin/luac -s {file_path}")
+
+    def package_info(self):
+        if self.settings.arch == "armv8" or self.settings.arch == "x86_64":
+            self.cpp_info.libdirs = ["usr/lib64"]
+            self.env_info.LD_LIBRARY_PATH.append(os.path.join(self.package_folder, "usr/lib64"))
+        else:
+            self.cpp_info.libdirs = ["usr/lib"]
+            self.env_info.LD_LIBRARY_PATH.append(os.path.join(self.package_folder, "usr/lib"))
+        self.env_info.PATH.append(os.path.join(self.package_folder, "opt/bmc/apps/${pkg.name}"))
+    % if pkg.package_info is not None:
+        % if len(pkg.package_info.get("libs", [])) > 0:
+        self.cpp_info.libs = [${", ".join("\"" + i + "\"" for i in pkg.package_info["libs"])}]
+        % endif
+    % endif
+    % 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