[question] Usage of ProcessHandleImpl::wait() in Unix implemention

[HR1025]

Some of the subprocesses from the fork() execute very quickly and complete before the waitpid().
In this situation poco will throw exception SystemException("Cannot wait for process").

int ProcessHandleImpl::wait() const
{
	int status;
	int rc;
	do
	{
		rc = waitpid(_pid, &status, 0);
	}
	while (rc < 0 && errno == EINTR);
	if (rc != _pid)
		throw SystemException("Cannot wait for process", NumberFormatter::format(_pid));

	if (WIFEXITED(status)) // normal termination
		return WEXITSTATUS(status);
	else // termination by a signal
		return 256 + WTERMSIG(status);
}

But maybe we still want to get it exit code, show as follow:

        try
        {
            res = ph.wait();
            LOG_INFO << "wait pid " << ph.id() << ", exit code is: " << res;
        }
        catch(const Poco::Exception& ex)
        {
            LOG_INFO << "fork process already return, manually acquire it exit code";
            int status;
            waitpid(ph.id(), &status, WUNTRACED);
            res = WIFEXITED(status);
            LOG_INFO << "wait pid " << ph.id() << ", exit code is: " << res;
        }

I don't know how to do it. Is there a better way?

[github-actions[bot]]

This issue is stale because it has been open for 365 days with no activity.

[aleks-f]

@pavledragisic couldn't reliably reproduce

#include "Poco/Process.h"
#include "Poco/Exception.h"
#include "Poco/NumberFormatter.h"
#include "Poco/Logger.h"
#include "Poco/ConsoleChannel.h"
#include <iostream>
#include <unistd.h>
#include <sys/wait.h>


#include <thread>

// Thread to reap the process early
void reapProcess(pid_t pid)
{
    usleep(100 * 1000); // 100ms delay to ensure child process exits
    int status;
    waitpid(pid, &status, 0); // Reap the child process
}

int main()
{
    Poco::AutoPtr<Poco::ConsoleChannel> consoleChannel(new Poco::ConsoleChannel());
    Poco::Logger::root().setChannel(consoleChannel);
    Poco::Logger& logger = Poco::Logger::get("ProcessLogger");

    try
    {
        Poco::Process::Args args;
        std::string command = "short-lived.sh"; // A command that exits immediately

        Poco::ProcessHandle ph = Poco::Process::launch(command, args);

        // Start a thread to reap the process
        //std::thread reaper(reapProcess, ph.id());

        // Simulate delay in parent process
        logger.information("Simulating delay in parent process...");
        sleep(60); // Allow child to exit and be reaped

        int exitCode = -1;
        try
        {
            exitCode = ph.wait(); // This should throw the exception
            logger.information("Child process completed, PID: " +
                               Poco::NumberFormatter::format(ph.id()) +
                               ", Exit code: " + Poco::NumberFormatter::format(exitCode));
        }
        catch (const Poco::Exception& ex)
        {
            logger.error("Exception caught: " + ex.displayText());
            // Attempt manual recovery
            int status;
            if (waitpid(ph.id(), &status, WUNTRACED) > 0)
            {
                if (WIFEXITED(status))
                {
                    exitCode = WEXITSTATUS(status);
                    logger.information("Manually acquired exit code: " +
                                       Poco::NumberFormatter::format(exitCode));
                }
                else
                {
                    logger.warning("Child process terminated abnormally.");
                }
            }
            else
            {
                logger.error("Failed to manually acquire process exit code.");
            }
        }

        //reaper.join(); // Wait for the reaper thread to finish
    }
    catch (const Poco::Exception& ex)
    {
        std::cerr << "Poco exception: " << ex.displayText() << std::endl;
    }
    catch (const std::exception& ex)
    {
        std::cerr << "Standard exception: " << ex.what() << std::endl;
    }

    return 0;
}