isuperviseapplication.h

Go to the documentation of this file.

/*
* Copyright 2025 Ingemar Hedvall
 * SPDX-License-Identifier: MIT
 */

#pragma once
 
#include <algorithm>
#include <atomic>
#include <string>
#include <string_view>
#include <vector>
 
namespace util::xml {
class IXmlNode;
}
 
namespace util::supervise {

enum class ApplicationState : uint8_t {
  Stopped = 0, 
  Running = 1, 
  Failing = 2, 
  Ready = 3,   
};

enum class ApplicationStartup : uint8_t {
  Manual = 0, 
  Once = 1, 
  Automatic = 2, 
};

enum class ApplicationPriority : uint8_t {
  Realtime, 
  High, 
  AboveNormal, 
  Normal, 
  BelowNormal, 
  Idle 
};

class ISuperviseApplication {
 public:
  virtual ~ISuperviseApplication() = default;

  void Name(std::string name) { name_ = std::move(name); }

  [[nodiscard]] const std::string &Name() const { return name_; }

  void Path(std::string path) {
    path_ = std::move(path);
  }

  [[nodiscard]] const std::string &Path() const {
    return path_;
  }

  void Arguments(std::string arguments) {
    arguments_ = std::move(arguments);
  }

  [[nodiscard]] const std::string &Arguments() const {
    return arguments_;
  }

  void Startup(ApplicationStartup startup) { startup_ = startup; }

  [[nodiscard]] ApplicationStartup Startup() const { return startup_; }
 

  void Priority(ApplicationPriority priority) { priority_ = priority; }

  [[nodiscard]] ApplicationPriority Priority() const { return priority_; }

  void ShowWindow(bool show) { show_window_ = show; }

  [[nodiscard]] bool ShowWindow() const { return show_window_; }

  void StartupDelay(uint32_t delay) { startup_delay_ = delay; }

  [[nodiscard]] uint32_t StartupDelay() const { return startup_delay_; }

  void MaxRestarts(uint32_t max_restarts) { max_restarts_ = max_restarts; }

  [[nodiscard]] uint32_t MaxRestarts() const { return max_restarts_; }

  void InService(bool in_service) { in_service_ = in_service; }

  [[nodiscard]] bool InService() const { return in_service_; }

  [[nodiscard]] uint32_t NofRestarts() const { return nof_restarts_; }

  [[nodiscard]] bool Operable() const { return operable_; }

  [[nodiscard]] ApplicationState State() const { return state_; }

  virtual void Start();

  virtual void Stop();

  virtual void Poll();

  void ReadConfig(const xml::IXmlNode &application_node);

  void SaveConfig(xml::IXmlNode &root_node) const;
 
 protected:

  void IncrementNofRestarts() { ++nof_restarts_; }

  void ResetNofRestarts() { nof_restarts_ = 0; }

  void Operable(bool operable) { operable_ = operable; }

  void State(ApplicationState state) { state_ = state; }

  std::vector<std::string> ParseCommandLine() const;
 
 private:
  std::string name_; 
  std::string path_; 
  std::string arguments_; 
 
  bool show_window_ = true; 
  uint32_t startup_delay_ = 0; 
  uint32_t max_restarts_ = 100; 
 
  std::atomic<ApplicationStartup> startup_ = ApplicationStartup::Manual;
  ApplicationPriority priority_ = ApplicationPriority::Normal;
 
  std::atomic<uint32_t> nof_restarts_ = 0;
  std::atomic<bool> in_service_ = false;
  std::atomic<bool> operable_ = false;
  std::atomic<ApplicationState> state_ = ApplicationState::Stopped;

  void StartupAsString(const std::string &startup);

  [[nodiscard]] std::string_view StartupAsString() const;

  void PriorityAsString(const std::string &priority);

  [[nodiscard]] std::string_view PriorityAsString() const;
 
};
 
} // util