ExternalApplicationManager.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::ArmarXObjects::ExternalApplicationManager
 * @author     Stefan Reither ( stef dot reither at web dot de )
 * @date       2016
 * @copyright  http://www.gnu.org/licenses/gpl-2.0.txt
 *             GNU General Public License
 */
 
#include "ExternalApplicationManager.h"
 
#include <signal.h>
 
#include <filesystem>
#include <thread>
 
#include <sys/prctl.h>
 
#include <boost/process/initializers.hpp>
#include <boost/regex.hpp>
 
#include <IceUtil/UUID.h>
 
#include <SimoxUtility/algorithm/string/string_tools.h>
 
#include <ArmarXCore/core/ArmarXManager.h>
#include <ArmarXCore/core/application/Application.h>
#include <ArmarXCore/core/logging/Logging.h>
#include <ArmarXCore/core/system/ArmarXDataPath.h>
#include <ArmarXCore/core/system/EnvExpander.h>
#include <ArmarXCore/core/system/cmake/CMakePackageFinder.h>
#include <ArmarXCore/core/time/TimeUtil.h>
#include <ArmarXCore/core/util/StringHelpers.h>
 
namespace armarx
{
 
    ExternalApplicationManagerPropertyDefinitions::ExternalApplicationManagerPropertyDefinitions(
        std::string prefix) :
        armarx::ComponentPropertyDefinitions(prefix)
    {
        defineRequiredProperty<std::string>(
            "ApplicationPath",
            "Either the name of the application if its directory is part of the PATH environment "
            "variable of the system or it is located in an ArmarX-package, or the relative or "
            "absolute path to the application.")
            .setCaseInsensitive(false);
        defineOptionalProperty<std::string>("ApplicationArguments",
                                            "",
                                            "Comma separated list of command line parameters. "
                                            "Commas in double-quoted strings are ignored.");
        defineOptionalProperty<std::string>(
            "ArmarXPackage",
            "",
            "Set this property if the application is located in an ArmarX-package.");
        defineOptionalProperty<std::string>(
            "WorkingDirectory",
            "",
            "If set, this path is used as working directory for the external app. This overrides "
            "BinaryPathAsWorkingDirectory. ${HOME} for env vars, $C{RobotAPI:BINARY_DIR} for "
            "CMakePackageFinder vars");
 
        defineOptionalProperty<bool>(
            "BinaryPathAsWorkingDirectory",
            false,
            "If true the path of the binary is set as the working directory.");
        defineOptionalProperty<bool>(
            "RestartInCaseOfCrash",
            false,
            "Whether the application should be restarted in case it crashed.");
 
        defineOptionalProperty<bool>(
            "DisconnectInCaseOfCrash",
            true,
            "Whether this component should disconnect as long as the application is not running.");
        defineOptionalProperty<int>(
            "FakeObjectStartDelay",
            0,
            "Delay in ms after which the fake armarx object is started on which other apps can "
            "depend. Not used if property FakeObjectDelayedStartKeyword is used.");
        defineOptionalProperty<std::string>(
            "FakeObjectDelayedStartKeyword",
            "",
            "If not empty, the start up of the fake armarx object will be delayed until this "
            "keyword is found in the stdout of the subprocess.");
        defineOptionalProperty<int>(
            "KillDelay",
            2000,
            "Delay ins ms before the subprocess is killed after sending the stop signal");
        defineOptionalProperty<bool>(
            "PythonUnbuffered",
            true,
            "If true, PYTHONUNBUFFERED=1 is added to the environment variables.");
        defineOptionalProperty<bool>("RedirectToArmarXLog",
                                     true,
                                     "If true, all outputs from the subprocess are printed with "
                                     "ARMARX_LOG, otherwise with std::cout");
        defineOptionalProperty<Ice::StringSeq>(
            "AdditionalEnvVars",
            {},
            "Comma-seperated list of env-var assignment, e.g. MYVAR=1,ADDPATH=/tmp");
        defineOptionalProperty<Ice::StringSeq>(
            "Dependencies",
            {},
            "Comma-seperated list of Ice Object dependencies. The external app will only be "
            "started after all dependencies have been found.");
    }
 
    void
    ExternalApplicationManager::addApplicationArguments(Ice::StringSeq& args)
    {
        const std::string argsStr = getProperty<std::string>("ApplicationArguments").getValue();
 
        const boost::regex re(",(?=(?:[^\\\"]*\\\"[^\\\"]*\\\")*[^\\\"]*$)");
 
        boost::match_results<std::string::const_iterator> what;
        boost::match_flag_type flags = boost::match_default;
        std::string::const_iterator s = argsStr.begin();
        std::string::const_iterator e = argsStr.end();
        size_t begin = 0;
        while (boost::regex_search(s, e, what, re, flags))
        {
            int pos = what.position();
            auto arg = argsStr.substr(begin, pos);
            if (!arg.empty())
            {
                args.push_back(arg);
            }
            std::string::difference_type l = what.length();
            std::string::difference_type p = what.position();
            begin += l + p;
            s += p + l;
        }
        std::string lastArg = argsStr.substr(begin);
        if (!lastArg.empty())
        {
            args.push_back(lastArg);
        }
    }
 
