openubmc-bingo 0.5.240__py3-none-any.whl

bmcgo/codegen/lua/script/redfish_source_tree.py

@@ -0,0 +1,118 @@
+#!/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 getopt
+import json
+import os
+import re
+import stat
+import sys
+
+from mako.template import Template
+
+
+def find_all_file(base):
+    for root, _, fs in os.walk(base):
+        for f in fs:
+            if '_' in f:
+                continue
+            if f.endswith('Collection.json'):
+                continue
+            else:
+                fullname = os.path.join(root, f)
+                yield fullname
+
+
+def generate_route(resource_path, template, out_dir):
+    exclude_file = ['LogEntry']
+    redfish_url = [
+        'Managers', 'Systems', 'Chassis', 'SessionService',
+        'AccountService', 'UpdateService', 'TaskService',
+        'EventService', 'Sms', 'Fabrics', 'DataAcquisitionService'
+    ]
+    my_template = Template(filename=template)
+    for i in find_all_file(resource_path):
+        temp_name = i.split("/")[-1]
+        file_name = temp_name.split(".")[0]
+        if file_name in exclude_file:
+            continue
+        with open(i, 'r') as temp:
+            load_json = json.load(temp)
+            if 'definitions' not in load_json:
+                continue
+            if file_name not in load_json['definitions']:
+                continue
+            if 'uris' in load_json['definitions'][file_name]:
+                # 拼接uris数组
+                temp_list = []
+                _format_url(file_name, load_json, redfish_url, temp_list)
+                _generate_proto(file_name, my_template, out_dir, temp_list)
+
+
+def _format_url(file_name, load_json, redfish_url, temp_list):
+    for url in load_json['definitions'][file_name]['uris']:
+        if url == '/redfish/v1':
+            continue
+        url = url.translate(str.maketrans({'{': ':', '}': ''}))
+        temp = url.split('/')[3]
+        if temp in redfish_url:
+            url = url.replace('/redfish/v1/', '')
+            temp_list.append(url)
+
+
+def _generate_proto(file_name, my_template, out_dir, temp_list):
+    if len(temp_list) > 0:
+        for i, url_temp in enumerate(temp_list):
+            dir_temp = out_dir + '/' + url_temp.replace(':', "")
+            if not os.path.exists(dir_temp):
+                os.makedirs(dir_temp)
+            # 生成proto文件
+            writer = os.fdopen(os.open(dir_temp + '/' + file_name + '.proto',
+                                       os.O_WRONLY | os.O_CREAT, stat.S_IWUSR), 'w')
+            writer.write(re.sub(r"\n\n\n+", "\n\n", my_template.render(
+                filename=file_name,
+                url=url_temp,
+                i=i
+            )))
+            writer.close()
+
+
+def main(argv):
+    resource_path = ''
+    template = ''
+    out_dir = ''
+    try:
+        opts, _ = getopt.getopt(
+            argv, "hi:t:d:", ["help", "input=", "tpl=", "dir="])
+    except getopt.GetoptError:
+        help()
+        return
+    for opt, arg in opts:
+        if opt in ("-h", "--help"):
+            usage()
+            return
+        elif opt in ("-i", "--input"):
+            resource_path = arg
+        elif opt in ("-t", "--tpl"):
+            template = arg
+        elif opt in ("-d", "--dir"):
+            out_dir = arg
+        else:
+            raise RuntimeError("不支持的选项: {}".format(opt))
+    if not resource_path or not template or not out_dir:
+        usage()
+        return
+    generate_route(resource_path, template, out_dir)
+
+
+if __name__ == "__main__":
+    main(sys.argv[1:])

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

