openubmc-bingo 0.5.240__py3-none-any.whl

bmcgo/codegen/lua/script/merge_model.py

@@ -0,0 +1,330 @@
+#!/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 logging
+import getopt
+import sys
+import os
+import stat
+from collections import OrderedDict
+import mds_util as utils
+from utils import Utils
+from bmcgo.utils.tools import Tools
+
+
+tool = Tools()
+log = tool.log
+OPTIONS_SETTING = ["explicit", "volatile"]
+CHECK_PROPS_SETTINGS = ["usage", "alias", "primaryKey", "uniqueKey", "privilege", "default", "featureTag", "critical",
+        "notAllowNull", "refInterface", "displayDescription", "sensitive"]
+
+
+def save_file(of_name, model_new):
+    if os.path.exists(of_name):
+        with os.fdopen(os.open(of_name, os.O_RDONLY, stat.S_IRUSR), "r") as load_f:
+            if json.load(load_f) == model_new:
+                logging.info("schema 未发生更改")
+                return
+
+    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(model_new, load_f, indent=4)
+        logging.info("schema 已经更改")
+
+
+def fill_req_optional(intf_info, prop, properties, prop_data):
+    if "req" not in properties[prop] or "req" not in prop_data:
+        return
+    
+    class_name, intf_name = intf_info["class_name"], intf_info["intf_name"]
+    has_optional = False
+    for req_param, req_param_data in prop_data["req"].items():
+        op = properties[prop]["req"].get(req_param, {}).get('optional', False)
+        if not op:
+            if has_optional:
+                raise RuntimeError(f"model.json中{class_name}类{intf_name}接口的{prop}方法不满足所有可选参数在入参列表的末尾")
+            continue
+
+        has_optional = True
+        default = properties[prop]["req"].get(req_param, {}).get('default')
+        if default is None:
+            raise RuntimeError(f"model.json中{class_name}类{intf_name}接口的{prop}方法的可选入参{req_param}未配置default字段")
+        req_param_data["optional"] = op
+        req_param_data["default"] = default
+
+
+def fill_req_displaydescription(intf_info, prop, properties, prop_data):
+    if "req" not in properties[prop] or "req" not in prop_data:
+        return
+
+    class_name, intf_name = intf_info["class_name"], intf_info["intf_name"]
+    for req_param, req_param_data in prop_data["req"].items():
+        display_des = properties[prop]["req"].get(req_param, {}).get('displayDescription', False)
+        if not display_des:
+            continue
+        
+        req_param_data["displayDescription"] = display_des
+
+
+def get_options_from_mds(prop, properties, prop_data):
+    if "options" not in properties[prop]:
+        return
+    for option in OPTIONS_SETTING:
+        if option in properties[prop]["options"]:
+            prop_data["options"] = prop_data.get("options", {})
+            prop_data["options"][option] = properties[prop]["options"].get(option)
+
+
+def merge_props_and_data(intf_info, prop, properties, prop_data, check_props):
+    if prop not in properties:
+        properties[prop] = {}
+    else:
+        if Utils.get_lua_codegen_version() >= 16:
+            fill_req_optional(intf_info, prop, properties, prop_data)
+            fill_req_displaydescription(intf_info, prop, properties, prop_data)
+
+        if Utils.get_lua_codegen_version() >= 18:
+            get_options_from_mds(prop, properties, prop_data)
+
+        for check_prop in check_props:
+            if properties[prop].get(check_prop, False):
+                prop_data[check_prop] = properties[prop].get(check_prop)
+    properties[prop] = prop_data
+
+
+def merge_when_intf_exist(model, intf, item, class_name, intf_name):
+    check_props = CHECK_PROPS_SETTINGS
+
+    if Utils.get_lua_codegen_version() >= 16:
+        check_props.append("cmdName")
+        check_props.append("displayDescription")
+
+    if item not in intf:
+        if item in model:
+            model.pop(item)
+        return
+
+    if item not in model:
+        model[item] = {}
+
+    properties = model[item]
+    for prop in list(properties):
+        if prop in intf[item]:
+            continue
+        label = "方法" if item == "methods" else "信号"
+        raise RuntimeError(f"model.json中类{class_name}接口{intf_name}的{label}{prop}在mdb_interface中没有被定义")
+
+    intf_info = {"class_name": class_name, "intf_name": intf_name}
+    for prop, prop_data in intf[item].items():
+        merge_props_and_data(intf_info, prop, properties, prop_data, check_props)
+
+
+def copy_when_exist(model, intf, prop):
+    if prop in intf:
+        model[prop] = intf[prop]
+
+
+def merge_model_intf(intf_data, model_intf, class_name, intf_name):
+    mdb_props = intf_data.get("properties", {})
+    if "properties" not in model_intf:
+        model_intf["properties"] = {}
+    model_props = model_intf["properties"]
+    for prop in model_props.keys():
+        if prop not in mdb_props:
+            raise RuntimeError(f"model.json中类{class_name}接口{intf_name}的属性{prop}在mdb_interface中没有被定义")
+    if mdb_props and "virtual" in intf_data:
+        model_props["priority"] = {
+            "baseType": "U8",
+            "default": 0
+            if "priority" not in model_intf
+            else model_intf["priority"],
+        }
+    intf_info = {"class_name": class_name, "intf_name": intf_name}
+    for prop, prop_data in mdb_props.items():
+        merge_props_and_data(intf_info, prop, model_props, prop_data, CHECK_PROPS_SETTINGS)
+
+    merge_when_intf_exist(model_intf, intf_data, "methods", class_name, intf_name)
+    merge_when_intf_exist(model_intf, intf_data, "signals", class_name, intf_name)
+    copy_when_exist(model_intf, intf_data, "package")
+    copy_when_exist(model_intf, intf_data, "virtual")
+    copy_when_exist(model_intf, intf_data, "default")
+
+
+def append_object_prop_intf(mds_data, mdb_data):
+    object_prop_intf = "bmc.kepler.Object.Properties"
+    if object_prop_intf not in mds_data:
+        mds_data[object_prop_intf] = {}
+    if object_prop_intf not in mdb_data:
+        mdb_data.append(object_prop_intf)
+
+
+def merge_model_class(class_name, mds_class, mdb_obj, mdb_path):
+    if "package" in mdb_obj[class_name]:
+        mds_class["package"] = mdb_obj[class_name]["package"]
+    append_object_prop_intf(mds_class["interfaces"], mdb_obj[class_name]["interfaces"])
+    for intf_name in mdb_obj[class_name]["interfaces"]:
+        if intf_name not in mds_class["interfaces"]:
+            raise RuntimeError(f"model.json中类{class_name}未配置资源树接口{intf_name}")
+        for item in mds_class["interfaces"][intf_name]:
+            if item not in ["properties", "methods", "signals", "privilege"]:
+                raise RuntimeError(f"model.json中类{class_name}接口{intf_name}的字段{item}超出取值范围")
+
+        intf_json = utils.get_intf(intf_name, mdb_path)
+        if "implement" in intf_json[intf_name]:
+            mds_class["interfaces"][intf_name] = utils.generate_default(
+                intf_json, mdb_path
+            )[intf_name]
+        if "defs" in intf_json:
+            mds_class["interfaces"][intf_name]["defs"] = intf_json["defs"]
+
+        merge_model_intf(intf_json[intf_name], mds_class["interfaces"][intf_name], class_name, intf_name)
+
+
+def get_class_name(path):
+    return list(filter(None, path.split("/")))[-1]
+
+
+def get_parent_path(origin_model, class_data):
+    if "parent" in class_data and class_data["parent"] in origin_model and \
+                "path" in origin_model[class_data["parent"]]:
+        return get_parent_path(origin_model, origin_model[class_data["parent"]]) \
+            + "/" + utils.cut_ids(class_data["path"])
+    else:
+        return utils.cut_ids(class_data["path"])
+
+
+def check_class_property_name_conflict(class_name, class_data):
+    prop_names = {}
+
+    for prop_name, prop_config in class_data.get("properties", {}).items():
+        name = prop_config.get('alias', prop_name)
+        if name in prop_names:
+            raise RuntimeError(f"在model.json文件{class_name}类中发现重名私有属性{prop_name}")
+        else:
+            prop_names[name] = True
+
+    for interface, intf_data in class_data.get("interfaces", {}).items():
+        for prop_name, prop_config in intf_data.get("properties", {}).items():
+            name = prop_config.get('alias', prop_name)
+            if name in prop_names:
+                raise RuntimeError(f"在model.json文件{class_name}类的{interface}接口中发现重名资源树属性{prop_name}")
+            else:
+                prop_names[name] = True
+
+
+def check_property_name_conflict(origin_model):
+    for class_name, class_data in origin_model.items():
+        check_class_property_name_conflict(class_name, class_data)
+
+
+def merge_model(origin_model, mdb_path):
+    for class_name, class_data in origin_model.items():
+        if "path" in class_data and class_name != "defs":
+            class_path = get_parent_path(origin_model, class_data)
+            mdb_obj = utils.get_path(class_name, mdb_path, class_path)
+            merge_model_class(class_name, class_data, mdb_obj, mdb_path)
+
+    check_property_name_conflict(origin_model)
+
+
+def save_merged_json(of_name, model):
+    paths = of_name.split("/")
+    paths.pop()
+    merged_json_path = os.path.realpath(("/").join(paths))
+    if not os.path.exists(merged_json_path):
+        os.mkdir(merged_json_path)
+    save_file(of_name, model)
+
+
+def check_method_cmd_name(class_name, intf_name, method, method_data, cmds):
+    if "cmdName" in method_data:
+        cmd_name = method_data["cmdName"]
+        if cmd_name in cmds:
+            if intf_name != cmds[cmd_name][0] or method != cmds[cmd_name][1]:
+                raise RuntimeError(f"model.json文件的{class_name}类的{intf_name}接口的{method}方法的cmdName {cmd_name}已被使用，请重新命名")
+        else:
+            cmds[cmd_name] = [intf_name, method]
+
+
+def check_cmd_name(mds_class, cmd_file):
+    cmds = {}
+    if os.path.exists(cmd_file):
+        load_f = os.fdopen(os.open(cmd_file, os.O_RDONLY, stat.S_IRUSR), "r")
+        try:
+            cmds = OrderedDict(json.load(load_f))
+        except json.JSONDecodeError as e:
+            log.debug(f"JSON 解析错误: {e}")
+        load_f.close()
+
+    for class_name, class_data in mds_class.items():
+        for intf_name, intf_data in class_data.get("interfaces", {}).items():
+            for method, method_data in intf_data.get("methods", {}).items():
+                check_method_cmd_name(class_name, intf_name, method, method_data, cmds)
+
+    save_file(cmd_file, cmds)
+
+
+def generate(if_name, of_name, mdb_path, cmd_file):
+    load_dict = {}
+    if os.path.exists(if_name):
+        load_f = os.fdopen(os.open(if_name, os.O_RDONLY, stat.S_IRUSR), "r")
+        load_dict = OrderedDict(json.load(load_f))
+        load_f.close()
+
+    if Utils.get_lua_codegen_version() >= 16:
+        check_cmd_name(load_dict, cmd_file)
+    merge_model(load_dict, mdb_path)
+    save_merged_json(of_name, load_dict)
+
+
+def usage():
+    logging.info("gen_schema.py -i <inputfile> -o <outfile>")
+
+
+def main(argv):
+    m_input = ""
+    output = ""
+    mdb_path = ""
+    try:
+        opts, _ = getopt.getopt(
+            argv, "hi:o:d:c:", ["help", "input=", "out=", "mdb_interfac_path", "cmdfile="]
+        )
+    except getopt.GetoptError:
+        help()
+        return
+    for opt, arg in opts:
+        if opt in ("-h", "--help"):
+            usage()
+            return
+        elif opt in ("-i", "--input"):
+            m_input = arg
+        elif opt in ("-o", "--out"):
+            output = arg
+        elif opt in ("-d", "--dir"):
+            mdb_path = arg
+        elif opt in ("-c", "--cmdfile"):
+            cmd_file = arg
+        else:
+            raise RuntimeError("不支持的选项: {}".format(opt))
+    if not m_input or not output:
+        usage()
+        return
+    generate(m_input, output, mdb_path, cmd_file)
+
+
+if __name__ == "__main__":
+    main(sys.argv[1:])

