arachne::coordination::domain_lock Class Reference

#include <include/arachne/coordinator.hpp>

Public Member Functions
	domain_lock (const std::filesystem::path &lock_root, std::string_view graph_domain, std::string_view run_id, std::chrono::seconds stale_after=std::chrono::hours(6))
	~domain_lock ()
	domain_lock (const domain_lock &)=delete
domain_lock &	operator= (const domain_lock &)=delete
	domain_lock (domain_lock &&other) noexcept
domain_lock &	operator= (domain_lock &&other) noexcept
bool	owns_lock () const noexcept
void	release ()

Private Attributes
std::filesystem::path	directory_
std::string	ownership_token_
bool	owns_ = false

Detailed Description

Definition at line 155 of file coordinator.hpp.

Constructor & Destructor Documentation

domain_lock() [1/3]

arachne::coordination::domain_lock::domain_lock	(	const std::filesystem::path &	lock_root,
		std::string_view	graph_domain,
		std::string_view	run_id,
		std::chrono::seconds	stale_after = std::chrono::hours(6) )

Definition at line 1569 of file coordinator.cpp.

                                            {
            throw std::logic_error(
                "running product attempt provenance is missing"
            );
        }
        execute(database, "COMMIT;");
    } catch (...) {
        execute(database, "ROLLBACK;");
        throw;
    }
}
 
void operational_ledger::finish_run(
    const std::string_view run_id, const std::string_view status,
    const std::string_view manifest_ref
) {
    if (status != "succeeded" && status != "failed") {
        throw std::invalid_argument("run status must be succeeded or failed");
    }
    if (!is_safe_identifier(run_id)) {
        throw std::invalid_argument("run_id must be a safe stable identifier");
    }
    sqlite3* database = impl_->database.get();
    execute(database, "BEGIN IMMEDIATE;");
    try {
        int attempt_number = 0;
        {
            auto current = prepare(database, R"SQL(
SELECT attempt_count FROM runs WHERE run_id=? AND status='running'
)SQL");
            bind_text(database, current.get(), 1, run_id);
            const int result = sqlite3_step(current.get());
            if (result != SQLITE_ROW) {
                if (result != SQLITE_DONE) {
                    throw_sqlite(database, "inspect running run");
                }
                throw std::logic_error("run is unknown or already finished");
            }
            attempt_number = sqlite3_column_int(current.get(), 0);
        }
        const std::string finished_at = utc_timestamp();
        auto statement = prepare(database, R"SQL(
UPDATE runs SET status = ?, manifest_ref = ?, finished_at = ?
WHERE run_id = ? AND status = 'running'
)SQL");
        bind_text(database, statement.get(), 1, status);
        bind_text(database, statement.get(), 2, manifest_ref);
        bind_text(database, statement.get(), 3, finished_at);
        bind_text(database, statement.get(), 4, run_id);
        step_done(database, statement.get());
        auto attempt = prepare(database, R"SQL(
UPDATE run_attempts SET status=?, manifest_ref=?, finished_at=?
WHERE run_id=? AND attempt=? AND status='running'
)SQL");
        bind_text(database, attempt.get(), 1, status);
        bind_text(database, attempt.get(), 2, manifest_ref);
        bind_text(database, attempt.get(), 3, finished_at);
        bind_text(database, attempt.get(), 4, run_id);
        if (sqlite3_bind_int(attempt.get(), 5, attempt_number) != SQLITE_OK) {
            throw_sqlite(database, "bind run attempt number");
        }
        step_done(database, attempt.get());
        if (sqlite3_changes(database) != 1) {
            throw std::logic_error("running attempt provenance is missing");
        }
        execute(database, "COMMIT;");
    } catch (...) {
        execute(database, "ROLLBACK;");
        throw;
    }
}
 
const std::filesystem::path& operational_ledger::path() const noexcept {
    return path_;
}
 
bool path_is_within(
    const std::filesystem::path& path,
    const std::filesystem::path& possible_parent
) {
    const auto child = weakly_canonical_or_absolute(path);
    const auto parent = weakly_canonical_or_absolute(possible_parent);
    auto child_it = child.begin();
    for (auto parent_it = parent.begin(); parent_it != parent.end();
         ++parent_it, ++child_it) {
        if (child_it == child.end() || *child_it != *parent_it) {
            return false;
        }
    }
    return true;
}
 
void reject_inbox_deletion_target(
    const std::filesystem::path& target, const std::filesystem::path& inbox_root
) {
    if (path_is_within(target, inbox_root)
        || path_is_within(inbox_root, target)) {
        throw std::invalid_argument(
            "refusing deletion inside or above the external legacy inbox"
        );
    }
}
 
