openubmc-bingo 0.5.240__py3-none-any.whl

bmcgo/codegen/lua/script/render_utils/service_lua.py

@@ -0,0 +1,130 @@
+#!/usr/bin/env 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 os
+import re
+from utils import Utils
+from dto.options import Options
+from render_utils.base import Base
+from render_utils.factory import Factory
+from render_utils.validate_lua import ValidateLua
+from render_utils.mdb_register import MdbRegister
+
+
+class ServicesUtils(Base, ValidateLua, Utils, MdbRegister):
+    def __init__(self, data: dict, options: Options):
+        super().__init__(data, options=options)
+
+    @staticmethod
+    def message_type(t):
+        if t == ".google.protobuf.Empty":
+            return "nil"
+        return t[1:] if t.startswith(".") else t
+
+    @staticmethod
+    def count(params, name):
+        num = 0
+        for param in params:
+            if param == name:
+                num += 1
+        return num
+
+    @staticmethod
+    def contains_csr(prop_configs):
+        for prop_config in prop_configs.values():
+            for usage in prop_config.get("usage", []):
+                if usage == "CSR":
+                    return True
+
+        return False
+
+    def err_module(self):
+        return (
+            "apps."
+            + Utils(self.data, self.options).camel_to_snake(self.data["package"])
+            + ".error"
+        )
+
+    def sig(self, msg_type):
+        msg = Utils(self.data, self.options).make_get_message(msg_type)
+        return "".join(
+            [
+                Utils(self.data, self.options).do_type_to_dbus(p["type"], p["repeated"])
+                for p in msg.get("properties")
+            ]
+        )
+
+    def params(self, msg_type):
+        msg = Utils(self.data, self.options).make_get_message(msg_type)
+        return ", ".join([p["name"] for p in msg.get("properties")])
+
+    def cb_name(self, rpc):
+        return Utils(self.data, self.options).camel_to_snake("__on" + rpc["name"])
+
+    def rsp_message(self, rpc):
+        return self.message_type(rpc["rsp"])
+
+    def req_message(self, rpc):
+        return self.message_type(rpc["req"])
+
+    def props(self, msg_type):
+        msg = Utils(self.data, self.options).make_get_message(msg_type)
+        return msg.get("properties")
+
+    def check_file_exist(self, file):
+        return os.path.exists(file)
+
+    def is_dynamic_obj(self, path):
+        return path.find(':') != -1
+
+    def make_path(self, path):
+        path = self.force_to_colon(path)
+        params = re.compile(r":([a-zA-Z_][0-9a-zA-Z_]+)").findall(path)
+        if len(params) == 0:
+            return f"'{path}'"
+        result = []
+        for name in params:
+            path_s = path.partition(f":{name}")
+            result.append(f"'{path_s[0]}'")
+            result.append(name)
+            path = path_s[2]
+
+        return (f"{' .. '.join(result)}") if path == '' else (f"{' .. '.join(result)} .. '{path}'")
+
+    def check_duplicate(self, params):
+        for name in params:
+            if self.count(params, name) > 1:
+                raise RuntimeError(f"重复参数: {name}")
+
+    def get_not_recover_tables(self, root):
+        not_recover_tables = {}
+        classes = {}
+        classes.update(root.get("class_require", {}))
+        classes.update(root.get("private_class_require", {}))
+        for class_data in classes.values():
+            data = class_data['data']
+            if "tableName" not in data:
+                continue
+
+            if self.contains_csr(data.get("properties", {})):
+                not_recover_tables[data["tableName"]] = True
+                continue
+
+            for intf_data in data.get("interfaces", {}).values():
+                if self.contains_csr(intf_data.get("properties", {})):
+                    not_recover_tables[data["tableName"]] = True
+                    break
+
+        return self.convert_to_lua(not_recover_tables)
+
+
+Factory().register("service.lua.mako", ServicesUtils)

bmcgo/codegen/lua/script/render_utils/utils_message_lua.py

