openubmc-bingo 0.5.240__py3-none-any.whl

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

@@ -0,0 +1,429 @@
+#!/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
+
+
+BASE_TYPE = "baseType"
+ITEMS = "items"
+ALIAS = "alias"
+PROPERTIES = "properties"
+ENUM = "Enum"
+DEFAULT = "default"
+
+
+class OldModelLuaUtils(Base, Utils):
+    TYPE_TO_DEFAULT_MAP = {
+        "U8": 0,
+        "U16": 0,
+        "U32": 0,
+        "U64": 0,
+        "S8": 0,
+        "S16": 0,
+        "S32": 0,
+        "S64": 0,
+        "Double": 0,
+        'String': "''",
+        "Boolean": 'false'
+    }
+
+    def __init__(self, data: dict, options: Options):
+        super().__init__(data, options=options)
+
+    @staticmethod
+    def has_path(msg):
+        return 'path' in msg
+
+    @staticmethod
+    def has_properties(msg):
+        return PROPERTIES in msg
+
+    @staticmethod
+    def make_class(classes):
+        string = '{\n'
+        for i in range(len(classes)):
+            string += '    ' + list(classes)[i] + ' = ' + list(
+                classes)[i] + ('\n' if (i == len(classes) - 1) else ',\n')
+        return string + '}\n'
+
+    @staticmethod
+    def has_methods(msg):
+        return 'methods' in msg
+
+    @staticmethod
+    def has_signals(msg):
+        return 'signals' in msg
+
+    @staticmethod
+    def has_table_name(msg):
+        return 'tableName' in msg
+
+    @staticmethod
+    def has_parent(msg):
+        return 'parent' in msg
+
+    @staticmethod
+    def has_arg_in(msg):
+        return 'req' in msg
+
+    @staticmethod
+    def get_arg_in_params(msg):
+        result = []
+        for (param, _) in msg.items():
+            result.append(param)
+        return result
+
+    @staticmethod
+    def get_intf_package_name(intf_name):
+        intfs = intf_name.split(".")
+        if intfs[-1] == "Default":
+            return intfs[-2] + intfs[-1]
+        return intfs[-1]
+
+    @staticmethod
+    def is_enum_array(prop_config):
+        return prop_config[BASE_TYPE] == 'Array' and ITEMS in prop_config and BASE_TYPE in prop_config[ITEMS] \
+            and prop_config[ITEMS][BASE_TYPE] == ENUM
+
+    def class_has_block_io(self, msg):
+        if self.has_path(msg):
+            for (interface, _) in msg['interfaces'].items():
+                if interface == 'bmc.kepler.Chip.BlockIO':
+                    return True
+        return False
+
+    def has_block_io(self, root):
+        for (_, msg) in root.items():
+            if self.class_has_block_io(msg):
+                return True
+        return False
+
+    def convert_dict_to_lua_table(self, msg):
+        string = '{\n'
+        i = 1
+        for (prop, value) in msg.items():
+            if prop == "pattern":
+                string += f"['{prop}'] = [=[{value}]=],\n"
+            elif prop == "validator":
+                string += f"['{prop}'] = {value},\n"
+            else:
+                string += f"['{prop}'] = " + self.convert_to_lua(value) + ",\n"
+            i += 1
+        return string + '}'
+
+    def convert_to_lua(self, value):
+        if isinstance(value, str):
+            return "'" + value + "'"
+        elif isinstance(value, bool):
+            return 'true' if value else 'false'
+        elif isinstance(value, int) or isinstance(value, float):
+            return str(value)
+        elif isinstance(value, dict):
+            return self.convert_dict_to_lua_table(value)
+        elif isinstance(value, list):
+            string = "{"
+            for val in value:
+                string += self.convert_to_lua(val) + ","
+            string += "}"
+            return string
+        raise Exception("无效值类型")
+
+    def get_enum_value(self, project_name, ref, enum_type):
+        if ref.startswith("types.json"):
+            return "require 'class.types.types'." + \
+                ref.replace("types.json#/defs/", "") + "." + enum_type
+        elif ref.startswith("mdb://"):
+            spices = ref.split(".json#")
+            return "require '" + project_name + ".json_types." + \
+                Utils.get_unique_intf_name(spices[0].replace("/", ".")) + "'." + \
+                spices[1].replace("/defs/", "") + "." + enum_type
+        raise Exception("枚举引用定义错误")
+
+    def get_prop_default_value(self, project_name, class_name, prop, prop_config):
+        if project_name != 'dft' and project_name != 'debug':
+            if DEFAULT not in prop_config:
+                if BASE_TYPE in prop_config and prop_config[BASE_TYPE] == ENUM:
+                    return f"require 'class.types.{class_name}'.{prop}.default[1]:value()"
+                else:
+                    return f"require 'class.types.{class_name}'.{prop}.default[1]"
+        else:
+            if DEFAULT not in prop_config:
+                if BASE_TYPE in prop_config and prop_config[BASE_TYPE] == ENUM:
+                    return f"require '{project_name}.class.types.{class_name}'.{prop}.default[1]:value()"
+                else:
+                    return f"require '{project_name}.class.types.{class_name}'.{prop}.default[1]"
+
+        default = prop_config[DEFAULT]
+        if BASE_TYPE not in prop_config:
+            return self.convert_to_lua(default)
+
+        if prop_config[BASE_TYPE] == ENUM:
+            return self.get_enum_value(project_name, prop_config["$ref"], default) + ":value()"
+        elif self.is_enum_array(prop_config):
+            result = "{"
+            for enum_type in default:
+                result += self.get_enum_value(project_name, prop_config[ITEMS]["$ref"], enum_type) + ":value(),"
+            return result + "}"
+
+        return self.convert_to_lua(default)
+
+    def get_mdb_prop_default_value(self, project_name, intf_name, prop, prop_config):
+        pkg_name = "require '" + project_name + ".json_types." + intf_name + "'."
+        if DEFAULT not in prop_config:
+            if BASE_TYPE in prop_config and prop_config[BASE_TYPE] == ENUM:
+                return pkg_name + prop + ".default[1]:value()"
+            else:
+                return pkg_name + prop + ".default[1]"
+
+        default = prop_config[DEFAULT]
+        if BASE_TYPE not in prop_config:
+            return self.convert_to_lua(default)
+
+        if prop_config[BASE_TYPE] == ENUM:
+            return pkg_name + \
+                prop_config["$ref"].replace("#/defs/", "") + "." + default + ":value()"
+        elif self.is_enum_array(prop_config):
+            result = "{"
+            for enum_type in default:
+                result += pkg_name + prop_config[ITEMS]["$ref"].replace("#/defs/", "") + "." + enum_type + ":value(),"
+            return result + "}"
+
+        return self.convert_to_lua(default)
+
+    def get_path(self, root, msg):
+        if not self.has_path(msg):
+            return ''
+        if not self.has_parent(msg):
+            return msg['path']
+        return msg['path'].replace(':parent/', self.get_path(root, root[msg['parent']]) + ':parent/')
+
+    def convert_dynamic_params(self, msg):
+        match_obj = re.search("\$\{(.+?)\}", msg)
+        if match_obj is None:
+            return msg
+
+        return self.convert_dynamic_params(re.sub('\$\{(.+?)\}', ':' + match_obj.group(1), msg, 1))
+
+    def get_primary_key(self, msg):
+        if self.has_properties(msg):
+            for (prop, prop_config) in msg[PROPERTIES].items():
+                if "primaryKey" in prop_config:
+                    return self.convert_to_lua({"field": prop, BASE_TYPE: prop_config.get(BASE_TYPE)})
+
+        if 'interfaces' not in msg:
+            return {}
+
+        for (_, intf_msg) in msg['interfaces'].items():
+            if not self.has_properties(intf_msg):
+                continue
+            for (prop, prop_config) in intf_msg[PROPERTIES].items():
+                if "primaryKey" not in prop_config:
+                    continue
+                result = {"field": prop_config.get(ALIAS, prop), BASE_TYPE: prop_config.get(BASE_TYPE)}
+                return self.convert_to_lua(result)
+
+        return {}
+
+    def get_prop_configs(self, class_name, msg, project_name):
+        if not self.has_properties(msg):
+            return '{}'
+        if project_name != 'dft' and project_name != 'debug':
+            for (prop, prop_config) in msg[PROPERTIES].items():
+                prop_config["validator"] = "require 'class.types." + class_name + "'." + prop
+        else:
+            for (prop, prop_config) in msg[PROPERTIES].items():
+                prop_config["validator"] = "require '" + project_name + ".class.types." + class_name + "'." + prop
+        return self.convert_to_lua(msg[PROPERTIES])
+
+    def get_default_props(self, project_name, class_name, msg):
+        if not self.has_properties(msg):
+            return '{}'
+        string = '{'
+        for (prop, prop_config) in msg[PROPERTIES].items():
+            string += "['" + str(prop) + "'] = " + \
+                str(self.get_prop_default_value(project_name, class_name, prop, prop_config)) + ","
+
+        return string + '}'
+
+    def get_mdb_default_props(self, project_name, msg):
+        if not self.has_path(msg):
+            return '{}'
+        string = '{'
+        for (interface, intf_msg) in msg['interfaces'].items():
+            if not self.has_properties(intf_msg):
+                continue
+            intf_name = self.get_intf_name(interface, intf_msg)
+            for (prop, prop_config) in intf_msg[PROPERTIES].items():
+                string += "['" + str(prop_config.get(ALIAS, prop)) + "'] = " + \
+                str(self.get_mdb_prop_default_value(project_name, intf_name, prop, prop_config)) + ","
+
+        return string + '}'
+
+    def get_mdb_prop_configs(self, project_name, msg):
+        if not self.has_path(msg):
+            return '{}'
+        string = '{'
+        for (interface, intf_msg) in msg['interfaces'].items():
+            if not self.has_properties(intf_msg):
+                continue
+            intf_name = self.get_intf_name(interface, intf_msg)
+            for (prop, prop_config) in intf_msg[PROPERTIES].items():
+                prop_config["validator"] = f"require '{project_name}.json_types.{intf_name}'.{prop}"
+            string += f"['{interface}'] = {self.convert_to_lua(intf_msg[PROPERTIES])},"
+
+        return string + '}'
+
+    def convert_methods(self, methods):
+        result = {}
+        for (method, method_config) in methods.items():
+            result[method] = {}
+            for (body, params) in method_config.items():
+                if body != 'req' and body != 'rsp':
+                    result[method][body] = params
+                    continue
+                result[method][body] = []
+                for (param, param_config) in params.items():
+                    param_config["param"] = param
+                    result[method][body].append(param_config)
+        return result
+
+    def convert_signals(self, signals):
+        result = {}
+        for (signal, signal_config) in signals.items():
+            result[signal] = []
+            for (param, param_config) in signal_config.items():
+                param_config["param"] = param
+                result[signal].append(param_config)
+        return result
+
+    def get_mdb_method_configs(self, msg):
+        if not self.has_path(msg):
+            return '{}'
+        string = '{'
+        for (interface, intf_msg) in msg['interfaces'].items():
+            if self.has_methods(intf_msg):
+                methods = self.convert_methods(intf_msg['methods'])
+                string += "['" + str(interface) + "'] = " + self.convert_to_lua(methods) + ","
+
+        return string + '}'
+
+    def get_mdb_signal_configs(self, msg):
+        if not self.has_path(msg):
+            return '{}'
+
+        string = '{'
+        for (interface, intf_msg) in msg['interfaces'].items():
+            if self.has_signals(intf_msg):
+                signals = self.convert_signals(intf_msg['signals'])
+                string += "['" + str(interface) + "'] = " + self.convert_to_lua(signals) + ","
+
+        return string + '}'
+
+    def get_alias_map(self, msg):
+        result = {}
+        if self.has_properties(msg):
+            for (prop, prop_config) in msg[PROPERTIES].items():
+                if ALIAS in prop_config:
+                    result[prop_config[ALIAS]] = {"original_name": prop}
+
+        if not self.has_path(msg):
+            return self.convert_to_lua(result)
+
+        for (interface, intf_msg) in msg['interfaces'].items():
+            if not self.has_properties(intf_msg):
+                continue
+
+            for (prop, prop_config) in intf_msg[PROPERTIES].items():
+                if ALIAS in prop_config:
+                    result[prop_config[ALIAS]] = {"original_name": prop, "interface": interface}
+
+        return self.convert_to_lua(result)
+
+    def get_mdb_classes(self, root, msg):
+        if not self.has_path(msg):
+            return '{}'
+
+        return "mdb.get_class_obj('" + self.deduplicate_path(self.convert_dynamic_params(self.get_path(root, msg))) + \
+            "')"
+
+    def get_intf_name(self, interface, intf_msg):
+        slices = interface.split(".")
+        if "implement" in intf_msg:
+            return slices[-2] + slices[-1]
+        return Utils.get_unique_intf_name(interface)
+
+    def get_privilege(self, config):
+        if 'privilege' not in config:
+            return 'nil'
+        privilege = []
+        for priv in config['privilege']:
+            privilege.append('privilege.' + priv)
+        return " | ".join(privilege)
+
+    def get_privileges(self, configs):
+        privileges = {}
+        for prop, prop_config in configs.items():
+            if 'privilege' not in prop_config:
+                continue
+            privileges[prop] = self.get_privilege(prop_config)
+
+        string = '{\n'
+        for (prop, value) in privileges.items():
+            string += "['" + prop + "'] = " + value + ",\n"
+        return string + '}'
+
+    def get_property_privilege(self, config):
+        result = {}
+        if 'privilege' not in config:
+            return result
+
+        for item, privileges in config['privilege'].items():
+            privilege = []
+            for priv in privileges:
+                privilege.append('privilege.' + priv)
+
+            result[item] = " | ".join(privilege)
+
+        return result
+
+    def get_property_privileges(self, configs):
+        privileges = {}
+        for prop, prop_config in configs.items():
+            if 'privilege' not in prop_config:
+                continue
+            privileges[prop] = self.get_property_privilege(prop_config)
+
+        result = '{\n'
+        for (prop, value) in privileges.items():
+            priv = '{\n'
+            for item, privilege in value.items():
+                priv += "['" + item + "'] = " + privilege + ",\n"
+            priv += '}'
+
+            result += "['" + prop + "'] = " + priv + ",\n"
+        return result + '}'
+
+    def get_readonlys(self, configs):
+        readonlys = {}
+        for prop, prop_config in configs.items():
+            if 'readOnly' not in prop_config:
+                continue
+            readonlys[prop] = prop_config['readOnly']
+        return self.convert_to_lua(readonlys)
+
+
+Factory().register("old_model.lua.mako", OldModelLuaUtils)

