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

bmcgo/error_analyzer/unified_error_analyzer.py

@@ -0,0 +1,359 @@
+#!/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 os
+import glob
+import logging
+
+from .log_parser import LogParser
+from .case_matcher import CaseMatcher
+
+
+class UnifiedErrorAnalyzer:
+    """统一的错误分析器 - 结合命令失败和日志分析"""
+
+    def __init__(self, cases):
+        self.log_parser = LogParser()
+        self.case_matcher = CaseMatcher()
+        self.cases = cases
+
+    @staticmethod
+    def _find_log_files_in_directory(directory, recursive=True):
+        """
+        在目录中查找日志文件
+
+        Args:
+            directory: 目录路径
+            recursive: 是否递归查找子目录
+        """
+        log_files = []
+
+        if recursive:
+            # 递归查找所有 .log 文件
+            pattern = os.path.join(directory, "**", "*.log")
+            log_files = glob.glob(pattern, recursive=True)
+        else:
+            # 只查找当前目录下的 .log 文件
+            pattern = os.path.join(directory, "*.log")
+            log_files = glob.glob(pattern)
+
+        # 也可以查找其他常见的日志文件扩展名
+        additional_patterns = [
+            os.path.join(directory, "**", "*.log.*"),  # 滚动日志文件
+            os.path.join(directory, "**", "*.txt"),  # 文本日志文件
+            os.path.join(directory, "**", "*.err"),  # 错误日志文件
+        ]
+
+        for pattern in additional_patterns:
+            log_files.extend(glob.glob(pattern, recursive=True))
+
+        # 去重并返回
+        return list(set(log_files))
+
+    @staticmethod
+    def _extract_error_code_from_failure(failure):
+        """从失败信息中提取错误代码"""
+        error = failure.get("error", "")
+        error_type = failure.get("error_type", "")
+
+        # 根据错误类型和内容生成错误代码
+        if "TimeoutExpired" in error_type:
+            return "COMMAND_TIMEOUT"
+        elif "CalledProcessError" in error_type:
+            return "COMMAND_FAILED"
+        elif "FileNotFoundError" in error_type:
+            return "COMMAND_NOT_FOUND"
+        elif "PermissionError" in error_type:
+            return "PERMISSION_DENIED"
+        else:
+            return "COMMAND_ERROR"
+
+    @staticmethod
+    def _format_failure_log(failure):
+        """格式化失败日志"""
+        parts = []
+
+        if failure.get("command_key"):
+            parts.append(f"[{failure['command_key']}]")
+
+        parts.append(failure["command_str"])
+        parts.append("[FAILED]")
+
+        exec_time = failure.get("execution_time", 0)
+        parts.append(f"[{exec_time:.2f}s]")
+
+        if "error" in failure:
+            parts.append(f"[ERROR: {failure['error']}]")
+
+        return " ".join(parts)
+
+    @staticmethod
+    def _deduplicate_cases(cases):
+        """案例去重"""
+        seen_signatures = set()
+        unique_cases = []
+
+        for case in cases:
+            # 创建更严格的案例签名
+            title = case.get("title", "")
+
+            # 使用原始日志内容（去除ANSI颜色码）进行去重
+            raw_log = case["log_data"].get("raw_log", "")
+
+            # 去除ANSI颜色码
+            import re
+
+            ansi_escape = re.compile(r"\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])")
+            clean_log = ansi_escape.sub("", raw_log).strip()
+
+            # 创建基于标题和清理后日志内容的签名
+            signature = f"{title}_{hash(clean_log)}"
+
+            if signature not in seen_signatures:
+                seen_signatures.add(signature)
+                unique_cases.append(case)
+
+        return unique_cases
+
+    @staticmethod
+    def _output_unified_case(case, case_number):
+        """输出统一格式的案例"""
+        source = case["log_data"].get("source", "unknown")
+        if source == "log_file":
+            source_icon = "📁"
+            source_text = "日志文件"
+            file_path = case["log_data"].get("file_path", "unknown")
+            file_name = file_path
+        else:
+            source_icon = "🔧"
+            source_text = "命令执行"
+            file_name = None
+
+        logging.info(
+            f"{source_icon} 案例 {case_number}: {case.get('title', '未命名案例')}"
+        )
+        logging.info("─" * 50)
+
+        logging.info(f"   🕐 发生时间: {case['log_data']['timestamp']}")
+        logging.info(f"   📍 来源: {source_text}")
+
+        if file_name:
+            logging.info(f"   📄 文件: {file_path}")
+
+        logging.info(f"   📝 问题描述: {case.get('description', '')}")
+
+        if case.get("steps"):
+            logging.info("   👣 重现步骤:")
+            for j, step in enumerate(case.get("steps", []), 1):
+                logging.info(f"      {j}. {step}")
+
+        logging.info("   📄 相关输出:")
+        logging.info(f"      {case['log_data']['raw_log']}")
+
+        # 如果是命令失败案例，显示额外信息
+        if source == "command_failure" and "command_data" in case:
+            cmd_data = case["command_data"]
+            logging.info("   🔧 命令详情:")
+            logging.info(f"      命令: {cmd_data['command_str']}")
+            logging.info(f"      执行时间: {cmd_data['execution_time']:.2f}秒")
+            logging.info(f"      错误类型: {cmd_data.get('error_type', 'Unknown')}")
+
+        if case.get("solution"):
+            logging.info(f"   💡 解决方案: {case['solution']}")
+
+        logging.info("─" * 50)
+
+    def analyze_errors(self, log_sources, command_failures=None):
+        """
+        统一分析错误：支持多种日志源
+
+        Args:
+            log_sources: 可以是以下类型：
+                        - 单个文件路径 (str)
+                        - 文件路径列表 (list)
+                        - 文件夹路径 (str) - 会分析该文件夹下所有 .log 文件
+            command_failures: 命令失败信息列表
+        """
+        logging.info("\n" + "=" * 60)
+        logging.info("🔍 开始统一错误分析")
+        logging.info("=" * 60)
+
+        # 解析日志源
+        log_files = self._resolve_log_sources(log_sources)
+
+        if not log_files:
+            logging.warning("❌ 未找到任何日志文件")
+            return []
+
+        all_cases = []
+        all_log_entries = []
+
+        # 1. 分析所有日志文件
+        for log_file in log_files:
+            file_cases, file_entries = self._analyze_single_log_file(log_file)
+            all_cases.extend(file_cases)
+            all_log_entries.extend(file_entries)
+
+        # 2. 分析命令失败信息
+        if command_failures:
+            command_cases = self._analyze_command_failures(command_failures)
+            all_cases.extend(command_cases)
+
+        # 3. 合并和去重
+        unique_cases = self._deduplicate_cases(all_cases)
+
+        # 4. 输出分析结果
+        self._output_unified_analysis(
+            unique_cases, log_files, command_failures, all_log_entries
+        )
+
+        return unique_cases
+
+    def _resolve_log_sources(self, log_sources):
+        """
+        解析日志源，返回文件路径列表
+
+        Args:
+            log_sources: 单个文件路径、文件列表或文件夹路径
+        """
+        if isinstance(log_sources, str):
+            # 单个路径
+            if os.path.isfile(log_sources):
+                # 单个文件
+                return [log_sources]
+            elif os.path.isdir(log_sources):
+                # 文件夹 - 查找所有 .log 文件
+                return self._find_log_files_in_directory(log_sources)
+            else:
+                # 可能是通配符模式
+                return glob.glob(log_sources)
+
+        elif isinstance(log_sources, list):
+            # 文件列表
+            all_files = []
+            for source in log_sources:
+                if os.path.isfile(source):
+                    all_files.append(source)
+                elif os.path.isdir(source):
+                    all_files.extend(self._find_log_files_in_directory(source))
+                else:
+                    # 通配符模式
+                    all_files.extend(glob.glob(source))
+            return all_files
+
+        else:
+            return []
+
+    def _analyze_single_log_file(self, log_file_path):
+        """分析单个日志文件"""
+        try:
+            log_entries = self.log_parser.parse_logs(log_file_path)
+            cases = self.cases
+            matched_cases = self.case_matcher.match_cases(log_entries, cases)
+
+            # 标记来源文件
+            for case in matched_cases:
+                case["log_data"]["source"] = "log_file"
+                case["log_data"]["file_path"] = log_file_path
+
+            return matched_cases, log_entries
+
+        except Exception as e:
+            logging.error(f"  ❌ 分析文件失败 {log_file_path}: {e}")
+            return [], []
+
+    def _analyze_command_failures(self, command_failures):
+        """分析命令失败信息"""
+        cases = self.cases
+        matched_cases = []
+
+        for failure in command_failures:
+            # 将命令失败信息转换为日志格式进行分析
+            log_entry = self._convert_failure_to_log_entry(failure)
+
+            # 匹配案例
+            case = self.case_matcher.find_matching_case(log_entry, cases)
+            if case:
+                enriched_case = self.case_matcher.enrich_case_with_log(case, log_entry)
+                enriched_case["command_data"] = failure  # 保留原始命令数据
+                matched_cases.append(enriched_case)
+
+        return matched_cases
+
+    def _convert_failure_to_log_entry(self, failure):
+        """将命令失败信息转换为日志条目格式"""
+        return {
+            "timestamp": failure["timestamp"],
+            "level": "ERROR",
+            "module": "CommandExecutor",
+            "message": f"Command failed: {failure['command_str']} - {failure['error']}",
+            "error_code": self._extract_error_code_from_failure(failure),
+            "parameters": {
+                "command": failure["command_str"],
+                "execution_time": failure["execution_time"],
+                "error_type": failure["error_type"],
+            },
+            "raw_line": self._format_failure_log(failure),
+            "source": "command_failure",
+        }
+
+    def _load_cases(self):
+        """加载案例模板"""
+        import yaml
+
+        try:
+            with open(self.case_file_path, "r", encoding="utf-8") as f:
+                data = yaml.safe_load(f)
+                return data.get("cases", [])
+        except Exception as e:
+            logging.error(f"❌ 加载案例文件失败: {e}")
+            return []
+
+    def _output_unified_analysis(
+        self, cases, log_files, command_failures, all_log_entries
+    ):
+        """输出统一分析结果"""
+        if not cases:
+            logging.warning("\n✅ 没有发现匹配的错误案例")
+            return
+
+        # 统计信息
+        log_cases = [c for c in cases if c["log_data"].get("source") == "log_file"]
+        command_cases = [
+            c
+            for c in cases
+            if c["log_data"].get("source") == "command_failure"
+        ]
+
+        # 按文件统计
+        file_stats = {}
+        for case in log_cases:
+            file_path = case["log_data"].get("file_path", "unknown")
+            file_stats[file_path] = file_stats.get(file_path, 0) + 1
+
+        logging.info(f"   📊 统一分析完成!")
+        logging.info(f"   分析文件数量: {len(log_files)} 个")
+        logging.info(f"   日志条目总数: {len(all_log_entries)} 条")
+        logging.info(f"   日志文件案例: {len(log_cases)} 个")
+        logging.info(f"   命令失败案例: {len(command_cases)} 个")
+        logging.info(f"   总案例: {len(cases)} 个")
+
+        if command_failures:
+            logging.info(f"   分析的命令失败: {len(command_failures)} 个")
+
+        # 输出所有案例
+        logging.info("\n" + "=" * 60)
+        logging.info("📋 详细错误分析")
+        logging.info("=" * 60)
+
+        for i, case in enumerate(cases, 1):
+            self._output_unified_case(case, i)