bmcgo/codegen/lua/script/merge_proto_algo.py

@@ -0,0 +1,85 @@
+#!/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.
+
+HW_DEFINE_ATTR_OPTION_DICT = {"validate": "", "readonly": False, "rename": ""}
+HW_DEFINE_MESSAGE_OPTION_DICT = {}
+
+
+def merge_options(new_attr: dict, old_attr: dict, self_define_option_set: dict):
+    options = old_attr.get("options")
+    if not isinstance(options, dict):
+        return
+    for option in options.keys():
+        if option in self_define_option_set:
+            new_attr.setdefault(option, options.get(option))
+
+
+def merge_property_list(new_property_dict, property_list):
+    for pt in property_list:
+        if not isinstance(pt, dict):
+            continue
+        attr_name = pt.get("name")
+        new_attr = new_property_dict.get(attr_name)
+        if not isinstance(new_attr, dict):
+            continue
+        merge_options(new_attr, pt, HW_DEFINE_ATTR_OPTION_DICT)
+
+
+def merge_message(new_message: dict, message: dict):
+    merge_options(new_message, message, HW_DEFINE_MESSAGE_OPTION_DICT)
+    property_list = message.get("properties")
+    if not isinstance(property_list, list):
+        return
+    new_property_dict = new_message.get("properties")
+    if not isinstance(new_property_dict, dict):
+        return
+
+    merge_property_list(new_property_dict, property_list)
+
+
+def merge_message_list(new_message_dict: dict, message_list: list):
+    for message in message_list:
+        name = message.get("name")
+        new_message = new_message_dict.get(name)
+        if not new_message:
+            continue
+        merge_message(new_message, message)
+
+
+def merge_json(redfish_json: dict, proto_json: dict):
+    if not isinstance(redfish_json, dict) or not isinstance(proto_json, dict):
+        return redfish_json
+    message_list = proto_json.get("data")
+    if not isinstance(message_list, list):
+        return redfish_json
+    new_message_dict = redfish_json.get("definitions")
+    if not isinstance(new_message_dict, dict):
+        return redfish_json
+    merge_message_list(new_message_dict, message_list)
+    return redfish_json
+
+
+def is_need_specify_option(key: str, value, option_dict: dict) -> bool:
+    if key not in option_dict:
+        return False
+    default_value = option_dict.get(key)
+    if default_value == value:
+        return False
+    return True
+
+
+def is_message_option(key: str, value) -> bool:
+    return is_need_specify_option(key, value, HW_DEFINE_MESSAGE_OPTION_DICT)
+
+
+def is_attr_option(key: str, value) -> bool:
+    return is_need_specify_option(key, value, HW_DEFINE_ATTR_OPTION_DICT)