@@ -0,0 +1,38 @@
+#!/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.
+
+__all__ = [
+    'Base', 'Factory', 'RequestLuaUtils', 'ControllerLuaUtils', 'IpmiMessageUtils', 'MessageUtils',
+    'UtilsMessageLua', 'ErrorLuaUtils', 'ClientLuaUtils',
+    'DbLuaUtils', 'IpmiLuaUtils', 'RedfishProtoUtils', 'ServicesUtils', 
+    'MdbLuaUtils', 'OldModelLuaUtils', 'ModelLuaUtils', "MdbRegister", 'MessagesLuaUtils', 'PluginLuaUtils'
+]
+
+from render_utils.base import Base
+from render_utils.client_lua import ClientLuaUtils
+from render_utils.controller_lua import ControllerLuaUtils
+from render_utils.db_lua import DbLuaUtils
+from render_utils.error_lua import ErrorLuaUtils
+from render_utils.factory import Factory
+from render_utils.ipmi_lua import IpmiLuaUtils
+from render_utils.ipmi_message_lua import IpmiMessageUtils
+from render_utils.mdb_lua import MdbLuaUtils
+from render_utils.message_lua import MessageUtils
+from render_utils.redfish_proto import RedfishProtoUtils
+from render_utils.request_lua import RequestLuaUtils
+from render_utils.service_lua import ServicesUtils
+from render_utils.utils_message_lua import UtilsMessageLua
+from render_utils.old_model_lua import OldModelLuaUtils
+from render_utils.model_lua import ModelLuaUtils
+from render_utils.mdb_register import MdbRegister
+from render_utils.messages_lua import MessagesLuaUtils
+from render_utils.plugin_lua import PluginLuaUtils

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

@@ -0,0 +1,25 @@
+#!/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 abc import abstractmethod
+
+from dto.options import Options
+
+
+class Base:
+    def __init__(self, data: dict, options: Options):
+        self.data = data
+        self.options: Options = options
+
+    @abstractmethod
+    def name(self) -> str:
+        return ""

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

