openubmc-bingo 0.5.240__py3-none-any.whl

bmcgo/codegen/lua/templates/new_app/permissions.ini.mako

@@ -0,0 +1,16 @@
+# syntax documentation
+# format: name type mode uid gid
+# name is the path to the file you want to create/modify
+# type is the type of the file, being one of:
+#   f: a regular file
+#   d: a directory
+#   r: a directory recursively
+# mode are the usual permissions settings (only numerical values are allowed)
+# name is the path to the file you want to create/modify
+opt/bmc/apps/${project_name} d 550 0 0
+opt/bmc/apps/${project_name} r 440 0 0
+opt/bmc/apps/${project_name} rd 550 0 0
+opt/bmc/apps/${project_name}/config.cfg f 640 0 0
+opt/bmc/apps/${project_name}/mds d 750 0 0
+opt/bmc/apps/${project_name}/mds r 640 0 0
+etc/systemd/system/${project_name}.service f 640 0 0

bmcgo/codegen/lua/templates/new_app/src/lualib/${project_name}_app.lua.mako

@@ -0,0 +1,16 @@
+${make_header('lua')}
+
+local class = require 'mc.class'
+local service = require '${project_name}.service'
+
+local ${project_name} = class(service)
+
+function ${project_name}:ctor()
+
+end
+
+function ${project_name}:init()
+    self.super.init(self)
+end
+
+return ${project_name}

bmcgo/codegen/lua/templates/new_app/src/service/main.lua.mako

@@ -0,0 +1,25 @@
+${make_header('lua')}
+
+require 'skynet.manager'
+local skynet = require 'skynet'
+local logging = require 'mc.logging'
+local ${project_name}_app = require '${project_name}_app'
+
+local CMD = {}
+
+function CMD.exit()
+    logging:notice('${project_name} service exit')
+end
+
+skynet.start(function()
+    skynet.uniqueservice('sd_bus')
+    skynet.register('${project_name}')
+    local ok, err = pcall(${project_name}_app.new)
+    if not ok then
+        logging:error('${project_name} start failed, err: %s', err)
+    end
+    skynet.dispatch('lua', function(_, _, cmd, ...)
+        local f = assert(CMD[cmd])
+        skynet.ret(skynet.pack(f(...)))
+    end)
+end)

bmcgo/codegen/lua/templates/new_app/test/integration/test_${project_name}.conf.mako

@@ -0,0 +1,9 @@
+include("$CONFIG_FILE")
+
+config:init_integration_test_dirs()
+config:set_start("test_${project_name}")
+config:include_app('${project_name}')
+config:done()
+
+TEST_DATA_DIR = 'test/integration/.test_temp_data/'
+test_apps_root = 'test/integration/apps/'

bmcgo/codegen/lua/templates/new_app/test/integration/test_${project_name}.lua.mako

@@ -0,0 +1,47 @@
+${make_header('lua')}
+local skynet = require 'skynet'
+require 'skynet.manager'
+local log = require 'mc.logging'
+local utils = require 'mc.utils'
+local test_common = require 'test_common.utils'
+
+local function prepare_test_data()
+    local test_data_dir = skynet.getenv('TEST_DATA_DIR')
+    os.execute('mkdir -p ' .. test_data_dir)
+    os.execute('mkdir -p ' .. '/tmp/test_dump')
+end
+
+local function clear_test_data(exit_test)
+    log:info('clear test data')
+    local test_data_dir = skynet.getenv('TEST_DATA_DIR')
+    if not exit_test then
+        return utils.remove_file(test_data_dir)
+    end
+
+    skynet.timeout(0, function()
+        skynet.sleep(20)
+        skynet.abort()
+        utils.remove_file(test_data_dir)
+        utils.remove_file('/tmp/test_dump')
+    end)
+end
+
+local function test_${project_name}()
+    log:info('================ test start ================')
+
+    log:info('================ test complete ================')
+end
+
+skynet.start(function()
+    clear_test_data(false)
+    prepare_test_data()
+    test_common.dbus_launch()
+    skynet.uniqueservice('main')
+    skynet.fork(function()
+        local ok, err = pcall(test_${project_name})
+        clear_test_data(true)
+        if not ok then
+            error(err)
+        end
+    end)
+end)

