openubmc-bingo 0.5.240__py3-none-any.whl

bmcgo/codegen/lua/templates/apps/model.lua.mako

@@ -0,0 +1,239 @@
+% if version >= 4:
+${make_header('lua')}
+local mdb = require 'mc.mdb'
+local class = require 'mc.class_mgnt'
+local privilege = require 'mc.privilege'
+% if version >= 9 and render_utils.get_features(root):
+require 'mc.plugin.loader'.load()
+  % for feature in render_utils.get_features(root):
+local ${feature} = require '${project_name}.features.${feature}'.get_instance()
+  % endfor
+% endif
+
+${render_utils.render_types(project_name, root)}
+
+% for (class_name, msg) in root.items():
+
+% if version >= 9:
+  % if class_name == 'private':
+    <% continue %>
+  % endif
+% endif
+local ${class_name} = {
+  % if render_utils.has_table_name(msg):
+    ['table_name'] = '${msg['tableName']}',
+  % endif
+  % if render_utils.has_alias(msg):
+    ['alias_map'] = ${render_utils.get_alias_map(msg)},
+  % endif
+  % if render_utils.has_prop_configs(msg):
+    ['prop_configs'] = ${render_utils.get_prop_configs(class_name, msg)},
+  % endif
+  % if render_utils.has_properties(msg):
+    ['default_props'] = ${render_utils.get_default_props(class_name, msg)},
+  % endif
+  % if render_utils.has_mdb_prop_configs(msg):
+    ['mdb_prop_configs'] = ${render_utils.get_mdb_prop_configs(msg)},
+  % endif
+  % if render_utils.has_mdb_method_configs(msg):
+    ['mdb_method_configs'] = ${render_utils.get_mdb_method_configs(msg)},
+  % endif
+  % if render_utils.has_mdb_signal_configs(msg):
+    ['mdb_signal_configs'] = ${render_utils.get_mdb_signal_configs(msg)},
+  % endif
+  % if render_utils.has_mdb_classes(msg):
+    ['mdb_classes'] = ${render_utils.get_mdb_classes(root, msg)},
+  % endif
+  % if render_utils.has_new_mdb_objects(msg):
+    ['new_mdb_objects'] = ${render_utils.get_new_mdb_objects(msg)},
+  % endif
+}
+
+% endfor
+local M = {}
+
+% if render_utils.has_block_io(root):
+M.block_io_classes = {
+  % for (class_name, msg) in root.items():
+    % if render_utils.has_path(msg):
+      % for (interface, intf_msg) in msg['interfaces'].items():
+        % if interface == 'bmc.kepler.Chip.BlockIO':
+    '${class_name}',
+        % endif
+      %endfor
+    % endif
+  % endfor
+}
+% endif
+
+function M.init(bus)
+% for (class_name, msg) in root.items():
+    % if class_name != 'private':
+    class('${class_name}', ${class_name}):set_bus(bus)
+    % endif
+% endfor
+end
+% for (class_name, msg) in root.items():
+  % if render_utils.has_path(msg):
+    % for (interface, intf_msg) in msg['interfaces'].items():
+      % if render_utils.has_methods(intf_msg):
+
+        % for (method, method_config) in intf_msg['methods'].items():
+-- The callback needs to be registered during app initialization
+function M.Impl${class_name}${render_utils.get_intf_name(interface, intf_msg)}${method}(cb)
+    class('${class_name}')['${interface}'].${method} = function(obj, ctx, ...)
+          % if version >= 9 and "featureTag" in method_config:
+        ${method_config["featureTag"]}:set_default_callback("${class_name}${render_utils.get_intf_name(interface, intf_msg)}${method}", cb)
+          % endif
+        local req = ${render_utils.get_intf_type(render_utils.get_intf_name(interface, intf_msg))}.${method}Req.new(...):validate(nil, nil, true)
+          % if version >= 9 and "featureTag" in method_config:
+        local rsp = ${render_utils.get_intf_type(render_utils.get_intf_name(interface, intf_msg))}.${method}Rsp.new(${method_config["featureTag"]}:${class_name}${render_utils.get_intf_name(interface, intf_msg)}${method}(obj, ctx, req:unpack())):validate()
+          % else:
+        local rsp = ${render_utils.get_intf_type(render_utils.get_intf_name(interface, intf_msg))}.${method}Rsp.new(cb(obj, ctx, req:unpack())):validate()
+          % endif
+        return rsp:unpack(true)
+    end
+end
+
+        %endfor
+      % endif
+    %endfor
+  % endif
+% endfor
+% if version >= 9:
+% for method, method_config in root.get("private", {}).get("methods", {}).items():
+  % if "featureTag" in method_config:
+-- The callback needs to be registered during app initialization
+function M.Impl${method}(cb)
+    ${method_config["featureTag"]}:set_default_callback("${method}", cb)
+end
+
+function M.${method}(...)
+    local req = ${render_utils.get_class_type("private")}.${method}Req.new(...):validate(nil, nil, true)
+    local rsp = ${render_utils.get_class_type("private")}.${method}Rsp.new(${method_config["featureTag"]}:${method}(req:unpack())):validate()
+    return rsp:unpack(true)
+end
+
+  % endif
+% endfor
+% endif
+return M
+% else:
+${make_header('lua')}
+local mdb = require 'mc.mdb'
+local utils = require 'mc.utils'
+local logging = require 'mc.logging'
+local class = require 'mc.class_mgnt'
+local err = require 'validate.errors'
+local privilege = require 'mc.privilege'
+
+local get_table_node = utils.get_table_node
+
+% for (class_name, msg) in root.items():
+  % if render_utils.has_path(msg):
+local ${class_name.lower()}_mdb_prop_configs =  ${render_utils.get_mdb_prop_configs(project_name, msg)}
+  % else:
+local ${class_name.lower()}_mdb_prop_configs = {}
+  % endif
+
+local ${class_name} = {
+  % if render_utils.has_table_name(msg):  
+    ['table_name'] = '${msg['tableName']}',
+  % endif
+    ['alias_map'] = ${render_utils.get_alias_map(msg)},
+    ['prop_configs'] = ${render_utils.get_prop_configs(class_name, msg, project_name)},
+    ['default_props'] = ${render_utils.get_default_props(project_name, class_name, msg)},
+    ['mdb_prop_configs'] = ${class_name.lower()}_mdb_prop_configs,
+    ['mdb_method_configs'] = ${render_utils.get_mdb_method_configs(msg)},
+    ['mdb_signal_configs'] = ${render_utils.get_mdb_signal_configs(msg)},
+    ['mdb_classes'] = ${render_utils.get_mdb_classes(root, msg)},
+    % if render_utils.has_path(msg):
+    ['new_mdb_objects'] = function(path)
+      local objs = {} <% num = 0 %>
+      % for (interface, intf_msg) in msg['interfaces'].items():
+        % if num == 0:
+        local obj_cls, params = mdb.match_interface(path, '${interface}')
+        % else:
+        obj_cls, params = mdb.match_interface(path, '${interface}')
+        % endif
+        if not obj_cls then <% intf_name = render_utils.get_intf_name(interface, intf_msg)%>
+          % if use_frame_log:
+          logging:mcf_warn('Not match interface, path:%s, interface:%s', path, '${interface}')
+          % else:
+          logging:warn('Not match interface, path:%s, interface:%s', path, '${interface}')
+          % endif
+        else
+          local obj = obj_cls.new(table.unpack(params))
+        % if render_utils.has_properties(intf_msg):
+          % for (prop, prop_config) in intf_msg['properties'].items():
+            obj["${prop}"] = ${render_utils.get_mdb_prop_default_value(project_name, intf_name, prop, prop_config)}
+          % endfor
+        % endif
+          obj:access_control({
+            % if 'privilege' in msg:
+            path = ${render_utils.get_privilege(msg)},
+            % endif
+            % if 'privilege' in intf_msg:
+            interface = ${render_utils.get_privilege(intf_msg)},
+            % endif
+            props = ${render_utils.get_property_privileges(intf_msg.get('properties', {}))},
+            methods = ${render_utils.get_privileges(intf_msg.get('methods', {}))}
+            }, 
+            ${render_utils.get_readonlys(intf_msg.get('properties', {}))},
+            require '${project_name}.json_types.${intf_name}')
+        objs['${interface}'] = obj
+        end<% num = num + 1 %>
+      % endfor
+      return objs
+    end
+  % else:
+    ['new_mdb_objects'] = nil
+  % endif
+}
+
+% endfor
+local M = {}
+
+% if render_utils.has_block_io(root):
+M.block_io_classes = {
+  % for (class_name, msg) in root.items():
+    % if render_utils.has_path(msg):
+      % for (interface, intf_msg) in msg['interfaces'].items():
+        % if interface == 'bmc.kepler.Chip.BlockIO':
+    '${class_name}',
+        % endif
+      %endfor
+    % endif
+  % endfor
+}
+% endif
+
+function M.init(bus)
+% for (class_name, msg) in root.items():
+    class('${class_name}', ${class_name}):set_bus(bus)
+% endfor
+end
+% for (class_name, msg) in root.items():
+  % if render_utils.has_path(msg):
+    % for (interface, intf_msg) in msg['interfaces'].items():
+      % if render_utils.has_methods(intf_msg):
+
+        % for (method, method_config) in intf_msg['methods'].items():
+-- The callback needs to be registered during app initialization
+function M.Impl${class_name}${render_utils.get_intf_name(interface, intf_msg)}${method}(cb)
+    class('${class_name}')['${interface}'].${method} = function(obj, ctx, ...)
+        local ${interface.split(".")[-1].lower()}_types = require "${project_name}.json_types.${render_utils.get_intf_name(interface, intf_msg)}"
+        local req = ${interface.split(".")[-1].lower()}_types.${method}Req.new(...):validate(nil, nil, true)
+        local rsp = ${interface.split(".")[-1].lower()}_types.${method}Rsp.new(cb(obj, ctx, req:unpack())):validate()
+        return rsp:unpack(true)
+    end
+end
+
+        %endfor
+      % endif
+    %endfor
+  % endif
+
+% endfor
+return M
+% endif