@@ -0,0 +1,98 @@
+#!/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
+from dto.options import Options
+from render_utils.base import Base
+from render_utils.factory import Factory
+from render_utils.mdb_register import MdbRegister
+
+
+class ClientLuaUtils(Base, 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
+
+    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 props(self, msg_type):
+        msg = Utils(self.data, self.options).make_get_message(msg_type)
+        return msg.get('properties')
+
+    def params(self, msg_type):
+        return ", ".join([p['name'] for p in self.props(msg_type)])
+
+    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 make_path_with_params(self, path):
+        path = self.force_to_colon(path)
+        params = self.get_path_params(path)
+        if not params:
+            return f"'{path}'"
+        result = []
+        for name in params:
+            parts = path.partition(f':{name}')
+            result.append(f"'{parts[0]}'")
+            result.append(f"path_params['{name}']")
+            path = parts[2]
+        ret = ' .. '.join(result)
+        if path:
+            ret += f" .. '{path}'"
+        return ret
+
+    def get_path_arg(self, path, with_comma=True):
+        if not self.get_path_params(path):
+            return ""
+        if with_comma:
+            return ", path_params"
+        return "path_params"
+
+    def get_dep_properties(self, properties):
+        if properties == ["*"]:
+            return ""
+
+        return ', {"' + '", "'.join(properties) + '"}'
+
+    def get_path_namespace(self, path):
+        if not self.get_path_params(path):
+            return f"'{path}'"
+        path_with_params = self.make_path_with_params(path)
+        if Utils.get_lua_codegen_version() >= 17:
+            return f"path_params and ({path_with_params}) or '{path}'"
+        prefix = path_with_params.split("/' ..")[0]
+        return f"path_params and ({path_with_params}) or {prefix}'"
+
+    def get_path_patterns(self, paths):
+        return MdbRegister.convert_to_lua(self, paths)
+
+    def get_object_path(self, path):
+        if not self.get_path_params(path):
+            return f"'{path}'"
+        path_with_params = self.make_path_with_params(path)
+        return f"path_params and ({path_with_params}) or '{path}'"
+
+Factory().register("client.lua.mako", ClientLuaUtils)

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

@@ -0,0 +1,71 @@
+#!/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 ControllerLuaUtils(Base, ValidateLua, UtilsMessageLua):
+    methods = ['get', 'post', 'patch', 'delete']
+
+    def __init__(self, data: dict, options: Options):
+        super().__init__(data, options)
+
+    @staticmethod
+    def get_property(properties, prop_name):
+        for prop in properties:
+            if prop["name"].lower() == prop_name.lower():
+                return prop
+        return False
+
+    @staticmethod
+    def get_lower_case_name(name):
+        lst = []
+        for index, char in enumerate(name):
+            if char.isupper() and index != 0:
+                lst.append("_")
+            lst.append(char)
+        return "".join(lst).lower()
+
+    @staticmethod
+    def get_auth(msg):
+        if 'auth' in msg["options"]:
+            return ', self.auth(ctx)'
+        return ''
+
+    def get_response(self, msg):
+        return self.get_property(msg["properties"], "response")
+
+    def get_body(self, msg):
+        return self.get_property(msg["properties"], "body")
+
+    def get_formdata_body(self, msg):
+        return self.get_property(msg["properties"], "formdatabody")
+
+
+    def get_header(self, msg):
+        return self.get_property(msg["properties"], "header")
+
+    def get_controller_methods(self, msg):
+        result = {}
+        for method in self.methods:
+            method_prop = self.get_property(msg['nested_type'], method)
+            if not method_prop:
+                continue
+            result[method] = method_prop
+        return result
+
+
+Factory().register("controller.lua.mako", ControllerLuaUtils)

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

@@ -0,0 +1,224 @@
+#!/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 json
+from utils import Utils
+from dto.options import Options
+from render_utils.base import Base
+from render_utils.factory import Factory
+
+
+class DbLuaUtils(Base, Utils):
+    TYPE_TO_DB_MAP = {
+        "int8": 'IntegerField',
+        'uint8': 'IntegerField',
+        'int16': 'IntegerField',
+        'uint16': 'IntegerField',
+        'int32': 'IntegerField',
+        'uint32': 'IntegerField',
+        'int64': 'IntegerField',
+        'uint64': 'IntegerField',
+        'double': 'RealField',
+        'float': 'RealField',
+        'bytes': 'BolbField',
+        'string': 'TextField',
+        'bool': 'BooleandField',
+    }
+
+    per_type_map = {
+        'PoweroffPer': 'protect_power_off',
+        'ResetPer': 'protect_reset',
+        'PermanentPer': 'protect_permanent',
+        'TemporaryPer': 'protect_temporary',
+        'PoweroffPerRetain': 'protect_power_off_retain',
+        'ResetPerRetain': 'protect_reset_retain',
+        'TemporaryPerRetain': 'protect_temporary_retain'
+    }
+
+    def __init__(self, data: dict, options: Options):
+        super().__init__(data, options=options)
+
+    @staticmethod
+    def table_name(msg):
+        if msg['type'] != 'Message' or not msg['options'] or not msg['options']['table_name']:
+            return False
+
+        return msg['options']['table_name']
+
+    @staticmethod
+    def table_max_rows(msg):
+        return msg.get('type') == 'Message' and msg.get('options', {}).get('table_max_rows', False)
+
+    @staticmethod
+    def all_persistence(msg):
+        if msg['type'] != 'Message' or not msg['options']:
+            return 'nil'
+
+        if 'persistence' in msg['options']:
+            return msg['options']['persistence']
+
+        if 'table_type' in msg['options']:
+            if msg['options']['table_type'] in DbLuaUtils.per_type_map:
+                return DbLuaUtils.per_type_map[msg['options']['table_type']]
+        return 'nil'
+
+    @staticmethod
+    def check_local_per_type(root):
+        per_map = {
+            "PoweroffPer": False,
+            "ResetPer": False,
+            "TemporaryPer": False
+        }
+        for msg in root["data"]:
+            table_type = msg["options"].get("table_type", "PoweroffPer")
+            if table_type not in per_map:
+                continue
+            per_map[table_type] = True
+        return per_map.values()
+
+    @staticmethod
+    def check_local_per_poweroff(msg):
+        if "options" not in msg or "table_type" not in msg["options"]:
+            return True
+        return "options" in msg and "table_type" in msg["options"] and msg["options"]["table_type"] == "PoweroffPer"
+
+    @staticmethod
+    def check_local_per_reset(msg):
+        return "options" in msg and "table_type" in msg["options"] and msg["options"]["table_type"] == "ResetPer"
+
+    @staticmethod
+    def check_local_per_temporary(msg):
+        return "options" in msg and "table_type" in msg["options"] and msg["options"]["table_type"] == "TemporaryPer"
+
+    @staticmethod
+    def column_max_len(prop):
+        if prop['repeated']:
+            return 0
+        type_name = prop['type']
+        if type_name == "int8" or type_name == 'uint8':
+            return 8
+        if type_name == "int16" or type_name == 'uint16':
+            return 16
+        if type_name == "int32" or type_name == 'uint32':
+            return 32
+        if type_name == "int64" or type_name == 'uint64':
+            return 64
+        if 'max_len' in prop['options']:
+            return prop['options']['max_len']
+        return 0
+
+    @staticmethod
+    def unique(prop):
+        if 'unique' not in prop['options']:
+            return ''
+        return f':unique()'
+
+    @staticmethod
+    def primary_key(prop):
+        if 'primary_key' not in prop['options']:
+            return ''
+        return f':primary_key()'
+
+    @staticmethod
+    def persistence_key(prop):
+        if 'persistence_ex' in prop['options']:
+            val = prop['options']['persistence_ex']
+            return f':persistence_key("{val}")'
+
+        if 'usage' not in prop['options']:
+            return ''
+        val = ''
+        for use_type in prop['options']['usage']:
+            if use_type in DbLuaUtils.per_type_map:
+                val = DbLuaUtils.per_type_map[use_type]
+                break
+        if val == '':
+            return ''
+
+        return f':persistence_key("{val}")'
+
+    @staticmethod
+    def allow_null(prop):
+        if prop['options'].get('allow_null', False):
+            return ':null()'
+        return ''
+
+    @staticmethod
+    def extend_field(prop):
+        if prop['options'].get('extend_field', False):
+            return ':extend_field()'
+        return ''
+
+    @staticmethod
+    def deprecated(prop):
+        if prop['options'].get('deprecated', False):
+            return ':deprecated()'
+        return ''
+
+    @staticmethod
+    def critical(prop):
+        if prop['options'].get('critical', False):
+            return ':critical()'
+        return ''
+
+    def column_type(self, prop):
+        type_name = prop['type']
+        if type_name in self.TYPE_TO_DB_MAP:
+            if prop['repeated']:
+                return "JsonField()"
+            else:
+                return self.TYPE_TO_DB_MAP[type_name] + "()"
+        types = Utils(self.data, self.options).load_types(type_name)
+        if types and ('type' in types) and types['type'] == 'Enum':
+            return f'EnumField({types["package"]}.{types["name"]})'
+        return "JsonField()"
+
+    def max_len(self, prop):
+        num = self.column_max_len(prop)
+        if num == 0:
+            return ''
+        return f':max_length({num})'
+
+    def default(self, class_name, prop):
+        if 'default' not in prop['options']:
+            return ''
+        return f':default({self._convert_default_value(class_name, prop)})'
+
+    def _convert_default_value(self, class_name, prop):
+        d_val = prop['options']['default']
+        type_name = prop['type']
+        types = Utils(self.data, self.options).load_types(type_name)
+        if types and ('type' in types) and types['type'] == 'Enum':
+            if isinstance(d_val, list):
+                result = "{"
+                for val in d_val:
+                    enum_type = Utils(self.data, self.options).enum_value_name(types["name"], val)
+                    result += f'{types["package"]}.{types["name"]}.{enum_type},'
+                return result + "}"
+            value_name = Utils(self.data, self.options).enum_value_name(types["name"], d_val)
+            return f'{types["package"]}.{types["name"]}.{value_name}'
+        if Utils.get_lua_codegen_version() >= 10:
+            if prop.get('repeated') and not isinstance(d_val, list):
+                raise RuntimeError(f"model.json中类{class_name}的属性{prop['name']}默认值{d_val}类型与属性类型不一致")
+            if isinstance(d_val, list) or isinstance(d_val, dict):
+                json_str = json.dumps(d_val).replace("'", "''")
+                return f"[['{json_str}']]"
+        if type_name == "string" or type_name == 'bytes':
+            return f'"\'{d_val}\'"'
+        if type_name == "bool":
+            return str(bool(d_val)).lower()
+        return d_val
+
+
+Factory().register("db.lua.mako", DbLuaUtils)
+Factory().register("local_db.lua.mako", DbLuaUtils)
+Factory().register("orm_classes.lua.mako", DbLuaUtils)