bmcgo/codegen/lua/templates/new_app/test/unit/test.lua.mako

@@ -0,0 +1,23 @@
+${make_header('lua')}
+<% camel_name=''.join(word.title() for word in project_name.split('_')) %>
+loadfile(os.getenv('CONFIG_FILE'), 't', {package = package, os = os})()
+
+local lu = require('luaunit')
+local utils = require 'utils.core'
+local logging = require 'mc.logging'
+
+local current_file_dir = debug.getinfo(1).source:match('@?(.*)/')
+
+utils.chdir(current_file_dir)
+logging:setPrint(nil)
+logging:setLevel(logging.INFO)
+
+Test${camel_name}Cfg = {}
+
+function Test${camel_name}Cfg:setupClass()
+end
+
+function Test${camel_name}Cfg:teardownClass()
+end
+
+os.exit(lu.LuaUnit.run())

bmcgo/codegen/lua/templates/new_app/user_conf/rootfs/etc/systemd/system/${project_name}.service.mako

@@ -0,0 +1,18 @@
+[Unit]
+Description=${project_name} service
+After=dbus.service
+Requires=dbus.service
+
+[Service]
+User=root
+Restart=always
+RestartSec=1
+StartLimitInterval=0
+EnvironmentFile=/dev/shm/dbus/.dbus
+Environment="ROOT_DIR="
+Environment="PROJECT_DIR="
+WorkingDirectory=/opt/bmc/apps/${project_name}
+ExecStart=/opt/bmc/skynet/skynet /opt/bmc/apps/${project_name}/config.cfg
+
+[Install]
+WantedBy=multi-user.target

bmcgo/codegen/lua/templates/new_app/user_conf/rootfs/etc/systemd/system/multi-user.target.wants/${project_name}.service.link

@@ -0,0 +1 @@
+../${project_name}.service

bmcgo/component/__init__.py

@@ -0,0 +1,10 @@
+# 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.

bmcgo/component/analysis/analysis.py

