#include "db.hpp" #include "outbox.hpp" #include "s3_client.hpp" #include #include #include #include namespace { void verify_source(S3Client& s3, const std::string& key, std::size_t expected, const std::string& checksum) { crypto_hash_sha256_state state; crypto_hash_sha256_init(&state); std::size_t received = 0; s3.get_object(key, [&](const char* data, std::size_t n) { if (received > expected || n > expected - received) throw std::runtime_error("source mismatch"); crypto_hash_sha256_update(&state, reinterpret_cast(data), n); received += n; }); unsigned char digest[crypto_hash_sha256_BYTES]; crypto_hash_sha256_final(&state, digest); char hex[crypto_hash_sha256_BYTES * 2 + 1]; sodium_bin2hex(hex, sizeof(hex), digest, sizeof(digest)); if (received != expected || checksum != hex) throw std::runtime_error("source checksum mismatch"); } } int main(int argc, char** argv) { const bool replay = argc == 7 && std::string(argv[1]) == "replay" && std::string(argv[3]) == "--actor" && std::string(argv[5]) == "--reason"; const bool upgrade = argc == 9 && std::string(argv[1]) == "upgrade" && std::string(argv[3]) == "--version" && std::string(argv[5]) == "--actor" && std::string(argv[7]) == "--reason"; if (!replay && !upgrade) { std::cerr << "usage: job_admin replay JOB_UUID --actor NAME --reason REASON\n" " job_admin upgrade ATTACHMENT_UUID --version 2 --actor NAME --reason REASON\n"; return 2; } const std::string id = argv[2], actor = argv[replay ? 4 : 6], reason = argv[replay ? 6 : 8]; const std::regex uuid("^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$"); if (!std::regex_match(id, uuid) || actor.empty() || actor.size() > 100 || reason.empty() || reason.size() > 500 || actor.find_first_not_of(" \t\r\n") == std::string::npos || reason.find_first_not_of(" \t\r\n") == std::string::npos) return 2; if (upgrade && std::string(argv[4]) != "1" && std::string(argv[4]) != "2") return 2; try { if (sodium_init() < 0) return 1; auto conn = open_pg_connection(read_secret_file("DATABASE_URL_FILE"), true); S3Client s3(S3Client::from_env()); pqxx::work tx(*conn); if (upgrade) { const int version = std::stoi(argv[4]); tx.exec("SELECT pg_advisory_xact_lock(hashtextextended('pipeline:' || $1::uuid::text,0))", pqxx::params{id}); auto rows = tx.exec("SELECT pipeline_version,s3_key,size_bytes,sha256 FROM attachments " "WHERE id=$1::uuid FOR UPDATE", pqxx::params{id}); if (rows.empty() || version < rows[0]["pipeline_version"].as()) return 1; if (version == rows[0]["pipeline_version"].as()) { const auto jobs = tx.exec("SELECT id FROM jobs WHERE attachment_id=$1::uuid AND pipeline_version=$2", pqxx::params{id, version}); if (jobs.empty()) return 1; std::cout << nlohmann::json{{"job_id", jobs[0][0].as()}, {"pipeline_version", version}, {"created", false}}.dump() << '\n'; return 0; } const auto& row = rows[0]; verify_source(s3, row["s3_key"].as(), row["size_bytes"].as(), row["sha256"].as()); const auto job = tx.exec("INSERT INTO jobs(id,attachment_id,pipeline_version,source_key) " "VALUES(gen_random_uuid(),$1::uuid,$2,$3) RETURNING id", pqxx::params{id, version, row["s3_key"].as()})[0][0].as(); tx.exec("UPDATE attachments SET pipeline_version=$2, " "status=CASE WHEN published_version IS NULL THEN 'queued' ELSE status END, " "error_code=CASE WHEN published_version IS NULL THEN NULL ELSE error_code END, " "updated_at=CASE WHEN published_version IS NULL THEN now() ELSE updated_at END WHERE id=$1::uuid", pqxx::params{id, version}); tx.exec("INSERT INTO pipeline_requests(attachment_id,pipeline_version,job_id,actor,reason) " "VALUES($1::uuid,$2,$3::uuid,$4,$5)", pqxx::params{id, version, job, actor, reason}); enqueue_attachment_job(tx, job); tx.commit(); std::cout << nlohmann::json{{"job_id", job}, {"pipeline_version", version}, {"created", true}}.dump() << '\n'; return 0; } if (!tx.exec("SELECT pg_try_advisory_xact_lock(hashtextextended($1::uuid::text,0))", pqxx::params{id})[0][0].as()) return 1; const auto rows = tx.exec( "SELECT j.attachment_id,j.status,j.retries,j.source_key,j.pipeline_version, " "a.pipeline_version AS desired_version,a.staging_cleaned_at,a.size_bytes,a.sha256 " "FROM jobs j JOIN attachments a ON a.id=j.attachment_id " "WHERE j.id=$1::uuid FOR UPDATE OF j,a", pqxx::params{id}); if (rows.empty() || rows[0]["status"].as() != "failed" || rows[0]["pipeline_version"].as() != rows[0]["desired_version"].as()) return 1; const auto& row = rows[0]; const std::string source = row["source_key"].as(); if (source.rfind("staging/",0) == 0 && !row["staging_cleaned_at"].is_null()) return 1; verify_source(s3, source, row["size_bytes"].as(), row["sha256"].as()); tx.exec("INSERT INTO job_replays(job_id,actor,reason,previous_error_code,retries_before) " "SELECT id,$2,$3,error_code,retries FROM jobs WHERE id=$1::uuid", pqxx::params{id, actor, reason}); tx.exec("UPDATE jobs SET status='queued',retry_base=retries,error_code=NULL, " "next_attempt_at=now(),updated_at=now() WHERE id=$1::uuid", pqxx::params{id}); tx.exec("UPDATE attachments SET status='queued',s3_key=$2,error_code=NULL,variants='[]'::jsonb,updated_at=now() " "WHERE id=$1::uuid AND published_version IS NULL", pqxx::params{row["attachment_id"].as(), source}); enqueue_attachment_job(tx, id); tx.commit(); std::cout << "replayed job=" << id << '\n'; return 0; } catch (const std::exception&) { std::cerr << "operator action failed; transaction was not confirmed\n"; return 1; } }