bmcgo/error_cases/cases.yml

@@ -0,0 +1,59 @@
+# yaml-language-server: $schema=cases_template_valid.json
+version: 1.0.0
+cases:
+  bingo_case_001:
+    title: 构建运行内存不足
+    description: 构建运行内存不足
+    matching_rules:
+      - field: message
+        operator: regex
+        value: internal compiler error
+    solution: 构建运行内存不足，请检查宿主机资源状态
+  bingo_case_002:
+    title: conan仓中不存在指定版本的组件
+    description: conan仓中不存在指定版本的组件
+    matching_rules:
+      - field: message
+        operator: regex
+        value: was not found in remote .*
+    solution: conan仓中不存在指定版本的组件，请检查组件是否发布
+  bingo_case_003:
+    title: 未设置对应的conan远程仓
+    description: 未设置对应的conan远程仓
+    matching_rules:
+      - field: message
+        operator: regex
+        value: No remote .* defined in remote
+    solution: 未设置对应的conan远程仓，请参考conan remote add xxx进行设置
+  bingo_case_004:
+    title: 环境未初始化
+    description: 环境未初始化
+    matching_rules:
+      - field: message
+        operator: regex
+        value: CMAKE_C_COMPILER not set, after EnableLanguage
+    solution: 请在manifest目录下执行python3 init.py初始化环境
+  bingo_case_005:
+    title: 无法下载git源码
+    description: 无法下载git源码
+    matching_rules:
+      - field: message
+        operator: regex
+        value: Couldn't checkout .* git
+    solution: 请检查本机git令牌配置，确保存在源码所需令牌
+  bingo_case_006:
+    title: 当前环境缺少待签名的uboot文件
+    description: 当前环境缺少待签名的uboot文件
+    matching_rules:
+      - field: message
+        operator: regex
+        value: 执行失败，打开了自签名模式但未找到待签名的uboot文件，构建失败
+    solution: 下载官网bmc_sdk，替换本地~/sdk, 确保带时间戳结尾的文件存在
+  bingo_case_007:
+    title: Linux权限错误
+    description: Linux权限错误
+    matching_rules:
+      - field: message
+        operator: regex
+        value: permission denied
+    solution: 请检查对应出错的文件权限，并确认当前用户是否有该操作权限