@@ -0,0 +1,183 @@
+#!/usr/bin/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
+
+from bmcgo import misc
+from bmcgo.component.analysis.build_deps import BuildDependenciesAnalysis
+from bmcgo.component.analysis.dep_node import DepNode
+from bmcgo.component.analysis.intf_deps import InterfaceDependenciesAnalysis
+from bmcgo.component.analysis.data_deps import DataDependenciesAnalysis
+from bmcgo.component.analysis.rule import SubSys, Rules
+from bmcgo.logger import Logger
+
+global log
+log = Logger()
+
+script_dir = os.path.split(os.path.realpath(__file__))[0]
+TABLE_CONFLICT_WHITE_LIST = {
+    "nsm": ["t_snmp_config", set(["Id", "Enabled"])],
+    "event_policy": ["t_snmp_config", set(["Id", "Enabled"])]
+}
+
+
+class AnalysisComp():
+    def __init__(self, board_name, artifact_dir, lock_file, custom_sr_dir):
+        self.board_name = board_name
+        self.artifact_dir = artifact_dir
+        self.lock_file = lock_file
+        self.custom_sr_dir = custom_sr_dir
+        if not self.artifact_dir:
+            self.artifact_dir = os.path.join(os.getcwd(), "..", "output/packet/inner")
+        if not lock_file:
+            self.lock_file = os.path.join(os.getcwd(), "..", "output/package.lock")
+        self.nodes: list[DepNode] = []
+        self.subsystems = {}
+        self.rules: list[Rules] = []
+
+    def read_rules(self):
+        rule_file = os.path.join(script_dir, "dep-rules.json")
+        if not os.path.isfile(rule_file):
+            raise Exception(f"依赖规则文件 {rule_file} 不存在")
+        with open(rule_file) as file_descriptor:
+            rules = json.load(file_descriptor)
+        data = rules.get("Subsystems", [])
+        for sub in data:
+            sys_data = data[sub]
+            level = sys_data.get("Level", 0)
+            subsys = SubSys(int(level))
+            apps = sys_data.get("Apps", [])
+            for app in apps:
+                subsys.apps.append(app)
+            libs = sys_data.get("Libraries", [])
+            for lib in libs:
+                subsys.libraries.append(lib)
+            tools = sys_data.get("Tools", [])
+            for tool in tools:
+                subsys.tools.append(tool)
+            configurations = sys_data.get("Configurations", [])
+            for config in configurations:
+                subsys.configurations.append(config)
+            commands = sys_data.get("Commands", [])
+            for cmd in commands:
+                subsys.commands.append(cmd)
+            self.subsystems[sub] = subsys
+        self.rules.append(Rules(rules.get("Allowed", []), True))
+        self.rules.append(Rules(rules.get("UnAllowed", []), False))
+
+    def set_node_subsys(self, node: DepNode):
+        for key, subsys in self.subsystems.items():
+            if node.package_name in subsys.apps:
+                node.set_subsys(key, subsys.level)
+                node.set_package_type("App")
+            if node.package_name in subsys.libraries:
+                node.set_subsys(key, subsys.level)
+                node.set_package_type("Library")
+            if node.package_name in subsys.tools:
+                node.set_subsys(key, subsys.level)
+                node.set_package_type("Tool")
+            if node.package_name in subsys.configurations:
+                node.set_subsys(key, subsys.level)
+                node.set_package_type("Configuration")
+            if node.package_name in subsys.commands:
+                node.set_subsys(key, subsys.level)
+                node.set_package_type("Command")
+        log.debug("app 名字: %s,类型: (%s), 子系统: %s", node.package_name, ", ".join(node.package_type),
+                      node.subsys_name)
+
+    def read_package_lock(self):
+        if not os.path.isfile(self.lock_file):
+            raise Exception(f"无法找到 {self.lock_file} 构建信息用于分析")
+        with open(self.lock_file) as file_descriptor:
+            lock = json.load(file_descriptor)
+        requires: dict = {}
+        packages = {}
+        for i in range(0, 10000):
+            node_data = lock.get("graph_lock", {}).get("nodes", {}).get(str(i), None)
+            if not node_data:
+                break
+            node = DepNode(node_data, i)
+            # busybox是调测包，当dev包引入时忽略架构治理分析（由schema模型看护）
+            user_stage = f"{misc.ConanUserEnum.CONAN_USER_DEV.value}/{misc.StageEnum.STAGE_DEV.value}"
+            if node.package_name == "busybox" and user_stage in node.ref:
+                continue
+            packages[node.index] = node
+            requires[node.index] = node_data.get("requires", [])
+        for index, pkg in packages.items():
+            if not pkg.name.startswith("openubmc"):
+                self.set_node_subsys(pkg)
+            for require_id in requires.get(index, []):
+                pkg.requires.append(packages.get(int(require_id), None))
+            if not pkg.name.startswith("openubmc"):
+                self.nodes.append(pkg)
+
+    def run(self):
+        self.read_rules()
+        self.read_package_lock()
+
+        table_valid = self._check_table_conflict()
+
+        build_deps_alys = BuildDependenciesAnalysis(self.nodes, self.rules)
+        all_deps_valid = build_deps_alys.is_dependency_allowed()
+        build_deps_alys.visualize_graph(
+            os.path.join(self.artifact_dir, "build_dependencies_graph_{}.html".format(self.board_name)))
+        build_deps_alys.assemble_deps_json_desc(
+            os.path.join(self.artifact_dir, "build_dependencies_graph_{}.json".format(self.board_name)))
+
+        intf_deps_alys = InterfaceDependenciesAnalysis(self.nodes, self.rules)
+        all_deps_valid = intf_deps_alys.is_dependency_allowed() and all_deps_valid
+        intf_deps_alys.visualize_graph(
+            os.path.join(self.artifact_dir, "interface_dependencies_graph_{}.html".format(self.board_name)))
+        intf_deps_alys.assemble_deps_json_desc(
+            os.path.join(self.artifact_dir, "interface_dependencies_graph_{}.json".format(self.board_name)))
+
+        data_deps_alys = DataDependenciesAnalysis(self.nodes, self.rules, self.custom_sr_dir)
+        data_deps_valid = data_deps_alys.run(
+            os.path.join(self.artifact_dir, "data_dependencies_graph_{}.html".format(self.board_name)),
+            os.path.join(self.artifact_dir, "data_dependencies_graph_{}.json".format(self.board_name)),
+            os.path.join(self.artifact_dir, "data_dependencies_issues_{}.log".format(self.board_name))
+        )
+        all_deps_valid = table_valid and data_deps_valid and all_deps_valid
+
+        if all_deps_valid:
+            log.info("依赖检查通过")
+        else:
+            log.error("依赖检查不通过")
+        return all_deps_valid
+
+    def _check_table_conflict(self):
+        result = True
+        remote_table_map = {}
+        for node in self.nodes:
+            if node.table_conflict:
+                result = False
+            for remote_table, value in node.remote_tables.items():
+                if remote_table not in remote_table_map:
+                    remote_table_map[remote_table] = [node.package_name, value]
+                    continue
+
+                hit_package_name = remote_table_map[remote_table][0]
+                hit_info = remote_table_map[remote_table][1]
+                if node.package_name not in TABLE_CONFLICT_WHITE_LIST \
+                    or remote_table != TABLE_CONFLICT_WHITE_LIST[node.package_name][0] \
+                    or hit_package_name not in TABLE_CONFLICT_WHITE_LIST:
+                    log.error("%s与%s远程持久化表名冲突: %s", node.package_name, hit_package_name, remote_table)
+                    result = False
+                    continue
+
+                intersection = hit_info.intersection(value) - TABLE_CONFLICT_WHITE_LIST[hit_package_name][1]
+                if intersection:
+                    log.error("%s与%s的远程持久化表%s存在历史冲突, 不允许再添加新的冲突字段%s", node.package_name, hit_package_name, remote_table,
+                        intersection)
+                    result = False
+        return result

