Merge branch 'master' into bugfix/parameterize-equals

Author: vkarak

reframe/core/logging.py

@@ -971,6 +971,19 @@ def adjust_verbosity(self, num_steps):
 
             h.setLevel(new_level)
 
+    def set_handler_level(self, level, filter=None):
+        '''Set handler level for handlers attached to this logger.
+
+        :arg level: The new level.
+        :arg filter: A callable accepting a single argument, which is the
+            handler type as declared in ReFrame's configuration. If the filter
+            is :obj:`None` then the level applies to all handlers, otherwise
+            it will apply to all handlers that the filter return :obj:`True`.
+        '''
+        for h in self.logger.handlers:
+            if filter is None or filter(h._rfm_type):
+                h.setLevel(level)
+
 
 # A logger that doesn't log anything
 null_logger = LoggerAdapter()

reframe/frontend/cli.py

@@ -28,6 +28,7 @@
 import reframe.utility.jsonext as jsonext
 import reframe.utility.osext as osext
 import reframe.utility.typecheck as typ
+from reframe.core.warnings import suppress_deprecations
 from reframe.frontend.testgenerators import (distribute_tests,
                                              getallnodes, repeat_tests,
                                              parameterize_tests)
@@ -149,13 +150,18 @@ def describe_checks(testcases, printer):
             #
             # 1. Add other fields that are relevant for users
             # 2. Remove all private fields
-            rec['name'] = tc.check.name
-            rec['unique_name'] = tc.check.unique_name
-            rec['display_name'] = tc.check.display_name
+            cls = type(tc.check)
+            if hasattr(cls, 'loggable_attrs'):
+                for name, alt_name in cls.loggable_attrs():
+                    key = alt_name if alt_name else name
+                    try:
+                        with suppress_deprecations():
+                            rec.setdefault(key, getattr(tc.check, name))
+                    except AttributeError:
+                        rec.setdefault(key, '<undefined>')
+
             rec['pipeline_hooks'] = {}
             rec['perf_variables'] = list(rec['perf_variables'].keys())
-            rec['prefix'] = tc.check.prefix
-            rec['variant_num'] = tc.check.variant_num
             for stage, hooks in tc.check.pipeline_hooks().items():
                 for hk in hooks:
                     if hk.__name__ not in tc.check.disabled_hooks:
@@ -1040,6 +1046,8 @@ def restrict_logging():
     if options.describe_stored_sessions:
         # Restore logging level
         printer.setLevel(logging.INFO)
