Executor.cpp

Go to the documentation of this file.

/*
 * This file is part of ArmarX.
 *
 * Copyright (C) 2011-2016, High Performance Humanoid Technologies (H2T), Karlsruhe Institute of Technology (KIT), all rights reserved.
 *
 * 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
 * @author     Nicola Miskowiec
 * @date       2016
 * @copyright  http://www.gnu.org/licenses/gpl-2.0.txt
 *             GNU General Public License
 */
 
 
#include "Executor.h"
 
#include <signal.h>
 
#include <chrono>
#include <filesystem>
#include <thread>
 
#include <sys/types.h>
 
#include <boost/process.hpp>
 
#include "ArmarXCore/util/ScenarioManagerCommon/parser/iceparser.h"
#include <ArmarXCore/core/exceptions/Exception.h>
#include <ArmarXCore/core/logging/Logging.h>
 
#include "ApplicationLifecycle.h"
#include "ProcessUtil.h"
 
using namespace ScenarioManager;
 
Exec::Executor::Executor(Exec::StopStrategyPtr strategy, Exec::ApplicationStarterPtr starter)
{
    setDefaultStopStrategy(strategy);
    setDefaultStarter(starter);
}
 
Exec::ApplicationLifecyclePtr
Exec::Executor::lifecycleFor(const ApplicationInstancePtr& application)
{
    std::lock_guard<std::mutex> guard(lifecyclesMutex);
 
    ApplicationLifecyclePtr& lifecycle = lifecycles[application.get()];
    if (!lifecycle)
    {
        lifecycle = std::make_shared<ApplicationLifecycle>(application, statusManager);
    }
    return lifecycle;
}
 
void
Exec::Executor::startApplication(ApplicationInstancePtr application,
                                 bool printOnly,
                                 const std::string& commandLineParameters)
{
    const Data_Structure::ScenarioPtr scenario = application->getScenario();
    lifecycleFor(application)
        ->request(Data_Structure::Intent::Start,
                  getStarter(scenario),
                  getStopStrategy(scenario),
                  commandLineParameters,
                  printOnly);
}
 
void
Exec::Executor::stopApplication(ApplicationInstancePtr application)
{
    const Data_Structure::ScenarioPtr scenario = application->getScenario();
    lifecycleFor(application)
        ->request(Data_Structure::Intent::Stop, getStarter(scenario), getStopStrategy(scenario));
}
 
void
Exec::Executor::restartApplication(ApplicationInstancePtr application, bool printOnly)
{
    const Data_Structure::ScenarioPtr scenario = application->getScenario();
    lifecycleFor(application)
        ->request(Data_Structure::Intent::Restart,
                  getStarter(scenario),
                  getStopStrategy(scenario),
                  "",
                  printOnly);
}
 
void
Exec::Executor::waitForApplication(const ApplicationInstancePtr& application)
{
    lifecycleFor(application)->wait();
}
 
void
Exec::Executor::waitForScenario(const Data_Structure::ScenarioPtr& scenario)
{
    for (const ApplicationInstancePtr& application : *scenario->getApplications())
    {
        waitForApplication(application);
    }
}
 
std::string
Exec::Executor::getApplicationStatus(ApplicationInstancePtr application)
{
    // An application with an intent in flight is shown as waiting rather than by whatever its
    // process happens to be doing halfway through a start or a stop.
    if (application->getPendingIntent() != Data_Structure::Intent::None)
    {
        return Data_Structure::ApplicationStatus::Waiting;
    }
    return getStarter(application->getScenario())->getStatus(application, statusManager);
}
 
void
Exec::Executor::requestForScenario(const Data_Structure::ScenarioPtr& scenario,
                                   Data_Structure::Intent intent,
                                   const std::string& commandLineParameters,
                                   bool printOnly)
{
    // Every application gets its own request, so a scenario operation is just a bulk of them and
    // an individual click on one application composes with it under the same last-intent-wins
    // rule. The applications are launched in no particular order; the LaunchMutex keeps the
    // spawning itself from happening all at once.
    for (const ApplicationInstancePtr& application : *scenario->getApplications())
    {
        lifecycleFor(application)
            ->request(intent,
                      getStarter(scenario),
                      getStopStrategy(scenario),
                      commandLineParameters,
                      printOnly);
    }
}
 
void
Exec::Executor::startScenario(Data_Structure::ScenarioPtr scenario,
                              bool printOnly,
                              const std::string& commandLineParameters)
{
    requestForScenario(scenario, Data_Structure::Intent::Start, commandLineParameters, printOnly);
}
 
void
Exec::Executor::stopScenario(Data_Structure::ScenarioPtr scenario)
{
    requestForScenario(scenario, Data_Structure::Intent::Stop, "", false);
}
 
void
Exec::Executor::restartScenario(Data_Structure::ScenarioPtr scenario, bool printOnly)
{
    requestForScenario(scenario, Data_Structure::Intent::Restart, "", printOnly);
}
 
