ProcessUtil.cpp

Go to the documentation of this file.

/*
 * This file is part of ArmarX.
 *
 * ArmarX is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * ArmarX is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 *
 * @package    ArmarXCore::core
 * @copyright  http://www.gnu.org/licenses/gpl-2.0.txt
 *             GNU General Public License
 */
 
#include "ProcessUtil.h"
 
#include <algorithm>
#include <cctype>
#include <filesystem>
#include <fstream>
#include <optional>
#include <string>
#include <system_error>
#include <thread>
 
namespace ScenarioManager::Exec::ProcessUtil
{
    namespace
    {
        std::string
        ProcPath(int pid, const std::string& entry = "")
        {
            return "/proc/" + std::to_string(pid) + entry;
        }
 
        std::string
        BaseName(const std::string& path)
        {
            const auto lastSeparator = path.rfind('/');
            return lastSeparator == std::string::npos ? path : path.substr(lastSeparator + 1);
        }
 
        /**
         * Parses a /proc/<pid> directory name into a pid. Returns -1 for the non-numeric entries
         * (self, thread-self, sys, ...).
         */
        int
        PidFromProcEntry(const std::string& entry)
        {
            if (entry.empty() ||
                !std::all_of(entry.begin(), entry.end(), [](unsigned char c)
                             { return std::isdigit(c) != 0; }))
            {
                return -1;
            }
 
            try
            {
                return std::stoi(entry);
            }
            catch (const std::exception&)
            {
                // A pid that does not fit into an int is not one of ours.
                return -1;
            }
        }
    } // namespace
 
    bool
    IsZombie(int pid)
    {
        if (pid <= 0)
        {
            return false;
        }
 
        // /proc/<pid>/stat is "<pid> (<comm>) <state> ...". The comm field is the only one that may
        // contain spaces and parentheses, so the state is the character two positions after the
        // *last* ')'.
        std::ifstream stat(ProcPath(pid, "/stat"));
        if (!stat.is_open())
        {
            return false;
        }
 
        std::string line;
        if (!std::getline(stat, line))
        {
            return false;
        }
 
        const auto commEnd = line.rfind(')');
        if (commEnd == std::string::npos || commEnd + 2 >= line.size())
        {
            return false;
        }
 
        return line[commEnd + 2] == 'Z';
    }
 
    bool
    IsAlive(int pid)
    {
        if (pid <= 0)
        {
            return false;
        }
 
        std::error_code ec;
        if (!std::filesystem::exists(ProcPath(pid), ec))
        {
            return false;
        }
 
        // A /proc entry that is only a corpse waiting to be reaped is not a live process. Counting
        // one as alive is what made a stopped application hang the stop for the full termination
        // timeout and then sit in Unknown, unstartable, for good: the process was dead, but its
        // entry never went away because nothing waits for the applications we launch.
        return !IsZombie(pid);
    }
 
    std::string
    GetProcessName(int pid)
    {
        if (pid <= 0)
        {
            return {};
        }
 
        const std::vector<std::string> arguments = GetProcessArguments(pid);
        return arguments.empty() ? std::string{} : BaseName(arguments.front());
    }
 
    std::vector<std::string>
    GetProcessArguments(int pid)
    {
        if (pid <= 0)
        {
            return {};
        }
 
        std::ifstream cmdline(ProcPath(pid, "/cmdline"), std::ios::binary);
        if (!cmdline.is_open())
        {
            return {};
        }
 
        // /proc/<pid>/cmdline is a sequence of NUL terminated strings; the first one is argv[0].
        // It is empty for zombies, kernel threads and processes that have not exec'd yet.
        std::vector<std::string> arguments;
        std::string argument;
        while (std::getline(cmdline, argument, '\0'))
        {
            arguments.push_back(argument);
        }
 
        if (arguments.empty() || arguments.front().empty())
        {
            return {};
        }
 
        return arguments;
    }
 
    std::vector<ProcessInfo>
    ScanProcesses()
    {
        std::vector<ProcessInfo> processes;
 
        std::error_code ec;
        std::filesystem::directory_iterator entries("/proc", ec);
        if (ec)
        {
            return processes;
        }
 
        for (const auto& entry : entries)
        {
            const int pid = PidFromProcEntry(entry.path().filename().string());
            if (pid < 0)
            {
                continue;
            }
 
            // Read the arguments before comparing anything: a process that exits while we walk
            // simply yields an empty vector and is skipped.
            std::vector<std::string> arguments = GetProcessArguments(pid);
            if (arguments.empty())
            {
                continue;
            }
 
            std::string name = BaseName(arguments.front());
            processes.push_back(ProcessInfo{pid, std::move(name), std::move(arguments)});
        }
 
        return processes;
    }
 
    std::optional<std::string>
    FindIceConfigArgument(const std::vector<std::string>& arguments)
    {
        static const std::string prefix = "--Ice.Config=";
        for (const std::string& argument : arguments)
        {
            if (argument.rfind(prefix, 0) == 0)
            {
                return argument.substr(prefix.size());
            }
        }
        return std::nullopt;
    }
 
    Identity
    IdentifyProcess(int pid, const std::string& executableName, const std::string& configPath)
    {
        if (pid <= 0 || executableName.empty())
        {
            return Identity::Unverifiable;
        }
 
        const std::vector<std::string> arguments = GetProcessArguments(pid);
        if (arguments.empty())
        {
            // Nothing to compare against. Saying "Differs" here would throw away the pid of a
            // running application every time /proc could not be read, which is the very bug the
            // Alive/Dead/Indeterminate split was introduced to fix.
            return Identity::Unverifiable;
        }
 
        if (BaseName(arguments.front()) != executableName)
        {
            return Identity::Differs;
        }
 
        // Same binary - but possibly a different scenario or instance of it. The config it was
        // launched with is what tells them apart.
        if (!configPath.empty())
        {
            const std::optional<std::string> configArgument = FindIceConfigArgument(arguments);
            if (configArgument.has_value() &&
                configArgument->find(configPath) == std::string::npos)
            {
                return Identity::Differs;
            }
        }
 
        return Identity::Matches;
    }
 
    bool
    WaitForExit(int pid, std::chrono::milliseconds timeout, std::chrono::milliseconds pollInterval)
    {
        const auto deadline = std::chrono::steady_clock::now() + timeout;
        while (IsAlive(pid))
        {
            if (std::chrono::steady_clock::now() >= deadline)
            {
                return !IsAlive(pid);
            }
            std::this_thread::sleep_for(pollInterval);
        }
        return true;
    }
} // namespace ScenarioManager::Exec::ProcessUtil