kyua: Make "debug -p" skip writing stdout/stderr to tmp files

Reviewed by:	kp, ngie
Differential Revision:	https://reviews.freebsd.org/D54363

contrib/kyua/cli/cmd_debug.cpp

@@ -149,7 +149,11 @@ cmd_debug::run(cmdline::ui* ui, const cmdline::parsed_cmdline& cmdline,
     const engine::test_filter filter = engine::test_filter::parse(
         test_case_name);
 
-    auto debugger = std::shared_ptr< engine::debugger >(new dbg(ui, cmdline));
+    engine::debugger_ptr debugger = nullptr;
+    if (cmdline.has_option(pause_before_cleanup_upon_fail_option.long_name())
+        || cmdline.has_option(pause_before_cleanup_option.long_name())) {
+        debugger = std::shared_ptr< engine::debugger >(new dbg(ui, cmdline));
+    }
 
     const drivers::debug_test::result result = drivers::debug_test::drive(
         debugger,

contrib/kyua/engine/scheduler.cpp

@@ -1283,7 +1283,9 @@ scheduler::exec_handle
 scheduler::scheduler_handle::spawn_test(
     const model::test_program_ptr test_program,
     const std::string& test_case_name,
-    const config::tree& user_config)
+    const config::tree& user_config,
+    const utils::optional<utils::fs::path>& stdout_target,
+    const utils::optional<utils::fs::path>& stderr_target)
 {
     _pimpl->generic.check_interrupt();
 
@@ -1305,7 +1307,7 @@ scheduler::scheduler_handle::spawn_test(
         run_test_program(interface, test_program, test_case_name,
                          user_config),
         test_case.get_metadata().timeout(),
-        unprivileged_user);
+        unprivileged_user, stdout_target, stderr_target);
 
     const exec_data_ptr data(new test_exec_data(
         test_program, test_case_name, interface, user_config, handle.pid()));
@@ -1563,8 +1565,16 @@ scheduler::scheduler_handle::debug_test(
     const fs::path& stdout_target,
     const fs::path& stderr_target)
 {
+    optional<fs::path> out = none;
+    optional<fs::path> err = none;
+    const model::test_case& test_case = test_program->find(test_case_name);
+    if (test_case.get_debugger() != nullptr) {
+        out = stdout_target;
+        err = stderr_target;
+    }
+
     const exec_handle exec_handle = spawn_test(
-        test_program, test_case_name, user_config);
+        test_program, test_case_name, user_config, out, err);
     result_handle_ptr result_handle = wait_any();
 
     // TODO(jmmv): We need to do this while the subprocess is alive.  This is
@@ -1574,12 +1584,12 @@ scheduler::scheduler_handle::debug_test(
     // Unfortunately, we cannot do so.  We cannot just read and block from a
     // file, waiting for further output to appear... as this only works on pipes
     // or sockets.  We need a better interface for this whole thing.
-    {
+    if (test_case.get_debugger() == nullptr) {
         std::unique_ptr< std::ostream > output = utils::open_ostream(
             stdout_target);
         *output << utils::read_file(result_handle->stdout_file());
     }
-    {
+    if (test_case.get_debugger() == nullptr) {
         std::unique_ptr< std::ostream > output = utils::open_ostream(
             stderr_target);
         *output << utils::read_file(result_handle->stderr_file());

contrib/kyua/engine/scheduler.hpp

@@ -74,6 +74,8 @@
 #include "utils/process/executor_fwd.hpp"
 #include "utils/process/status_fwd.hpp"
 
+using utils::none;
+
 namespace engine {
 namespace scheduler {
 
@@ -248,7 +250,9 @@ class scheduler_handle {
                                      const utils::config::tree&);
     exec_handle spawn_test(const model::test_program_ptr,
                            const std::string&,
-                           const utils::config::tree&);
+                           const utils::config::tree&,
+                           const utils::optional<utils::fs::path>& = none,
+                           const utils::optional<utils::fs::path>& = none);
     result_handle_ptr wait_any(void);
 
     result_handle_ptr debug_test(const model::test_program_ptr,