openubmc-bingo 0.5.240__py3-none-any.whl

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

@@ -0,0 +1,185 @@
+#!/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
+from dto.options import Options
+from render_utils.base import Base
+from render_utils.factory import Factory
+
+
+class ErrorLuaUtils(Base, Utils):
+    LOG_MAP = {
+        "error": "log.ERROR",
+        "warning": "log.WARN",
+        "debug": "log.DEBUG",
+        "trace": "log.TRACE",
+    }
+
+    def __init__(self, data: dict, options: Options):
+        super().__init__(data, options=options)
+
+    @staticmethod
+    def get_error_name(code):
+        err = code.split(".")
+        if err == -1 or len(err) != 3:  # 不满足3段式格式则抛错
+            raise Exception("无法满足 <xx.xx.xx> 的格式要求, %s" % code)
+        idx = code.rfind(".")
+        if idx == -1:
+            return code
+        return code[idx + 1:]
+
+    @staticmethod
+    def match_placeholders(msg):
+        return sorted(set([int(v) for v in re.findall(r"{(\d+)}", msg)]))
+
+    @staticmethod
+    def format_hex(data):
+        return "0x%02X" % data
+
+    @staticmethod
+    def format(msg):
+        return re.sub(r"{(\d+)}", r"%s", msg)
+
+    @staticmethod
+    def get_app_name(code):
+        name = code.split(".")
+        if name == -1:
+            return code
+        return name[1]
+
+    @staticmethod
+    def get_http_response(root, err):
+        ret = -1
+        if 'http_response' in err:
+            ret = err['http_response']
+        elif 'http_response' in root:
+            ret = root['http_response']
+        http_check_list = [
+            400, 401, 402, 403, 404, 405, 406, 408, 409, 410, 426,
+            429, 444, 451, 500, 501, 502, 503, 504, 505, 507
+        ]
+        if ret == -1: # 没有配置则返回nil
+            return 'nil'
+        if ret not in http_check_list: # 不在规定的返回码列表中则抛错
+            raise Exception("http 响应无效: %d" % ret)
+        return str(ret)
+
+    @staticmethod
+    def get_redfish_response(root, err):
+        if 'redfish_response' in err and len(err['redfish_response']) > 0:
+            return "\"{}\"".format(err['redfish_response'])
+        if 'redfish_response' in root and len(root['redfish_response']) > 0:
+            return "\"{}\"".format(root['redfish_response'])
+        return 'nil'
+
+    @staticmethod
+    def ret_check_ipmi(res):
+        generic_completion_codes = [
+            0x00,
+            0xC0,
+            0xC1,
+            0xC2,
+            0xC3,
+            0xC4,
+            0xC5,
+            0xC6,
+            0xC7,
+            0xC8,
+            0xC9,
+            0xCA,
+            0xCB,
+            0xCC,
+            0xCD,
+            0xCE,
+            0xCF,
+            0xD0,
+            0xD1,
+            0xD2,
+            0xD3,
+            0xD4,
+            0xD5,
+            0xD6,
+            0xFF,
+        ]
+        device_specific_codes = range(0x01, 0x7E + 1)
+        command_specific_codes = range(0x80, 0xBE + 1)
+        if res == -1:  # 没有配置则返回nil
+            return "nil"
+        valid = res in generic_completion_codes or res in device_specific_codes \
+                or res in command_specific_codes
+        if not valid:  # 不在规定的返回码范围中则抛错
+            raise Exception("ipmi 响应无效: 0x%02X" % res)
+        return "0x%02X" % res
+
+    @staticmethod
+    def get_ipmi_response(root, err):
+        res = 0
+        if "ipmi_response" in err:
+            res = err["ipmi_response"]
+        elif "ipmi_response" in root:
+            res = root["ipmi_response"]
+        return ErrorLuaUtils.ret_check_ipmi(res)
+
+    @staticmethod
+    def get_ipmi_response_json(err):
+        res = 0
+        if "ipmi_response" in err:
+            res = int(err["ipmi_response"], 16)
+
+        return ErrorLuaUtils.ret_check_ipmi(res)
+
+    @staticmethod
+    def get_backtrace_level(root, err):
+        ret = 0
+        if "backtrace_level" in err:
+            ret = err["backtrace_level"]
+        elif "backtrace_level" in root:
+            ret = root["backtrace_level"]
+        if ret > 5:  # 层级不超过5层
+            return 5
+        return ret
+
+    @staticmethod
+    def get_severity_err(err):
+        if "severity" in err and err["severity"] in ErrorLuaUtils.LOG_MAP:
+            return ErrorLuaUtils.LOG_MAP.get(err["severity"])
+        return "log.DEBUG"  # 不在log_map映射表中则默认返回debug
+
+    @staticmethod
+    def get_severity(root, err):
+        if 'severity' in err and err['severity'] in ErrorLuaUtils.LOG_MAP:
+            return ErrorLuaUtils.LOG_MAP.get(err['severity'])
+        if 'severity' in root and root['severity'] in ErrorLuaUtils.LOG_MAP:
+            return ErrorLuaUtils.LOG_MAP.get(root['severity'])
+        return 'log.DEBUG' # 不在log_map映射表中则默认返回debug
+
+    def error_params(self, err):
+        s = self.params(err["message"])
+        if len(s) == 0:
+            return ""
+        return f", {s}"
+
+    def params(self, msg):
+        placeholders = self.match_placeholders(msg)
+        if len(placeholders) == 0:
+            return ""
+        elif len(placeholders) != placeholders[len(placeholders) - 1]:
+            raise RuntimeError("无效错误信息: `{}`, 未匹配到占位符".format(msg))
+        return ", ".join(["val" + str(v) for v in placeholders])
+
+    def get_function_name(self, code):
+        return Utils.camel_to_snake(self.get_error_name(code))
+
+
+Factory().register("errors.lua.mako", ErrorLuaUtils)

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