bmcgo/component/analysis/build_deps.py

@@ -0,0 +1,165 @@
+#!/usr/bin/env python
+# 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 collections import defaultdict
+from typing import Dict, List, Set
+
+import json
+import os
+import stat
+
+from pyecharts import options as opts
+from pyecharts.charts import Graph
+from pyecharts.options import GraphLink, GraphNode
+
+from bmcgo.component.analysis.dep_node import DepNode
+from bmcgo.component.analysis.rule import Rules
+from bmcgo.logger import Logger
+from bmcgo import misc
+
+global log
+log = Logger()
+TARGET_COMPONENTS = "targetComponents"
+
+
+class BuildDependenciesAnalysis():
+    def __init__(self, nodes: List[DepNode], rules: List[Rules]):
+        self._nodes = nodes
+        self._rules = rules
+        self.build_deps_graph: Dict[str, Set[str]] = defaultdict(set)
+        self.build_deps_unallowed_graph: Dict[str, Set[str]] = defaultdict(set)
+        self.isolated_packages: Set[str] = set()
+        self._node_build_relation()
+        self._get_isolated_packages()
+
+    def is_dependency_allowed(self):
+        is_allowed = True
+        for pkg in self._nodes:
+            if pkg.subsys_name == "unknown":
+                is_allowed = False
+                log.error("发现一个不在子系统中的包, 包名为: %s", pkg.name)
+            if pkg.package_name in self.isolated_packages and "Library" in pkg.package_type:
+                if pkg.subsys_name != "opensource" and pkg.subsys_name != "public":
+                    is_allowed = False
+                    log.error("找到一个孤立的库, 库名为: %s", pkg.name)
+                else:
+                    log.warning("找到一个孤立的开源/平台公共库, 库名为: %s", pkg.name)
+        return is_allowed and not bool(self.build_deps_unallowed_graph)
+
+    def assemble_deps_json_desc(self, path):
+        node_name_map = dict()
+        for node in self._nodes:
+            node_name_map[node.package_name] = {
+                misc.NAME: node.package_name,
+                "version": node.package_version,
+                "subsystem": node.subsys_name,
+                "type": node.package_type
+            }
+
+        json_dict = {"AllBuildDependencyGraph": [], "IllegalBuildDependencyGraph": []}
+        for src in self.build_deps_graph:
+            entry = {"sourceComponent": node_name_map.get(src), TARGET_COMPONENTS: []}
+            for tgt in self.build_deps_graph[src]:
+                entry[TARGET_COMPONENTS].append(node_name_map.get(tgt))
+            json_dict["AllBuildDependencyGraph"].append(entry)
+
+        for src in self.build_deps_unallowed_graph:
+            entry = {"sourceComponent": node_name_map.get(src), TARGET_COMPONENTS: []}
+            for tgt in self.build_deps_unallowed_graph[src]:
+                entry[TARGET_COMPONENTS].append(node_name_map.get(tgt))
+            json_dict["IllegalBuildDependencyGraph"].append(entry)
+
+        log.info("保存 BMC 组件构建依赖信息到: %s", path)
+        flags = os.O_WRONLY | os.O_CREAT | os.O_TRUNC
+        modes = stat.S_IWUSR | stat.S_IRUSR 
+        with os.fdopen(os.open(path, flags, modes), 'w') as file_descriptor:
+            file_descriptor.write(json.dumps(json_dict, indent=4))
+
+    def visualize_graph(self, path):
+        subsystems = set()
+        for pkg in self._nodes:
+            subsystems.add(pkg.subsys_name)
+        categories = []
+        for subsys in subsystems:
+            categories.append({misc.NAME: subsys, "symbolSize": 100})
+        categories.append({misc.NAME: "unknown", "symbolSize": 100})
+        category_id_map: Dict[str, int] = dict()
+        for index, category in enumerate(categories):
+            category_id_map[category[misc.NAME]] = index
+
+        graph_nodes: List[GraphNode] = []
+        for pkg in self._nodes:
+            label_opts = None
+            if pkg.subsys_name == "unknown":
+                label_opts = opts.LabelOpts(color=misc.COLOR_RED)
+            if pkg.package_name in self.isolated_packages and "Library" in pkg.package_type:
+                label_opts = opts.LabelOpts(color=misc.COLOR_RED)
+            graph_nodes.append(GraphNode(
+                name=pkg.package_name,
+                symbol_size=5,
+                category=category_id_map.get(pkg.subsys_name, len(categories)),
+                label_opts=label_opts))
+
+        links: list[GraphLink] = []
+        for src in self.build_deps_graph:
+            for dest in self.build_deps_graph[src]:
+                if src in self.build_deps_unallowed_graph and dest in self.build_deps_unallowed_graph[src]:
+                    links.append(GraphLink(source=src, target=dest,
+                                           linestyle_opts=opts.LineStyleOpts(color=misc.COLOR_RED, width=1.5)))
+                else:
+                    links.append(GraphLink(source=src, target=dest))
+
+        log.info("保存 BMC 组件构建依赖图到 %s", path)
+        (Graph(init_opts=opts.InitOpts(width="100%", height="1200px", page_title="BMC构建依赖关系图"))
+        .add("", graph_nodes, links, categories,
+             repulsion=100,
+             is_draggable=False,
+             edge_symbol="arrow",
+             edge_symbol_size=[0, 5],
+             is_layout_animation=False,
+             label_opts=opts.LabelOpts(position="right", formatter="{b}"))
+             .set_global_opts(
+            title_opts=opts.TitleOpts(title="Graph-BMC构建依赖关系图"), 
+            legend_opts=opts.LegendOpts(orient="vertical", pos_left="2%", pos_top="20%"))
+            .render(path))
+
+    def _node_build_relation(self): 
+        for src in self._nodes:
+            for dest in src.requires:
+                self.build_deps_graph[src.package_name].add(dest.package_name)
+                if not self._check_build_dependency(src, dest):
+                    self.build_dependency_allowed = False
+                    self.build_deps_unallowed_graph[src.package_name].add(dest.package_name)
+
+    def _check_build_dependency(self, src: DepNode, tgt: DepNode):
+        if src.subsys_level < tgt.subsys_level:
+            log.error("发现不被允许的构建依赖. 源包: %s, 目标包: %s",
+                    src.name, tgt.name)
+            return False
+        for rules in self._rules:
+            if rules.build_dep_check(src, tgt):
+                log.debug("源名: %s, 目标: %s", src.name, tgt.name)
+                return True
+        log.error("发现不被允许的构建依赖. 源包: %s, 目标包: %s", src.name, tgt.name)
+        return False
+
+    def _get_isolated_packages(self):
+        indegree: Dict[str, int] = dict()
+        for node in self._nodes:
+            indegree[node.package_name] = 0
+        for src in self.build_deps_graph:
+            for dest in self.build_deps_graph[src]:
+                indegree[dest] += 1
+
+        for pkg, degree in indegree.items():
+            if degree == 0:
+                self.isolated_packages.add(pkg)