openubmc-bingo 0.6.45__py3-none-any.whl → 0.6.99__py3-none-any.whl

bmcgo/component/fixture/dbus_signature.py

@@ -0,0 +1,110 @@
+#!/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 dbus_next import Variant
+
+
+class DBusSignature:
+
+    @staticmethod
+    def get_dbus_signature(value):
+        """获取D-Bus值的签名
+
+        dbus-next使用Python原生类型表示D-Bus类型，这里基于值类型推断签名
+        """
+        if isinstance(value, bool):
+            return 'b'  # boolean
+        elif isinstance(value, int):
+            # 根据值范围推断整数类型
+            if value >= 0 and value <= 255:
+                return 'y'  # byte
+            elif value >= -32768 and value <= 32767:
+                # 注意：先检查正值范围，确保非负整数被正确识别为uint16
+                if value >= 0:
+                    return 'q'  # uint16
+                else:
+                    return 'n'  # int16
+            elif value >= 0 and value <= 65535:
+                return 'q'  # uint16
+            elif value >= -2147483648 and value <= 2147483647:
+                if value >= 0:
+                    return 'u'  # uint32
+                else:
+                    return 'i'  # int32
+            elif value >= 0 and value <= 4294967295:
+                return 'u'  # uint32
+            elif value >= -9223372036854775808 and value <= 9223372036854775807:
+                if value >= 0:
+                    return 't'  # uint64
+                else:
+                    return 'x'  # int64
+            elif value >= 0 and value <= 18446744073709551615:
+                return 't'  # uint64
+            else:
+                raise ValueError(f"Integer value {value} out of range for DBus types")
+        elif isinstance(value, float):
+            return 'd'  # double
+        elif isinstance(value, bytes):
+            return 'ay'  # array of bytes
+        elif isinstance(value, str):
+            # 检查是否是对象路径
+            if value.startswith('/') and '//' not in value:
+                return 'o'  # object path
+            # 暂时移除对签名的自动检测，避免普通字符串被错误识别为签名
+            # 在实际应用中，我们应该只在明确是签名的情况下才返回'g'
+            return 's'  # 默认为string类型
+        elif isinstance(value, list):
+            # 首先检查是否是混合类型列表，如果是则视为结构体
+            if len(value) > 0:
+                # 获取所有元素的类型
+                types = set(type(item) for item in value)
+                # 如果有多种类型，或者包含字符串和数字的混合，视为结构体
+                if len(types) > 1 or (int in types and str in types):
+                    inner_sig = ''.join([DBusSignature.get_dbus_signature(elem) for elem in value])
+                    return f'({inner_sig})'  # struct
+
+                # 特殊处理结构体：如果列表内容看起来像结构体（混合类型或含有复杂类型）
+                if all(isinstance(item, (str, bytes)) for item in value) and \
+                    any(isinstance(item, bytes) for item in value):
+                    # 这看起来像一个结构体（包含字符串和字节数组）
+                    inner_sig = ''.join([DBusSignature.get_dbus_signature(elem) for elem in value])
+                    return f'({inner_sig})'  # struct
+            # 普通数组处理
+            if value:
+                # 检查是否是整数列表
+                if all(isinstance(item, int) for item in value):
+                    # 整数列表应该被识别为整数数组(ai)，而不是字节数组(ay)
+                    return 'ai'
+                # 假设所有元素类型相同
+                elem_sig = DBusSignature.get_dbus_signature(value[0])
+                # 移除自动将整数列表转换为字节数组的逻辑，因为dbus-next要求字节数组必须是bytes类型
+                # 只有当明确传入bytes类型时才返回ay（这在前面的代码中已经处理）
+                return f'a{elem_sig}'
+            return 'av'  # 默认为variant数组
+        elif isinstance(value, dict):
+            if value:
+                key, val = next(iter(value.items()))
+                key_sig = DBusSignature.get_dbus_signature(key)
+                # 特殊处理variant值
+                if isinstance(val, Variant):
+                    val_sig = 'v'
+                else:
+                    val_sig = DBusSignature.get_dbus_signature(val)
+                return f'a{{{key_sig}{val_sig}}}'
+            return 'a{sv}'  # 默认为string:variant字典
+        elif isinstance(value, tuple):
+            # 结构体签名需要用括号包围
+            inner_sig = ''.join([DBusSignature.get_dbus_signature(elem) for elem in value])
+            return f'({inner_sig})'  # struct
+        elif isinstance(value, Variant):
+            return 'v'
+        else:
+            return 's'  # 默认视为字符串

