testAsyncProcess.cpp

Go to the documentation of this file.

/**
 * @file
 * @ingroup daq_test
 * @copyright (c) Copyright ESO 2022
 * All Rights Reserved
 * ESO (eso.org) is an Intergovernmental Organisation, and therefore special legal conditions apply.
 *
 * @brief daq::AsyncProcess integration tests
 *
 * This starts subprocesses that depend on @c bash, sleep and @c dd so they are not part of unit
 * tests.
 */
#include <thread>
 
#include <gtest/gtest.h>
 
#include <rad/ioExecutor.hpp>
 
#include <daq/process/asyncProcess.hpp>
 
class AsyncProcessTest : public ::testing::Test {
public:
    AsyncProcessTest() : m_ctx(), m_exec(m_ctx) {
    }
 
protected:
    boost::asio::io_context m_ctx;
    rad::IoExecutor m_exec;
};
 
TEST_F(AsyncProcessTest, ReadAll) {
    std::vector<std::string> args = {
        "bash",
        "-c",
        "for x in {1. .2}; do sleep 1 && dd if=/dev/random of=/dev/stdout count=2 bs=4096 "
        "iflag=fullblock  status=none; done"};
 
    std::string stdout;
    std::string stdout_at_term;
    bool done = false;
    auto proc = daq::AsyncProcess(m_ctx, args);
    EXPECT_FALSE(proc.IsRunning());
    EXPECT_FALSE(proc.GetPid().has_value());
 
    // Simple slot that stores all output in a string.
    proc.ConnectStdout([&](pid_t, std::string const& line) { stdout += line; });
 
    boost::future<int> fut = proc.Initiate().then(m_exec, [&](boost::future<int> exit_code) -> int {
        done = true;
        stdout_at_term = stdout;
        EXPECT_FALSE(proc.IsRunning());
        auto code = exit_code.get();
        EXPECT_EQ(code, 0) << "Unexpected exit code";
        return code;
    });
 
    EXPECT_TRUE(proc.IsRunning());
    EXPECT_TRUE(proc.GetPid().has_value());
 
    m_ctx.run();  // runs until there's no more work
 
    EXPECT_TRUE(done)
        << "Expected continuation to have been executed as io_context::run has exited";
    EXPECT_EQ(stdout, stdout_at_term)
        << "Output changed after future continuation executed. "
           "This indicates that the process termination synchronization in AsyncProcess "
           "doesn't work as advertised!";
    EXPECT_EQ(stdout.size(), 2 * 4096 * 2);
    EXPECT_EQ(fut.get(), 0);
}
 
TEST_F(AsyncProcessTest, SignalWithSigterm) {
    std::vector<std::string> args = {"sleep", "2"};
 
    bool done = false;
    auto proc = daq::AsyncProcess(m_ctx, args);
    EXPECT_EQ(proc.Signal(SIGTERM), std::errc::no_such_process);
    EXPECT_FALSE(proc.IsRunning());
 
    // Note
    boost::future<int> fut = proc.Initiate().then(m_exec, [&](boost::future<int> exit_code) -> int {
        done = true;
        EXPECT_FALSE(proc.IsRunning());
        auto code = exit_code.get();
        EXPECT_EQ(code, 15) << "Unexpected exit code for SIGTERM";
        return code;
    });
 
    EXPECT_TRUE(proc.IsRunning());
 
    proc.Signal(SIGTERM);
 
    m_ctx.run();  // runs until there's no more work
 
    EXPECT_TRUE(done)
        << "Expected continuation to have been executed as io_context::run has exited";
    EXPECT_EQ(fut.get(), 15);
}
 
// Disabled due to bug in boost (https://github.com/boostorg/process/issues/357)
TEST_F(AsyncProcessTest, DISABLED_Abort) {
    std::vector<std::string> args = {"sleep", "2"};
 
    bool done = false;
    auto proc = daq::AsyncProcess(m_ctx, args);
    EXPECT_EQ(proc.Abort(), std::errc::no_such_process);
    EXPECT_FALSE(proc.IsRunning());
 
    // Note
    boost::future<int> fut = proc.Initiate().then(m_exec, [&](boost::future<int> exit_code) -> int {
        done = true;
        EXPECT_FALSE(proc.IsRunning());
        auto code = exit_code.get();
        EXPECT_EQ(code, 9) << "Unexpected exit code for a SIGKILL";
        return code;
    });
 
    EXPECT_TRUE(proc.IsRunning());
 
    proc.Abort();
 
    m_ctx.run();  // runs until there's no more work
 
    EXPECT_TRUE(done)
        << "Expected continuation to have been executed as io_context::run has exited";
    EXPECT_EQ(fut.get(), 9);
}
 
// Test that allows error code or exception when aborting as workaround for
// (https://github.com/boostorg/process/issues/357)
TEST_F(AsyncProcessTest, AbortTolerant) {
    std::vector<std::string> args = {"sleep", "2"};
 
    bool done = false;
    auto proc = daq::AsyncProcess(m_ctx, args);
    EXPECT_EQ(proc.Abort(), std::errc::no_such_process);
    EXPECT_FALSE(proc.IsRunning());
 
    // Note
    boost::future<int> fut = proc.Initiate().then(m_exec, [&](boost::future<int> exit_code) -> int {
        done = true;
        EXPECT_FALSE(proc.IsRunning());
        auto code = exit_code.get();
        EXPECT_EQ(code, 9) << "Unexpected exit code for a SIGKILL";
        return code;
    });
 
    EXPECT_TRUE(proc.IsRunning());
 
    proc.Abort();
 
    m_ctx.run();  // runs until there's no more work
 
    EXPECT_TRUE(done)
        << "Expected continuation to have been executed as io_context::run has exited";
    ASSERT_TRUE(fut.is_ready());
    if (!fut.has_exception()) {
        EXPECT_EQ(fut.get(), 9);
    }
}
 
TEST_F(AsyncProcessTest, ReadAllMultiple) {
    std::vector<std::string> args = {
        "bash",
        "-c",
        "for x in {1. .2}; do sleep 1 && dd if=/dev/random of=/dev/stdout count=2 bs=4096 "
        "iflag=fullblock  status=none; done"};
 
    for (int i = 0; i < 10; ++i) {
        auto proc = std::make_shared<daq::AsyncProcess>(m_ctx, args);
        auto stdout = std::make_shared<std::string>();
        proc->ConnectStdout([&, stdout](pid_t, std::string const& line) { *stdout += line; });
        // Note: Capture proc by value to keep AsyncProcess alive
        proc->Initiate().then(m_exec, [&, proc, stdout](boost::future<int> exit_code) {
            EXPECT_EQ(stdout->size(), 2 * 4096 * 2);
            EXPECT_EQ(exit_code.get(), 0) << "Unexpected exit code";
        });
    }
 
    m_ctx.run();
}