@@ -0,0 +1,125 @@
+#!/usr/bin/env 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.
+
+from utils import Utils
+
+
+class UtilsMessageLua(Utils):
+
+    @staticmethod
+    def params(msg):
+        return ", ".join([p.get('original_name', p['name']) for p in msg['properties']])
+
+    @staticmethod
+    def get_group_names(names):
+        return ', '.join([f"'{name}'" for name in names])
+
+    @staticmethod
+    def get_group_names_for_set(names):
+        return ', '.join([f"{name}" for name in names])
+
+    @staticmethod
+    def get_group_names_for_join(names):
+        return ', '.join([f"body.{name}" for name in names])
+
+    @staticmethod
+    def construct_rename(prop, option_name):
+        return prop.get('original_name', prop['name']), prop['options'][option_name]
+
+    @staticmethod
+    def construct_group(prop, groups):
+        group_id = prop['options']['group']
+        if group_id in groups:
+            groups[group_id].append(prop['name'])
+        else:
+            groups[group_id] = [prop['name']]
+
+    def json_to_lua_value(self, val):
+        if isinstance(val, str):
+            return f'[=[{val}]=]'
+        if isinstance(val, bool):
+            return 'true' if val else 'false'
+        if isinstance(val, list):
+            result = '{'
+            for value in val:
+                result += f"{self.json_to_lua_value(value)},"
+            return result + '}'
+        if isinstance(val, int) or isinstance(val, float):
+            return str(val)
+        if isinstance(val, dict):
+            return self.convert_dict_to_lua_table(val)
+        return val
+
+    def with_default(self, p):
+        if 'options' in p and 'default' in p['options']:
+            default = p['options']['default']
+            if "is_enum" not in p or not p["is_enum"]:
+                if p['type'] == 'bool' and default:
+                    return f"{p.get('original_name', p['name'])} == nil and true or \
+                        obj.{p.get('original_name', p['name'])}"
+                else:
+                    return f"{p.get('original_name', p['name'])} or {self.json_to_lua_value(default)}"
+
+            if p["repeated"]:
+                result = f"{p.get('original_name', p['name'])} or {{"
+                for default_var in default:
+                    result += f"{p['type']}.{default_var},"
+                return result + "}"
+            else:
+                return f"{p.get('original_name', p['name'])} or {p['type']}.{default}"
+        else:
+            return p.get('original_name', p['name'])
+
+    def obj_construct(self, msg):
+        return "\n  ".join([f"self.{p.get('original_name', p['name'])} = \
+            obj.{self.with_default(p)}" for p in msg['properties']])
+
+    def remove_props_construct(self, msg):
+        return "\n  ".join(
+            [f"if errs.{p['name']} then obj.{self.with_default(p)} = nil end" for p in msg['properties']])
+
+    def unpack_prop_name(self, p):
+        if Utils(self.data, self.options).check_is_enum(p['type']):
+            return f"{p.get('original_name', p['name'])}"
+        elif Utils(self.data, self.options).check_is_message(self.data, p['type']):
+            if 'repeated' in p and p['repeated']:
+                return f"utils.unpack(raw, self.{p.get('original_name', p['name'])}, true)"
+            else:
+                return f"utils.unpack(raw, self.{p.get('original_name', p['name'])})"
+        return f"self.{p.get('original_name', p['name'])}"
+
+    def unpack(self, msg):
+        return ", ".join([self.unpack_prop_name(p) for p in msg['properties']])
+
+    def get_enums(self, msg, ):
+        return [p for p in msg['properties'] if Utils(self.data, self.options).check_is_enum(p['type'])]
+
+    def get_sub_type(self, msg):
+        return [p for p in msg['properties'] if Utils(self.data, self.options).check_is_message(self.data, p['type'])]
+
+    def get_rename_fields(self, msg):
+        return [self.construct_rename(prop, 'rename')
+                for prop in msg['properties']
+                if 'options' in prop and 'rename' in prop['options']]
+
+    def get_group_fields(self, msg):
+        groups = {}
+        [self.construct_group(prop, groups)
+         for prop in msg['properties']
+         if 'options' in prop and 'group' in prop['options']]
+        return groups
+
+    def get_groups(self, msg):
+        return ',\n    '.join(['{' + self.get_group_names(v) + "}" for v in self.get_group_fields(msg).values()])
+
+    def is_routes(self, file):
+        return file.find("routes/") != -1