bmcgo/codegen/lua/script/render_utils/plugin_lua.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.
+
+from utils import Utils
+from dto.options import Options
+from render_utils.base import Base
+from render_utils.factory import Factory
+
+
+class PluginLuaUtils(Base, Utils):
+
+    def __init__(self, data: dict, options: Options):
+        super().__init__(data, options=options)
+
+    def collect_features(self, intf_msg, features):
+        for method_config in intf_msg.get('methods', {}).values():
+            if "featureTag" in method_config:
+                features.add(method_config["featureTag"])
+
+    def get_features(self, root):
+        features = set()
+        if "private" in root:
+            self.collect_features(root["private"], features)
+        for msg in root.values():
+            for intf_msg in msg.get('interfaces', {}).values():
+                self.collect_features(intf_msg, features)
+        return sorted(list(features))
+
+Factory().register("plugin.lua.mako", PluginLuaUtils)

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

@@ -0,0 +1,86 @@
+#!/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 merge_proto_algo
+from dto.options import Options
+from render_utils.base import Base
+from render_utils.factory import Factory
+
+
+class RedfishProtoUtils(Base):
+    def __init__(self, data: dict, options: Options):
+        super().__init__(data, options=options)
+
+    @staticmethod
+    def replace_tag(field):
+        return field.translate(str.maketrans({'@': '', '#': '', '.': '_', '-': '_', '+': '_', ' ': '_'}))
+
+    @staticmethod
+    def get_class_name(file_name):
+        resource_string_fields = {'Id', 'Name', 'UUID', 'Description', 'VLANPriority', 'SubnetMask', 'MACAddress'}
+        should_in32_fields = {'VLANId', 'PrefixLength'}
+        target = file_name.split('/')[-1]
+        if target in resource_string_fields:
+            return 'string'
+        if target in should_in32_fields:
+            return 'int32'
+        if 'http' in file_name:
+            if 'Resource.json' in file_name:
+                return 'Resource.' + file_name.split('/')[-1]
+            elif 'odata' in file_name:
+                return 'string'
+            else:
+                return 'Common.ODataID'
+        return file_name.split('/')[-1]
+
+    @staticmethod
+    def get_lua_type(field, para_type):
+        type_map = {
+            'array': 'repeated ' + field, 'boolean': 'bool', 'integer': 'int32',
+            'number': 'int32', 'string': 'string'
+        }
+        return type_map.get(para_type, '')
+
+    @staticmethod
+    def attr_option_field(field):
+        option_list = []
+        for attr in field.keys():
+            value = field.get(attr)
+            if merge_proto_algo.is_attr_option(attr, value):
+                if isinstance(value, (bytes, str)):
+                    option_list.append('''(%s) = "%s"''' % (attr, value))
+                else:
+                    option_list.append("(%s) = %s" % (attr, ("%s" % value).lower()))
+        if not option_list:
+            return ""
+        return "[%s]" % (",".join(option_list))
+
+    def get_type(self, field, para_type):
+        all_type = ['array', 'boolean', 'integer', 'number', 'string']
+        ret = ''
+        if isinstance(para_type, list):
+            for sub_type in para_type:
+                if sub_type in all_type:
+                    ret = self.get_lua_type(field, sub_type)
+                    return ret
+        else:
+            ret = self.get_lua_type(field, para_type)
+        return ret
+
+    def get_file_name(self):
+        temp = self.data['$id'].split('/')[-1]
+        return temp.split('.')[0]
+
+
+
+
+Factory().register("redfish.proto.mako", RedfishProtoUtils)

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