bmcgo/error_cases/cases_template_valid.json

@@ -0,0 +1,71 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "Bingo Cases Schema",
+  "description": "Schema for validating bingo cases configuration",
+  "type": "object",
+  "required": ["version", "cases"],
+  "properties": {
+    "version": {
+      "type": "string",
+      "description": "版本号，必须符合三段式版本格式",
+      "pattern": "^\\d+\\.\\d+\\.\\d+$"
+    },
+    "cases": {
+      "type": "object",
+      "description": "案例集合",
+      "minProperties": 1,
+      "patternProperties": {
+        "^bingo_case_[0-9]{3,}$": {
+          "type": "object",
+          "required": ["title", "description", "matching_rules"],
+          "properties": {
+            "title": {
+              "type": "string",
+              "description": "案例标题",
+              "minLength": 1
+            },
+            "description": {
+              "type": "string",
+              "description": "案例描述",
+              "minLength": 1
+            },
+            "matching_rules": {
+              "type": "array",
+              "description": "匹配规则列表",
+              "minItems": 1,
+              "items": {
+                "type": "object",
+                "required": ["field", "operator", "value"],
+                "properties": {
+                  "field": {
+                    "type": "string",
+                    "description": "匹配字段",
+                    "enum": ["message"]
+                  },
+                  "operator": {
+                    "type": "string",
+                    "description": "匹配操作符",
+                    "enum": ["regex", "contains", "equals"]
+                  },
+                  "value": {
+                    "type": "string",
+                    "description": "匹配值",
+                    "minLength": 1
+                  }
+                },
+                "additionalProperties": false
+              }
+            },
+            "solution": {
+              "type": "string",
+              "description": "解决方案"
+            }
+          },
+          "additionalProperties": false
+        }
+      },
+      "additionalProperties": false
+    }
+  },
+  "additionalProperties": false
+}

