StopStrategy.h

Go to the documentation of this file.

#pragma once
 
#include <chrono>
 
#include "../data_structure/ApplicationInstance.h"
#include "../parser/StatusManager.h"
#include "ApplicationStopper.h"
 
using ApplicationInstancePtr =
    std::shared_ptr<ScenarioManager::Data_Structure::ApplicationInstance>;
 
namespace ScenarioManager::Data_Structure
{
    using ApplicationInstancePtr = std::shared_ptr<ApplicationInstance>;
}
 
namespace ScenarioManager::Exec
{
    class ApplicationStopper;
    typedef std::shared_ptr<ApplicationStopper> ApplicationStopperPtr;
 
    /**
    * @class StopStrategy
    * @ingroup exec
    * @brief Interface for classes that define how an application get stopped.
    */
    class StopStrategy
    {
    protected:
        ApplicationStopperPtr stopper;
 
        /**
         * How long to wait for a signalled process to actually disappear before giving up.
         */
        static constexpr std::chrono::milliseconds TerminationTimeout{10000};
 
        /**
         * Waits until the process that was signalled has terminated, then clears the application's
         * pid.
         *
         * A stop is only finished once the process is really gone. Returning earlier would let a
         * directly following start race with a process that is still shutting down, and would make
         * the status poller and the stopper fight over the pid and the cached pid file.
         *
         * @param application the application that was signalled.
         * @param signalledPid the pid that was signalled, or -1 if nothing was signalled.
         */
        void awaitTermination(const Data_Structure::ApplicationInstancePtr& application,
                              int signalledPid);
 
    public:
        StopStrategy(ApplicationStopperPtr stopper);
 
        /**
        * Stops an application. Implement this method to define the behaviour when stopping applications.
        * @param application application to be stopped.
        */
        virtual void stop(Data_Structure::ApplicationInstancePtr application) = 0;
    };
 
    using StopStrategyPtr = std::shared_ptr<StopStrategy>;
} // namespace ScenarioManager::Exec