domain_lock::domain_lock(
    const std::filesystem::path& lock_root, const std::string_view graph_domain,
    const std::string_view run_id, const std::chrono::seconds stale_after
) {
    if (graph_domain != "product_graph"
        && graph_domain != "research_candidate_graph") {
        throw std::invalid_argument("unknown graph domain");
    }
    if (!is_safe_identifier(run_id)) {
        throw std::invalid_argument("run_id must be a safe stable identifier");
    }
    if (stale_after.count() <= 0) {
        throw std::invalid_argument("lock stale interval must be positive");
    }
    reject_symlink_components(lock_root, "lock root");
    std::filesystem::create_directories(lock_root);
    reject_symlink_components(lock_root, "lock root");
    const auto root = weakly_canonical_or_absolute(lock_root);
    if (root == root.root_path()) {
        throw std::invalid_argument("lock root must be a scoped directory");
    }
    directory_ = root / (std::string(graph_domain) + ".lock");
    std::error_code error;
    const bool created = std::filesystem::create_directory(directory_, error);
    if (!created) {
        if (error) {
            throw std::runtime_error(
                "cannot create graph-domain lock: " + error.message()
            );
        }
        const auto lock_status
            = std::filesystem::symlink_status(directory_, error);

~domain_lock()

arachne::coordination::domain_lock::~domain_lock

(

)

Definition at line 1706 of file coordinator.cpp.

                                                        {
            throw std::runtime_error(
                "graph-domain lock path is not a safe directory"
            );
        }

domain_lock() [2/3]

arachne::coordination::domain_lock::domain_lock ( const domain_lock & )

delete

domain_lock() [3/3]

arachne::coordination::domain_lock::domain_lock ( domain_lock && other )

noexcept

Definition at line 1712 of file coordinator.cpp.

                                                            {
            throw std::runtime_error(
                "graph-domain lock lease is missing or unsafe; maintainer "
                "recovery required"
            );

Member Function Documentation

operator=() [1/2]

domain_lock & arachne::coordination::domain_lock::operator= ( const domain_lock & )

delete

operator=() [2/2]

domain_lock & arachne::coordination::domain_lock::operator= ( domain_lock && other )

noexcept

Definition at line 1720 of file coordinator.cpp.

            {
            std::ifstream input(lease, std::ios::binary);
            nlohmann::json document;
            if (!input) {
                throw std::runtime_error("cannot read graph-domain lock lease");
            }
            input >> document;
            if (!document.is_object()
                || document.value("format_version", 0) != 1
                || document.value("graph_domain", std::string {})
                    != graph_domain
                || !is_safe_identifier(document.value("run_id", std::string {}))
                || !document.contains("acquired_unix")

owns_lock()

bool arachne::coordination::domain_lock::owns_lock ( ) const

nodiscardnoexcept

Definition at line 1734 of file coordinator.cpp.

release()

void arachne::coordination::domain_lock::release

(

)

Definition at line 1736 of file coordinator.cpp.

                                                                      {
                throw std::runtime_error(
                    "graph-domain lock lease ownership token is malformed"
                );
            }
            const auto acquired
                = document.at("acquired_unix").get<std::int64_t>();
            if (acquired <= 0) {
                throw std::runtime_error(
                    "graph-domain lock lease timestamp is malformed"
                );
            }
            if (unix_seconds() - acquired >= stale_after.count()) {
                throw std::runtime_error(
                    "graph-domain lock is stale; maintainer recovery required"
                );
            }
        } catch (const nlohmann::json::exception&) {
            throw std::runtime_error("graph-domain lock lease is malformed");
        }
        throw std::runtime_error("graph domain already has an active writer");
    }
    std::random_device entropy;
    ownership_token_ = crypto::sha256(
        std::string(run_id) + "\n" + std::string(graph_domain) + "\n"
        + std::to_string(
            std::chrono::high_resolution_clock::now().time_since_epoch().count()
        )
        + "\n" + std::to_string(lock_token_sequence.fetch_add(1)) + "\n"
        + std::to_string(entropy())
    );
    const nlohmann::ordered_json lease {
        { "format_version", 1 },
        { "run_id", run_id },
        { "graph_domain", graph_domain },
        { "acquired_unix", unix_seconds() },
        { "ownership_token", ownership_token_ },
    };
    const auto lease_path = directory_ / "lease.json";
    const auto temporary
        = directory_ / (".lease-" + ownership_token_.substr(0, 16) + ".tmp");
    try {
        std::ofstream output(temporary, std::ios::binary | std::ios::trunc);
        if (!output) {
            throw std::runtime_error("cannot write graph-domain lease");
        }
        output << lease.dump(2) << '\n';
        output.flush();
        output.close();
        if (!output) {
            throw std::runtime_error("cannot flush graph-domain lease");
        }
        std::filesystem::rename(temporary, lease_path, error);
        if (error) {
            throw std::runtime_error(
                "cannot publish graph-domain lease: " + error.message()
            );
        }
    } catch (...) {
        std::error_code ignored;
        std::filesystem::remove(temporary, ignored);
        std::filesystem::remove(lease_path, ignored);
        std::filesystem::remove(directory_, ignored);

Member Data Documentation

directory_

std::filesystem::path arachne::coordination::domain_lock::directory_

private

Definition at line 173 of file coordinator.hpp.

ownership_token_

std::string arachne::coordination::domain_lock::ownership_token_

private

Definition at line 174 of file coordinator.hpp.

owns_

bool arachne::coordination::domain_lock::owns_ = false

private

Definition at line 175 of file coordinator.hpp.

---

The documentation for this class was generated from the following files:

• coordinator.hpp
• coordinator.cpp