bmcgo/error_cases/conanfile.py

@@ -0,0 +1,58 @@
+# Copyright (c) 2025 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
+import json
+import stat
+
+from conan import ConanFile
+from conan.tools.files import copy, load
+
+
+class BingoCasesConan(ConanFile):
+    name = "bingo_cases"
+    user = "openubmc"
+    channel = "stable"
+    settings = None
+    exports_sources = ["cases.yml", "cases_template_valid.json"]
+
+    def set_version(self):
+        import jsonschema
+
+        cases_data = self._load_cases_data()
+        # 验证cases模板
+        valid_content = load(self, "cases_template_valid.json")
+        valid_data = json.loads(valid_content)
+        jsonschema.validate(cases_data, valid_data)
+
+        self.version = cases_data["version"]
+
+    def build(self):
+        import yaml
+
+        cases_data = self._load_cases_data()
+        with os.fdopen(
+            os.open(
+                "cases.yml",
+                os.O_WRONLY | os.O_CREAT | os.O_TRUNC,
+                stat.S_IWUSR | stat.S_IRUSR,
+            ),
+            "w",
+        ) as file_handler:
+            yaml.dump(cases_data, file_handler, encoding="utf-8", allow_unicode=True)
+
+    def package(self):
+        copy(self, "cases.yml", self.build_folder, self.package_folder)
+
+    def _load_cases_data(self):
+        import yaml
+
+        # 从 case.yml 文件读取
+        cases_content = load(self, "cases.yml")
+        return yaml.safe_load(cases_content)