    void
    ExternalApplicationManager::onInitComponent()
    {
        getProperty(redirectToArmarXLog, "RedirectToArmarXLog");
        getProperty(restartWhenCrash, "RestartInCaseOfCrash");
        getProperty(disconnectWhenCrash, "DisconnectInCaseOfCrash");
 
        updateLogSenderComponentName();
 
        workingDir = deriveWorkingDir();
        application = deriveApplicationPath();
 
        std::filesystem::path appPath(application);
        ARMARX_INFO << "Application absolute path: " << appPath;
        Logging::setTag(appPath.stem().string());
 
        args.insert(args.begin(), application);
        addApplicationArguments(args);
 
        if (getProperty<bool>("PythonUnbuffered"))
        {
            envVars.push_back("PYTHONUNBUFFERED=1");
        }
        if (getProperty<Ice::StringSeq>("AdditionalEnvVars").isSet())
        {
            auto addEnvVrs = getProperty<Ice::StringSeq>("AdditionalEnvVars").getValue();
 
            for (const auto& var : addEnvVrs)
            {
                ARMARX_INFO << "Adding additional environment variable (raw): " << QUOTED(var);
 
                const auto envVarResolved = armarx::core::system::EnvExpander::expand(var);
                envVars.push_back(envVarResolved);
            }
        }
 
        for (auto& var : envVars)
        {
            auto split = Split(var, "=");
            if (split.size() >= 2)
            {
                ARMARX_INFO << "Setting env var: " << split.at(0) << "=" << split.at(1);
                setenv(split.at(0).c_str(), split.at(1).c_str(), 1);
            }
        }
 
        getProperty(startUpKeyword, "FakeObjectDelayedStartKeyword");
        starterUUID = "ExternalApplicationManagerStarter" + IceUtil::generateUUID();
        depObjUUID = "ExternalApplicationManagerDependency" + IceUtil::generateUUID();
 
        usingProxy(depObjUUID);
        addStarterObject();
    }
 
    void
    ExternalApplicationManager::onConnectComponent()
    {
        ARMARX_DEBUG << "External App Manager started";
        //    startApplication();
    }
 
    void
    ExternalApplicationManager::onDisconnectComponent()
    {
        ARMARX_DEBUG << "Disconnecting " << getName();
    }
 
    void
    ExternalApplicationManager::onExitComponent()
    {
        ARMARX_DEBUG << "Exiting " << getName();
    }
 
    armarx::PropertyDefinitionsPtr
    ExternalApplicationManager::createPropertyDefinitions()
    {
        return armarx::PropertyDefinitionsPtr(
            new ExternalApplicationManagerPropertyDefinitions(getConfigIdentifier()));
    }
 
    void
    ExternalApplicationManager::updateLogSenderComponentName()
    {
        if (Application::getInstance() &&
            Application::getInstance()->getProperty<std::string>("ApplicationName").isSet())
        {
            LogSender::SetComponentName(
                Application::getInstance()->getProperty<std::string>("ApplicationName").getValue());
        }
        else if (getProperty<std::string>("ObjectName").isSet())
        {
            LogSender::SetComponentName(getProperty<std::string>("ObjectName").getValue());
        }
        else
        {
            LogSender::SetComponentName("ExtApp");
        }
    }
 
    std::string
    ExternalApplicationManager::deriveWorkingDir() const
    {
        std::string workingDir;
        try
        {
            workingDir = getProperty<bool>("BinaryPathAsWorkingDirectory")
                             ? std::filesystem::path(application).parent_path().string()
                             : std::filesystem::current_path().string();
        }
        catch (std::exception& e)
        {
            ARMARX_ERROR << "caught exception in line " << __LINE__ << " what:\n" << e.what();
            throw;
        }
 
        if (getProperty<std::string>("WorkingDirectory").isSet())
        {
            workingDir = getProperty<std::string>("WorkingDirectory").getValueAndReplaceAllVars();
            try
            {
                std::filesystem::current_path(workingDir);
            }
            catch (std::exception& e)
            {
                ARMARX_ERROR << "caught exception in line " << __LINE__
                             << " when setting the current working directory to '" << workingDir
                             << "'. except.what:\n"
                             << e.what();
                throw;
            }
            ARMARX_INFO << "Using '" << workingDir << "' as working directory";
        }
 
        return workingDir;
    }
 