@@ -0,0 +1,52 @@
+#!/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 typing import Optional
+
+from dto.options import Options
+from render_utils.base import Base
+
+
+class NoRenderUtilsException(Exception):
+    pass
+
+
+class Factory:
+    _instance = None
+    _has_init = False
+
+    @classmethod
+    def __new__(cls, *args, **kwargs):
+        if not isinstance(Factory._instance, Factory):
+            Factory._instance = object.__new__(cls)
+        return Factory._instance
+
+    def __init__(self):
+        if Factory._has_init:
+            return
+        self._utils_dict: dict = {}
+        Factory._has_init = True
+
+    def new_utils(self, template_name: str, data: dict, options: Options) -> Optional[Base]:
+        if not self._utils_dict.get(template_name):
+            return NoRenderUtilsException
+
+        if template_name == 'model.lua.mako' and options.version < 4:
+            template_name = 'old_model.lua.mako'
+
+        return self._utils_dict.get(template_name)(data, options)
+
+    def register(self, template_name: str, utils_type: type):
+        self._utils_dict.setdefault(template_name, utils_type)
+
+    def get(self, template_name: str):
+        return self._utils_dict.get(template_name)

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

@@ -0,0 +1,159 @@
+#!/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 dto.options import Options
+from render_utils.base import Base
+from render_utils.factory import Factory
+
+
+class IpmiLuaUtils(Base):
+    def __init__(self, data: dict, options: Options):
+        super().__init__(data, options=options)
+
+    @staticmethod
+    def params(msg):
+        return ", ".join([p["name"] for p in msg["properties"]])
+
+    @staticmethod
+    def params_array(msg):
+        return (
+            "{" + ", ".join([("'" + p["name"] + "'") for p in msg["properties"]]) + "}"
+        )
+
+    @staticmethod
+    def is_req(t):
+        return t["name"] == "Req"
+
+    @staticmethod
+    def is_rsp(t):
+        return t["name"] == "Rsp"
+
+    @staticmethod
+    def get_option(ipmi, option):
+        return (
+            ipmi["options"][option]
+            if option in ipmi["options"] and ipmi["options"][option]
+            else ""
+        )
+
+    @staticmethod
+    def format_hex(data):
+        return "0x%02x" % data
+
+    @staticmethod
+    def wrap_json(msg):
+        return (
+            "{"
+            + (", ".join([(p["name"] + " = " + p["name"]) for p in msg["properties"]]))
+            + "}"
+        )
+
+    @staticmethod
+    def get_privilege(ipmi):
+        if len(ipmi['options']['privilege']) == 0:
+            return 'nil'
+        return " | ".join([("privilege." + p) for p in ipmi['options']['privilege']])
+
+    def req(self, ipmi):
+        result = None
+        if "nested_type" not in ipmi:
+            return result
+
+        req_list = [p for p in ipmi["nested_type"] if self.is_req(p)]
+        return req_list[0] if req_list else None
+
+    def rsp(self, ipmi):
+        result = None
+        if "nested_type" not in ipmi:
+            return result
+
+        rsp_list = [p for p in ipmi["nested_type"] if self.is_rsp(p)]
+        return rsp_list[0] if rsp_list else None
+
+    def req_params(self, ipmi):
+        req_info = self.req(ipmi)
+        return self.params(req_info) if req_info else ""
+
+    def req_properties(self, ipmi):
+        req_info = self.req(ipmi)
+        return req_info["properties"] if req_info else []
+
+    def rsp_properties(self, ipmi):
+        rsp_info = self.rsp(ipmi)
+        return rsp_info["properties"] if rsp_info else []
+
+    def req_json(self, ipmi):
+        req_info = self.req(ipmi)
+        return self.wrap_json(req_info) if req_info else ""
+
+    def get_netfn(self, ipmi):
+        if "net_fn" in ipmi["options"]:
+            return ipmi["options"]["net_fn"]
+        if "netfn" in ipmi["options"]:
+            return ipmi["options"]["netfn"]
+        return ""
+
+    def get_priority(self, ipmi):
+        if "prio" in ipmi["options"]:
+            return ipmi["options"]["prio"]
+        if "priority" in ipmi["options"]:
+            return ipmi["options"]["priority"]
+        return ""
+
+
+    def get_sys_locked_policy(self, ipmi):
+        if "sysLockedPolicy" in ipmi["options"]:
+            return ipmi["options"]["sysLockedPolicy"]
+        return "Allowed"
+
+    def is_generate_service(self, ipmi):
+        if "prio" in ipmi["options"] and ipmi["options"]["prio"]:
+            return True
+        if "priority" in ipmi["options"] and ipmi["options"]["priority"]:
+            return True
+        return False
+
+    def has_generate_service(self):
+        for ipmi in self.data["data"]:
+            if self.is_generate_service(ipmi):
+                return True
+
+        return False
+
+    def has_generate_client(self):
+        for ipmi in self.data["data"]:
+            if "prio" not in ipmi["options"] or not ipmi["options"]["prio"]:
+                return True
+            if "priority" not in ipmi["options"] or not ipmi["options"]["priority"]:
+                return True
+
+        return False
+
+    def get_channel(self, ipmi):
+        if "channel" in ipmi["options"] and ipmi["options"]["channel"]:
+            return ipmi["options"]["channel"]
+        else:
+            return self.data["options"]["default_channel"]
+
+    def get_restricted_channel(self, ipmi):
+        if "restricted_channels" in ipmi["options"] and ipmi["options"]["restricted_channels"]:
+            return '{' + ','.join([("'" + p + "'") for p in ipmi["options"]["restricted_channels"]]) + '}'
+        else:
+            return "{}"
+
+    def get_manufacturer(self, ipmi):
+        manufacturer = [-1, -1]
+        for i in range(2):
+            manufacturer[i] = ipmi["nested_type"][i]["manufacturer"]
+        return manufacturer
+
+Factory().register("ipmi.lua.mako", IpmiLuaUtils)

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