bmcgo/frame.py

@@ -45,7 +45,6 @@ class Frame(object):
         self.perf = PerfAnalysis(os.path.join(bconfig.manifest.folder, "output"))
         self.code_path = os.path.join(bconfig.manifest.folder, "build")
         sys.path.append(self.code_path)
-        os.makedirs(misc.CACHE_DIR, exist_ok=True)
         self.ws_server = None
         self.config = config
         self.config.log_init()
@@ -217,8 +216,5 @@ class Frame(object):
 
     def _prepare(self):
         tool.sudo_passwd_check()
-        shutil.rmtree(misc.CACHE_DIR)
-        os.makedirs(misc.CACHE_DIR)
-        os.chmod(misc.CACHE_DIR, 0o777)
         if shutil.which(misc.CONAN) is not None and misc.conan_v1():
             tool.run_command("conan remove --locks")

bmcgo/functional/analysis.py

@@ -12,7 +12,6 @@
 # See the Mulan PSL v2 for more details.
 import os
 import argparse
-from multiprocessing import Process
 import urllib3
 from bmcgo.frame import Frame
 from bmcgo.misc import CommandInfo
@@ -60,23 +59,30 @@ class BmcgoCommand:
         self.out_dir = pre_parsed_args.out_dir
         self.lock_file = pre_parsed_args.lock_file
         self.board_name = pre_parsed_args.board_name
+
+    def component_analysis(self):
+        if not InterfaceValidation(self.remote).run() or not SrValidate(os.getcwd()).run():
+            return -1
+        return 0
     
+    def product_analysis(self, custom_sr_dir):
+        analysis_task = AnalysisComp(self.board_name, self.out_dir, self.lock_file, custom_sr_dir)
+        result = analysis_task.run()
+        return result
+
     def run(self):
         is_integrated, work_dir = self._is_integrated_project()
         if is_integrated:
             os.chdir(work_dir)
         else:
             os.chdir(self.bconfig.component.folder)
-        # 组件级构建
+        # 组件级
         if not is_integrated:
