ApplicationLifecycle.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 "ApplicationLifecycle.h"
 
#include <thread>
#include <utility>
 
#include <ArmarXCore/core/exceptions/Exception.h>
#include <ArmarXCore/core/logging/Logging.h>
 
#include "../parser/iceparser.h"
#include "Executor.h"
#include "ProcessUtil.h"
 
using namespace ScenarioManager;
using namespace Exec;
using namespace Data_Structure;
 
std::mutex&
ScenarioManager::Exec::LaunchMutex()
{
    static std::mutex mutex;
    return mutex;
}
 
std::shared_mutex&
ScenarioManager::Exec::GlobalOperationMutex()
{
    static std::shared_mutex mutex;
    return mutex;
}
 
ApplicationLifecycle::ApplicationLifecycle(ApplicationInstancePtr application,
                                           StatusManager statusManager) :
    application(std::move(application)), statusManager(statusManager)
{
}
 
void
ApplicationLifecycle::request(Intent intent,
                              const ApplicationStarterPtr& starter,
                              const StopStrategyPtr& stopStrategy,
                              const std::string& commandLineParameters,
                              bool printOnly)
{
    if (intent == Intent::None)
    {
        return;
    }
 
    std::lock_guard<std::mutex> guard(mutex);
 
    if (pending.intent != Intent::None && pending.intent != intent)
    {
        ARMARX_INFO_S << "Superseding the pending " << ToString(pending.intent) << " of `"
                      << application->getName() << "` with " << ToString(intent) << ".";
    }
 
    pending = Request{intent, starter, stopStrategy, commandLineParameters, printOnly};
    publishIntent();
 
    if (!workerRunning)
    {
        workerRunning = true;
        // The worker keeps this object (and through it the application) alive for as long as it
        // runs, so the ScenarioManager may be closed while an operation is still in flight.
        std::thread([self = shared_from_this()] { self->run(); }).detach();
    }
}
 
Intent
ApplicationLifecycle::effectiveIntent() const
{
    std::lock_guard<std::mutex> guard(mutex);
    return pending.intent != Intent::None ? pending.intent : current.intent;
}
 
bool
ApplicationLifecycle::busy() const
{
    return effectiveIntent() != Intent::None;
}
 
void
ApplicationLifecycle::wait()
{
    std::unique_lock<std::mutex> guard(mutex);
    idleCondition.wait(guard,
                       [this] { return !workerRunning && pending.intent == Intent::None; });
}
 
void
ApplicationLifecycle::publishIntent()
{
    application->setPendingIntent(pending.intent != Intent::None ? pending.intent : current.intent);
}
 
void
ApplicationLifecycle::run()
{
    for (;;)
    {
        Request request;
        {
            std::lock_guard<std::mutex> guard(mutex);
            if (pending.intent == Intent::None)
            {
                // Nothing left to do - let the thread go. A later request() spawns a new one.
                current = Request{};
                workerRunning = false;
                publishIntent();
                idleCondition.notify_all();
                return;
            }
 
            request = pending;
            pending = Request{};
            current = request;
            publishIntent();
        }
 
        try
        {
            execute(request);
        }
        catch (...)
        {
            ARMARX_WARNING_S << "The " << ToString(request.intent) << " of application `"
                             << application->getName()
                             << "` failed: " << armarx::GetHandledExceptionString();
        }
 
        {
            std::lock_guard<std::mutex> guard(mutex);
            current = Request{};
            publishIntent();
        }
    }
}
 
void
ApplicationLifecycle::execute(const Request& request)
{
    // Blocks while a global operation such as `armarx killAll` is running.
    std::shared_lock<std::shared_mutex> globalLock(GlobalOperationMutex());
 
    switch (request.intent)
    {
        case Intent::Start:
            executeStart(request);
            break;
        case Intent::Stop:
            executeStop(request);
            break;
        case Intent::Restart:
            executeRestart(request);
            break;
        case Intent::None:
            break;
    }
}
 