    std::string
    ExternalApplicationManager::deriveApplicationPath() const
    {
        std::filesystem::path applicationPath =
            getProperty<std::string>("ApplicationPath").getValueAndReplaceAllVars();
 
        if (applicationPath.is_absolute())
        {
            if (!std::filesystem::exists(applicationPath))
            {
                throw LocalException() << applicationPath << " does not exist.";
            }
            return applicationPath;
        }
 
        if (getProperty<std::string>("ArmarXPackage").isSet())
        {
            CMakePackageFinder finder(getProperty<std::string>("ArmarXPackage").getValue());
            if (finder.packageFound())
            {
                const std::filesystem::path path =
                    (finder.getBinaryDir() / applicationPath).lexically_normal();
                if (!std::filesystem::exists(path))
                {
                    throw LocalException()
                        << path << " does not exist in ArmarX-package " << finder.getName();
                }
                return path;
            }
            else
            {
                throw LocalException() << finder.getName() << " is not an ArmarX-package";
            }
        }
        else
        {
            std::string applicationPathStr = applicationPath.string();
            ArmarXDataPath::ResolveHomePath(applicationPathStr);
            CMakePackageFinder::ReplaceCMakePackageFinderVars(applicationPathStr);
            ArmarXDataPath::ReplaceEnvVars(applicationPathStr);
            applicationPath = applicationPathStr;
 
            if (!std::filesystem::exists(applicationPath))
            {
                const std::string path = boost::process::search_path(applicationPath);
                if (path.empty())
                {
                    throw LocalException()
                        << applicationPath << " does not represent an executable.";
                }
                else
                {
                    return path;
                }
            }
            else
            {
                return applicationPath;
            }
        }
    }
 
    void
    ExternalApplicationManager::restartApplication(const Ice::Current&)
    {
        stopApplication();
        startApplication();
    }
 
    void
    ExternalApplicationManager::terminateApplication(const Ice::Current&)
    {
        stopApplication();
    }
 
    std::string
    ExternalApplicationManager::getPathToApplication(const Ice::Current&)
    {
        return application;
    }
 
    bool
    ExternalApplicationManager::isApplicationRunning(const Ice::Current&)
    {
        return isAppRunning;
    }
 
    void
    ExternalApplicationManager::waitForApplication()
    {
        if (isAppRunning)
        {
            try
            {
                wait_for_exit(*childProcess);
                cleanUp();
 
                if (restartWhenCrash && !appStoppedOnPurpose)
                {
                    ARMARX_INFO << "Restarting application ...";
                    startApplication();
                }
                else
                {
                    isAppRunning = false;
                    if (this->disconnectWhenCrash)
                    {
                        this->getArmarXManager()->removeObjectBlocking(starterUUID);
                    }
                }
            }
            catch (...)
            {
            }
        }
    }
 
    void
    ExternalApplicationManager::addDependencyObject()
    {
        depObj = new ExternalApplicationManagerDependency;
        depObj->setParent(this);
 
        this->getArmarXManager()->addObject(depObj, false, depObjUUID);
        ARMARX_INFO << "Adding dummy app with name " << depObjUUID;
    }
 
    void
    ExternalApplicationManager::addStarterObject()
    {
        starter = new ExternalApplicationManagerStarter();
        starter->setParent(this);
        starter->setDependencies(getProperty<Ice::StringSeq>("Dependencies").getValue());
 
        this->getArmarXManager()->addObject(starter, false, starterUUID);
    }
 
    void
    ExternalApplicationManager::setupStream(StreamMetaData& meta)
    {
 
 
        meta.read = [&, this](const boost::system::error_code& error, std::size_t length)
        {
            if (!error)
            {
                std::ostringstream ss;
                ss << &meta.input_buffer;
                std::string s = ss.str();
 
                std::filesystem::path appPath(application);
                if (redirectToArmarXLog)
                {
                    *((ARMARX_LOG_S).setBacktrace(false)->setTag(LogTag(appPath.stem().string())))
                        << meta.level << s;
                }
                else
                {
                    std::cout << s << std::flush;
                }
 
                if (!startUpKeyword.empty() && !depObj)
                {
                    if (Contains(s, startUpKeyword))
                    {
                        addDependencyObject();
                    }
                }
                boost::asio::async_read_until(meta.pend, meta.input_buffer, "\n", meta.read);
            }
            else if (error == boost::asio::error::not_found)
            {
                std::cout << "Did not receive ending character!" << std::endl;
            }
        };
        boost::asio::async_read_until(meta.pend, meta.input_buffer, "\n", meta.read);
        auto run = [&]() { meta.io_service.run(); };
 
        std::thread{run}.detach();
    }
 