bmcgo/codegen/lua/script/render_utils/validate_lua.py

@@ -0,0 +1,221 @@
+#!/usr/bin/env 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 re
+from utils import Utils
+
+
+class ValidateLua(Utils):
+    readonly_fields = {
+        "odata_context",
+        "odata_etag",
+        "odata_id",
+        "odata_type",
+        "Actions",
+        "Links",
+    }
+    validate_need_readonly = {"Required", "Optional", "RequiredArray", "OptionalArray"}
+    type_default = {
+        "uint8" : "0",
+        "int8" : "0",
+        "int16" : "0",
+        "uint16" : "0",
+        "int32" : "0",
+        "uint32" : "0",
+        "uint64" : "0",
+        "int64" : "0",
+        "string" : "''",
+        "bytes" : "''",
+        "float" : "0",
+        "double" : "0",
+        "bool" : "false"
+    }
+
+    @staticmethod
+    def is_required(prop):
+        options = prop["options"]
+        return ("allow_null" not in options) or not options["allow_null"]
+
+    @staticmethod
+    def format_param(vv):
+        result = []
+        for p in vv[1]:
+            if isinstance(p, str):
+                if vv[0] == "regex":
+                    result.append('[=[{}]=]'.format(p))
+                else:
+                    result.append('"{}"'.format(p))
+            else:
+                result.append("nil" if p is None else str(p))
+
+        if vv[0] == "enum":
+            return "Enum", ["'', {" + ", ".join(result) + "}"]
+        return vv[0], result
+
+    @staticmethod
+    def proper_name(name, prefix):
+        if not prefix:
+            return name
+        return prefix + name
+
+    @staticmethod
+    def validate_name(name, prefix):
+        if not prefix:
+            return f"'{name}'"
+        return f"{prefix} .. '{name}'"
+
+    def get_struct_require(self, prop):
+        prop_type = prop["type"]
+        if not Utils(self.data, self.options).is_base_type(prop_type) and prop_type != 'Enum':
+            return {"type": prop_type, "repeated": prop["repeated"]}
+        return {}
+
+    def get_no_struct_require(self, prop):
+        prop_type = prop["type"]
+        params = [f'"{prop_type}"']
+        if not Utils(self.data, self.options).is_base_type(prop_type) and prop_type != 'Enum':
+            return []
+
+        if self.is_required(prop):
+            val = "RequiredArray" if prop["repeated"] else "Required"
+        else:
+            val = "OptionalArray" if prop["repeated"] else "Optional"
+        return [[val, params]]
+
+    def get_struct_requires(self, msg):
+        result = {}
+        if "properties" not in msg:
+            return result
+
+        for prop in msg["properties"]:
+            prop_type = prop["type"]
+            if not Utils(self.data, self.options).is_base_type(prop_type) and prop_type != 'Enum':
+                result[prop["name"]] = {"type": prop_type, "repeated": prop["repeated"]}
+        return result
+
+    def get_no_struct_requires(self, msg):
+        if "properties" not in msg:
+            return []
+
+        result = []
+        for prop in msg["properties"]:
+            prop_type = prop["type"]
+            params = [f'"{prop_type}"']
+            if not Utils(self.data, self.options).is_base_type(prop_type) and prop_type != 'Enum':
+                continue
+
+            if self.is_required(prop):
+                val = "RequiredArray" if prop["repeated"] else "Required"
+            else:
+                val = "OptionalArray" if prop["repeated"] else "Optional"
+            result.append((prop, [[val, params]]))
+
+        return result
+
+    def params1(self, var, msg):
+        if msg["type"] == "Dictionary":
+            return var
+
+        paras = []
+        if "properties" in msg:
+            for p in msg["properties"]:
+                paras.append(var + "." + p["name"])
+        return ", ".join(paras)
+
+    def get_requires(self, msg):
+        if "properties" not in msg:
+            return []
+
+        result = []
+        for prop in msg["properties"]:
+            prop_type = prop["type"]
+            params = [f'"{prop_type}"']
+
+            if self.is_required(prop):
+                val = "RequiredArray" if prop["repeated"] else "Required"
+            else:
+                val = "OptionalArray" if prop["repeated"] else "Optional"
+            result.append((prop, [[val, params]]))
+
+        return result
+
+    def get_descriptions(self, msg, intf_name):
+        pattern = r'^bmc\..*\.(Debug|Release)\..*$'
+        if not re.match(pattern, intf_name):
+            return ''
+
+        if "properties" not in msg:
+            return ''
+
+        count = 0
+        has_description = False
+        name = msg['name']
+        result = f'T{name}.descriptions = {{'
+        for prop in msg["properties"]:
+            if count != 0:
+                result += ", "
+            count += 1
+            if "description" in prop:
+                has_description = True
+                result += '[=[' + prop["description"] + ']=]'
+            else:
+                result += "nil"
+
+        return (result + '}') if has_description else ''
+
+    def get_default(self, required, type_str):
+        type_str = type_str.replace('"', '')
+        match_obj = re.search("(.+?)\[\]", type_str)
+        if match_obj is not None:
+            type_str = match_obj.group(1)
+        if type_str in self.type_default:
+            type_default = self.type_default[type_str]
+            return ("{}") if "Array" in required else type_default
+        return ("{}") if "Array" in required else (type_str + '.default')
+
+    def is_array(self, required):
+        return "true" if "Array" in required else "false"
+
+    def get_struct(self, type_str):
+        type_str = type_str.replace('"', '')
+        match_obj = re.search("(.+?)\[\]", type_str)
+        if match_obj is not None:
+            type_str = match_obj.group(1)
+        if type_str in self.type_default:
+            return "nil"
+        return type_str + ".struct"
+
+    def get_validates(self, msg):
+        if "properties" not in msg:
+            return []
+
+        result = []
+        for prop in msg["properties"]:
+            if "validate" not in prop["options"]:
+                continue
+
+            opt_validate = Utils(self.data, self.options).get_validate(
+                prop["options"]["validate"]
+            )
+
+            prop_result = [self.format_param(v) for v in opt_validate]
+            result.append((prop, prop_result))
+        return result
+
+    def readonly(self, validate_type, field, types, options):
+        if validate_type not in self.validate_need_readonly:
+            return ""
+        if field in self.readonly_fields or "Resource." in types:
+            return ", true"
+        if "readonly" in options:
+            return ", true"
+        return ", false"