void
ApplicationLifecycle::executeStart(const Request& request)
{
    if (isRunning())
    {
        ARMARX_INFO_S << "Application `" << application->getName() << "` is already running.";
        return;
    }
 
    prepare();
 
    // Preparing can take seconds. If the user has asked for a stop in the meantime, never launch
    // the process in the first place.
    if (supersededByStop())
    {
        ARMARX_INFO_S << "Not launching `" << application->getName()
                      << "`: a stop was requested while it was being prepared.";
        return;
    }
 
    launch(request);
}
 
void
ApplicationLifecycle::executeStop(const Request& request)
{
    if (!isRunning())
    {
        return;
    }
 
    stopAndWait(request);
}
 
void
ApplicationLifecycle::executeRestart(const Request& request)
{
    if (isRunning())
    {
        stopAndWait(request);
 
        if (isRunning())
        {
            // Launching now would leave the old process running next to the new one, and only the
            // new pid would be remembered - the ScenarioManager would lose track of the old one.
            ARMARX_WARNING_S << "Not restarting `" << application->getName()
                             << "`: it did not shut down. Force kill it and try again.";
            return;
        }
 
        if (supersededByStop())
        {
            ARMARX_INFO_S << "Not restarting `" << application->getName()
                          << "`: a stop was requested while it was shutting down.";
            return;
        }
    }
 
    // Restarting an application that is not running simply starts it.
    prepare();
 
    if (supersededByStop())
    {
        ARMARX_INFO_S << "Not launching `" << application->getName()
                      << "`: a stop was requested while it was being prepared.";
        return;
    }
 
    launch(request);
}
 
void
ApplicationLifecycle::prepare()
{
    // Generates the property definitions if the cache is cold or the binary was rebuilt, then
    // parses them. The launch needs them: the config domain comes from that xml.
    Executor::loadAndSetCachedProperties(application, Parser::IceParser::getCacheDir(), false, false);
    application->load();
}
 
void
ApplicationLifecycle::launch(const Request& request)
{
    ARMARX_CHECK_NOT_NULL(request.starter);
 
    std::lock_guard<std::mutex> serialize(LaunchMutex());
    request.starter->startApplication(
        application, statusManager, request.commandLineParameters, request.printOnly);
}
 
void
ApplicationLifecycle::stopAndWait(const Request& request)
{
    ARMARX_CHECK_NOT_NULL(request.stopStrategy);
    request.stopStrategy->stop(application);
}
 
bool
ApplicationLifecycle::isRunning()
{
    const int pid = application->getPid();
    if (pid <= 0)
    {
        return false;
    }
 
    if (ProcessUtil::IsAlive(pid))
    {
        // A live pid is only this application's as long as it is still running the right
        // executable. Once our process has exited the kernel may hand its pid to something
        // unrelated, and taking that stranger for the application refuses every start ("it is
        // already running") and makes every stop signal the wrong process.
        //
        // Only a positive mismatch is acted upon: a pid whose /proc entry cannot be read at all is
        // kept, because wrongly declaring a running application dead is the worse error.
        if (ProcessUtil::IdentifyProcess(pid,
                                         application->getExecutableName(),
                                         application->getConfigPath()) !=
            ProcessUtil::Identity::Differs)
        {
            return true;
        }
 
        ARMARX_INFO_S << "The pid " << pid << " remembered for application `"
                      << application->getName()
                      << "` has been recycled by an unrelated process. Forgetting it.";
    }
 
    // A pid left behind by a process that has already died would otherwise block every future
    // start of this application.
    if (application->compareAndResetPid(pid))
    {
        statusManager.savePid(application);
    }
    return false;
}
 
bool
ApplicationLifecycle::supersededByStop() const
{
    std::lock_guard<std::mutex> guard(mutex);
    return pending.intent == Intent::Stop;
}