    void
    ExternalApplicationManager::startApplication()
    {
        appStoppedOnPurpose = false;
 
        Ice::StringSeq managedObjects = this->getArmarXManager()->getManagedObjectNames();
        bool dummyAlreadyAdded = false;
        for (std::string s : managedObjects)
        {
            if (s == depObjUUID)
            {
                dummyAlreadyAdded = true;
            }
        }
 
        outMetaData.reset(new StreamMetaData());
        errMetaData.reset(new StreamMetaData());
 
        {
            outMetaData->sink = boost::iostreams::file_descriptor_sink(
                outMetaData->pipe.sink, boost::iostreams::close_handle);
            errMetaData->sink = boost::iostreams::file_descriptor_sink(
                errMetaData->pipe.sink, boost::iostreams::close_handle);
 
 
            if (hasProperty("ApplicationArguments") &&
                !getProperty<std::string>("ApplicationArguments").getValue().empty())
            {
                ARMARX_INFO << "Application arguments: "
                            << getProperty<std::string>("ApplicationArguments").getValue();
            }
            ARMARX_INFO << "Commandline: " << simox::alg::join(args, " ");
            childProcess.reset(new boost::process::child(boost::process::execute(
                boost::process::initializers::set_args(args),
                boost::process::initializers::start_in_dir(workingDir),
                boost::process::initializers::bind_stdout(outMetaData->sink),
                boost::process::initializers::bind_stderr(errMetaData->sink),
                boost::process::initializers::inherit_env(),
                // Guarantees that the child process gets killed, even when this process recieves SIGKILL(9) instead of SIGINT(2)
                boost::process::initializers::on_exec_setup(
                    [](boost::process::executor&) { ::prctl(PR_SET_PDEATHSIG, SIGKILL); }))));
        }
 
        outMetaData->level = MessageTypeT::INFO;
        errMetaData->level = MessageTypeT::WARN;
        setupStream(*outMetaData);
        setupStream(*errMetaData);
 
 
        isAppRunning = true;
 
        waitTask = new RunningTask<ExternalApplicationManager>(
            this, &ExternalApplicationManager::waitForApplication);
        waitTask->start();
 
        usleep(1000 * getProperty<int>("FakeObjectStartDelay").getValue());
        if (!dummyAlreadyAdded && startUpKeyword.empty())
        {
            addDependencyObject();
        }
 
        ARMARX_INFO << "Application started";
    }
 
    void
    ExternalApplicationManager::stopApplication()
    {
 
        if (isAppRunning)
        {
            int processId = (*childProcess).pid;
            ARMARX_INFO << "Stopping application with PID " << processId << " with SIGINT";
            appStoppedOnPurpose = true;
 
            if (this->disconnectWhenCrash && this->getArmarXManager())
            {
                this->getArmarXManager()->removeObjectBlocking(depObjUUID);
                depObj = nullptr;
            }
 
            ::killpg(processId, SIGINT);
 
            ARMARX_VERBOSE << "waiting for application " << processId;
            if (!waitForProcessToFinish(processId, getProperty<int>("KillDelay").getValue()))
            {
                ARMARX_VERBOSE << "Application wont stop - killing it now";
                boost::process::terminate(*childProcess); // Sends SIGTERM to the process
            }
 
            cleanUp();
            isAppRunning = false;
        }
    }
 
    void
    ExternalApplicationManager::cleanUp()
    {
        if (waitTask)
        {
            waitTask->stop();
        }
        errMetaData->io_service.stop();
        outMetaData->io_service.stop();
        ARMARX_VERBOSE << "Application cleaned up";
    }
 
    bool
    ExternalApplicationManager::waitForProcessToFinish(int pid, int timeoutMS)
    {
        if (pid <= 0)
        {
            return false;
        }
 
        double startTime = TimeUtil::GetTime().toMilliSecondsDouble();
 
        while ((startTime + timeoutMS > TimeUtil::GetTime().toMilliSecondsDouble()) &&
               ::kill(pid, 0) != -1)
        {
            TimeUtil::MSSleep(100);
        }
 
        if (::kill(pid, 0) == -1)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
 
    ExternalApplicationManager::StreamMetaData::StreamMetaData() :
        pipe(boost::process::create_pipe()), pend(pipe_end(io_service, pipe.source))
    {
    }
 
    ExternalApplicationManager::StreamMetaData::StreamMetaData(
        const ExternalApplicationManager::StreamMetaData& data) :
        pipe(boost::process::create_pipe()), pend(pipe_end(io_service, pipe.source))
    {
    }
 
} // namespace armarx