bmcgo/codegen/lua/templates/apps/orm_classes.lua.mako

@@ -0,0 +1,16 @@
+${make_header('lua')}
+local c_object = require 'mc.orm.object'
+
+local orm_classes = {}
+
+% if utils_py.check_db_open(project_name):
+function orm_classes.init(db)
+% for msg in root['data']:
+  % if render_utils.table_name(msg):
+    orm_classes.${msg['name']} = c_object("${msg['name']}")
+  % endif
+% endfor
+end
+% endif
+
+return orm_classes

bmcgo/codegen/lua/templates/apps/plugin.lua.mako

@@ -0,0 +1,8 @@
+${make_header('lua')}
+  % for feature in render_utils.get_features(root):
+% if project_name != 'dft' and project_name != 'debug':
+require 'plugin.features.${feature}'
+% else:
+require 'plugin.${project_name}.features.${feature}'
+% endif
+  % endfor

bmcgo/codegen/lua/templates/apps/redfish.proto.mako

@@ -0,0 +1,47 @@
+${make_header('proto')}
+syntax = "proto3";
+import "types.proto";
+import "apps/redfish/types/common.proto";
+import "apps/redfish/types/resource.proto";
+%if utils_py.oem_is_exist(render_utils.get_file_name()):
+import "apps/redfish/resource/oem/hw/${render_utils.get_file_name()}.proto";${load_import(f"apps/redfish/resource/oem/hw/{render_utils.get_file_name()}.proto",render_utils.get_file_name())}
+%endif
+package ${render_utils.get_file_name()};
+<%def name="unpack_enum(key,properties)">
+%for idx, val in enumerate(properties):
+    ${key}_${render_utils.replace_tag(val)} = ${idx};
+%endfor
+</%def>
+<%def name="unpack_propties(k,properties)">
+%for idx, val in enumerate([(k, v) for k, v in properties.items()]):
+    %if val[0] == 'PowerState':
+    Resource.PowerState PowerState = ${idx+1}${render_utils.attr_option_field(val[1])};
+    %elif val[0] == 'Oem' and utils_py.oem_is_exist(render_utils.get_file_name()) and utils_py.is_oem_message(render_utils.get_file_name(),k):
+    ${utils_py.get_oem_message(render_utils.get_file_name(),k)['package']}.${k} oem = ${idx+1}${render_utils.attr_option_field(val[1])};
+    %elif 'type' in val[1] and 'items' in val[1]:
+        %if 'anyOf' in val[1]['items']:
+    ${render_utils.get_class_name(val[1]['items']['anyOf'][0]['$ref'])} ${render_utils.replace_tag(val[0])} = ${idx+1}${render_utils.attr_option_field(val[1])};
+        %elif 'type' in val[1]['items'] :
+    repeated ${render_utils.get_type(val[0],val[1]['items']['type'])} ${render_utils.replace_tag(val[0])} = ${idx+1}${render_utils.attr_option_field(val[1])};
+        %else:
+    ${render_utils.get_class_name(val[1]['items']['$ref'])} ${render_utils.replace_tag(val[0])} = ${idx+1}${render_utils.attr_option_field(val[1])};
+        %endif
+    %elif '$ref' in val[1]:
+    ${render_utils.get_class_name(val[1]['$ref'])} ${render_utils.replace_tag(val[0])} = ${idx+1}${render_utils.attr_option_field(val[1])};
+    %elif 'anyOf' in val[1]:
+    ${render_utils.get_class_name(val[1]['anyOf'][0]['$ref'])} ${render_utils.replace_tag(val[0])} = ${idx+1}${render_utils.attr_option_field(val[1])};
+    %elif 'type' in val[1]:
+    ${render_utils.get_type(val[0],val[1]['type'])} ${render_utils.replace_tag(val[0])} = ${idx+1}${render_utils.attr_option_field(val[1])};
+    %else:
+    ${val[0]} ${render_utils.replace_tag(val[0])} = ${idx+1}${render_utils.attr_option_field(val[1])};
+    %endif
+%endfor
+</%def>
+%for k,v in root['definitions'].items():
+    %if 'enum' in v and k != 'PowerState':
+enum ${k} {${unpack_enum(k,v['enum'])}}
+    %elif 'properties' in v:
+message ${k} {${unpack_propties(k, v['properties'])}}
+    %endif
+
+%endfor