squidient 3.0.2__tar.gz → 3.0.4__tar.gz

{squidient-3.0.2 → squidient-3.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: squidient
-Version: 3.0.2
+Version: 3.0.4
 Summary: CI/CD framework for alya
 Project-URL: Homepage, https://alya.gitlab.bsc.es/alya/ci-cd/squidient
 Project-URL: Bug Tracker, https://alya.gitlab.bsc.es/alya/ci-cd/squidient/issues

{squidient-3.0.2 → squidient-3.0.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "squidient"
-version = "3.0.2"
+version = "3.0.4"
 authors = [
   { name="Damien Dosimont", email="damien.dosimont@gmail.com" },
 ]

{squidient-3.0.2 → squidient-3.0.4}/src/squidient/builds/build_definition.py

@@ -46,7 +46,6 @@ class BuildDefinition:
         self._file = ""
         self._job_config = ""
         self._platform = ""
-        self._lock = ""
         self._runnable = ""
         self._timeout = ""
         self._timeoffset = ""
@@ -119,8 +118,6 @@ class BuildDefinition:
             self._system = build["system"]
         if self._platform == "" and "platform" in build:
             self._platform = build["platform"]
-        if self._lock == "" and "lock" in build:
-            self._lock = build["lock"]
         if self._runnable == "" and "runnable" in build:
             self._runnable = build["runnable"]
         if self._threads == "" and "threads" in build:

{squidient-3.0.2 → squidient-3.0.4}/src/squidient/builds/build_execution.py

@@ -286,9 +286,14 @@ class BuildExecution(BuildDefinition):
         self._ssh.scp_send(system=self._system, local=self._report_dir + "/*", remote=self._build_path + "/", server_path=True, critical=True)
 
     def launch_job(self):
-        self._job_id = self._job_manager.launch_job(internal_job_id=self._build_id, path=self._build_path + "/JOB.SB",
-                                             system=self._system, platform=self._platform,
-                                             server_path=True, key_lock=self._lock, max_jobs=self._max_jobs)
+        self._job_id = self._job_manager.launch_job(
+            internal_job_id=self._build_id,
+            path=self._build_path + "/JOB.SB",
+            system=self._system,
+            platform=self._platform,
+            server_path=True,
+            max_jobs=self._max_jobs,
+        )
         return self._job_id
 
     def get_job_id(self):

{squidient-3.0.2 → squidient-3.0.4}/src/squidient/builds/build_orchestrator.py

@@ -51,7 +51,6 @@ class BuildOrchestrator:
         self._pending_builds = {}
         self._consumed_builds = {}
         self._unlaunched_builds = {}
-        self._platform_ready = {}
         self._ssh = ssh
         self._job_manager = job
         self._password = password

{squidient-3.0.2 → squidient-3.0.4}/src/squidient/cli/staging.py

@@ -42,7 +42,7 @@ class IgnoredInterrupts(object):
         for sig in [signal.SIGINT, signal.SIGTERM]:
             self._old_handlers[sig] = signal.signal(sig, self.handler)
 
-    def handler(self, sig, frame):
+    def handler(self, sig, _frame):
         logging.debug('Interrupt signal received. Delaying KeyboardInterrupt.')
 
     def __exit__(self, type, value, traceback):

{squidient-3.0.2 → squidient-3.0.4}/src/squidient/code_coverage/gcovr_code_coverage.py

@@ -33,7 +33,7 @@ def read_base_xml(filename):
     return cobertura
 
 
-def create_package_file(cobertura, package, destination_path):
+def create_package_file(cobertura, package):
     filename = "cobertura-{}.xml".format(package.attrib['name'])
     console.step("Creating package file {}".format(filename))
     xml_to_write = copy.deepcopy(cobertura)
@@ -132,5 +132,5 @@ class GcovrCodeCoverage(CodeCoverage):
         current_dir = os.getcwd()
         os.chdir(xml_report_dir)
         for package in cobertura_xml.find('packages'):
-            create_package_file(cobertura_xml, package, xml_report_dir)
+            create_package_file(cobertura_xml, package)
         os.chdir(current_dir)

{squidient-3.0.2 → squidient-3.0.4}/src/squidient/connection/job.py

@@ -25,7 +25,6 @@ import re
 import threading
 import time
 
-from ..connection.build_lock import BuildLock
 from ..definitions import actualize_time, check_jobs_every_normal, max_jobs_staging
 from ..utils.log import logger
 from ..utils.message import console
@@ -127,7 +126,6 @@ class Job:
         self._run_id = run_id
         self._ssh = ssh
         self._time = -1
-        self._build_lock = BuildLock()
         self._jobs = {}
         self._jobs_not_actualized = {}
         self._jobs_launched = {}
@@ -154,16 +152,7 @@ class Job:
         shutil.rmtree("squeue", ignore_errors=True)
         os.makedirs("squeue", exist_ok=True)
 
-    def launch_job(self, internal_job_id, path, system, platform, server_path=False, key_lock="", asynchronous=False, max_jobs=max_jobs_staging):
-        dep = ""
-        if key_lock != "":
-            if asynchronous:
-                console.section("Job submission")
-                console.error("You cannot launch an asynchronous job with a dependency", level=1)
-                raise RuntimeError
-            lock_id = self._build_lock.get_lock(key_lock)
-            if lock_id != -1:
-                dep = "--dependency=afterany:" + str(lock_id) + " "
+    def launch_job(self, internal_job_id, path, system, platform, server_path=False, asynchronous=False, max_jobs=max_jobs_staging):
         if platform not in self._job_threads[system]:
             self._input_queues[system][platform] = queue.Queue()
             self._output_queues[system][platform] = queue.Queue()
@@ -187,7 +176,7 @@ class Job:
         job = {}
         job["id"] = internal_job_id
         job["launched"] = False
-        job["command"] = "sbatch " + dep + path
+        job["command"] = "sbatch " + path
         job["server_path"] = server_path
         self._input_queues[system][platform].put(job)
         self._jobs_not_launched[system][platform][internal_job_id] = job
@@ -195,8 +184,6 @@ class Job:
             while not self.is_launched(system, platform, internal_job_id):
                 time.sleep(1)
             job_id = self.get_job_id(system, platform, internal_job_id)
-            if key_lock != "":
-                self._build_lock.set_lock(key_lock, job_id)
             return job_id
         else:
             return -1

{squidient-3.0.2 → squidient-3.0.4}/src/squidient/definitions.py

@@ -22,7 +22,6 @@ test_default_timeout = "00:01:00"
 test_max_timeout = "00:05:00"
 merged_max_timeout = "02:00:00"
 queue_max_timeout = "02:00:00"
-max_waiting_time = 2  # 2 hours
 queue_test_sleep_before_get_launch_time = 30  # seconds
 test_max_retry = 3
 report_dir = "reports"
@@ -36,13 +35,10 @@ queue_report_dir = report_dir + "/queues"
 terraform_dir = "terraform"
 mpio2txt_bin = "mpio2txt"
 actualize_time = 60
-enable_svn = False
 max_async_threads = 8
 max_jobs_staging = 100
 max_jobs_monitoring = 50
-max_jobs_debug = 10
 check_jobs_every_normal = 30
-check_jobs_every_debug = 10
 config_file = "configuration.json"
 build_file = "builds/builds.json"
 default_file = "builds/defaults.json"
@@ -70,6 +66,7 @@ max_advised_builds = 2
 database_name = {"test": "rooster_test", "production": "rooster"}
 benchmark_failure_sender = "damien.dosimont@bsc.es"
 benchmark_failure_copy = ["damien.dosimont@bsc.es"]
+benchmark_notification_failure_log = "log/benchmark_notification_failures.log"
 benchmark_failure_log_files = [
     "sbatch.out",
     "sbatch.err",

{squidient-3.0.2 → squidient-3.0.4}/src/squidient/monitoring/monitoring.py

@@ -19,10 +19,11 @@
 
 
 import logging
+import os
 
 from ..builds.benchmark_build_execution import BenchmarkBuildExecution
 from ..builds.benchmark_build_orchestrator import BenchmarkBuildOrchestrator
-from ..definitions import benchmark_build_report_dir
+from ..definitions import benchmark_build_report_dir, benchmark_notification_failure_log
 from ..reports.monitoring import MonitoringReport
 from ..staging.staging import Staging, WorkflowFailure
 from ..testing.benchmarks.test_orchestrator import BenchmarkTestOrchestrator
@@ -122,6 +123,7 @@ class Monitoring(Staging):
             return
         failures = self._test_orchestrator.get_notification_failures()
         if len(failures) > 0:
+            self.write_notification_failure_log(failures)
             self._report.write_notification_failures(failures)
 
     def validate(self):
@@ -130,12 +132,27 @@ class Monitoring(Staging):
             failures = self._report.get_notification_failures()
         if len(failures) > 0:
             console.section("Notification failures")
+            self.write_notification_failure_log(failures)
         for failure in failures:
-            console.error(failure.get("message", str(failure)), level=1)
+            message = failure.get("message", str(failure))
+            log_path = failure.get("log", benchmark_notification_failure_log)
+            console.error(message + "\nDetails written to " + log_path, level=1)
         if len(failures) > 0:
             raise WorkflowFailure("Benchmark notification email could not be sent")
         super().validate()
 
+    def write_notification_failure_log(self, failures):
+        log_dir = os.path.dirname(benchmark_notification_failure_log)
+        if log_dir != "":
+            os.makedirs(log_dir, exist_ok=True)
+        with open(benchmark_notification_failure_log, "w", encoding="utf-8") as log:
+            for index, failure in enumerate(failures, start=1):
+                failure["log"] = benchmark_notification_failure_log
+                log.write("Notification failure " + str(index) + "\n")
+                log.write("=" * 80 + "\n")
+                log.write(failure.get("details", failure.get("message", str(failure))))
+                log.write("\n\n")
+
     def build(self, terraform):
         with self.timer("monitoring.build"):
             self._monitoring_db = MonitoringDB(self._config, enable=False)

{squidient-3.0.2 → squidient-3.0.4}/src/squidient/reports/cases/base.py

@@ -25,7 +25,6 @@ class BaseCaseReport:
     # _____________________________________
     def __init__(self, case):
 
-        self._case = case
         self._file = case + ".json"
 
         self._json = None

{squidient-3.0.2 → squidient-3.0.4}/src/squidient/staging/staging.py

@@ -72,7 +72,6 @@ class Staging:
         self._arguments = arguments
         self._test_list = arguments.get_test_list()
         self._test_directories = arguments.get_test_directories()
-        self._generic_arguments = arguments.get_generic_arg()
         self._gitlab = arguments.get_gitlab()
         self._config = open_critical_json(config_file)
         self._benchmarks = open_critical_json(benchmark_file)

{squidient-3.0.2 → squidient-3.0.4}/src/squidient/systems/platform.py

@@ -59,7 +59,6 @@ class Platform(System):
         self._platform_type = architecture["type"]
 
         self._gpus_per_node = 0
-        self._gpu_sbatch = {}
         if "gpu" in architecture:
             self._gpu = architecture["gpu"]
             if "gpus_per_node" in self._gpu:

{squidient-3.0.2 → squidient-3.0.4}/src/squidient/testing/benchmarks/failure_notifier.py

@@ -39,12 +39,12 @@ class BenchmarkFailureNotificationError(Exception):
             "Benchmark failure email could not be sent.\n"
             "Recipients: " + ", ".join(self.recipients) + "\n"
             "Subject: " + self.subject + "\n"
-            "Transport error: " + self.error + "\n"
-            "\n"
-            "Mail body:\n"
-            + self.body
+            "Transport error: " + self.error
         )
 
+    def details(self):
+        return self.message() + "\n\nMail body:\n" + self.body
+
     def as_dict(self):
         return {
             "recipients": self.recipients,
@@ -52,6 +52,7 @@ class BenchmarkFailureNotificationError(Exception):
             "body": self.body,
             "error": self.error,
             "message": self.message(),
+            "details": self.details(),
         }
 
 
@@ -140,7 +141,11 @@ class BenchmarkFailureNotifier:
         message.set_content(body)
         sendmail = shutil.which("sendmail")
         if sendmail is not None:
-            subprocess.run([sendmail, "-t"], input=message.as_string(), text=True, check=True)
+            command = [sendmail]
+            if self._from_address is not None:
+                command.extend(["-f", self._from_address])
+            command.append("-t")
+            subprocess.run(command, input=message.as_string(), text=True, check=True)
             return
         with smtplib.SMTP("localhost") as smtp:
             smtp.send_message(message)

{squidient-3.0.2 → squidient-3.0.4}/src/squidient/testing/cases/instance_merger.py

@@ -57,7 +57,6 @@ class InstanceMerger:
         self._job_launched = False
         self._job_id = 0
         self._job_submission = {}
-        self._waiting_job_id = False
         self._exec_modules = []
 
         self._queue = ""
@@ -102,8 +101,6 @@ class InstanceMerger:
         self.generate_job()
 
     def generate_job(self):
-        gpu = False
-        gpus = 0
         tasks = 0
         self.set_queue()
         spath = self._server_path + "/"

{squidient-3.0.2 → squidient-3.0.4}/src/squidient/testing/test_orchestrator.py

@@ -33,8 +33,6 @@ from ..utils.message import LiveOutput, console, jump
 from ..utils.utils import json2js, open_json, save_json
 from .cases.test_case import TestCase
 
-alya_tests = "alya/tests"
-
 
 class TestOrchestrator:
 

{squidient-3.0.2 → squidient-3.0.4}/src/squidient/utils/watchdog.py

@@ -33,7 +33,6 @@ class Watchdog(threading.Thread):
     def __init__(self, ts_pid, tokens, pipelines, api):
         threading.Thread.__init__(self)
         self._ts_pid = ts_pid
-        self._thread_id = 1
         self.name = "watchdog"
         self._pipeline_list = pipelines
         self._pipelines = {}

squidient-3.0.2/src/squidient/connection/build_lock.py

@@ -1,32 +0,0 @@
-#########################################################################
-#                                                                       #
-#  This file is part of squidient.                                      #
-#                                                                       #
-#  squidient is free software: you can redistribute it and/or modify    #
-#  it under the terms of the GNU General Public License as published by #
-#  the Free Software Foundation, either version 3 of the License, or    #
-#  (at your option) any later version.                                  #
-#                                                                       #
-#  squidient is distributed in the hope that it will be useful,         #
-#  but WITHOUT ANY WARRANTY; without even the implied warranty of       #
-#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the        # 
-#  GNU General Public License for more details.                         #
-#                                                                       #
-#  You should have received a copy of the GNU General Public License    #
-#  along with squidient. If not, see <https://www.gnu.org/licenses/>.   #
-#                                                                       #
-#########################################################################
-
-class BuildLock:
-
-    def __init__(self):
-        self._locks = {}
-
-    def get_lock(self, key):
-        if key in self._locks:
-            return self._locks[key]
-        else:
-            return -1
-
-    def set_lock(self, key, value):
-        self._locks[key] = value