procedure_manager.h

Go to the documentation of this file.

#pragma once
 
#include <atomic>
#include <cstdint>
#include <expected>
#include <functional>
#include <map>
#include <memory>
#include <mutex>
#include <optional>
#include <ostream>
#include <stop_token>
#include <string>
#include <string_view>
#include <thread>
#include <utility>
#include <vector>
 
#include "node/device.h"
#include "node/device_manager.h"
#include "node/procedure.h"
 
namespace mm::node {
 
struct ProcedureContext {
  DeviceManager& manager;
  Device& device;
  uint16_t devicePosition = 0;
};
 
using ProcedureBody = std::function<std::expected<void, std::string>(
    const ProcedureContext&, ProgressReporter&, std::stop_token)>;
 
struct ProcedureError {
  enum class Kind : uint8_t {
    kBusy,              
    kUnknownDevice,     
    kUnknownProcedure,  
    kInvalidRequest,    
  };
 
  Kind kind = Kind::kBusy;
  std::string message;
 
  const std::string& what() const { return message; }
};
 
inline std::ostream& operator<<(std::ostream& os, const ProcedureError& e) {
  return os << e.message;
}
 
class ProcedureManager {
 public:
  explicit ProcedureManager(DeviceManager& deviceManager) : deviceManager_(deviceManager) {}
 
  ~ProcedureManager();
 
  ProcedureManager(const ProcedureManager&) = delete;
  ProcedureManager& operator=(const ProcedureManager&) = delete;
 
  std::expected<void, ProcedureError> start(uint16_t devicePosition, std::string name,
                                            std::vector<ProgressStep> steps, ProcedureBody body);
 
  std::optional<ProcedureSnapshot> snapshot(uint16_t devicePosition, std::string_view name) const;
 
  bool cancel(uint16_t devicePosition, std::string_view name);
 
 private:
  struct Run {
    std::shared_ptr<ProgressReporter> reporter;  
    uint32_t runCount = 0;                       
    int64_t startedAt = 0;                       
    uint64_t topologyGeneration = 0;
    std::atomic<ProcedureStatus> status{ProcedureStatus::kRunning};
    std::atomic<int64_t> finishedAt{0};  
    std::atomic<bool> running{true};     
    std::jthread thread;
 
    void setError(std::string reason) {
      const std::lock_guard lock(errorMutex_);
      error_ = std::move(reason);
    }
 
    std::optional<std::string> error() const {
      const std::lock_guard lock(errorMutex_);
      return error_;
    }
 
   private:
    mutable std::mutex errorMutex_;
    std::optional<std::string> error_;
  };
 
  using Key = std::pair<uint16_t, std::string>;
 
  using ResolvedWork =
      std::function<std::expected<void, std::string>(ProgressReporter&, std::stop_token)>;
 
  std::expected<void, ProcedureError> startRun(uint16_t devicePosition, std::string name,
                                               std::vector<ProgressStep> steps, ResolvedWork work);
 
  void discardIfRescanned() const;
 
  DeviceManager& deviceManager_;
  mutable std::mutex mutex_;                          
  mutable std::map<Key, std::shared_ptr<Run>> runs_;  
};
 
}  // namespace mm::node