+        printer.set_handler_level(logging.WARNING,
+                                  lambda htype: htype != 'stream')
         with exit_gracefully_on_error('failed to retrieve session data',
                                       printer):
             printer.info(jsonext.dumps(reporting.session_info(
@@ -1050,6 +1058,8 @@ def restrict_logging():
     if options.describe_stored_testcases:
         # Restore logging level
         printer.setLevel(logging.INFO)
+        printer.set_handler_level(logging.WARNING,
+                                  lambda htype: htype != 'stream')
         namepatt = '|'.join(n.replace('%', ' %') for n in options.names)
         with exit_gracefully_on_error('failed to retrieve test case data',
                                       printer):

reframe/frontend/executors/__init__.py

@@ -591,8 +591,13 @@ def on_task_success(self, task):
         '''Called when a regression test has succeeded.'''
 
 
-def _handle_sigterm(signum, frame):
-    raise ForceExitError('received TERM signal')
+def _force_exit(signum, frame):
+    # ReFrame will exit, ignore all other signals that cause a graceful
+    # termination
+    signal.signal(signal.SIGINT, signal.SIG_IGN)
+    signal.signal(signal.SIGHUP, signal.SIG_IGN)
+    signal.signal(signal.SIGTERM, signal.SIG_IGN)
+    raise ForceExitError(f'received signal {signum}')
 
 
 class Runner:
@@ -620,7 +625,8 @@ def __init__(self, policy, printer=None, max_retries=0,
         self._policy.printer = self._printer
         self._policy.max_failures = max_failures
 
-        signal.signal(signal.SIGTERM, _handle_sigterm)
+        signal.signal(signal.SIGHUP, _force_exit)
+        signal.signal(signal.SIGTERM, _force_exit)
 
     @property
     def max_failures(self):

reframe/frontend/reporting/storage.py

@@ -228,6 +228,7 @@ def _db_store_report(self, conn, report, report_file_path):
 
         return session_uuid
 
+    @time_function
     def store(self, report, report_file=None):
         with self._db_lock():
             with self._db_connect(self._db_file()) as conn:

unittests/conftest.py

@@ -10,6 +10,7 @@
 import contextlib
 import copy
 import pytest
+import signal
 import tempfile
 
 import reframe.core.settings as settings
@@ -105,9 +106,17 @@ def _make_loader(check_search_path, *args, **kwargs):
     return _make_loader
 
 
+@pytest.fixture
+def restore_signals():
+    yield
+    signal.signal(signal.SIGTERM, signal.SIG_DFL)
+    signal.signal(signal.SIGINT, signal.SIG_DFL)
+    signal.signal(signal.SIGHUP, signal.SIG_DFL)
+
+
 @pytest.fixture(params=[policies.SerialExecutionPolicy,
                         policies.AsynchronousExecutionPolicy])
-def make_runner(request):
+def make_runner(request, restore_signals):
     '''Test runner with all the execution policies'''
 
     def _make_runner(*args, **kwargs):
@@ -120,7 +129,7 @@ def _make_runner(*args, **kwargs):
 
 
 @pytest.fixture
-def make_async_runner():
+def make_async_runner(restore_signals):
     def _make_runner(*args, **kwargs):
         policy = policies.AsynchronousExecutionPolicy()
         policy._pollctl.SLEEP_MIN = 0.001

unittests/resources/checks/frontend_checks.py

@@ -8,7 +8,6 @@
 #
 
 import os
-import signal
 import sys
 import time
 
@@ -190,10 +189,13 @@ class SelfKillCheck(rfm.RunOnlyRegressionTest, special=True):
     executable = 'echo'
     sanity_patterns = sn.assert_true(1)
 
+    def __init__(self, signum):
+        self.signum = signum
+
     def run(self):
         super().run()
         time.sleep(0.5)
-        os.kill(os.getpid(), signal.SIGTERM)
+        os.kill(os.getpid(), self.signum)
 
 
 class CompileFailureCheck(rfm.RegressionTest):

unittests/test_policies.py

@@ -6,6 +6,7 @@
 import contextlib
 import os
 import pytest
+import signal
 
 import reframe as rfm
 import reframe.core.runtime as rt
@@ -310,11 +311,16 @@ def test_pass_in_retries(make_runner, make_cases, tmp_path, common_exec_ctx):
     assert 0 == len(runner.stats.failed())
 
 
-def test_sigterm_handling(make_runner, make_cases, common_exec_ctx):
+@pytest.fixture(params=[signal.SIGTERM, signal.SIGHUP])
+def signum(request):
+    return request.param
+
+
+def test_signal_handling(signum, make_runner, make_cases, common_exec_ctx):
     runner = make_runner()
     with pytest.raises(ForceExitError,
-                       match='received TERM signal'):
-        runner.runall(make_cases([SelfKillCheck()]))
+                       match=f'received signal {signum}'):
+        runner.runall(make_cases([SelfKillCheck(signum)]))
 
     assert_all_dead(runner)
     assert runner.stats.num_cases() == 1
@@ -442,7 +448,7 @@ def max_jobs_opts(n):
 
 
 @pytest.fixture
-def make_async_runner():
+def make_async_runner(restore_signals):
     # We need to have control in the unit tests where the policy is created,
     # because in some cases we need it to be initialized after the execution
     # context. For this reason, we use a constructor fixture here.