-            if not InterfaceValidation(self.remote).run() or not SrValidate(os.getcwd()).run():
-                return -1
-            return 0
-        custom_sr_dir = None
-        # 非集成环境
-        if not is_integrated:
-            custom_sr_dir = os.getcwd()
-        elif self.rebuild:
+            return self.component_analysis()
+
+        # 产品级
+        custom_sr_dir = os.getcwd()
+        if self.rebuild:
             parsed = []
             if self.board_name:
                 parsed.append("-b")
@@ -85,9 +91,9 @@ class BmcgoCommand:
                 frame = Frame(self.bconfig, config)
                 frame.parse(parsed)
                 frame.run()
+
         os.chdir(os.path.join(work_dir, misc.BUILD))
-        analysis_task = AnalysisComp(self.board_name, self.out_dir, self.lock_file, custom_sr_dir)
-        rc = analysis_task.run()
+        rc = self.product_analysis(custom_sr_dir)
         if not rc:
             return -1
         log.success("BMC 构建分析成功")

bmcgo/functional/bmc_studio_action.py

@@ -34,16 +34,10 @@ def if_available(bconfig: BmcgoConfig):
     return True
 
 
-class BmcgoCommand(object):
+class BmcgoCommand():
     def __init__(self, bconfig: BmcgoConfig, *args):
         self.bconfig = bconfig
-        parser = argparse.ArgumentParser(prog="bmc studio", description="启动停止bmc studio", add_help=True,
-                                        formatter_class=argparse.RawTextHelpFormatter)
-        action_group = parser.add_mutually_exclusive_group()
-        action_group.add_argument("-start", action=ACTION_TRUE, help="bmc studio的启动操作")
-        action_group.add_argument("-stop", action=ACTION_TRUE, help="bmc studio的停止操作")
-        action_group.add_argument("-restart", action=ACTION_TRUE, help="bmc studio的重启操作")
-        parser.add_argument("-b", "--backend", help="指定bmc studio是前端运行还是后端运行，默认前端运行", action=ACTION_TRUE)
+        parser = self._create_parser()
         parsed_args, _ = parser.parse_known_args(*args)
         self.action = self.get_action(parsed_args)
         self.backend = parsed_args.backend
@@ -54,7 +48,8 @@ class BmcgoCommand(object):
             self.studio_script = f"{self.studio_path}/bmc_studio.sh"
             self.studio_command = f"{self.studio_script} {self.action}"
 
-    def get_action(self, parsed_args):
+    @staticmethod
+    def get_action(parsed_args):
         if parsed_args.stop:
             return "stop"
         elif parsed_args.restart:
@@ -84,7 +79,7 @@ class BmcgoCommand(object):
 
     def run_start(self):
         if not self.backend:
-            tools.run_command(self.studio_command, command_echo=False, show_log=True, timeout=None)
+            self._run_front_end()
             return
 
         self.studio_command = f"{self.studio_command} backend"
@@ -96,3 +91,19 @@ class BmcgoCommand(object):
             return
 
         log.warning(start_out)
+
+    def _run_front_end(self):
+        self.studio_command = f"trap ':' INT; /bin/bash {self.studio_command}; :"
+        command_list = ['/bin/bash', '-c', self.studio_command]
+        tools.run_command(command_list, command_echo=False, show_log=True, timeout=None)
+
+    def _create_parser(self):
+        _ = self
+        parser = argparse.ArgumentParser(prog="bmc studio", description="启动停止bmc studio", add_help=True,
+                                        formatter_class=argparse.RawTextHelpFormatter)
+        action_group = parser.add_mutually_exclusive_group()
+        action_group.add_argument("-start", action=ACTION_TRUE, help="bmc studio的启动操作")
+        action_group.add_argument("-stop", action=ACTION_TRUE, help="bmc studio的停止操作")
+        action_group.add_argument("-restart", action=ACTION_TRUE, help="bmc studio的重启操作")
+        parser.add_argument("-b", "--backend", help="指定bmc studio是前端运行还是后端运行，默认前端运行", action=ACTION_TRUE)
+        return parser