Include skiplist file in the analysis info

The skiplist file is already included in the store ZIP,
but it is not currently stored in the database.
This patch introduces a new table called AnalysisInfoFile,
which is intended to store files related to analysis information.
The actual file contents are stored separately in the FileContent
table.
With this PR, only the skipfile is included as an analysis info
file, but this could be extended later.

Author: barnabasdomozi

web/server/codechecker_server/api/mass_store_run.py

@@ -15,11 +15,13 @@
 from collections import defaultdict
 from datetime import datetime, timedelta
 import fnmatch
+import hashlib
 from hashlib import sha256
 import json
 import os
 from pathlib import Path
 import sqlalchemy
+from sqlalchemy.orm import Session as SA_Session
 import tempfile
 import time
 from typing import Any, Callable, Dict, List, Optional, Set, Tuple, Union, \
@@ -46,7 +48,7 @@
 from ..database.config_db_model import Product
 from ..database.database import DBSession
 from ..database.run_db_model import \
-    AnalysisInfo, AnalysisInfoChecker, AnalyzerStatistic, \
+    AnalysisInfo, AnalysisInfoChecker, AnalysisInfoFile, AnalyzerStatistic, \
     BugPathEvent, BugReportPoint, \
     Checker, \
     ExtendedReportData, \
@@ -814,8 +816,8 @@ def __add_file_content(
         self,
         session: DBSession,
         source_file_name: str,
-        content_hash: Optional[str]
-    ):
+        content_hash: Optional[str] = None
+    ) -> str:
         """
         Add the necessary file contents. If content_hash in None then this
         function calculates the content hash. Or if it's available at the
@@ -871,6 +873,8 @@ def __add_file_content(
                 # the meantime.
                 session.rollback()
 
+        return content_hash
+
     def __store_checker_identifiers(self, checkers: Set[Tuple[str, str]]):
         """
         Stores the identifiers "(analyzer, checker_name)" in the database into
