openubmc-bingo 0.5.240__py3-none-any.whl

bmcgo/codegen/lua/script/dto/kepler_abstract.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.
+
+from typing import Dict
+
+from dto.url_route import Url
+
+
+class KeplerAbstract:
+    def __init__(self, url_path: str, interface: str, file_path: str, package: str, name: str):
+        self.url = Url(url_path)
+        self.interface = interface
+        self.file_path = file_path
+        self.package: str = package
+        self.name: str = name
+
+    @classmethod
+    def from_json(cls, data: dict):
+        return KeplerAbstract(data.get("path"), data.get("interface"), data.get("file_path"),
+                              data.get("package"), data.get("name"))
+
+    def to_json(self):
+        return {"path": self.url.url, "interface": self.interface, "file_path": self.file_path,
+                "package": self.package, "name": self.name}
+
+    def class_type(self):
+        return f"{self.package}.{self.name}"
+
+
+class KeplerAbstractMgr:
+    def __init__(self):
+        self.url_abstract_map: Dict[str, KeplerAbstract] = {}
+
+    def add(self, kepler_abstract: KeplerAbstract):
+        self.url_abstract_map.setdefault(kepler_abstract.url.url_feature, kepler_abstract)
+
+    def get(self, url_feature: str) -> KeplerAbstract:
+        return self.url_abstract_map.get(url_feature)

bmcgo/codegen/lua/script/dto/options.py

@@ -0,0 +1,33 @@
+#!/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
+
+
+class Options:
+    def __init__(self, options):
+        self.source_file_path: str = options.source_file_path
+        self.template_name: str = options.template_name
+        self.output_file_path: str = options.output_file_path
+        self.enable_auto_merge: bool = options.enable_auto_merge
+        self.project_name = options.project_name
+        self.version = options.version
+        self.proto_root_path = os.path.normpath(options.proto_root_path)
+        self.proto_json_root_path = os.path.normpath(
+            options.proto_json_root_path)
+        self.kepler_root_path = os.path.join(
+            options.proto_json_root_path, "mdb", "bmc", "kepler")
+        self.formatter = options.formatter
+
+    @staticmethod
+    def from_parse_args_result(options):
+        return Options(options)

bmcgo/codegen/lua/script/dto/print_simple.py

@@ -0,0 +1,19 @@
+#!/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.
+
+
+class PrintSimple:
+    def __str__(self):
+        return "%s" % self.__dict__
+
+    def __repr__(self):
+        return "%s(%s)" % (self.__class__, self.__dict__)

bmcgo/codegen/lua/script/dto/redfish_api.py