bmcgo/codegen/lua/script/sep_ipmi_message_cmds.py

@@ -0,0 +1,217 @@
+#!/usr/bin/env 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 re
+import os
+import sys
+import json
+import stat
+import logging
+import shutil
+from typing import List, Dict
+from bmcgo.utils.tools import Tools
+
+tools = Tools("bmcgo_config")
+
+
+def get_package_name(ipmi_json_filename: str) -> str:
+    """ 从ipmi.json中读取package名 """
+    with os.fdopen(os.open(ipmi_json_filename, os.O_RDONLY, stat.S_IRUSR), "r") as json_f:
+        ipmi_json_dict = json.load(json_f)
+        return ipmi_json_dict.get("package")
+
+
+def get_cmd_names(ipmi_json_filename: str) -> List[str]:
+    """ 从ipmi.json中读取所有命令名 """
+    with os.fdopen(os.open(ipmi_json_filename, os.O_RDONLY, stat.S_IRUSR), "r") as json_f:
+        ipmi_json_dict = json.load(json_f)
+        cmds_dict = ipmi_json_dict.get("cmds")
+        return list(cmds_dict.keys())
+
+
+def get_copyright_comments(lines: List[str]) -> List[str]:
+    """ 取出ipmi_message的copyright注释 """
+    comments_end = -1
+
+    # 找到copyright注释的结束位置
+    for i, line in enumerate(lines):
+        match_obj = re.search(f"local (.+) = require (.+)", line)
+        if match_obj:
+            comments_end = i
+            break
+
+    copyright_comments = lines[:comments_end]
+
+    return copyright_comments
+
+
+def filter_out_cmds_requires(lines: List[str], package_name: str) -> List[str]:
+    """ 取出ipmi_message的require语句, 并从lines中删除 """
+    requires_end = -1
+    requires = []
+    remove_lines = []
+
+    # 找到require语句的结束位置
+    for i, line in enumerate(lines):
+        match_obj = re.search(f"local {package_name}Msg = ", line)
+        if match_obj:
+            requires_end = i
+            break
+
+    for i, line in enumerate(lines):
+        if i >= requires_end:
+            break
+        match_obj = re.search(f"local (.+) = require (.+)", line)
+        if match_obj:
+            remove_lines.append(i)
+            requires.append(line)
+
+    # 从lines中删除require语句
+    for i in reversed(remove_lines):
+        del lines[i]
+
+    return requires
+
+
+def save_cmds_to(output_dir: str, ipmi_cmd_dict: Dict, package_name: str, requires: List[str], 
+                copyright_comments: List[str]):
+    """ 将每个命令保存到output_dir目录单独的文件中 """
+    requires_s = ''.join(requires) # require语句
+    copyright_comments_s = ''.join(copyright_comments) # copyright注释
+    file_list = []
+
+    for cmd_name in ipmi_cmd_dict:
+        cmd_filename = os.path.join(output_dir, f"{cmd_name}.lua")
+        with os.fdopen(os.open(cmd_filename, os.O_WRONLY | os.O_CREAT | os.O_TRUNC,
+                               stat.S_IWUSR | stat.S_IRUSR), 'w') as output_f:
+            code_prepend = f"\nlocal {cmd_name} = " + "{}\n\n" # declaration语句
+            code_append = f"\nreturn {cmd_name}" # return语句
+            code = copyright_comments_s + requires_s + code_prepend + ipmi_cmd_dict[cmd_name]['code'] + code_append
+            code = code.replace(f'{package_name}Msg', cmd_name)
+            output_f.write(code)
+        file_list.append(cmd_filename)
+    return file_list
+
+
+def modify_ipmi_message_lines(lines: List[str], ipmi_cmd_dict: Dict, package_name: str, project_name: str):
+    """ 修改lines, 删除多余的命令信息, 添加require语句引用单独的命令文件 """
+    trim_start = -1
+    trim_end = -1
+
+    # 找到需要删除的首行和尾行
+    for i, line in enumerate(lines):
+        match_obj = re.search(f"local {package_name}Msg = ", line)
+        if match_obj:
+            trim_start = i
+        match_obj = re.search(f"return {package_name}Msg", line)
+        if match_obj:
+            trim_end = i
+
+    del lines[trim_start: trim_end]
+
+    # 添加require语句引用单独的命令文件
+    requires = [f"local {package_name}Msg = " + "{\n"]
+    for i, cmd_name in enumerate(ipmi_cmd_dict):
+        requires.append(f"    {cmd_name}Req = (require '{project_name}.ipmi.cmds.{cmd_name}').{cmd_name}Req,\n")
+        if i == len(ipmi_cmd_dict) - 1:
+            requires.append(f"    {cmd_name}Rsp = (require '{project_name}.ipmi.cmds.{cmd_name}').{cmd_name}Rsp\n")
+        else:
+            requires.append(f"    {cmd_name}Rsp = (require '{project_name}.ipmi.cmds.{cmd_name}').{cmd_name}Rsp,\n")
+    requires.append("}\n")
+    requires.append("\n")
+
+    lines[:] = lines[:trim_start] + requires + lines[trim_start:]
+
+
+def get_ipmi_cmd_dict(lines: List[str], cmd_names: List[str], package_name: str):
+    """ 读取lines, 生成并返回ipmi_cmd_dict """
+    ipmi_cmd_dict = {} # cmd_name -> {start: int, end: int, code: str}
+
+    for i, line in enumerate(lines):
+        match_obj = re.search(f"@class {package_name}.(.+)", line)
+        if match_obj:
+            cmd_name = match_obj.group(1)[:-3] # 最后三位是Rsp/Req
+            if cmd_name not in ipmi_cmd_dict:
+                ipmi_cmd_dict[cmd_name] = {
+                    "start": i,
+                    "end": -1,
+                    "code": ''
+                }
+        for cmd_name in cmd_names:
+            found_cmd_end = (f'{package_name}Msg.{cmd_name}Req' in line) or (f'{package_name}Msg.{cmd_name}Rsp' in line)
+            if cmd_name in ipmi_cmd_dict and found_cmd_end:
+                ipmi_cmd_dict[cmd_name]['end'] = i
+                code_start = ipmi_cmd_dict[cmd_name].get('start', 0)
+                code_end = ipmi_cmd_dict[cmd_name].get('end', -1)
+                ipmi_cmd_dict[cmd_name]['code'] = ''.join(lines[code_start: code_end + 1])
+
+    return ipmi_cmd_dict
+
+
+def sep_ipmi_message_cmds(ipmi_json_filename: str, ipmi_message_filename: str, output_dir: str, project_name: str,
+                          lua_format: str):
+    """ 分离集中在ipmi_message.lua的命令到单独的文件 """
+    if not os.path.isdir(output_dir):
+        os.mkdir(output_dir)
+    else:
+        shutil.rmtree(output_dir)
+        os.mkdir(output_dir)
+
+    package_name = get_package_name(ipmi_json_filename)
+    cmd_names = get_cmd_names(ipmi_json_filename)
+    lines = []
+
+    # 读取ipmi_message文件到ipmi_cmd_dict(cmd_name -> {start: int, end: int, code: str}) 
+    with os.fdopen(os.open(ipmi_message_filename, os.O_RDONLY, stat.S_IRUSR), "r") as input_f:
+        lines = input_f.readlines()
+    ipmi_cmd_dict = get_ipmi_cmd_dict(lines, cmd_names, package_name)
+
+    copyright_comments = get_copyright_comments(lines)
+
+    requires = filter_out_cmds_requires(lines, package_name)
+
+    file_list = save_cmds_to(output_dir, ipmi_cmd_dict, package_name, requires, copyright_comments)
+
+    # 修改ipmi_message文件，引用分离开的单独的命令
+    modify_ipmi_message_lines(lines, ipmi_cmd_dict, package_name, project_name)
+    os.chmod(ipmi_message_filename, 0o666)
+    with os.fdopen(os.open(ipmi_message_filename, os.O_WRONLY | os.O_CREAT | os.O_TRUNC,
+                           stat.S_IWUSR | stat.S_IRUSR), 'w') as output_f:
+        output_f.write(''.join(lines))
+    file_list.append(ipmi_message_filename)
+    for file_path in file_list:
+        if os.path.exists(lua_format):
+            tools.run_command(["python3", lua_format, file_path], command_echo=False)
+        os.chmod(file_path, 0o444)
+
+
+def usage():
+    """ 输出脚本使用示例 """
+    logging.info("sep_ipmi_message.py <ipmi.json path> <ipmi_message.lua path> <output directory> <lua_format path>")
+
+
+def main(args: List[str]):
+    if len(args) < 5:
+        usage()
+        return
+
+    ipmi_json_filename = args[0]
+    ipmi_message_filename = args[1]
+    output_dir = args[2]
+    project_name = args[3]
+    lua_format = args[4]
+
+    sep_ipmi_message_cmds(ipmi_json_filename, ipmi_message_filename, output_dir, project_name, lua_format)
+
+
+if __name__ == "__main__":
+    main(sys.argv[1:])