#include "supervisor/tasks/task_envelope.hpp" #include #include #include #include #include "supervisor/common/clock.hpp" #include "supervisor/common/json.hpp" namespace molo::tasks { std::string to_string(TaskState state) { switch (state) { case TaskState::Queued: return "queued"; case TaskState::Leased: return "leased"; case TaskState::Running: return "running"; case TaskState::Succeeded: return "succeeded"; case TaskState::FailedRetryable: return "failed-retryable"; case TaskState::FailedPermanent: return "failed-permanent"; case TaskState::DeadLettered: return "dead-lettered"; case TaskState::Cancelled: return "cancelled"; } return "queued"; } bool parse_state(const std::string& text, TaskState& out) { if (text == "queued") { out = TaskState::Queued; } else if (text == "leased") { out = TaskState::Leased; } else if (text == "running") { out = TaskState::Running; } else if (text == "succeeded") { out = TaskState::Succeeded; } else if (text == "failed-retryable") { out = TaskState::FailedRetryable; } else if (text == "failed-permanent") { out = TaskState::FailedPermanent; } else if (text == "dead-lettered") { out = TaskState::DeadLettered; } else if (text == "cancelled") { out = TaskState::Cancelled; } else { return false; } return true; } std::string TaskEnvelope::encode() const { using common::JValue; JValue::Object obj; obj["id"] = JValue(id); obj["name"] = JValue(name); JValue payload_value; if (!common::json_decode(payload, payload_value)) { payload_value = JValue(payload); // non-JSON payloads ride as strings } obj["payload"] = payload_value; obj["attempts"] = JValue(attempts); obj["max_retries"] = JValue(max_retries); if (run_at_ms.has_value()) { obj["run_at"] = JValue(common::iso8601(*run_at_ms)); } else { obj["run_at"] = JValue(nullptr); } obj["timeout_soft_ms"] = JValue(static_cast(timeout_soft_ms)); obj["timeout_hard_ms"] = JValue(static_cast(timeout_hard_ms)); obj["idempotency_key"] = JValue(idempotency_key); obj["enqueued_at"] = JValue(common::iso8601(enqueued_at_ms)); obj["state"] = JValue(to_string(state)); return common::json_encode(JValue(obj)); } bool TaskEnvelope::decode(const std::string& text, TaskEnvelope& out) { using common::JValue; JValue root; if (!common::json_decode(text, root) || !root.is_object()) { return false; } const JValue* id = root.find("id"); const JValue* name = root.find("name"); if (id == nullptr || name == nullptr || !id->is_string() || !name->is_string()) { return false; } TaskEnvelope env; env.id = id->as_string(); env.name = name->as_string(); const JValue* payload = root.find("payload"); if (payload != nullptr) { env.payload = common::json_encode(*payload); } const JValue* attempts = root.find("attempts"); const JValue* max_retries = root.find("max_retries"); if (attempts != nullptr) { env.attempts = static_cast(attempts->as_int(0)); } if (max_retries != nullptr) { env.max_retries = static_cast(max_retries->as_int(5)); } const JValue* run_at = root.find("run_at"); if (run_at != nullptr && run_at->is_string()) { const std::int64_t parsed = common::parse_iso8601(run_at->as_string()); if (parsed < 0) { return false; } env.run_at_ms = parsed; } const JValue* soft = root.find("timeout_soft_ms"); const JValue* hard = root.find("timeout_hard_ms"); if (soft != nullptr) { env.timeout_soft_ms = static_cast(soft->as_int(30000)); } if (hard != nullptr) { env.timeout_hard_ms = static_cast(hard->as_int(60000)); } const JValue* key = root.find("idempotency_key"); if (key != nullptr) { env.idempotency_key = key->as_string(); } const JValue* enqueued = root.find("enqueued_at"); if (enqueued != nullptr && enqueued->is_string()) { env.enqueued_at_ms = common::parse_iso8601(enqueued->as_string()); } const JValue* state = root.find("state"); if (state != nullptr && state->is_string()) { if (!parse_state(state->as_string(), env.state)) { return false; } } out = std::move(env); return true; } std::string TaskEnvelope::generate_id() { // UUIDv7 shape: 48-bit unix ms plus 74 random bits, hex with dashes. static thread_local std::mt19937_64 rng{std::random_device{}()}; const auto now = std::chrono::system_clock::now(); const auto ms = static_cast( std::chrono::duration_cast(now.time_since_epoch()).count()); const std::uint64_t hi = (ms << 16) | (rng() & 0xFFFFu); const std::uint64_t lo = rng(); std::ostringstream out; out << std::hex << std::setfill('0') << std::setw(12) << (hi >> 16) << "-" << std::setw(4) << (hi & 0xFFFFu) << "-7" << std::setw(3) << ((lo >> 48) & 0xFFFu) << "-" << std::setw(4) << (((lo >> 32) & 0x3FFFu) | 0x8000u) << "-" << std::setw(12) << (lo & 0xFFFFFFFFFFFFULL); return out.str(); } } // namespace molo::tasks