@@ -0,0 +1,76 @@
+#!/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
+from typing import Dict
+
+from dto.exception import UrlNotMatchException
+from dto.kepler_abstract import KeplerAbstractMgr
+from dto.options import Options
+from dto.redfish_api import MessageSchemaMgr, MessageSchema, Property
+from dto.url_route import UrlRouteDict
+from loader import kepler_abstract_loader
+from loader.redfish_loader import RedfishLoader
+from render_utils.factory import Factory
+from render_utils.base import Base
+
+
+class RequestLua:
+    def __init__(self, msg_mgr: MessageSchemaMgr, abstract_mgr: KeplerAbstractMgr, kepler_msg_mgr: MessageSchemaMgr):
+        self.msg_mgr = msg_mgr
+        self.abstract_mgr = abstract_mgr
+        self.msg_route_map: Dict[str, UrlRouteDict] = {}
+        self.kepler_msg_mgr: MessageSchemaMgr = kepler_msg_mgr
+
+    def get(self, message_name: str) -> MessageSchema:
+        return self.msg_mgr.messages.get(message_name)
+
+    def related_objects(self, message_name: str) -> UrlRouteDict:
+        if self.msg_route_map.get(message_name):
+            return self.msg_route_map.get(message_name)
+        msg = self.get(message_name)
+        ret = self.msg_mgr.related_objects(msg)
+        self.msg_route_map.setdefault(message_name, ret)
+        return ret
+
+    def related_message(self, url_feature: str) -> MessageSchema:
+        abstract = self.abstract_mgr.get(url_feature)
+        if not abstract:
+            raise UrlNotMatchException(url_feature)
+        return self.kepler_msg_mgr.messages.get(abstract.class_type())
+
+    def inner_var(self, message_name: str, pt: Property) -> str:
+        url_feature = self.related_objects(message_name).url_dict.get(pt.url_route.inner_url_code()).url_feature
+        return self.related_message(url_feature).class_var_name()
+
+
+class RequestLuaExt(RequestLua):
+    def __init__(self, data, options: Options):
+        self.data = data
+        loader = RedfishLoader(options.proto_json_root_path, options.source_file_path)
+        schema_mgr = MessageSchemaMgr()
+        interfaces = loader.interface_list(schema_mgr)
+        abstract_mgr = kepler_abstract_loader.load(os.path.join(options.kepler_root_path, "abstract.json"))
+        kepler_schema_mgr = kepler_abstract_loader.load_related_kepler_schemas(
+            options.kepler_root_path, interfaces, schema_mgr, abstract_mgr)
+        super().__init__(schema_mgr, abstract_mgr, kepler_schema_mgr)
+
+
+class RequestLuaUtils(Base, RequestLuaExt):
+    def __init__(self, data: dict, options: Options):
+        super().__init__(data=data, options=options)
+
+    def name(self) -> str:
+        return "request.lua.mako"
+
+
+Factory().register("request.lua.mako", RequestLuaUtils)