@@ -1000,6 +1004,28 @@ def __store_analysis_statistics(
 
             session.add(analyzer_statistics)
 
+    def __store_analysis_info_files(
+        self,
+        session: SA_Session,
+        analysis_info_id: int,
+        report_dir_path: str
+    ):
+        """ Store analyzer related config files (e.g. skipfile) """
+        zip_report_dir = os.path.join(
+            self._zip_dir, "reports",
+            hashlib.md5(report_dir_path.encode('utf-8')).hexdigest())
+
+        skip_file = os.path.join(zip_report_dir, 'skip_file')
+        if os.path.isfile(skip_file):
+            content_hash = self.__add_file_content(session, skip_file)
+
+            if (not session.get(AnalysisInfoFile,
+                                (analysis_info_id, content_hash))):
+                session.add(AnalysisInfoFile(
+                    analysis_info_id=analysis_info_id,
+                    filename="skip_file",
+                    content_hash=content_hash))
+
     def __store_analysis_info(
         self,
         session: DBSession,
@@ -1012,37 +1038,30 @@ def __store_analysis_info(
                     analyzer_command.encode("utf-8"),
                     zlib.Z_BEST_COMPRESSION)
 
-                analysis_info_rows = session \
-                    .query(AnalysisInfo) \
-                    .filter(AnalysisInfo.analyzer_command == cmd) \
-                    .all()
-
-                if analysis_info_rows:
-                    # It is possible when multiple runs are stored
-                    # simultaneously to the server with the same analysis
-                    # command that multiple entries are stored into the
-                    # database. In this case we will select the first one.
-                    analysis_info = analysis_info_rows[0]
-                else:
-                    analysis_info = AnalysisInfo(analyzer_command=cmd)
-
-                    # Obtain the ID eagerly to be able to use the M-to-N table.
-                    session.add(analysis_info)
-                    session.flush()
-                    session.refresh(analysis_info, ["id"])
-
-                    for analyzer in mip.analyzers:
-                        q = session \
-                            .query(Checker) \
-                            .filter(Checker.analyzer_name == analyzer)
-                        db_checkers = {r.checker_name: r for r in q.all()}
-
-                        connection_rows = [AnalysisInfoChecker(
-                            analysis_info, db_checkers[chk], is_enabled)
-                            for chk, is_enabled
-                            in mip.checkers.get(analyzer, {}).items()]
-                        for r in connection_rows:
-                            session.add(r)
+                analysis_info = AnalysisInfo(analyzer_command=cmd)
+
+                # Obtain the ID eagerly to be able to use the M-to-N table.
+                session.add(analysis_info)
+                session.flush()
+                session.refresh(analysis_info, ["id"])
+
+                for analyzer in mip.analyzers:
+                    q = session \
+                        .query(Checker) \
+                        .filter(Checker.analyzer_name == analyzer)
+                    db_checkers = {r.checker_name: r for r in q.all()}
+
+                    connection_rows = [AnalysisInfoChecker(
+                        analysis_info, db_checkers[chk], is_enabled)
+                        for chk, is_enabled
+                        in mip.checkers.get(analyzer, {}).items()]
+                    for r in connection_rows:
+                        session.add(r)
+
+                if mip.report_dir_path:
+                    self.__store_analysis_info_files(session,
+                                                     analysis_info.id,
+                                                     mip.report_dir_path)
 
                 run_history.analysis_info.append(analysis_info)
                 self.__analysis_info[src_dir_path] = analysis_info

web/server/codechecker_server/api/report_server.py

@@ -63,7 +63,8 @@
 from ..database.config_db_model import Product
 from ..database.database import conv, DBSession, escape_like
 from ..database.run_db_model import \
-    AnalysisInfo, AnalysisInfoChecker as DB_AnalysisInfoChecker, \
+    AnalysisInfo, \
+    AnalysisInfoChecker as DB_AnalysisInfoChecker, AnalysisInfoFile, \
     AnalyzerStatistic, \
     BugPathEvent, BugReportPoint, \
     CleanupPlan, CleanupPlanReportHash, Checker, Comment, \
@@ -1723,6 +1724,19 @@ def getAnalysisInfo(self, analysis_info_filter, limit, offset):
                         checkers[analyzer][checker] = API_AnalysisInfoChecker(
                             enabled=enabled)
 
+                    analysis_config_files = session \
+                        .query(AnalysisInfoFile.filename,
+                               FileContent.content) \
+                        .join(FileContent, AnalysisInfoFile.content_hash
+                              == FileContent.content_hash) \
+                        .filter(AnalysisInfoFile.analysis_info_id
+                                == cmd.id).all()
+
+                    # Append analysis files to the command string
+                    for filename, content in analysis_config_files:
+                        command += f"\n\n{filename}:\n"
+                        command += zlib.decompress(content).decode("utf-8")
+
                     res.append(ttypes.AnalysisInfo(
                         analyzerCommand=html.escape(command),
                         checkers=checkers))

web/server/codechecker_server/database/db_cleanup.py

@@ -13,6 +13,7 @@
 from typing import Dict
 
 import sqlalchemy
+from sqlalchemy import union
 
 from codechecker_api.codeCheckerDBAccess_v6.ttypes import Severity
 
@@ -21,7 +22,7 @@
 
 from .database import DBSession
 from .run_db_model import \
-    AnalysisInfo, \
+    AnalysisInfo, AnalysisInfoFile, \
     BugPathEvent, BugReportPoint, \
     Comment, Checker, \
     File, FileContent, \
@@ -108,8 +109,9 @@ def remove_unused_files(product):
             if total_count:
                 LOG.debug("%d dangling files deleted.", total_count)
 
-            files = session.query(File.content_hash) \
-                .group_by(File.content_hash)
+            files = union(
+                session.query(File.content_hash),
+                session.query(AnalysisInfoFile.content_hash))
 
             session.query(FileContent) \
                 .filter(FileContent.content_hash.notin_(files)) \

web/server/codechecker_server/database/run_db_model.py

@@ -79,12 +79,41 @@ def __init__(self,
         self.enabled = is_enabled
 
 
+class AnalysisInfoFile(Base):
+    __tablename__ = "analysis_info_files"
+
+    analysis_info_id = Column(Integer,
+                              ForeignKey("analysis_info.id",
+                                         deferrable=True,
+                                         initially="DEFERRED",
+                                         ondelete="CASCADE"),
+                              primary_key=True)
+
+    filename = Column(String, nullable=False)
+
+    content_hash = Column(String,
+                          ForeignKey("file_contents.content_hash",
+                                     deferrable=True,
+                                     initially="DEFERRED",
+                                     ondelete="CASCADE"),
+                          primary_key=True)
+
+    def __init__(self,
+                 analysis_info_id: int,
+                 filename: str,
+                 content_hash: str):
+        self.analysis_info_id = analysis_info_id
+        self.filename = filename
+        self.content_hash = content_hash
+
+
 class AnalysisInfo(Base):
     __tablename__ = "analysis_info"
 
     id = Column(Integer, autoincrement=True, primary_key=True)
     analyzer_command = Column(LargeBinary)
     available_checkers = relationship(AnalysisInfoChecker, uselist=True)
+    analyzer_files = relationship(AnalysisInfoFile, uselist=True)
 
     def __init__(self, analyzer_command: bytes):
         self.analyzer_command = analyzer_command

web/server/codechecker_server/metadata.py

@@ -66,6 +66,8 @@ def __init__(self, metadata_file_path):
         self.disabled_checkers: DisabledCheckers = set()
         self.checker_to_analyzer: CheckerToAnalyzer = {}
 
+        self.report_dir_path = None
+
         self.__metadata_dict: Dict[str, Any] = {}
         if os.path.isfile(metadata_file_path):
             self.__metadata_dict = cast(Dict[str, Any],
@@ -184,6 +186,9 @@ def __process_metadata_info_v2(self):
             if tool['name'] == 'codechecker' and 'version' in tool:
                 cc_versions.add(tool['version'])
 
+            if tool['name'] == 'codechecker':
+                self.report_dir_path = tool.get('output_path')
+
             if 'command' in tool:
                 check_commands.add(' '.join(tool['command']))
 

web/server/codechecker_server/migrations/report/versions/29e5047b6513_add_analysis_info_files_table.py

@@ -0,0 +1,51 @@
+"""
+Add analysis_info_files table
+
+Revision ID: 29e5047b6513
+Revises:     198654dac219
+Create Date: 2026-03-05 17:35:36.286847
+"""
+
+from logging import getLogger
+
+from alembic import op
+import sqlalchemy as sa
+
+
+# Revision identifiers, used by Alembic.
+revision = '29e5047b6513'
+down_revision = '198654dac219'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    LOG = getLogger("migration/report")
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.create_table(
+        'analysis_info_files',
+        sa.Column('analysis_info_id', sa.Integer(), nullable=False),
+        sa.Column('filename', sa.String(), nullable=False),
+        sa.Column('content_hash', sa.String(), nullable=False),
+        sa.ForeignKeyConstraint(
+            ['analysis_info_id'], ['analysis_info.id'],
+            name=op.f(
+                'fk_analysis_info_files_analysis_info_id_analysis_info'),
+            ondelete='CASCADE', initially='DEFERRED', deferrable=True),
+        sa.ForeignKeyConstraint(
+            ['content_hash'], ['file_contents.content_hash'],
+            name=op.f(
+                'fk_analysis_info_files_content_hash_file_contents'),
+            ondelete='CASCADE', initially='DEFERRED', deferrable=True),
+        sa.PrimaryKeyConstraint(
+            'analysis_info_id', 'content_hash',
+            name=op.f('pk_analysis_info_files'))
+    )
+    # ### end Alembic commands ###
+
+
+def downgrade():
+    LOG = getLogger("migration/report")
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_table('analysis_info_files')
+    # ### end Alembic commands ###

web/tests/functional/store/test_proj/divide_zero/skipfile

@@ -0,0 +1 @@
+-*.txt

web/tests/functional/store/test_store.py

@@ -264,6 +264,8 @@ def test_store_multiple_report_dirs(self):
         cfg['reportdir'] = report_dir1
         cfg['checkers'] = [
             '-d', 'core.DivideZero', '-e', 'deadcode.DeadStores']
+        cfg['skip_file'] = os.path.join(self._divide_zero_workspace,
+                                        'skipfile')
         codechecker.analyze(cfg, self._divide_zero_workspace)
 
         with open(os.path.join(report_dir1, 'metadata.json'), 'r+',
@@ -278,6 +280,7 @@ def test_store_multiple_report_dirs(self):
         cfg['reportdir'] = report_dir2
         cfg['checkers'] = [
             '-e', 'core.DivideZero', '-d', 'deadcode.DeadStores']
+        cfg.pop('skip_file')
         codechecker.analyze(cfg, self._divide_zero_workspace)
 
         def store_multiple_report_dirs(report_dirs):
@@ -323,12 +326,28 @@ def store_multiple_report_dirs(report_dirs):
             analysis_info_filter = AnalysisInfoFilter(runId=report['runId'])
             analysis_info = self._cc_client.getAnalysisInfo(
                 analysis_info_filter, limit, offset)
+
             self.assertEqual(len(analysis_info), 2)
             self.assertTrue(
                 any(report_dir1 in i.analyzerCommand for i in analysis_info))
             self.assertTrue(
                 any(report_dir2 in i.analyzerCommand for i in analysis_info))
 
+            # Skip file content
+            skip_file_info = "skip_file:\n-*.txt"
+
+            # During the analysis of report_dir1, we used a skipfile,
+            # and the skipfile content should appear in the analyzer command.
+            self.assertTrue(all(skip_file_info in
+                                i.analyzerCommand for i in analysis_info
+                                if report_dir1 in i.analyzerCommand))
+
+            # No skipfile was used during the analysis of report_dir2,
+            # so we shouldn't see skipfile content in this case.
+            self.assertFalse(any(skip_file_info in
+                                 i.analyzerCommand for i in analysis_info
+                                 if report_dir2 in i.analyzerCommand))
+
             self.assertTrue(all(
                 '<' not in i.analyzerCommand for i in analysis_info))
             self.assertTrue(any(