openubmc-bingo 0.5.240__py3-none-any.whl

bmcgo/codegen/lua/script/loader/redfish_loader.py

@@ -0,0 +1,127 @@
+#!/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 Set, List, Dict
+
+from dto.exception import MessageParseException
+from dto.redfish_api import MessageSchemaMgr, MessageSchema, MessageType, join_father_options, ALLOW_BASIC_TYPES, \
+    FatherFields
+from loader.file_utils import load_json
+
+
+def json_file_path(rel_path: str):
+    if not rel_path.endswith(".json"):
+        return f"{rel_path}.json"
+    return rel_path
+
+
+class RedfishLoader:
+    def __init__(self, root_path: str, full_file_path: str, father_options_dict: Dict[str, dict] = None):
+        self.root_path: str = root_path
+        self.full_file_path: str = full_file_path
+        self.father_options_dict: Dict[str, dict] = father_options_dict
+        if self.father_options_dict is None:
+            self.father_options_dict = {}
+
+    @staticmethod
+    def _get_property_json(msg: dict, attr_name: str) -> dict:
+        for pt in msg.get("properties"):
+            if pt.get("name") == attr_name:
+                return pt
+        raise MessageParseException(f"在 {msg.get('package')}.{msg.get('name')} 中无法找到 {attr_name}")
+
+    @staticmethod
+    def _extend_property_options(index, msg, parsed_msg_list):
+        for pt in parsed_msg_list[index].properties:
+            pt_json = RedfishLoader._get_property_json(msg, pt.attr_name)
+            join_father_options(pt_json, msg.get("options"))
+            pt.url_route.merge_options(pt_json.get("options"))
+
+    def parse(self, schema_mgr: MessageSchemaMgr, parsed_file_set: Set[str] = None,
+              father_options: dict = None) -> List[MessageSchema]:
+        if parsed_file_set is None:
+            parsed_file_set = set()
+        json_data = load_json(self.full_file_path)
+        father_fields = FatherFields()
+        father_fields.father_options = father_options
+        interfaces = self._parse_data(json_data.get("data"), schema_mgr, parsed_file_set, father_fields)
+        self._parse_dependency(json_data, parsed_file_set, schema_mgr)
+        return interfaces
+
+    def interface_list(self, schema_mgr: MessageSchemaMgr) -> List[MessageSchema]:
+        return [msg for msg in self.parse(schema_mgr) if msg.msg_type == MessageType.INTERFACE]
+
+    def join_extend_options(self, father_options, msg):
+        temp_father_options = self.father_options_dict.get(msg.get("package") + "." + msg.get("name"))
+        if temp_father_options is None:
+            temp_father_options = father_options
+        join_father_options(msg, temp_father_options)
+
+    def _collect_property_options(self, message, msg, force: bool = False):
+        for pt in message.properties:
+            if pt.attr_type not in ALLOW_BASIC_TYPES:
+                if force:
+                    self.father_options_dict[pt.attr_type] = msg.get("options")
+                else:
+                    self.father_options_dict.setdefault(pt.attr_type, msg.get("options"))
+
+    def _parse_dependency(self, json_data, parsed_file_set, schema_mgr):
+        if not json_data.get("dependency"):
+            return
+        for dependency in json_data.get("dependency"):
+            if dependency == "types.proto":
+                continue
+            file_path = os.path.normpath(os.path.join(self.root_path, json_file_path(dependency)))
+            if file_path in parsed_file_set:
+                continue
+            parsed_file_set.add(file_path)
+            loader = RedfishLoader(self.root_path, file_path, self.father_options_dict)
+            loader.parse(schema_mgr, parsed_file_set)
+
+    def _parse_data(self, msg_list: List[dict], schema_mgr: MessageSchemaMgr, parsed_file_set: Set[str],
+                    father_fields: FatherFields) -> List[MessageSchema]:
+        if not msg_list:
+            return []
+        ret: List[MessageSchema] = []
+        for msg in msg_list:
+            self.join_extend_options(father_fields.father_options, msg)
+            message = MessageSchema.from_proto_json(msg, father_fields.father, msg.get("options"))
+            schema_mgr.append(message)
+            self._collect_property_options(message, msg)
+            ret.append(message)
+            f_fields = FatherFields()
+            f_fields.father_options = msg.get("options")
+            f_fields.father = message.class_type()
+            ret.extend(
+                self._parse_data(msg.get("nested_type"), schema_mgr, parsed_file_set, f_fields))
+        self._extend_msg_options(father_fields.father_options, msg_list, ret)
+        return ret
+
+    def _extend_msg_options(self, father_options: dict,
+                            raw_msg_list: List[dict], parsed_msg_list: List[MessageSchema], input_index: int = 0):
+        if not raw_msg_list:
+            return input_index
+        has_changed = True
+        while has_changed:
+            has_changed = False
+            index = input_index
+            for msg in raw_msg_list:
+                self.join_extend_options(father_options, msg)
+                if parsed_msg_list[index].url_route.merge_options(msg.get("options")):
+                    has_changed = True
+                    self._extend_property_options(index, msg, parsed_msg_list)
+                    self._collect_property_options(parsed_msg_list[index], msg, force=True)
+                index += 1
+                index = self._extend_msg_options(msg.get("options"), msg.get("nested_type"),
+                                                 parsed_msg_list, index)
+        return index