@@ -0,0 +1,241 @@
+#!/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 enum
+from typing import Dict, List
+
+from dto.print_simple import PrintSimple
+from dto.url_route import UrlRoute, UrlRouteDict
+
+ALLOW_BASIC_TYPES = {"bool", "string", "int32", "uint32", "int64", "uint64", "float", "double", "bytes"}
+
+
+def join_father_options(data: dict, father_options: dict):
+    if not father_options:
+        return
+    data.setdefault("options", {})
+    for key in father_options.keys():
+        data["options"].setdefault(key, father_options.get(key))
+
+
+class Mapping(PrintSimple):
+    def __init__(self, inner_attr_name: str = "", to_inner_func: str = "", from_inner_func: str = "",
+                 auto_enable: bool = True):
+        self.inner_attr_name: str = inner_attr_name
+        self.to_inner_func: str = to_inner_func
+        self.from_inner_func: str = from_inner_func
+        self.auto_enable: bool = auto_enable
+
+    @classmethod
+    def from_proto_json(cls, data: Dict[str, str]):
+        ret = cls()
+        ret.inner_attr_name = data.get("v_attr")
+        ret.to_inner_func = data.get("cvt_to_inner")
+        ret.from_inner_func = data.get("cvt_to_out")
+        ret.auto_enable = data.get("auto_map") in [True, 1, "true", "TRUE", "Y", "YES"]
+        return ret
+
+
+class Converter(PrintSimple):
+    def __init__(self, raw_convert: str):
+        self._raw_convert: str = raw_convert
+        self.use_self: bool = False
+        self.cvt_fun: str = None
+        if raw_convert:
+            self.cvt_fun: str = raw_convert.split("@")[0]
+            if raw_convert.find("@self") >= 0:
+                self.use_self = True
+
+    def valid(self) -> bool:
+        return self.cvt_fun not in ["", None]
+
+
+class Property(PrintSimple):
+    def __init__(self, attr_name: str, attr_type: str, route: UrlRoute, mapping: Mapping, out_attr_name: str = None,
+                 dft_value: str = None, read_only: bool = False, repeated: bool = False, attr_to_view: Converter = "",
+                 attr_from_view: Converter = ""):
+        self.attr_name: str = attr_name
+        self.attr_type: str = attr_type
+        self.url_route: UrlRoute = route
+        self.mapping: Mapping = mapping
+        self.out_attr_name: str = out_attr_name
+        if not self.out_attr_name:
+            self.out_attr_name: str = self.attr_name
+        self.dft_value: str = dft_value
+        if not self.mapping.inner_attr_name:
+            self.mapping.inner_attr_name = self.attr_name
+        self.read_only: bool = read_only
+        self.repeated: bool = repeated
+        self.attr_to_view: Converter = attr_to_view
+        self.attr_from_view: Converter = attr_from_view
+
+    @classmethod
+    def from_proto_json(cls, data: dict, father_options: dict = None):
+        options = data.get("options")
+        if options is None:
+            options = {}
+        join_father_options(data, father_options)
+        return cls(
+            attr_name=data.get("name"),
+            attr_type=data.get("type"),
+            route=UrlRoute(options),
+            mapping=Mapping.from_proto_json(options),
+            out_attr_name=options.get("rename"),
+            dft_value=options.get("default"),
+            read_only=options.get("read_only"),
+            repeated=data.get("repeated"),
+            attr_to_view=Converter(options.get("attr_to_view")),
+            attr_from_view=Converter(options.get("attr_from_view"))
+        )
+
+    def complex_type(self, msg_mgr) -> bool:
+        if self.attr_type in ALLOW_BASIC_TYPES:
+            return False
+        msg = msg_mgr.messages.get(self.attr_type)
+        if msg is None:
+            return False
+        return not msg.msg_type.basic_attr()
+
+
+
+class Value(PrintSimple):
+    def __init__(self, name: str, value: int):
+        self.name: str = name
+        self.value: int = value
+
+    @classmethod
+    def from_proto_json(cls, data: dict):
+        return cls(name=data.get("name"), value=data.get("value"))
+
+
+class ServiceType(enum.Enum):
+    DATA = ("_Data", "_data")
+    GET = ("Get", "get")
+    PUT = ("Put", "put")
+    PATCH = ("Patch", "patch")
+    POST = ("Post", "post")
+    DELETE = ("Delete", "delete")
+
+    def __init__(self, http_name: str, code_name: str):
+        self.http_name: str = http_name
+        self.code_name: str = code_name
+
+    @classmethod
+    def from_json(cls, data: dict):
+        for service_type in cls:
+            if service_type.http_name == data.get("name"):
+                return service_type
+        return cls.DATA
+
+
+REQ_BODY_VAR_NAME = "Body"
+REQ_RESPONSE_VAR_NAME = "Response"
+
+
+class MessageType(enum.Enum):
+    ENUM = "Enum"
+    MESSAGE = "Message"
+    INTERFACE = "Interface"
+
+    @classmethod
+    def from_json(cls, data: dict):
+        service_type = ServiceType.from_json(data)
+        if service_type != ServiceType.DATA:
+            return cls.INTERFACE
+        for msg_type in cls:
+            if msg_type.value == data.get("type"):
+                return msg_type
+        return cls.MESSAGE
+
+    def basic_attr(self) -> bool:
+        return self == MessageType.ENUM
+
+
+class MessageSchema(PrintSimple):
+    def __init__(self):
+        self.package: str = ""
+        self.name: str = ""
+        self.url_route: UrlRoute = UrlRoute({})
+        self.auth_enable: bool = False
+        self.msg_type: MessageType = MessageType.MESSAGE
+        self.service_type: ServiceType = ServiceType.DATA
+        self.properties: List[Property] = []
+        self.values: List[Property] = []
+
+    @classmethod
+    def from_proto_json(cls, data: dict, father: str = "", father_options: dict = None):
+        ret = cls()
+        options = data.get("options")
+        if options is None:
+            options = {}
+        join_father_options(data, father_options)
+        if not father:
+            ret.package = data.get("package")
+        else:
+            ret.package = father
+        ret.name = data.get("name")
+        ret.url_route = UrlRoute(options)
+        if options.get("auth"):
+            ret.auth_enable = options.get("auth")
+        properties = data.get("properties")
+        if properties is None:
+            properties = []
+        ret.properties = [Property.from_proto_json(pt, data.get("options")) for pt in properties if pt.get("name")]
+        values = data.get("values")
+        if values is None:
+            values = []
+        ret.values = [Value.from_proto_json(value) for value in values]
+        ret.msg_type = MessageType.from_json(data)
+        ret.service_type = ServiceType.from_json(data)
+        return ret
+
+    def class_type(self):
+        return f"{self.package}.{self.name}"
+
+    def class_var_name(self):
+        return self.class_type().lower().replace(".", "_")
+
+
+class MessageSchemaMgr(PrintSimple):
+    def __init__(self):
+        self.messages: Dict[str, MessageSchema] = {}
+        self._msg_route_map: Dict[str, UrlRouteDict] = {}
+
+    def append(self, msg: MessageSchema):
+        self.messages.setdefault(msg.class_type(), msg)
+
+    def related_objects(self, msg: MessageSchema) -> UrlRouteDict:
+        if self._msg_route_map.get(msg.class_type()):
+            return self._msg_route_map.get(msg.class_type())
+        route_dict = self._calc_related_url_route(msg)
+        self._msg_route_map.setdefault(msg.class_type(), route_dict)
+        return route_dict
+
+    def _calc_related_url_route(self, msg: MessageSchema):
+        route_dict = UrlRouteDict()
+        if not msg:
+            return route_dict
+        if msg.msg_type.basic_attr():
+            return route_dict
+        for pt in msg.properties:
+            route_dict.add_url(pt.url_route, msg.url_route)
+            if pt.attr_type not in ALLOW_BASIC_TYPES:
+                sub_msg = self.messages.get(pt.attr_type)
+                if sub_msg:
+                    route_dict.extend(self.related_objects(sub_msg))
+        return route_dict
+
+
+class FatherFields:
+    def __init__(self):
+        self.father_options: dict = {}
+        self.father: str = ""

