squad 1.92__tar.gz → 1.93.1__tar.gz

{squad-1.92 → squad-1.93.1}/CHANGELOG.md

@@ -1,3 +1,12 @@
+# 1.93.1
+
+This 1.93.1 release has minor bug fixes on log parser plugin and it silences a warning
+when receiving a job that already exist within a build.
+
+# 1.93
+
+This 1.93 release adds support for a build log parser as well as some other minor bug fixes and improvements.
+
 # 1.92
 
 This 1.92 release avoids an extra retry when fetching errored builds/tests in Tuxsuite.

{squad-1.92/squad.egg-info → squad-1.93.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: squad
-Version: 1.92
+Version: 1.93.1
 Summary: Software Quality Dashboard
 Home-page: https://github.com/Linaro/squad
 Author: Antonio Terceiro

{squad-1.92 → squad-1.93.1}/doc/intro.rst

@@ -232,7 +232,9 @@ strings. The following fields are recognized:
   test run
 * ``datetime``: timestamp of the test run, as a ISO-8601 date
   representation, with seconds. This is the representation that ``date
-  --iso-8601=seconds`` gives you.
+  --iso-8601=seconds`` gives you. If datetime is not supplied in the
+  metadata, the datetime of a test run will be set to the current
+  timestamp during creation.
 * ``job_id``: identifier for the test run. Must be unique for the
   project. **This field is mandatory**
 * ``job_status``: string identifying the status of the project. SQUAD

{squad-1.92 → squad-1.93.1}/squad/ci/backend/tuxsuite.py

@@ -10,6 +10,7 @@ from requests.adapters import HTTPAdapter, Retry
 from functools import reduce
 from urllib.parse import urljoin
 
+from cryptography.exceptions import InvalidSignature
 from cryptography.hazmat.primitives.asymmetric import ec
 from cryptography.hazmat.primitives import (
     hashes,
@@ -481,22 +482,18 @@ class Backend(BaseBackend):
         if public_key is None:
             raise Exception("missing tuxsuite public key for this project")
 
-        payload = json.loads(request.body)
         signature = base64.urlsafe_b64decode(signature)
         key = serialization.load_ssh_public_key(public_key.encode("ascii"))
-        key.verify(
-            signature,
-            payload.encode("utf-8"),
-            ec.ECDSA(hashes.SHA256()),
-        )
+        try:
+            key.verify(
+                signature,
+                request.body,
+                ec.ECDSA(hashes.SHA256()),
+            )
+        except InvalidSignature:
+            raise Exception("Failed to verify signature against payload")
 
     def process_callback(self, json_payload, build, environment, backend):
-        # The payload coming from Tuxsuite is formatted as bytes,
-        # so after the first json.loads(request.body), the result
-        # will still be a string containing the actual json document
-        # We need to call json.loads() once more to get the actual
-        # python dict containing all the information we need
-        json_payload = json.loads(json_payload)
         if "kind" not in json_payload or "status" not in json_payload:
             raise Exception("`kind` and `status` are required in the payload")
 

{squad-1.92 → squad-1.93.1}/squad/ci/models.py

@@ -138,10 +138,8 @@ class Backend(models.Model):
                 completed=completed,
             )
             test_job.testrun = testrun
-        except InvalidMetadata as exception:
+        except (DuplicatedTestJob, InvalidMetadata) as exception:
             test_job.failure = str(exception)
-        except DuplicatedTestJob as exception:
-            logger.error('Failed to fetch test_job(%d): "%s"' % (test_job.id, str(exception)))
 
         if test_job.needs_postprocessing():
             # Offload postprocessing plugins to a new task

squad-1.93.1/squad/core/management/commands/run_log_parser.py

@@ -0,0 +1,44 @@
+from django.core.management.base import BaseCommand
+
+from squad.plugins.linux_log_parser import Plugin as BootTestLogParser
+from squad.plugins.linux_log_parser_build import Plugin as BuildLogParser
+
+
+class FakeTestRun:
+    log_file = None
+    id = None
+
+
+log_parsers = {
+    'linux_log_parser_boot_test': BootTestLogParser(),
+    "linux_log_parser_build": BuildLogParser(),
+}
+
+
+class Command(BaseCommand):
+
+    help = """Run a log parser and print the outputs to the stdout."""
+
+    def add_arguments(self, parser):
+
+        parser.add_argument(
+            "LOG_FILE",
+            help="Log file to parser",
+        )
+
+        parser.add_argument(
+            "LOG_PARSER",
+            choices=log_parsers.keys(),
+            help="Which log parser to run"
+        )
+
+    def handle(self, *args, **options):
+        self.options = options
+
+        with open(options["LOG_FILE"], "r") as f:
+            log_file = f.read()
+
+        testrun = FakeTestRun()
+        testrun.log_file = log_file
+        parser = log_parsers[options["LOG_PARSER"]]
+        parser.postprocess_testrun(testrun, squad=False, print=True)

{squad-1.92 → squad-1.93.1}/squad/core/models.py

@@ -493,6 +493,9 @@ class Build(models.Model):
         ordering = ['datetime']
 
     def save(self, *args, **kwargs):
+        # Initialize this to timezone.now(), then if a testrun is seen with an
+        # earlier datetime, keep this value up to date with the earliest
+        # testrun.datetime (handled in ReceiveTestRun.__call__).
         if not self.datetime:
             self.datetime = timezone.now()
         with transaction.atomic():
@@ -577,12 +580,17 @@ class Build(models.Model):
         List of attachments from all testruns
         """
         if self.__attachments__ is None:
+            test_run_ids = self.test_runs.values_list('id', flat=True)
+            all_attachments = Attachment.objects.filter(test_run_id__in=test_run_ids).values(
+                'test_run_id', 'filename'
+            )
+
             attachments = {}
-            for test_run in self.test_runs.all():
-                attachments[test_run.pk] = []
-                for attachment in test_run.attachments.all():
-                    attachments[test_run.pk].append(attachment.filename)
+            for attachment in all_attachments:
+                attachments.setdefault(attachment['test_run_id'], []).append(attachment['filename'])
+
             self.__attachments__ = attachments
+
         return self.__attachments__
 
     @property
@@ -801,6 +809,9 @@ class TestRun(models.Model):
         unique_together = ('build', 'job_id')
 
     def save(self, *args, **kwargs):
+        # testrun.datetime will take datetime from the metadata if it exists
+        # (during ReceiveTestRun.__call__). If datetime is not in the metadata,
+        # set it to timezone.now()
         if not self.datetime:
             self.datetime = timezone.now()
         if self.__metadata__:

{squad-1.92 → squad-1.93.1}/squad/core/tasks/__init__.py

@@ -178,6 +178,8 @@ class ReceiveTestRun(object):
 
         testrun.refresh_from_db()
 
+        # This keeps the datetime of the build in line with the earliest
+        # observed testrun.datetime.
         if not build.datetime or testrun.datetime < build.datetime:
             build.datetime = testrun.datetime
             build.save()

squad-1.93.1/squad/plugins/lib/base_log_parser.py

@@ -0,0 +1,233 @@
+import hashlib
+import re
+from collections import defaultdict
+
+from django.template.defaultfilters import slugify
+
+REGEX_NAME = 0
+REGEX_BODY = 1
+REGEX_EXTRACT_NAME = 2
+
+tstamp = r"\[[ \d]+\.[ \d]+\]"
+pid = r"(?:\s*?\[\s*?[CT]\d+\s*?\])"
+not_newline_or_plus = r"[^\+\n]"
+square_brackets_and_contents = r"\[[^\]]+\]"
+
+
+class BaseLogParser:
+    def compile_regexes(self, regexes):
+        with_brackets = [r"(%s)" % r[REGEX_BODY] for r in regexes]
+        combined = r"|".join(with_brackets)
+
+        # In the case where there is only one regex, we need to add extra
+        # bracket around it for it to behave the same as the multiple regex
+        # case
+        if len(regexes) == 1:
+            combined = f"({combined})"
+
+        return re.compile(combined, re.S | re.M)
+
+    def remove_numbers_and_time(self, snippet):
+        # [   92.236941] CPU: 1 PID: 191 Comm: kunit_try_catch Tainted: G        W         5.15.75-rc1 #1
+        # <4>[   87.925462] CPU: 0 PID: 135 Comm: (crub_all) Not tainted 6.7.0-next-20240111 #14
+        # Remove '(Not t|T)ainted', to the end of the line.
+        without_tainted = re.sub(r"(Not t|T)ainted.*", "", snippet)
+
+        # x23: ffff9b7275bc6f90 x22: ffff9b7275bcfb50 x21: fff00000cc80ef88
+        # x20: 1ffff00010668fb8 x19: ffff8000800879f0 x18: 00000000805c0b5c
+        # Remove words with hex numbers.
+        # <3>[    2.491276][    T1] BUG: KCSAN: data-race in console_emit_next_record / console_trylock_spinning
+        # -> <>[    .][    T1] BUG: KCSAN: data-race in console_emit_next_record / console_trylock_spinning
+        without_hex = re.sub(r"\b(?:0x)?[a-fA-F0-9]+\b", "", without_tainted)
+
+        # <>[ 1067.461794][  T132] BUG: KCSAN: data-race in do_page_fault spectre_v4_enable_task_mitigation
+        # -> <>[ .][  T132] BUG: KCSAN: data-race in do_page_fault spectre_v_enable_task_mitigation
+        # But should not remove numbers from functions.
+        without_numbers = re.sub(
+            r"(0x[a-f0-9]+|[<\[][0-9a-f]+?[>\]]|\b\d+\b(?!\s*\())", "", without_hex
+        )
+
+        # <>[ .][  T132] BUG: KCSAN: data-race in do_page_fault spectre_v_enable_task_mitigation
+        # ->  BUG: KCSAN: data-race in do_page_fault spectre_v_enable_task_mitigation
+        without_time = re.sub(
+            f"^<?>?{square_brackets_and_contents}({square_brackets_and_contents})?",
+            "",
+            without_numbers,
+        )  # noqa
+
+        return without_time
+
+    def create_name(self, snippet, compiled_regex=None):
+        matches = None
+        if compiled_regex:
+            matches = compiled_regex.findall(snippet)
+        if not matches:
+            # Only extract a name if we provide a regex to extract the name and
+            # there is a match
+            return None
+        snippet = matches[0]
+        without_numbers_and_time = self.remove_numbers_and_time(snippet)
+
+        return slugify(without_numbers_and_time)
+
+    def create_shasum(self, snippet):
+        sha = hashlib.sha256()
+        without_numbers_and_time = self.remove_numbers_and_time(snippet)
+        sha.update(without_numbers_and_time.encode())
+        return sha.hexdigest()
+
+    def create_name_log_dict(self, test_name, lines, test_regex=None, create_shas=True):
+        """
+        Produce a dictionary with the test names as keys and the extracted logs
+        for that test name as values. There will be at least one test name per
+        regex. If there were any matches for a given regex, then a new test
+        will be generated using test_name + shasum.
+        """
+        # Run the REGEX_EXTRACT_NAME regex over the log lines to sort them by
+        # extracted name. If no name is extracted or the log parser did not
+        # have any output for a particular regex, just use the default name
+        # (for example "check-kernel-oops").
+        tests_without_shas_to_create = defaultdict(set)
+        tests_with_shas_to_create = None
+
+        # If there are lines, then create the tests for these.
+        for line in lines:
+            extracted_name = self.create_name(line, test_regex)
+            if extracted_name:
+                max_name_length = 256
+                # If adding SHAs, limit the name length to 191 characters,
+                # since the max name length for SuiteMetadata in SQUAD is 256
+                # characters. The SHA and "-" take 65 characters: 256-65=191
+                if create_shas:
+                    max_name_length -= 65
+                extended_test_name = f"{test_name}-{extracted_name}"[:max_name_length]
+            else:
+                extended_test_name = test_name
+            tests_without_shas_to_create[extended_test_name].add(line)
+
+        if create_shas:
+            tests_with_shas_to_create = defaultdict(set)
+            for name, test_lines in tests_without_shas_to_create.items():
+                # Some lines of the matched regex might be the same, and we don't want to create
+                # multiple tests like test1-sha1, test1-sha1, etc, so we'll create a set of sha1sums
+                # then create only new tests for unique sha's
+
+                for line in test_lines:
+                    sha = self.create_shasum(line)
+                    name_with_sha = f"{name}-{sha}"
+                    tests_with_shas_to_create[name_with_sha].add(line)
+
+        return tests_without_shas_to_create, tests_with_shas_to_create
+
+    def create_squad_tests_from_name_log_dict(
+        self,
+        suite_name,
+        testrun,
+        tests_without_shas_to_create,
+        tests_with_shas_to_create=None,
+    ):
+        # Import SuiteMetadata from SQUAD only when required so BaseLogParser
+        # does not require a SQUAD to work. This makes it easier to reuse this
+        # class outside of SQUAD for testing and developing log parser
+        # patterns.
+        from squad.core.models import SuiteMetadata
+
+        suite, _ = testrun.build.project.suites.get_or_create(slug=suite_name)
+
+        for name, lines in tests_without_shas_to_create.items():
+            metadata, _ = SuiteMetadata.objects.get_or_create(
+                suite=suite.slug, name=name, kind="test"
+            )
+            testrun.tests.create(
+                suite=suite,
+                result=(len(lines) == 0),
+                log="\n".join(lines),
+                metadata=metadata,
+                build=testrun.build,
+                environment=testrun.environment,
+            )
+        if tests_with_shas_to_create:
+            for name_with_sha, lines in tests_with_shas_to_create.items():
+                metadata, _ = SuiteMetadata.objects.get_or_create(
+                    suite=suite.slug, name=name_with_sha, kind="test"
+                )
+                testrun.tests.create(
+                    suite=suite,
+                    result=False,
+                    log="\n---\n".join(lines),
+                    metadata=metadata,
+                    build=testrun.build,
+                    environment=testrun.environment,
+                )
+
+    def print_squad_tests_from_name_log_dict(
+        self,
+        suite_name,
+        tests_without_shas_to_create,
+        tests_with_shas_to_create=None,
+    ):
+        for name, lines in tests_without_shas_to_create.items():
+            print(f"\nName: {suite_name}/{name}")
+            log = "\n".join(lines)
+            print(f"Log:\n{log}")
+
+        if tests_with_shas_to_create:
+            for name_with_sha, lines in tests_with_shas_to_create.items():
+                print(f"\nName: {suite_name}/{name_with_sha}")
+                log = "\n---\n".join(lines)
+                print(f"Log:\n{log}")
+
+    def create_squad_tests(
+        self,
+        testrun,
+        suite_name,
+        test_name,
+        lines,
+        test_regex=None,
+        create_shas=True,
+        print=False,
+        squad=True,
+    ):
+        """
+        There will be at least one test per regex. If there were any match for
+        a given regex, then a new test will be generated using test_name +
+        shasum. This helps comparing kernel logs across different builds
+        """
+
+        tests_without_shas_to_create, tests_with_shas_to_create = (
+            self.create_name_log_dict(
+                test_name, lines, test_regex, create_shas=create_shas
+            )
+        )
+        if print:
+            self.print_squad_tests_from_name_log_dict(
+                suite_name,
+                tests_without_shas_to_create,
+                tests_with_shas_to_create,
+            )
+        if squad:
+            self.create_squad_tests_from_name_log_dict(
+                suite_name,
+                testrun,
+                tests_without_shas_to_create,
+                tests_with_shas_to_create,
+            )
+
+    def join_matches(self, matches, regexes):
+        """
+        group regex in python are returned as a list of tuples which each
+        group match in one of the positions in the tuple. Example:
+        regex = r'(a)|(b)|(c)'
+        matches = [
+            ('match a', '', ''),
+            ('', 'match b', ''),
+            ('match a', '', ''),
+            ('', '', 'match c')
+        ]
+        """
+        snippets = {regex_id: [] for regex_id in range(len(regexes))}
+        for match in matches:
+            for regex_id in range(len(regexes)):
+                if len(match[regex_id]) > 0:
+                    snippets[regex_id].append(match[regex_id])
+        return snippets

{squad-1.92 → squad-1.93.1}/squad/plugins/linux_log_parser.py

@@ -44,8 +44,9 @@ class Plugin(BasePlugin, BaseLogParser):
         kernel_msgs = re.findall(f'({tstamp}{pid}? .*?)$', log, re.S | re.M) # noqa
         return '\n'.join(kernel_msgs)
 
-    def postprocess_testrun(self, testrun):
-        if testrun.log_file is None:
+    def postprocess_testrun(self, testrun, squad=True, print=False):
+        # If running as a SQUAD plugin, only run the boot/test log parser if this is not a build testrun
+        if testrun.log_file is None or (squad and testrun.tests.filter(suite__slug="build").exists()):
             return
 
         boot_log, test_log = self.__cutoff_boot_log(testrun.log_file)
@@ -56,7 +57,7 @@ class Plugin(BasePlugin, BaseLogParser):
 
         for log_type, log in logs.items():
             log = self.__kernel_msgs_only(log)
-            suite, _ = testrun.build.project.suites.get_or_create(slug=f'log-parser-{log_type}')
+            suite_name = f'log-parser-{log_type}'
 
             regex = self.compile_regexes(REGEXES)
             matches = regex.findall(log)
@@ -68,4 +69,4 @@ class Plugin(BasePlugin, BaseLogParser):
                 test_name_regex = None
                 if regex_pattern:
                     test_name_regex = re.compile(regex_pattern, re.S | re.M)
-                self.create_squad_tests(testrun, suite, test_name, snippets[regex_id], test_name_regex)
+                self.create_squad_tests(testrun, suite_name, test_name, snippets[regex_id], test_name_regex, squad=squad, print=print)