bmcgo/codegen/lua/script/lua_format.py

@@ -0,0 +1,62 @@
+#!/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 argparse
+import shutil
+import os
+import stat
+from subprocess import Popen, PIPE
+
+
+def find_lua_format():
+    lua_format = shutil.which('lua-format', mode=os.X_OK)
+    if lua_format:
+        return lua_format
+    lua_format = os.getenv('LUA_FORMAT')
+    if os.access(lua_format, os.X_OK):
+        return lua_format
+    raise RuntimeError('找不到工具 lua-format')
+
+
+def find_config_file(file):
+    parent_dir = os.path.dirname(file)
+    while len(parent_dir) > 1:
+        if os.path.exists(os.path.join(parent_dir, '.lua-format')):
+            return os.path.join(parent_dir, '.lua-format')
+        parent_dir = os.path.dirname(parent_dir)
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('files', metavar='FILE', type=str, nargs='+',
+                        help='Source File Paths')
+    options = parser.parse_args()
+    files = options.files
+    if len(files) == 0:
+        return
+    if len(files) > 1:
+        raise RuntimeError('格式化文件不得超过一个')
+
+    cmds = [find_lua_format()]
+    cfg = find_config_file(__file__)
+    if cfg:
+        cmds += ['-c', cfg]
+    cmds += files
+    with Popen(cmds, stdout=PIPE) as proc:
+        data, _ = proc.communicate(timeout=50)
+        output = data.decode('utf-8')
+    with os.fdopen(os.open(files[0], os.O_WRONLY | os.O_TRUNC, stat.S_IWUSR | stat.S_IRUSR), 'w') as out_fp:
+        out_fp.write(output)
+
+
+if __name__ == "__main__":
+    main()

bmcgo/codegen/lua/script/mds_util.py