@@ -0,0 +1,24 @@
+#!/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 dto.options import Options
+from render_utils.base import Base
+from render_utils.factory import Factory
+from render_utils.utils_message_lua import UtilsMessageLua
+from render_utils.validate_lua import ValidateLua
+
+
+class IpmiMessageUtils(Base, ValidateLua, UtilsMessageLua):
+    def __init__(self, data: dict, options: Options):
+        super().__init__(data, options)
+
+Factory().register("ipmi_message.lua.mako", IpmiMessageUtils)

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

@@ -0,0 +1,177 @@
+#!/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
+from dto.options import Options
+from render_utils.base import Base
+from render_utils.factory import Factory
+from render_utils.utils_message_lua import UtilsMessageLua
+from render_utils.validate_lua import ValidateLua
+
+
+class MdbLuaUtils(Base, ValidateLua, UtilsMessageLua):
+    flag_names = ['const', 'emit_change', 'emit_no_value', 'explicit']
+
+    def __init__(self, data: dict, options: Options):
+        super().__init__(data, options=options)
+
+    @staticmethod
+    def message_type(msg_type):
+        if msg_type == ".google.protobuf.Empty":
+            return 'nil'
+        return msg_type[1:] if msg_type.startswith('.') else msg_type
+
+    @staticmethod
+    def filename(name):
+        if name.endswith("/index.proto"):
+            return name[:-len("/index.proto")]
+        elif name.endswith(".proto"):
+            return name[:-len(".proto")]
+        return name
+
+    @staticmethod
+    def count(params, name):
+        c = 0
+        for n in params:
+            if n == name:
+                c += 1
+        return c
+
+    @staticmethod
+    def has_path(msg):
+        return 'options' in msg and 'path' in msg['options']
+
+    @staticmethod
+    def has_interface(msg):
+        return 'options' in msg and 'interface' in msg['options']
+
+    @staticmethod
+    def make_methods(root, interface):
+        methods = []
+        if 'service' not in root:
+            return methods
+        for method in root['service']:
+            if 'options' in method and 'service_interface' in method['options'] and \
+                    method['options']['service_interface'] == interface:
+                methods.append(method)
+        return methods
+
+    @staticmethod
+    def has_signals(msg):
+        return 'nested_type' in msg and len(msg['nested_type']) > 0
+
+    @staticmethod
+    def make_interface(msg):
+        return msg['options']['interface'] if 'options' in msg and 'interface' in msg['options'] else 'bmc.mdb.object'
+
+    @staticmethod
+    def realtime(prop):
+        return 'true' if 'realtime' in prop['options'] and prop['options']['realtime'] else 'false'
+
+    @staticmethod
+    def readonly_flag(prop):
+        return 'true' if 'readonly' in prop['options'] and prop['options']['readonly'] else 'false'
+
+    @staticmethod
+    def get_req(msg):
+        return 'nil' if msg['req'] == '.google.protobuf.Empty' else msg['req'][1:]
+
+    @staticmethod
+    def get_rsp(msg):
+        return 'nil' if msg['rsp'] == '.google.protobuf.Empty' else msg['rsp'][1:]
+
+    @staticmethod
+    def get_json_req(msg):
+        return 'nil' if msg['req'] == '.google.protobuf.Empty' else ('msg' + msg['req'])
+
+    @staticmethod
+    def get_json_rsp(msg):
+        return 'nil' if msg['rsp'] == '.google.protobuf.Empty' else ('msg' + msg['rsp'])
+
+    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 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 get_flags(self, prop):
+        if 'options' not in prop:
+            return '0'
+        options = prop['options']
+        result = [f"'{name.upper()}'" for name in self.flag_names if name in options and options[name]]
+        if len(result) == 0:
+            return 'nil'
+        return f"{{{','.join(result)}}}"
+
+    def check_duplicate(self, params):
+        for name in params:
+            if self.count(params, name) > 1:
+                raise RuntimeError(f"重复的参数: {name}")
+
+    def make_path(self, msg):
+        path = msg['options']['path']
+        params = Utils.get_path_params(self, path)
+        if len(params) == 0:
+            return f"'{path}'"
+        result = []
+        for name in params:
+            s = path.partition(f':{name}')
+            result.append(f"'{s[0]}'")
+            result.append(name)
+            path = s[2]
+
+        return (f"{' .. '.join(result)}") if path == '' else (f"{' .. '.join(result)} .. '{path}'")
+
+    def default(self, prop):
+        if 'default' not in prop['options']:
+            return 'nil'
+        default_val = prop['options']['default']
+        type_name = prop['type']
+        if type_name == "string" or type_name == 'bytes':
+            default_val = f'"{default_val}"'
+        t = Utils(self.data, self.options).load_types(type_name)
+        if t and ('type' in t) and t['type'] == 'Enum':
+            default_val = f'{t["package"]}.{t["name"]}.' \
+                          f'{Utils(self.data, self.options).enum_value_name(t["name"], default_val)}'
+        return default_val
+
+    def dependency(self, root):
+        if 'dependency' in root:
+            return [(pkg, self.filename(data['filename'])) for (pkg, data) in root['dependency'].items()]
+        return []
+
+    def has_msg(self, root):
+        for msg in root['data']:
+            if self.has_path(msg):
+                return True
+        return False
+
+
+Factory().register("mdb.lua.mako", MdbLuaUtils)
+Factory().register("mdb_interface.lua.mako", MdbLuaUtils)