Fork.hpp

Go to the documentation of this file.

// @formatter:off
//
// Balau core C++ library
//
// Copyright (C) 2008 Bora Software (contact@borasoftware.com)
//
// Licensed under the Boost Software License - Version 1.0 - August 17th, 2003.
// See the LICENSE file for the full license text.
//


#ifndef COM_BORA_SOFTWARE__BALAU_CONCURRENT__FORK
#define COM_BORA_SOFTWARE__BALAU_CONCURRENT__FORK

#include <Balau/Exception/SystemExceptions.hpp>
#include <Balau/Dev/Assert.hpp>

#include <boost/predef.h>
#include <sys/wait.h>

namespace Balau::Concurrent {

class Fork {
    public: static bool forkSupported() {
        #pragma clang diagnostic push
        #pragma ide diagnostic ignored "OCSimplifyInspection"
        #pragma ide diagnostic ignored "OCDFAInspection"
        return BOOST_OS_UNIX;
        #pragma clang diagnostic pop
    }

    public: static int performFork(const std::function<int ()> & function, bool exitChild) {
        Assert::assertion(forkSupported(), "fork() called for platform that does not support it.");

        const int pid = ::fork();

        if (pid == 0) {
            const int status = function();

            if (exitChild) {
                _Exit(status);
            } else {
                return status;
            }
        } else if (pid > 0) {
            return pid;
        } else {
            ThrowBalauException(Exception::ForkException, errno, "Failed to fork process.");
        }
    }

    public: static int performFork(const std::function<int ()> & function) {
        Assert::assertion(forkSupported(), "fork() called for platform that does not support it.");

        const int pid = ::fork();

        if (pid == 0) {
            function();
            return 0;
        } else if (pid > 0) {
            return pid;
        } else {
            ThrowBalauException(Exception::ForkException, errno, "Failed to fork process.");
        }
    }

    public: struct TerminationReport {
        int pid;

        int code;

        int exitStatus;

        TerminationReport() : pid(0), code(0), exitStatus(0) {}

        TerminationReport(int pid_, int code_, int exitStatus_)
            : pid(pid_), code(code_), exitStatus(exitStatus_) {}

        TerminationReport(const TerminationReport & copy) = default;

        TerminationReport(TerminationReport && rhs) noexcept
            : pid(rhs.pid), code(rhs.code), exitStatus(rhs.exitStatus) {}

        TerminationReport & operator = (const TerminationReport & copy) = default;

        TerminationReport & operator = (TerminationReport && rhs) noexcept {
            pid = rhs.pid;
            code = rhs.code;
            exitStatus = rhs.exitStatus;
            return *this;
        }
    };

    public: static TerminationReport waitOnProcess(int pid) {
        if (pid <= 0) {
            return TerminationReport();
        }

        siginfo_t infop;
        int options = WEXITED;

        memset(&infop, 0, sizeof(siginfo_t));

        if (waitid(P_PID, (unsigned int) pid, &infop, options) == -1) {
            ThrowBalauException(Exception::WaitException, errno);
        } else if (infop.si_pid) {
            return TerminationReport(pid, infop.si_code, infop.si_status);
        }

        // TODO what else may happen here?
        return TerminationReport();
    }

    public: static TerminationReport checkForTermination(int pid) {
        if (pid <= 0) {
            return TerminationReport();
        }

        siginfo_t infop;
        int options = WEXITED | WNOHANG;

        memset(&infop, 0, sizeof(siginfo_t));

        if (waitid(P_PID, (unsigned int) pid, &infop, options) == -1) {
            ThrowBalauException(Exception::WaitException, errno);
        } else if (infop.si_pid) {
            switch (infop.si_code) {
                case CLD_EXITED:
                case CLD_KILLED:
                case CLD_DUMPED: {
                    return TerminationReport(pid, infop.si_code, infop.si_status);
                }

                default: {
                    break;
                }
            }
        }

        return TerminationReport();
    }

    public: static std::vector<TerminationReport> checkForTermination(const std::vector<int> & pids) {
        std::vector<TerminationReport> reports;
        siginfo_t infop;
        int options = WEXITED | WNOHANG; // NOLINT

        for (int pid : pids) {
            if (pid <= 0) {
                continue;
            }

            memset(&infop, 0, sizeof(siginfo_t));

            if (waitid(P_PID, (unsigned int) pid, &infop, options) == -1) {
                ThrowBalauException(Exception::WaitException, errno);
            } else if (infop.si_pid) {
                switch (infop.si_code) {
                    case CLD_EXITED:
                    case CLD_KILLED:
                    case CLD_DUMPED: {
                        reports.emplace_back(pid, infop.si_code, infop.si_status);
                    }

                    default: {
                        break;
                    }
                }
            }
        }

        return reports;
    }

    public: static TerminationReport terminateProcess(int pid) {
        if (pid <= 0) {
            return TerminationReport();
        }

        siginfo_t infop;
        int options = WEXITED | WNOHANG; // NOLINT

        memset(&infop, 0, sizeof(siginfo_t));

        if (waitid(P_PID, (unsigned int) pid, &infop, options) == -1) {
            ThrowBalauException(Exception::WaitException, errno);
        } else if (infop.si_pid) {
            switch (infop.si_code) {
                case CLD_EXITED:
                case CLD_KILLED:
                case CLD_DUMPED: {
                    return TerminationReport(pid, infop.si_code, infop.si_status);
                }

                default: {
                    kill(pid, SIGKILL);
                    break;
                }
            }
        }

        return TerminationReport();
    }
};

} // namespace Balau::Concurrent

#endif // COM_BORA_SOFTWARE__BALAU_CONCURRENT__FORK