bmcgo/component/template_v2/conanbase.py.mako

@@ -214,11 +214,7 @@ class ConanBase(ConanFile):
                 os.path.join(self.package_folder, "usr/share/doc/openubmc/${pkg.name}/docs")),
             ("*", os.path.join(self.source_folder, "build"),
                 os.path.join(self.package_folder, "include")),
-            ("permissions.ini", os.path.join(self.source_folder, "dist"), self.package_folder),
-            ("*.md", self.source_folder, os.path.join(self.package_folder,
-                "usr/share/doc/openubmc/${pkg.name}/docs")),
-            ("*.MD", self.source_folder, os.path.join(self.package_folder,
-                "usr/share/doc/openubmc/${pkg.name}/docs"))
+            ("permissions.ini", os.path.join(self.source_folder, "dist"), self.package_folder)
         ]
         for pattern, src, dst in files_to_copy:
             copy(self, pattern, src=src, dst=dst, keep_path=True)

bmcgo/component/test.py

@@ -33,6 +33,7 @@ from bmcgo.component.coverage.incremental_cov import IncrementalCov
 from bmcgo.bmcgo_config import BmcgoConfig
 from bmcgo.utils.tools import Tools
 from bmcgo.errors import BmcGoException
+from bmcgo.component.busctl_log_parse.busctl_log_parser import BusCtlLogParser
 
 log = Logger("comp_test")
 cwd = os.getcwd()
@@ -97,6 +98,15 @@ class TestComp():
         self.origin_cov = "luacov.stats.out"
         self.cov_filter = "luacov.stats.filter"
         self.cov_report = "luacov.report.html"
+        # robot-test定义
+        self.robot_gen = self.args.robot_gen
+        self.robot_test = self.args.robot_test
+        self.log_file = self.args.log_file
+        if self.robot_gen and (not self.log_file or not os.path.isdir(self.log_file)):
+            raise BmcGoException("未指定 \"--log_file\" 参数，或该参数指定的目录不存在")
+        self.test_service = "bmc.kepler." + self.info.name
+        self.robot_output_dir = os.path.join(self.folder, "test/robot_it/test_db")
+        self.rt_folder = os.path.join(self.folder, "test/robot_it/")
         # dt-fuzz定义
         self.fuzz_test = self.args.fuzz_test
         self.fuzz_gen = self.args.fuzz_gen
@@ -130,10 +140,13 @@ class TestComp():
         parser.add_argument("-it", "--integration_test", help="Enable integration test", action=misc.STORE_TRUE)
         parser.add_argument("-ft", "--fuzz_test", help="Enable fuzz test", action=misc.STORE_TRUE)
         parser.add_argument("-fg", "--fuzz_gen", help="Generate fuzz case", action=misc.STORE_TRUE)
+        parser.add_argument("-rt", "--robot_test", help="Enable robot test", action=misc.STORE_TRUE)
+        parser.add_argument("-rg", "--robot_gen", help="Generate robot case", action=misc.STORE_TRUE)
+        parser.add_argument("-lf", "--log_file", help="Monitor log file directory path")
         parser.add_argument("-cnt", "--fuzz_count", help="Fuzz count", required=False, type=int, default=100000)
         parser.add_argument("-f", "--test_filter", help="Run unit test with a filter", required=False, default='.')
         parser.add_argument("-a", "--app", help="App in hica", required=False, default='all')