bmcgo/codegen/lua/script/proto_loader.py

@@ -0,0 +1,47 @@
+#!/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 stat
+import subprocess
+
+proto_cvt_plugin_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "proto_plugin.py"))
+
+
+def proto_to_json(proto_root_path: str, relative_path: str, proto_json_root_path: str):
+    os.makedirs(proto_json_root_path, exist_ok=True)
+    cmd = [
+        "protoc",
+        f"--plugin=protoc-gen-custom={proto_cvt_plugin_path}",
+        f"--custom_out={proto_json_root_path}",
+        f"-I{proto_root_path}",
+        relative_path
+    ]
+    subprocess.run(cmd, shell=False)
+
+
+def parse(proto_root_path, relative_path: str, proto_json_root_path: str) -> dict:
+    json_file_path = os.path.abspath(os.path.join(proto_json_root_path, relative_path + ".json"))
+    proto_file_path = os.path.abspath(os.path.join(proto_root_path, relative_path))
+    if not os.path.exists(proto_file_path):
+        return {}
+    if not os.path.exists(json_file_path):
+        proto_to_json(proto_root_path, relative_path, proto_json_root_path)
+    json_stat = os.stat(json_file_path)
+    proto_stat = os.stat(proto_file_path)
+    if json_stat[stat.ST_MTIME] <= proto_stat[stat.ST_MTIME]:
+        proto_to_json(proto_root_path, relative_path, proto_json_root_path)
+    if not os.path.exists(json_file_path):
+        return {}
+    with open(json_file_path, "r", encoding="utf-8") as fd:
+        return json.load(fd)

