Allow commands whose output is not logged unless they fail

tests/unit/test_utils.py

@@ -20,6 +20,7 @@
 import tmt.plugins
 import tmt.steps.discover
 import tmt.utils
+from tmt.log import Logger
 from tmt.utils import (
     Command,
     Common,
@@ -41,7 +42,7 @@
     wait,
     )
 
-from . import MATCH, assert_log
+from . import MATCH, assert_log, assert_not_log
 
 run = Common(logger=tmt.log.Logger.create(verbose=0, debug=0, quiet=False)).run
 
@@ -700,6 +701,35 @@ def test_run_big(root_logger):
     assert len(output.stdout) == 200000
 
 
+def test_command_run_without_streaming(root_logger: Logger, caplog) -> None:
+    ShellScript('ls -al /').to_shell_command().run(
+        cwd=Path.cwd(),
+        stream_output=True,
+        logger=root_logger)
+
+    assert_log(caplog, message=MATCH('out: drwx.+? mnt'))
+
+    caplog.clear()
+
+    ShellScript('ls -al /').to_shell_command().run(
+        cwd=Path.cwd(),
+        stream_output=False,
+        logger=root_logger)
+
+    assert_not_log(caplog, message=MATCH('out: drwx.+? mnt'))
+
+    caplog.clear()
+
+    with pytest.raises(tmt.utils.RunError):
+        ShellScript('ls -al / /does/not/exist').to_shell_command().run(
+            cwd=Path.cwd(),
+            stream_output=False,
+            logger=root_logger)
+
+    assert_log(caplog, message=MATCH('out: drwx.+? mnt'))
+    assert_log(caplog, message=MATCH("err: ls: cannot access '/does/not/exist'"))
+
+
 def test_get_distgit_handler():
     for _wrong_remotes in [[], ["blah"]]:
         with pytest.raises(tmt.utils.GeneralError):

tmt/checks/watchdog.py

@@ -243,6 +243,7 @@ def _handle_output(ping_output: str) -> None:
                                        '-c',
                                        str(self.ping_packets),
                                        invocation.guest.primary_address) .run(cwd=Path.cwd(),
+                                                                              stream_output=False,
                                                                               logger=logger)
 
             _handle_output(output.stdout or '')
@@ -327,6 +328,7 @@ def _success(ncat_output: str) -> None:
                                        '-zv',
                                        invocation.guest.primary_address,
                                        str(invocation.guest.port or 22)) .run(cwd=Path.cwd(),
+                                                                              stream_output=False,
                                                                               logger=logger)
 
             _success(output.stderr or '')

tmt/utils.py

@@ -965,14 +965,16 @@ def __init__(
             *,
             stream: Optional[IO[bytes]] = None,
             logger: Optional[tmt.log.LoggingFunction] = None,
-            click_context: Optional[click.Context] = None) -> None:
+            click_context: Optional[click.Context] = None,
+            stream_output: bool = True) -> None:
         super().__init__(daemon=True)
 
         self.stream = stream
         self.output: list[str] = []
         self.log_header = log_header
         self.logger = logger
         self.click_context = click_context
+        self.stream_output = stream_output
 
     def run(self) -> None:
         if self.stream is None:
@@ -986,7 +988,7 @@ def run(self) -> None:
 
         for _line in self.stream:
             line = _line.decode('utf-8', errors='replace')
-            if line != '':
+            if self.stream_output and line != '':
                 self.logger(
                     self.log_header,
                     line.rstrip('\n'),
@@ -1155,6 +1157,7 @@ def run(
             friendly_command: Optional[str] = None,
             log: Optional[tmt.log.LoggingFunction] = None,
             silent: bool = False,
+            stream_output: bool = True,
             caller: Optional['Common'] = None,
             logger: tmt.log.Logger) -> CommandOutput:
         """
@@ -1182,6 +1185,9 @@ def run(
             default, ``logger.debug`` is used.
         :param silent: if set, logging of steps taken by this function would be
             reduced.
+        :param stream_output: if set, command output would be streamed
+            live into the log. When unset, the output would be logged
+            only when the command fails.
         :param caller: optional "parent" of the command execution, used for better
             linked exceptions.
         :param logger: logger to use for logging.
@@ -1277,7 +1283,8 @@ def _spawn_process() -> subprocess.Popen[bytes]:
                 'out',
                 stream=process.stdout,
                 logger=output_logger,
-                click_context=click.get_current_context(silent=True))
+                click_context=click.get_current_context(silent=True),
+                stream_output=stream_output)
 
             if join:
                 stderr_logger: StreamLogger = UnusedStreamLogger('err')
@@ -1287,7 +1294,8 @@ def _spawn_process() -> subprocess.Popen[bytes]:
                     'err',
                     stream=process.stderr,
                     logger=output_logger,
-                    click_context=click.get_current_context(silent=True))
+                    click_context=click.get_current_context(silent=True),
+                    stream_output=stream_output)
 
             stdout_logger.start()
             stderr_logger.start()
@@ -1347,6 +1355,15 @@ def log_event(msg: str) -> None:
         if process.returncode != 0:
             logger.debug(f"Command returned '{process.returncode}'.", level=3)
 
+            if not stream_output:
+                if stdout is not None:
+                    for line in stdout.splitlines():
+                        output_logger('out', value=line, color='yellow', level=3)
+
+                if stderr is not None:
+                    for line in stderr.splitlines():
+                        output_logger('err', value=line, color='yellow', level=3)
+
             raise RunError(
                 f"Command '{friendly_command or str(self)}' returned {process.returncode}.",
                 self,