@@ -0,0 +1,385 @@
+#!/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
+import os
+import re
+import stat
+from collections import OrderedDict
+from utils import Utils
+
+USAGE = "usage"
+
+
+def get_real_path(path):
+    if path == "*":
+        return path
+
+    path = cut_ids(path)
+    return os.path.realpath(path)
+
+
+def convert_path_params(path: str):
+    return re.sub(r":[\w\.]*", "*", re.sub(r"\$\{[\w\.]*\}", "*", path))
+
+
+def get_intf(interface, mdb_path):
+    real_path = ("/").join(
+        [mdb_path, "intf", "mdb", interface.replace(".", "/") + ".json"]
+    )
+    with os.fdopen(os.open(real_path, os.O_RDONLY, stat.S_IRUSR), "r") as intf_file:
+        return OrderedDict(json.load(intf_file))
+
+
+def get_path(class_name, mdb_path, path):
+    real_path = ("/").join([mdb_path, "path",
+                            "mdb", path, class_name + ".json"])
+
+    with os.fdopen(os.open(real_path, os.O_RDONLY, stat.S_IRUSR), "r") as obj_file:
+        return OrderedDict(json.load(obj_file))
+
+
+def get_path_by_interface(mdb_path: str, interface, path):
+    real_path = os.path.join(mdb_path, "path", "mdb", get_real_path(path).lstrip("/"))
+    expected_path = convert_path_params(path)
+    for obj_file in os.scandir(real_path):
+        if not obj_file.is_file():
+            continue
+        with os.fdopen(os.open(obj_file, os.O_RDONLY, stat.S_IRUSR), "r") as obj_fp:
+            obj_dict = OrderedDict(json.load(obj_fp))
+        for class_name, class_data in obj_dict.items():
+            converted_path = convert_path_params(class_data.get("path"))
+            if converted_path == expected_path and interface in class_data["interfaces"]:
+                return class_name, obj_dict
+    error_msg = f"service.json中配置的接口{interface}和路径{path}在mdb_interface中没有匹配的定义\n"\
+    f"mdb_interface路径匹配目录为: {real_path}"
+    raise RuntimeError(error_msg)
+
+
+def save_proto_json(of_name, data):
+    with os.fdopen(
+        os.open(
+            of_name, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, stat.S_IWUSR | stat.S_IRUSR
+        ),
+        "w",
+    ) as load_f:
+        json.dump(data, load_f, indent=4)
+
+
+def open_file(file):
+    return os.fdopen(os.open(file, os.O_RDONLY, stat.S_IRUSR), "r")
+
+
+ALLOW_BASIC_TYPES = {
+    "Boolean": "bool",
+    "String": "string",
+    "S32": "int32",
+    "U32": "uint32",
+    "S64": "int64",
+    "U64": "uint64",
+    "Double": "double",
+    "U8": "uint8",
+    "S8": "int8",
+    "U16": "uint16",
+    "S16": "int16",
+    "Array": "message",
+    "Binary": "string"
+}
+
+
+def get_base_type(base_type, is_array):
+    if is_array:
+        return base_type[0:-2]
+    return base_type
+
+
+def get_ref_type(referenced_type):
+    if referenced_type.startswith("types.json"):
+        return referenced_type.replace(
+                    "types.json#/defs/", "def_types.defs_").replace("/", ".")
+    elif referenced_type.startswith("mdb://"):
+        slices = referenced_type.split(".json#")
+        return (Utils.get_unique_intf_name(slices[0].replace("/", ".")) + slices[1]) \
+            .replace("/defs/", ".defs_").replace("/", ".")
+    else:
+        return referenced_type.replace("#/", "").replace("/", ".")
+
+
+def get_types(prop_name, prop_data):
+    if "baseType" in prop_data:
+        if prop_data["baseType"] == "Struct" or prop_data["baseType"] == "Enum" \
+            or prop_data["baseType"] == "Dictionary":
+            return False, get_ref_type(prop_data["$ref"])
+        elif prop_data["baseType"] == "Array":
+            return True, get_ref_type(prop_data["items"]["$ref"])
+        elif prop_data["baseType"].endswith("[]"):
+            return True, ALLOW_BASIC_TYPES[prop_data["baseType"][0:-2]]
+        else:
+            return False, ALLOW_BASIC_TYPES[prop_data["baseType"]]
+    if "$ref" not in prop_data:
+        raise RuntimeError(f"属性 {prop_name} 没有基类定义或找不到引用")
+    return False, get_ref_type(prop_data["$ref"])
+
+
+def get_validate_option(prop_data):
+    validate_opt = ''
+    if "maximum" in prop_data or "minimum" in prop_data:
+        validate_opt += "ranges({}, {}),".format(
+            prop_data["minimum"] if "minimum" in prop_data else None,
+            prop_data["maximum"] if "maximum" in prop_data else None
+        )
+    if "maxLength" in prop_data or "minLength" in prop_data:
+        validate_opt += "lens({}, {}),".format(
+            prop_data["minLength"] if "minLength" in prop_data else None,
+            prop_data["maxLength"] if "maxLength" in prop_data else None
+        )
+    if "enum" in prop_data:
+        validate_opt += "enum({}),".format(prop_data["enum"])
+    if "pattern" in prop_data:
+        validate_opt += 'regex("{}"),'.format(prop_data["pattern"])
+    return validate_opt
+
+
+def get_options(prop_name, prop_data):
+    options = {}
+    if "readOnly" in prop_data and prop_data["readOnly"]:
+        options["readonly"] = True
+    if "default" in prop_data:
+        options["default"] = prop_data["default"]
+    if "deprecated" in prop_data:
+        options["deprecated"] = prop_data["deprecated"]
+
+    options["validate"] = get_validate_option(prop_data)
+    options["allow_null"] = not prop_data.get("notAllowNull", False)
+
+    if "primaryKey" in prop_data and prop_data["primaryKey"]:
+        options["primary_key"] = prop_data["primaryKey"]
+        if not prop_data.get("notAllowNull", True):
+            raise RuntimeError(f"属性{prop_name}冲突: primaryKey 为真, 同时 notAllowNull 又为假")
+        options["allow_null"] = False
+
+    if "uniqueKey" in prop_data and prop_data["uniqueKey"]:
+        options["unique"] = prop_data["uniqueKey"]
+
+    if USAGE in prop_data:
+        options[USAGE] = prop_data[USAGE]
+
+    options["critical"] = prop_data.get("critical", False)
+    return options
+
+
+def is_enum(prop_data):
+    if 'baseType' not in prop_data:
+        return False
+    elif prop_data['baseType'] == "Enum":
+        return True
+    elif prop_data['baseType'] == "Array" and 'baseType' in prop_data["items"] \
+        and prop_data["items"]['baseType'] == "Enum":
+        return True
+    else:
+        return False
+
+
+# only db.lua need index
+def get_property(prop_name, prop_data, index):
+    original_name = prop_name
+    repeated, prop_type = get_types(prop_name, prop_data)
+
+    if "alias" in prop_data:
+        prop_name = prop_data["alias"]
+
+    data = {
+        "original_name": original_name,
+        "name": prop_name,
+        "type": prop_type,
+        "options": get_options(prop_name, prop_data),
+        "id": index,
+        "repeated": repeated,
+        "is_enum": is_enum(prop_data)
+    }
+
+    if "displayDescription" in prop_data:
+        data["description"] = prop_data["displayDescription"]
+    return data
+
+
+def get_dict_item(prop_name, prop_data, index):
+    repeated, prop_type = get_types(prop_name, prop_data)
+
+    data = {
+        "original_name": prop_name,
+        "name": prop_name,
+        "type": prop_type,
+        "options": get_options(prop_name, prop_data),
+        "id": index,
+        "repeated": repeated,
+        "is_enum": is_enum(prop_data)
+    }
+
+    if "displayDescription" in prop_data:
+        data["description"] = prop_data["displayDescription"]
+    return data
+
+
+def get_enum(prop_name, prop_data, index):
+    return {
+        "name": prop_name,
+        "value": prop_data,
+        "id": index
+    }
+
+
+def get_message_type(struct_data):
+    if 'key' in struct_data and 'value' in struct_data:
+        return 'dict'
+
+    dict_iter = iter(struct_data)
+    first_key = next(dict_iter, None)
+    if first_key is None or isinstance(struct_data[first_key], dict):
+        return 'struct'
+
+    return 'enum'
+
+
+def get_struct_message(package, struct_name, struct_data):
+    struct_properties = []
+    index = 0
+    for prop, prop_data in struct_data.items():
+        struct_properties.append(get_property(prop, prop_data, index))
+        index = index + 1
+
+    return {
+        "package": package,
+        "name": struct_name,
+        "options": {},
+        "type": "Message",
+        "properties": struct_properties,
+        "nested_type": [],
+    }
+
+
+def get_enum_message(package, struct_name, struct_data):
+    enum_type = str
+    index = 0
+    enum_values = []
+    for prop, prop_data in struct_data.items():
+        if not isinstance(prop_data, (int, str)):
+            raise RuntimeError("确保枚举 {} 有正确的类型".format(prop))
+        if index == 0:
+            enum_type = type(prop_data)
+        elif not isinstance(prop_data, enum_type):
+            raise RuntimeError("确保枚举 {} 有正确的类型".format(prop))
+        enum_values.append(get_enum(prop, prop_data, 0))
+        index += 1
+
+    return {
+        "package": package,
+        "name": struct_name,
+        "options": {},
+        "type": "Enum",
+        "default": 2147483647 if enum_type == int else "''",
+        "values": enum_values
+    }
+
+
+def get_dict_message(package, struct_name, struct_data):
+    return {
+        "package": package,
+        "name": struct_name,
+        "options": {},
+        "type": "Dictionary",
+        "properties": [
+            get_dict_item('key', struct_data['key'], 0),
+            get_dict_item('value', struct_data['value'], 1)
+        ]
+    }
+
+
+def cut_ids_new(path):
+    paths = []
+    current = 0
+
+    pos = path.find("${")
+    while pos != -1:
+        paths.append(path[current:pos])
+        end = path.find("}", pos)
+        if end != -1:
+            path = path[end + 1:]
+            pos = path.find("${")
+        else:
+            path = ""
+            pos = -1
+    paths.append(path)
+    paths.append("/")
+    return "".join(paths)
+
+
+def cut_ids(path):
+    path = path.replace(" ", "")
+    paths = []
+    current = 0
+    path = cut_ids_new(path)
+    pos = path.find(":")
+    while pos != -1:
+        paths.append(path[current:pos])
+        end = path.find("/", pos)
+        if end != -1:
+            path = path[end:]
+            pos = path.find(":")
+        else:
+            path = ""
+            pos = -1
+    paths.append(path)
+    paths.append("/")
+    return "".join(paths)
+
+
+def get_intf_package_name(intf_name):
+    intfs = intf_name.split(".")
+    if intfs[-1] == "Default":
+        return intfs[-2] + intfs[-1]
+    return intfs[-1]
+
+
+def get_default_intf(intf_data, origin_intf):
+    if "properties" in origin_intf:
+        intf_data["properties"] = origin_intf["properties"]
+
+    if "signals" in origin_intf:
+        intf_data["signals"] = origin_intf["signals"]
+
+    if "methods" not in origin_intf:
+        return
+    intf_data["methods"] = {}
+    default = intf_data["methods"]
+    for method, method_intf in origin_intf["methods"].items():
+        new_method = method
+        default[new_method] = {}
+        if "req" in method_intf:
+            default[new_method]["req"] = {}
+            default[new_method]["req"]["path"] = {"baseType": "String"}
+            for arg, arg_data in method_intf["req"].items():
+                default[new_method]["req"][arg] = arg_data.copy()
+        if "rsp" in method_intf:
+            default[new_method]["rsp"] = method_intf["rsp"].copy()
+
+
+def generate_default(load_dict, mdb_path):
+    for intf_data in load_dict.values():
+        if "implement" in intf_data:
+            if "properties" not in intf_data:
+                intf_data["properties"] = {}
+            default_intf = intf_data["implement"]
+            intf = get_intf(default_intf, mdb_path)[default_intf]
+            get_default_intf(intf_data, intf)
+
+    return load_dict