bmcgo/codegen/lua/script/proto_plugin.py

@@ -0,0 +1,140 @@
+#!/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 itertools
+import json
+import sys
+import types_pb2
+import ipmi_types_pb2
+
+from google.protobuf.descriptor_pb2 import DescriptorProto, \
+    EnumDescriptorProto, FieldDescriptorProto, ServiceDescriptorProto
+from google.protobuf.compiler.plugin_pb2 import CodeGeneratorRequest, CodeGeneratorResponse
+
+BASIC_TYPES = {
+    getattr(FieldDescriptorProto, t):
+        t 
+        for t in dir(FieldDescriptorProto)
+        if t.startswith("TYPE_")
+        }
+
+ALLOW_BASIC_TYPES = {
+    FieldDescriptorProto.TYPE_BOOL: "bool",
+    FieldDescriptorProto.TYPE_STRING: "string",
+    FieldDescriptorProto.TYPE_INT32: "int32",
+    FieldDescriptorProto.TYPE_UINT32: "uint32",
+    FieldDescriptorProto.TYPE_INT64: "int64",
+    FieldDescriptorProto.TYPE_UINT64: "uint64",
+    FieldDescriptorProto.TYPE_FLOAT: "float",
+    FieldDescriptorProto.TYPE_DOUBLE: "double",
+    FieldDescriptorProto.TYPE_BYTES: "bytes",
+}
+
+
+def get_type_name(n_type, t_name, label):
+    if n_type == FieldDescriptorProto.TYPE_MESSAGE or n_type == FieldDescriptorProto.TYPE_ENUM:
+        if t_name.startswith("."):
+            return t_name[1:]
+        return t_name
+    elif n_type in ALLOW_BASIC_TYPES:
+        type_allow = ALLOW_BASIC_TYPES[n_type]
+        return type_allow if label != FieldDescriptorProto.LABEL_REPEATED else f'{type_allow}[]'
+    raise RuntimeError("无效类型 {}({})".format(BASIC_TYPES[n_type], n_type))
+
+
+def traverse(proto_file):
+    def _traverse(package, items):
+        for item in items:
+            yield item, package
+
+    return itertools.chain(
+        _traverse(proto_file.package, proto_file.enum_type),
+        _traverse(proto_file.package, proto_file.message_type),
+        _traverse(proto_file.package, proto_file.service),
+    )
+
+
+def process_item(item, package):
+    data = {
+        'package': package or 'root',
+        'name': item.name,
+        'options': {op.name: item.options.Extensions[op] for op in item.options.Extensions}
+    }
+
+    if isinstance(item, DescriptorProto):
+        data.update({
+            'type': 'Message',
+            "properties": [{
+                "name": f.name,
+                'type': get_type_name(f.type, f.type_name, f.label),
+                "options": {op.name: f.options.Extensions[op] for op in f.options.Extensions},
+                'id': f.number,
+                'repeated': f.label == FieldDescriptorProto.LABEL_REPEATED
+            } for f in item.field],
+            "nested_type": [process_item(nested_item, package) for nested_item in item.nested_type]})
+    elif isinstance(item, EnumDescriptorProto):
+        data.update({
+            'type': 'Enum',
+            'values': [{
+                'name': v.name,
+                'value': v.number,
+                'id': v.number
+            } for v in item.value]
+        })
+    return data
+
+
+def generate_code(req, resp):
+    imports = []
+    for proto_file in req.proto_file:
+        if proto_file.name not in req.file_to_generate:
+            imports.append(proto_file.name)
+            continue
+
+        o_put = []
+        service = []
+        for item, package in traverse(proto_file):
+            if isinstance(item, ServiceDescriptorProto):
+                [service.append({
+                    'method_options': {op.name: v.options.Extensions[op] for op in v.options.Extensions},
+                    'options': {op.name: item.options.Extensions[op] for op in item.options.Extensions},
+                    'name': v.name,
+                    'req': v.input_type,
+                    'rsp': v.output_type,
+                }) for v in item.method]
+            else:
+                o_put.append(process_item(item, package))
+
+        file = resp.file.add()
+        file.name = proto_file.name + '.json'
+        file.content = json.dumps({
+            'imports': imports,
+            'dependency': [v for v in proto_file.dependency],
+            'data': o_put,
+            'service': service,
+            'filename': proto_file.name,
+            'package': proto_file.package,
+            'options': {op.name: proto_file.options.Extensions[op] for op in proto_file.options.Extensions}
+        }, indent=2)
+
+
+def read_data():
+    data = sys.stdin.buffer.read()
+    return data
+
+if __name__ == '__main__':
+    request = CodeGeneratorRequest()
+    request.ParseFromString(read_data())
+    response = CodeGeneratorResponse()
+    generate_code(request, response)
+    output = response.SerializeToString()
+    sys.stdout.buffer.write(output)