-        parser.add_argument("--coverage_exclude", help="Specify coverage exclude file path of whitelist", 
+        parser.add_argument("--coverage_exclude", help="Specify coverage exclude file path of whitelist",
                             required=False, default="")
         return parser
 
@@ -200,7 +213,6 @@ class TestComp():
             missed_lines = total_lines - hit_lines
             return (f"{coverage}%", hit_lines, missed_lines)
 
-
     @staticmethod
     def _clear_result(file):
         if not os.path.isfile(file):
@@ -238,9 +250,18 @@ class TestComp():
         if results:
             summary = f"# Ran {total} tests in {duration:.3f} seconds, {total - failed} successes, {failed} failures"
             results.append(summary)
-
         return results
 
+    def generate_robot(self, test_service, log_file, output_dir):
+        parser = BusCtlLogParser(test_service=test_service)
+        out_dir = os.path.join(output_dir, self.info.name)
+        parser.parse_dbus_log(log_file, out_dir)
+        dir_os = os.path.dirname(os.path.abspath(__file__))
+        Helper.run(["/usr/bin/env", "python3", os.path.join(dir_os, "fixture", "auto_case_generator.py"), 
+                    "--bmc-test-db-dir", output_dir, "--test-db-name", self.info.name,
+                    "--fixture-dir", dir_os
+                    ])
+
     def get_excluded_files_on_key(self, lang):
         if not self.coverage_exclude:
             return []
@@ -719,6 +740,17 @@ class TestComp():
 
     def run_independent_test(self, test_env):
         log.info("================ 测试 %s 开始 ================", self.current_app)
+        if not os.getenv("DBUS_SESSION_BUS_ADDRESS"):
+            result = self.tools.run_command(["dbus-launch", "--auto-syntax"], capture_output=True)
+            for line in result.stdout.strip().split(";"):
+                if '=' in line:
+                    key, value = line.split('=', 1)
+                    os.environ[key.strip()] = value.strip().strip("'").strip(';')
+        if self.robot_test:
+            self.tools.run_command(["robot", "-v", f"PROJECT_DIR:{self.folder}", "-v", f"DBUS_ADDRESS:{os.getenv("DBUS_SESSION_BUS_ADDRESS")}", "-o", 
+                        os.path.join(self.rt_folder, "results/output.xml"), "-l", os.path.join(self.rt_folder, "results/log.xml"),
+                        "-r", os.path.join(self.rt_folder, "results/report.xml"), os.path.join(self.folder, "test/robot_it/")], show_log=True)
+
         # 配置额外的环境变量
         self.set_additional_env(test_env, self.folder, self.current_app)
         test_entry = os.path.join(self.folder, "test/unit/test.lua")
@@ -846,6 +878,7 @@ class TestComp():
         ljust_width = 30
         log.info("%s %s", "单元测试(ut):".ljust(ljust_width), str(self.unit_test))
         log.info("%s %s", "集成测试(it):".ljust(ljust_width), str(self.integration_test))
+        log.info("%s %s", "自动测试(rt):".ljust(ljust_width), str(self.robot_test))
         log.info("%s %s", "覆盖率:".ljust(ljust_width), str(self.coverage))
         log.info("%s %s", "地址消毒:".ljust(ljust_width), str(self.asan))
         log.info("============================================================================")
@@ -876,8 +909,31 @@ class TestComp():
 
     def check_folder(self):
         test_package_folder = os.path.join(self.folder, "test_package")
-        test_folder = os.path.join(self.folder, "test")
-        if os.path.isdir(test_folder) or os.path.isdir(test_package_folder):
+        flag_ut_path = os.path.isdir(os.path.join(self.folder, "test", "unit"))
+        flag_it_path = os.path.isdir(os.path.join(self.folder, "test", "integration"))
+        flag_fz_path = os.path.isdir(os.path.join(self.folder, "test", "fuzz"))
+        flag_rt_path = os.path.isdir(os.path.join(self.folder, "test", "robot_it"))
+
+        if self.fuzz_gen or self.robot_gen:
+            if self.fuzz_gen and not flag_fz_path:
+                log.error("fuzz 测试目录不存在！请检查当前组件的test目录下是否存在fuzz目录！")
+                return False
+            elif self.robot_gen and not flag_rt_path:
+                log.error("自动测试目录不存在！请检查当前组件的test目录下是否存在robot目录！")
+                return False
+            else:
+                return True
+
+        has_dt_type = self.unit_test or self.integration_test or self.fuzz_test or self.robot_test
+        if not has_dt_type:
+            self.unit_test = True
+        self.unit_test = flag_ut_path and self.unit_test
+        self.integration_test = flag_it_path and self.integration_test
+        self.fuzz_test = flag_fz_path and self.fuzz_test
+        self.robot_test = flag_rt_path and self.robot_test
+        has_dt_type = self.unit_test or self.integration_test or self.fuzz_test or self.robot_test
+
+        if os.path.isdir(test_package_folder) or has_dt_type:
             return True
         return False
 
@@ -894,17 +950,20 @@ class TestComp():
     def run(self):
         self.print_build_menu()
         if not self.check_folder():
-            log.warning("当前组件不存在开发者测试的test文件夹或test_package文件夹，开发者测试终止！")
+            log.warning("当前组件不存在开发者测试的相关文件夹，开发者测试终止！")
+            return
+
+        # --robot-gen自动生成测试用例和打桩数据
+        if self.robot_gen:
+            if not os.path.isdir(self.robot_output_dir):
+                os.makedirs(self.robot_output_dir)
+            self.generate_robot(self.test_service, self.log_file, self.robot_output_dir)
             return
 
         # -gen代码自动生成逻辑
         if self.fuzz_gen:
             self.generate_fuzz()
             return
-        # 构建完后单独运行DT
-        has_dt_type = self.unit_test or self.integration_test or self.fuzz_test
-        if not has_dt_type:
-            self.unit_test = True
 
         # 构建被测组件
         if not self.without_build:

bmcgo/error_analyzer/case_matcher.py

@@ -0,0 +1,114 @@
+#!/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.
+
+
+class CaseMatcher:
+    def __init__(self):
+        self.rules = self.load_matching_rules()
+
+    @staticmethod
+    def fill_template(template, log_entry):
+        """填充模板中的占位符"""
+        import re
+
+        def replace_placeholder(match):
+            placeholder = match.group(1)
+            if placeholder.startswith("log."):
+                path = placeholder[4:].split(".")
+                value = log_entry
+                for key in path:
+                    if isinstance(value, dict):
+                        value = value.get(key, "")
+                    else:
+                        value = getattr(value, key, "")
+                return str(value)
+            return match.group(0)
+
+        return re.sub(r"\{\{(\w+(?:\.\w+)*)\}\}", replace_placeholder, template)
+
+    @staticmethod
+    def load_matching_rules():
+        """加载匹配规则（可扩展）"""
+        return {}
+
+    @staticmethod
+    def check_single_rule(log_entry, rule):
+        """检查单个匹配规则"""
+        field = rule["field"]
+        operator = rule["operator"]
+        value = rule["value"]
+
+        log_value = log_entry.get(field, "")
+
+        if operator == "equals":
+            return log_value == value
+        elif operator == "contains":
+            return value in str(log_value)
+        elif operator == "regex":
+            import re
+
+            return bool(re.search(value, str(log_value)))
+
+        return False
+
+    def match_cases(self, log_entries, cases):
+        """将日志条目与案例模板匹配"""
+        matched_cases = []
+
+        for log_entry in log_entries:
+            case = self.find_matching_case(log_entry, cases)
+            if case:
+                matched_case = self.enrich_case_with_log(case, log_entry)
+                matched_cases.append(matched_case)
+
+        return matched_cases
+
+    def find_matching_case(self, log_entry, cases):
+        """根据规则找到匹配的案例模板"""
+        for case in cases:
+            if self.matches_rule(log_entry, case):
+                return case
+        return None
+
+    def matches_rule(self, log_entry, case_template):
+        """检查日志是否匹配案例规则"""
+        rules = case_template.get("matching_rules", [])
+
+        for rule in rules:
+            if not self.check_single_rule(log_entry, rule):
+                return False
+        return True
+
+    def enrich_case_with_log(self, case_template, log_entry):
+        """用日志信息丰富案例内容"""
+        enriched_case = case_template.copy()
+
+        enriched_case["log_data"] = {
+            "timestamp": log_entry["timestamp"],
+            "parameters": log_entry["parameters"],
+            "raw_log": log_entry["raw_line"],
+            "line_number": log_entry["line_number"],
+        }
+
+        # 替换模板中的占位符
+        if "description" in enriched_case:
+            enriched_case["description"] = self.fill_template(
+                enriched_case["description"], log_entry
+            )
+
+        if "steps" in enriched_case:
+            enriched_case["steps"] = [
+                self.fill_template(step, log_entry)
+                for step in enriched_case["steps"]
+            ]
+
+        return enriched_case

bmcgo/error_analyzer/log_parser.py

@@ -0,0 +1,128 @@
+#!/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 logging
+
+
+class LogParser:
+    @staticmethod
+    def extract_timestamp(log_line):
+        """提取时间戳"""
+        import re
+
+        # 匹配常见的时间戳格式
+        patterns = [
+            r"\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}",
+            r"\d{2}/\d{2}/\d{4} \d{2}:\d{2}:\d{2}",
+        ]
+        for pattern in patterns:
+            match = re.search(pattern, log_line)
+            if match:
+                return match.group()
+        return "未知时间"
+
+    @staticmethod
+    def extract_log_level(log_line):
+        """提取日志级别"""
+
+        levels = ["ERROR", "WARN", "WARNING", "INFO", "DEBUG", "FATAL", "Exception"]
+        for level in levels:
+            if level in log_line.upper():
+                return level
+        return "UNKNOWN"
+
+    @staticmethod
+    def extract_module(log_line):
+        """提取模块名"""
+        import re
+
+        # 匹配 [ModuleName] 格式
+        pattern = r"\[([^\]]+)\]"
+        match = re.search(pattern, log_line)
+        return match.group(1) if match else "未知模块"
+
+    @staticmethod
+    def extract_message(log_line):
+        """提取主要消息"""
+        return log_line.strip()
+
+    @staticmethod
+    def extract_error_code(log_line):
+        """提取错误代码"""
+        import re
+
+        pattern = r"[A-Z]+_\d{3,}"
+        match = re.search(pattern, log_line)
+        return match.group() if match else "UNKNOWN"
+
+    @staticmethod
+    def extract_parameters(log_line):
+        """提取日志中的参数"""
+        parameters = {}
+        import re
+
+        pattern = r"(\w+)=([^,\s]+)"
+        matches = re.findall(pattern, log_line)
+        for key, value in matches:
+            parameters[key] = value
+        return parameters
+
+    def parse_logs(self, file_path):
+        """解析错误日志文件"""
+        log_entries = []
+        seen_logs = set()  # 用于去重的集合
+
+        try:
+            with open(file_path, "r", encoding="utf-8") as f:
+                for line_num, line in enumerate(f, 1):
+                    entry = self.parse_log_entry(line, line_num)
+                    if entry:
+                        # 去除颜色码并标准化日志内容
+                        import re
+
+                        ansi_escape = re.compile(
+                            r"\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])"
+                        )
+                        clean_log = ansi_escape.sub("", entry["raw_line"]).strip()
+
+                        # 检查是否已经处理过相同的日志
+                        if clean_log not in seen_logs:
+                            seen_logs.add(clean_log)
+                            log_entries.append(entry)
+        except FileNotFoundError:
+            logging.warning(f"❌ 日志文件不存在: {file_path}")
+        except Exception as e:
+            logging.error(f"❌ 读取日志文件失败: {e}")
+
+        return log_entries
+
+    def parse_log_entry(self, log_line, line_num):
+        """解析单条日志记录"""
+        try:
+            # 跳过空行
+            if not log_line.strip():
+                return None
+
+            entry = {
+                "timestamp": self.extract_timestamp(log_line),
+                "level": self.extract_log_level(log_line),
+                "module": self.extract_module(log_line),
+                "message": self.extract_message(log_line),
+                "error_code": self.extract_error_code(log_line),
+                "parameters": self.extract_parameters(log_line),
+                "raw_line": log_line.strip(),
+                "line_number": line_num,
+            }
+            return entry
+        except Exception as e:
+            logging.error(f"⚠️  解析日志行 {line_num} 失败: {e}")
+            return None