bmcgo/codegen/lua/script/dto/url_route.py

@@ -0,0 +1,195 @@
+#!/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 Dict, List, Optional
+
+from dto.exception import UrlParseException
+from dto.print_simple import PrintSimple
+
+GET_URL_SEG_FUNC = "GetUrl"  # 传入URL路径和参数位置，获取参数值的函数, 如: GetUrl(path, id)
+REQ_PARAMS = "req.params"
+
+
+class Variable(PrintSimple):
+    def __init__(self, name: str, segment_pos: int, order: int):
+        self.name: str = name
+        self.segment_pos: int = segment_pos
+        self.order: int = order
+
+    def to_param_name(self):
+        return self.name.lower().replace(":", "")
+
+
+class Url(PrintSimple):
+    def __init__(self, url: str):
+        self.url = url
+        self.segments: List[str] = []
+        if self.url:
+            self.segments: List[str] = url.split("/")
+        self.variable_list: List[Variable] = []
+        self.url_feature: str = ""
+        self._parse_url_variable_id(url)
+
+    def __eq__(self, other) -> bool:
+        return self.url == other.url
+
+    def relative_json_path(self):
+        return "/".join([seg for seg in self.segments if seg.find(":") < 0]) + ".proto.json"
+
+    def find_variable_by_name(self, mapping_name: str) -> Optional[Variable]:
+        ret = None
+        for variable in self.variable_list:
+            if variable.name == mapping_name:
+                return variable
+        return ret
+
+    def find_variable_by_variable(self, outer_var: Variable) -> Optional[Variable]:
+        var = None
+        var = self.find_variable_by_name(outer_var.name)
+        if var:
+            return var
+        for variable in self.variable_list:
+            if variable.order == outer_var.order:
+                return variable
+        return var
+
+    def find(self, outer_var: Variable, mapping_name: str = None) -> Optional[Variable]:
+        var = self.find_variable_by_name(mapping_name)
+        if var:
+            return var
+        return self.find_variable_by_variable(outer_var)
+
+    def _parse_url_variable_id(self, url):
+        self.url_feature = ""
+        if url is None:
+            return
+        seg_list = []
+        pos = 0
+        for name in self.segments:
+            if name.startswith(":"):
+                self.variable_list.append(Variable(name, pos, len(self.variable_list)))
+                seg_list.append(":id")
+            else:
+                seg_list.append(name)
+            pos += 1
+        self.url_feature = "/".join(seg_list)
+
+
+class UrlRoute(PrintSimple):
+    def __init__(self, options: Dict[str, str]):
+        if options.get("url"):
+            self.outer = Url(options.get("url"))
+        else:
+            self.outer = Url(options.get("path"))
+        self.inner = Url(options.get("inner_url"))
+        self.interface: str = options.get("interface")
+        self.outer_variable_mapping: Dict[str, str] = {}
+        self.inner_variable_mapping: Dict[str, str] = {}
+        variable_mapping = options.get("variable_mapping")
+        self._parse_variable_mapping(variable_mapping)
+
+    def __eq__(self, other):
+        return self.outer == other.outer and self.inner == other.inner and \
+               self.inner_variable_mapping == other.inner_variable_mapping and \
+               self.outer_variable_mapping == other.outer_variable_mapping
+
+    @staticmethod
+    def _check_variable_exists(mapping: str, url: Url, variable_id: str):
+        if url.url is None:
+            return
+        if not url.find_variable_by_name(variable_id):
+            raise UrlParseException(f"{mapping} 错误, {variable_id} 不在 {url.url} 中")
+
+    @staticmethod
+    def _merge_code(ret_list, join_tag=".."):
+        ret = ""
+        for i, _ in enumerate(ret_list):
+            if i != 0:
+                ret += join_tag
+            if ret_list[i].find(REQ_PARAMS) >= 0:  # 该段是变量场景
+                ret += ret_list[i]
+                if i < len(ret_list) - 1 and ret_list[i + 1].find(REQ_PARAMS) >= 0:  # 紧跟着的也是变量
+                    ret += join_tag + '"/"'
+                continue
+            if len(ret_list) > 1 + i:
+                ret += f'"{ret_list[i]}/"'
+            else:
+                if i > 0:
+                    ret += f'"/{ret_list[i]}"'
+                else:
+                    ret += f'"{ret_list[i]}"'
+        return ret
+
+    def valid(self) -> bool:
+        return self.inner.url not in [None, ""] and self.outer.url not in [None, ""]
+
+    def merge_options(self, options: dict) -> bool:
+        if self.outer.url != options.get("url") or self.inner.url != options.get("inner_url"):
+            self.outer = Url(options.get("url"))
+            self.inner = Url(options.get("inner_url"))
+            return True
+        return False
+
+    def inner_url_code(self, join_tag="..") -> str:
+        ret_list = []
+        start_pos = 0
+        for variable in self.inner.variable_list:
+            buff = "/".join(self.inner.segments[start_pos:variable.segment_pos])
+            if buff:
+                ret_list.append(f'{buff}')
+            out_var = self.outer.find(variable, self.inner_variable_mapping.get(variable.name))
+            if out_var is None:
+                raise UrlParseException(f"没有匹配到变量: {variable}")
+            ret_list.append(f"{REQ_PARAMS}.{out_var.to_param_name()}")
+            start_pos = variable.segment_pos + 1
+        buff = "/".join(self.inner.segments[start_pos:])
+        if buff:
+            ret_list.append(f'{buff}')
+        return self._merge_code(ret_list, join_tag)
+
+    def _parse_variable_mapping(self, variable_mapping):
+        if len(self.inner.variable_list) > len(self.outer.variable_list):
+            raise UrlParseException("内部地址变量数量 %s > 外部地址变量 %s." % (
+                len(self.inner.variable_list), len(self.outer.variable_list)))
+        if variable_mapping is not None:
+            self._parse_user_define_mapping(variable_mapping)
+
+    def _parse_user_define_mapping(self, variable_mapping):
+        for kv in variable_mapping.split():
+            if kv.find("=") <= 0:
+                continue
+            outer_variable_id = kv.split("=")[0].strip()  # 前面有find判断, 这里是=前面部分
+            inner_variable_id = kv.split("=")[1].strip()  # 前面有find判断, 这里是=后面部分
+            self._check_variable_exists(kv, self.outer, outer_variable_id)
+            self._check_variable_exists(kv, self.inner, inner_variable_id)
+            self.outer_variable_mapping[outer_variable_id] = inner_variable_id
+            self.inner_variable_mapping[inner_variable_id] = outer_variable_id
+
+
+class UrlRouteDict:
+    def __init__(self):
+        self.url_dict: Dict[str, Url] = {}  # kepler 访问代码 --> Url的映射
+
+    def add_url(self, attr_route: UrlRoute, class_route: UrlRoute):
+        if attr_route.valid():
+            if class_route.valid():
+                if attr_route == class_route:
+                    self.url_dict.setdefault(class_route.inner_url_code(), class_route.inner)
+                    return
+            self.url_dict.setdefault(attr_route.inner_url_code(), attr_route.inner)
+        else:
+            if class_route.valid():
+                self.url_dict.setdefault(class_route.inner_url_code(), class_route.inner)
+
+    def extend(self, other):
+        for key in other.url_dict.keys():
+            self.url_dict.setdefault(key, other.url_dict.get(key))