daggy/daggy/include/daggy/Defines.hpp

#pragma once

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

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

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

    // DAG Runs
    using DAGDefID = int16_t;
    using DAGRunID = size_t;
    using TaskID = size_t;

    enum class RunState : uint32_t {
        QUEUED = 0,
        RUNNING = 1,
        RETRY = 1 << 1,
        ERRORED = 1 << 2,
        KILLED = 1 << 3,
        COMPLETED = 1 << 4
    };

    struct Task {
        std::string name;
        std::vector<std::string> command;
        uint32_t maxRetries;
        uint32_t retryIntervalSeconds; // Time to wait between retries
        std::unordered_set<std::string> children;

        bool operator==(const Task &other) const {
            return (name == other.name)
                   and (maxRetries == other.maxRetries)
                   and (retryIntervalSeconds == other.retryIntervalSeconds)
                   and (command == other.command)
                   and (children == other.children);
        }
    };

    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
    };
}