ProcessService.h

Go to the documentation of this file.

#ifndef LINTEL_PROCESSSERVICE_H
#define LINTEL_PROCESSSERVICE_H
 
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <filesystem>
#include <future>
#include <memory>
#include <mutex>
#include <thread>
 
#include "lintel/core/configuration/Configuration.h"
#include "lintel/core/configuration/EnvironmentConfiguration.h"
#include "lintel/core/models/ProcessName.h"
#include "lintel/core/services/PropertyRegistration.h"
#include "lintel/core/utils/ProcessResourceReader.h"
#include "lintel/features/base/controller/ProcessGroupDto.h"
#include "lintel/features/base/models/Process.h"
#include "lintel/features/base/models/ProcessGroup.h"
#include "lintel/features/base/models/ProcessInfo.h"
#include "lintel/features/base/services/IHistoryService.h"
 
#include <boost/process/v1/detail/config.hpp>
 
// boost::process::v1 is an inline namespace only for BOOST_PROCESS_VERSION == 1 and a plain nested
// namespace otherwise - see BOOST_PROCESS_V1_INLINE in boost/process/v1/detail/config.hpp. A
// hardcoded "inline" here therefore only compiles while this header happens to be seen before any
// boost/process header; the reverse order (which every consumer that spawns a process itself will
// have) fails with "inline namespace must be specified at initial definition". config.hpp is the
// cheap header that defines the macro, so forward declaring through it keeps the child type
// incomplete - no boost/process/child.hpp in every translation unit that sees ProcessService.h.
namespace boost::process {
BOOST_PROCESS_V1_INLINE namespace v1 { class child; }
}// namespace boost::process
 
namespace lintel {
class ProcessService : public PropertyRegistration<ProcessService>
{
private:
  class ProcessExecutes
  {
  private:
    // variables
    std::shared_ptr<Process> m_process = nullptr;
    std::shared_ptr<boost::process::v1::child> m_child;
    std::shared_ptr<std::promise<int>> m_promise = nullptr;
    // automation state
    std::chrono::steady_clock::time_point m_processStartTime{};
    std::chrono::steady_clock::time_point m_lastRestartTime{};
    int m_consecutiveFailures = 0;
    bool m_failed = false;
    std::optional<ProcessResourceData> m_lastResourceSample;
    std::chrono::steady_clock::time_point m_lastNotifyTime{};
 
  public:
    ProcessExecutes() = default;
 
    void setProcess(std::shared_ptr<Process> process) { m_process = std::move(process); }
 
    void setChild(std::shared_ptr<boost::process::v1::child> child)
    {
      m_child = std::move(child);
      m_processStartTime = std::chrono::steady_clock::now();
    }
 
    [[nodiscard]] const std::shared_ptr<Process> &getProcess() const { return m_process; }
 
    [[nodiscard]] std::shared_ptr<boost::process::v1::child> &getChild() { return m_child; }
 
    void setPromiseValue(int exitCode)
    {
      if (m_promise == nullptr) { m_promise = std::make_shared<std::promise<int>>(); }
      m_promise->set_value(exitCode);
    }
 
    void setPromiseException(const std::exception_ptr &p)
    {
      if (m_promise == nullptr) { m_promise = std::make_shared<std::promise<int>>(); }
      m_promise->set_exception(p);
    }
 
    std::future<int> getFuture()
    {
      if (m_promise == nullptr) { m_promise = std::make_shared<std::promise<int>>(); }
      return m_promise->get_future();
    }
 
    void markStart() { m_processStartTime = std::chrono::steady_clock::now(); }
 
    [[nodiscard]] std::chrono::steady_clock::time_point processStartTime() const { return m_processStartTime; }
 
    void markRestart() { m_lastRestartTime = std::chrono::steady_clock::now(); }
 
    [[nodiscard]] std::chrono::steady_clock::time_point lastRestartTime() const { return m_lastRestartTime; }
 
    void setConsecutiveFailures(int failures) { m_consecutiveFailures = failures; }
 
    [[nodiscard]] int consecutiveFailures() const { return m_consecutiveFailures; }
 
    void setFailed(bool failed) { m_failed = failed; }
 
    [[nodiscard]] bool isFailed() const { return m_failed; }
 
    void setResourceSample(ProcessResourceData sample) { m_lastResourceSample = sample; }
 
    [[nodiscard]] const std::optional<ProcessResourceData> &resourceSample() const { return m_lastResourceSample; }
 
    void setLastNotifyTime(std::chrono::steady_clock::time_point time) { m_lastNotifyTime = time; }
 
    [[nodiscard]] std::chrono::steady_clock::time_point lastNotifyTime() const { return m_lastNotifyTime; }
  };
 
  // injections
  std::shared_ptr<ProcessName> m_processName;
  std::shared_ptr<EnvironmentConfiguration> m_environmentConfiguration;
  std::shared_ptr<Process> m_process;
  std::shared_ptr<Configuration> m_configuration;
  std::shared_ptr<IHistoryService> m_historyService;
  // variables
  std::mutex m_processesMutex;
  std::map<std::string, ProcessExecutes> m_processes;
  std::mutex m_processGroupMutex;
  std::map<std::string, std::shared_ptr<ProcessGroup>> m_processGroups;
  std::thread m_monitorThread;
  std::atomic_bool m_running = true;
  std::condition_variable m_condition;
  std::mutex m_mutex;
  // properties
  std::shared_ptr<Property<std::chrono::seconds>> m_monitorWaitTime;
  std::shared_ptr<Property<std::chrono::milliseconds>> m_processStopWaitTime;
 
  void run();
 
  void monitorProcess();
 
  void monitorProcessGroups();
 
  std::filesystem::path resolvePath(const std::filesystem::path &path) const;
 
  std::shared_ptr<boost::process::v1::child>
    spawnChild(const std::filesystem::path &path, const std::vector<std::string> &args, const std::string &configName);
 
  void sampleResources(const std::string &id, ProcessExecutes &processExecutes);
 
  void refreshResourceSampleIfStale(ProcessExecutes &processExecutes);
 
  ProcessInfo processInfoOf(const std::string &id,
    ProcessExecutes &processExecutes,
    const std::string &groupName,
    const std::string &groupId);
 
public:
  ProcessService(std::shared_ptr<ProcessName> processName,
    std::shared_ptr<EnvironmentConfiguration> environmentConfiguration,
    std::shared_ptr<Configuration> configuration,
    std::shared_ptr<IHistoryService> historyService);
 
  ~ProcessService() override;
 
  // Process Information
  std::vector<ProcessGroupDto> allGroupsOf(const std::string &name);
 
  std::vector<ProcessInfo> allActiveOf();
 
  ProcessInfo currentOf();
 
  std::optional<std::shared_ptr<Process>> of(const std::string &id);
 
  // Process operations
  std::optional<std::future<int>> startOf(const Process &process);
 
  void restartOf(const Process &process);
 
  bool stopOf(const Process &process);
 
  void terminateOf(const Process &process);
 
  void detachOf(const Process &process);
 
  void resetOf(const Process &process);
 
  // Process group operations
  void startOf(const ProcessGroup &processGroup);
 
  void restartOf(const ProcessGroup &processGroup);
 
  bool stopOf(const ProcessGroup &processGroup);
 
  void terminateOf(const ProcessGroup &processGroup);
 
  void detachOf(const ProcessGroup &processGroup);
 
  bool isLastProcess();
 
  ShutdownPriority shutdownPriorityOf() const override { return ShutdownPriority::PROCESS_SERVICE; }
 
  void onInitialize() override;
};
 
}// namespace lintel
#endif// LINTEL_PROCESSSERVICE_H