daggy/libdaggy/include/daggy/Defines.hpp

#pragma once

#include <enum.h>

#include <chrono>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <variant>
#include <vector>

namespace daggy {
  // Commands and parameters
  using ConfigValue  = std::variant<std::string, std::vector<std::string>>;
  using ConfigValues = std::unordered_map<std::string, ConfigValue>;
  using Command      = std::vector<std::string>;

  // Time
  using Clock     = std::chrono::high_resolution_clock;
  using TimePoint = std::chrono::time_point<Clock>;

  // DAG Runs
  using DAGRunID = size_t;

  BETTER_ENUM(RunState, uint32_t, QUEUED = 1, RUNNING, RETRY, ERRORED, KILLED,
              PAUSED, COMPLETED);

  struct Task
  {
    std::string definedName;
    bool isGenerator;  // True if the output of this task is a JSON set of tasks
                       // to complete
    uint32_t maxRetries;
    uint32_t retryIntervalSeconds;  // Time to wait between retries
    ConfigValues job;  // It's up to the individual inspectors to convert values
                       // from strings // array of strings
    std::unordered_set<std::string> children;
    std::unordered_set<std::string> parents;

    bool operator==(const Task &other) const
    {
      return (definedName == other.definedName) and
             (maxRetries == other.maxRetries) and
             (retryIntervalSeconds == other.retryIntervalSeconds) and
             (job == other.job) and (children == other.children) and
             (parents == other.parents) and (isGenerator == other.isGenerator);
    }
  };

  using TaskSet = std::unordered_map<std::string, Task>;

  // All the components required to define and run a DAG
  struct TaskParameters
  {
    ConfigValues variables;
    ConfigValues jobDefaults;
  };

  struct DAGSpec
  {
    std::string tag;
    TaskSet tasks;
    TaskParameters taskConfig;
  };

  struct AttemptRecord
  {
    TimePoint startTime;
    TimePoint stopTime;
    int rc;                   // RC from the task
    std::string executorLog;  // Logs from the dag_executor
    std::string outputLog;    // stdout from command
    std::string errorLog;     // stderr from command
  };
}  // namespace daggy

BETTER_ENUMS_DECLARE_STD_HASH(daggy::RunState)