void
Exec::Executor::generatePropertiesXml(const Data_Structure::ApplicationPtr& application,
                                      const std::filesystem::path& xmlFilePath)
{
    // Launches the application binary once so that it dumps its property definitions.
    //
    // This used to be a system() call. Once SIGCHLD is set to SIG_IGN - which the starter does
    // process wide - system() still waits for the command, but can no longer reap it and so always
    // returns -1: every generation was reported as failed even when it had worked, and a genuine
    // failure was indistinguishable from success. Spawn the child directly and watch the process
    // instead, which does not depend on the signal disposition, bounds the wait, and lets us check
    // that something was actually written.
    const std::string executable = application->getExecutableAbsPath();
    const std::string commandLine = executable + " -p -f xml -o " + xmlFilePath.string();
 
    using namespace boost::process;
    using namespace boost::process::initializers;
 
    int pid = -1;
    try
    {
        child c = execute(run_exe(executable), set_cmd_line(commandLine), inherit_env());
        pid = c.pid;
    }
    catch (const std::exception& e)
    {
        ARMARX_WARNING << "Failed to generate properties xml for " << application->getName()
                       << ": " << e.what() << "\nCommand was: " << commandLine;
        return;
    }
 
    if (!ProcessUtil::WaitForExit(pid, PropertyGenerationTimeout))
    {
        ARMARX_WARNING << "Generating the properties xml for " << application->getName()
                       << " did not finish within " << PropertyGenerationTimeout.count()
                       << " ms, giving up on it.\nCommand was: " << commandLine;
        ::kill(pid, SIGKILL);
        return;
    }
 
    std::error_code ec;
    if (!std::filesystem::exists(xmlFilePath, ec) ||
        std::filesystem::file_size(xmlFilePath, ec) == 0)
    {
        ARMARX_WARNING << "Failed to generate properties xml for " << application->getName()
                       << "\nCommand was: " << commandLine;
    }
}
 
void
Exec::Executor::loadAndSetCachedProperties(Data_Structure::ApplicationPtr application,
                                           std::string path,
                                           bool reload,
                                           bool set)
{
    std::filesystem::path xmlFilePath =
        std::filesystem::path(path) / std::filesystem::path(application->getPackageName() + "." +
                                                            application->getName() + ".xml");
 
    if (reload || !std::filesystem::exists(xmlFilePath))
    {
        // The properties can only be dumped by running the binary, so there is nothing to do if it
        // is not there. Without this check we would fork and then wait out the whole generation
        // timeout for an application that can never produce anything.
        application->updateFound();
        if (!application->getFound())
        {
            ARMARX_WARNING << "Cannot generate the properties xml for " << application->getName()
                           << ": the binary is missing at " << application->getExecutableAbsPath();
            return;
        }
 
        std::filesystem::create_directories(path);
        generatePropertiesXml(application, xmlFilePath);
    }
    else
    {
        application->updateFound();
        if (!application->getFound())
        {
            return;
        }
        //if executable more recent that xml reload xml
        auto xmlDate = (std::filesystem::last_write_time(xmlFilePath));
 
        auto execDate =
            std::filesystem::last_write_time(application->getPathToExecutable().append("/").append(
                application->getExecutableName()));
 
        if (execDate > xmlDate)
        {
            loadAndSetCachedProperties(application, path, true, set);
            return;
        }
    }
 
    if (set)
    {
        Parser::IceParser parser;
        application->setProperties(parser.loadFromXml(xmlFilePath.string()));
    }
}
 
void
Exec::Executor::setDefaultStopStrategy(StopStrategyPtr strategy)
{
    defaultStopStrategy = strategy;
}
 
void
Exec::Executor::setDefaultStarter(ApplicationStarterPtr appStarter)
{
    defaultStartStrategy = appStarter;
}
 
void
Exec::Executor::setStopStrategy(StopStrategyPtr strategy, Data_Structure::ScenarioPtr scenario)
{
    this->stopStrategy[scenario] = strategy;
}
 
void
Exec::Executor::setStarter(ApplicationStarterPtr appStarter, Data_Structure::ScenarioPtr scenario)
{
    this->starter[scenario] = appStarter;
}
 
Exec::ApplicationStarterPtr
Exec::Executor::getStarter(Data_Structure::ScenarioPtr scenario)
{
    if (starter.count(scenario) == 0)
    {
        return defaultStartStrategy;
    }
    return starter[scenario];
}
 
Exec::StopStrategyPtr
Exec::Executor::getStopStrategy(Data_Structure::ScenarioPtr scenario)
{
    if (stopStrategy.count(scenario) == 0)
    {
        return defaultStopStrategy;
    }
    return stopStrategy[scenario];
}
 
Exec::StopStrategyPtr
Exec::Executor::getDefaultStopStrategy()
{
    return defaultStopStrategy;
}