Add cellular durable action record lookup
Foundation / checks (deploy) (push) Successful in 5s
Foundation / checks (checks) (push) Failing after 40s
Foundation / checks (ecs) (push) Successful in 1m50s
Foundation / checks (tsan) (push) Canceled after 0s
Foundation / postgres-tools (push) Canceled after 0s
Foundation / server-image (push) Canceled after 0s
Foundation / image (push) Canceled after 0s
Foundation / checks (postgres) (push) Canceled after 26s
Foundation / checks (network) (push) Canceled after 1m49s
Foundation / checks (client) (push) Canceled after 2m29s
Foundation / checks (deploy) (push) Successful in 5s
Foundation / checks (checks) (push) Failing after 40s
Foundation / checks (ecs) (push) Successful in 1m50s
Foundation / checks (tsan) (push) Canceled after 0s
Foundation / postgres-tools (push) Canceled after 0s
Foundation / server-image (push) Canceled after 0s
Foundation / image (push) Canceled after 0s
Foundation / checks (postgres) (push) Canceled after 26s
Foundation / checks (network) (push) Canceled after 1m49s
Foundation / checks (client) (push) Canceled after 2m29s
This commit is contained in:
@@ -114,6 +114,43 @@ template <typename T> std::optional<T> parse_integer(const std::optional<std::st
|
||||
return std::nullopt;
|
||||
return value;
|
||||
}
|
||||
std::uint64_t little(std::span<const std::uint8_t> bytes, std::size_t at, std::size_t width) {
|
||||
std::uint64_t value{};
|
||||
for (std::size_t i = 0; i < width; ++i)
|
||||
value |= static_cast<std::uint64_t>(bytes[at + i]) << (i * 8);
|
||||
return value;
|
||||
}
|
||||
std::optional<CommittedActionRecord> parse_action_record(const PgRows::value_type& row,
|
||||
std::size_t at) {
|
||||
if (row.size() < at + 6)
|
||||
return std::nullopt;
|
||||
const auto region = parse_integer<std::uint64_t>(row[at]);
|
||||
const auto tick = parse_integer<std::uint64_t>(row[at + 1]);
|
||||
const auto sequence = parse_integer<std::uint64_t>(row[at + 2]);
|
||||
const auto kind = parse_integer<std::uint16_t>(row[at + 3]);
|
||||
const auto result = parse_integer<std::uint8_t>(row[at + 4]);
|
||||
if (!region || !tick || !sequence || !kind || !result)
|
||||
return std::nullopt;
|
||||
std::optional<std::vector<std::uint8_t>> input;
|
||||
if (row[at + 5]) {
|
||||
input = unhex_bytes(*row[at + 5]);
|
||||
if (!input)
|
||||
return std::nullopt;
|
||||
}
|
||||
if (*kind == 1) {
|
||||
if (*result != 1 || input)
|
||||
return std::nullopt;
|
||||
} else if (*kind == 2) {
|
||||
if (*result != 5 || !input || input->size() != 24 || little(*input, 0, 8) != *tick ||
|
||||
(*input)[12] > 1 || (*input)[13] != 0 || (*input)[14] != 0 || (*input)[15] != 0 ||
|
||||
((*input)[12] == 0 && little(*input, 16, 8) != 0))
|
||||
return std::nullopt;
|
||||
} else {
|
||||
return std::nullopt;
|
||||
}
|
||||
return CommittedActionRecord{CommittedAction{*region, *tick, *sequence}, *kind, *result,
|
||||
std::move(input)};
|
||||
}
|
||||
std::string bytea(std::span<const std::uint8_t> b) {
|
||||
return "\\x" + hex(b);
|
||||
}
|
||||
@@ -354,6 +391,30 @@ find_region_action(Postgres& db, RegionKey key, const LeaseGrant& lease, const U
|
||||
return std::optional<CommittedAction>{CommittedAction{*region, *tick, *sequence}};
|
||||
}
|
||||
|
||||
std::expected<std::optional<CommittedActionRecord>, LeaseStoreFailure>
|
||||
find_region_action_record(Postgres& db, RegionKey key, const LeaseGrant& lease,
|
||||
const Uuid& account, std::uint64_t action_id, milliseconds timeout) {
|
||||
const std::array<std::string, 6> p{std::to_string(key.world), std::to_string(key.region),
|
||||
uuid_text(lease.holder), std::to_string(lease.epoch),
|
||||
uuid_text(account), std::to_string(action_id)};
|
||||
auto rows = db.query("SELECT action_region, action_tick, action_commit, action_kind, "
|
||||
"action_result, encode(action_input, 'hex') "
|
||||
"FROM evolution.find_region_action_record($1::evolution.u64, "
|
||||
"$2::evolution.u64, $3::uuid, $4::evolution.u64, $5::uuid, "
|
||||
"$6::evolution.u64)",
|
||||
p, timeout);
|
||||
if (!rows)
|
||||
return std::unexpected{classify(rows.error())};
|
||||
if (rows->empty())
|
||||
return std::optional<CommittedActionRecord>{};
|
||||
if (rows->size() != 1 || (*rows)[0].size() != 6)
|
||||
return std::unexpected{malformed(false)};
|
||||
const auto record = parse_action_record((*rows)[0], 0);
|
||||
if (!record)
|
||||
return std::unexpected{malformed(false)};
|
||||
return std::optional<CommittedActionRecord>{*record};
|
||||
}
|
||||
|
||||
std::expected<std::vector<std::optional<CommittedAction>>, LeaseStoreFailure>
|
||||
find_region_actions(Postgres& db, RegionKey key, const LeaseGrant& lease,
|
||||
std::span<const ActionRef> actions, milliseconds timeout) {
|
||||
@@ -398,6 +459,44 @@ find_region_actions(Postgres& db, RegionKey key, const LeaseGrant& lease,
|
||||
return out;
|
||||
}
|
||||
|
||||
std::expected<std::vector<std::optional<CommittedActionRecord>>, LeaseStoreFailure>
|
||||
find_region_action_records(Postgres& db, RegionKey key, const LeaseGrant& lease,
|
||||
std::span<const ActionRef> actions, milliseconds timeout) {
|
||||
std::vector<std::optional<CommittedActionRecord>> out(actions.size());
|
||||
if (actions.empty())
|
||||
return out;
|
||||
std::string accounts = "{", ids = "{";
|
||||
for (std::size_t i = 0; i < actions.size(); ++i) {
|
||||
accounts += (i == 0 ? "" : ",") + uuid_text(actions[i].account);
|
||||
ids += (i == 0 ? "" : ",") + std::to_string(actions[i].action_id);
|
||||
}
|
||||
accounts += "}";
|
||||
ids += "}";
|
||||
const std::array<std::string, 6> p{std::to_string(key.world), std::to_string(key.region),
|
||||
uuid_text(lease.holder), std::to_string(lease.epoch),
|
||||
accounts, ids};
|
||||
auto rows = db.query("SELECT x.n, f.action_region, f.action_tick, f.action_commit, "
|
||||
"f.action_kind, f.action_result, encode(f.action_input, 'hex') "
|
||||
"FROM unnest($5::uuid[], $6::numeric[]) WITH ORDINALITY AS x(a, i, n) "
|
||||
"CROSS JOIN LATERAL evolution.find_region_action_record("
|
||||
"$1::evolution.u64, $2::evolution.u64, $3::uuid, $4::evolution.u64, "
|
||||
"x.a, x.i::evolution.u64) AS f",
|
||||
p, timeout);
|
||||
if (!rows)
|
||||
return std::unexpected{classify(rows.error())};
|
||||
for (const auto& row : *rows) {
|
||||
if (row.size() != 7)
|
||||
return std::unexpected{malformed(false)};
|
||||
const auto ordinal = parse_integer<std::uint64_t>(row[0]);
|
||||
const auto record = parse_action_record(row, 1);
|
||||
if (!ordinal || *ordinal == 0 || *ordinal > actions.size() ||
|
||||
out[*ordinal - 1].has_value() || !record)
|
||||
return std::unexpected{malformed(false)};
|
||||
out[*ordinal - 1] = *record;
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
namespace {
|
||||
std::expected<std::vector<CommittedDecision>, LeaseStoreFailure>
|
||||
decisions_from(const PgRows& rows) {
|
||||
|
||||
@@ -1,5 +1,7 @@
|
||||
#include "evo/server/postgres_action_ledger.hpp"
|
||||
|
||||
#include <algorithm>
|
||||
|
||||
namespace evo::server {
|
||||
std::expected<std::optional<network::ActionOutcome>, network::ActionLedgerError>
|
||||
PostgresActionLedger::find(const network::AccountId& account, std::uint64_t action_id) {
|
||||
@@ -26,6 +28,95 @@ PostgresActionLedger::find(const network::AccountId& account, std::uint64_t acti
|
||||
record.value().tick, record.value().commit_sequence}};
|
||||
}
|
||||
|
||||
std::expected<std::optional<network::DurableActionRecord>, network::ActionLedgerError>
|
||||
PostgresActionLedger::find_record(const network::AccountId& account, std::uint64_t action_id) {
|
||||
const auto lease = lease_();
|
||||
if (!lease)
|
||||
return std::unexpected(network::ActionLedgerError::unavailable);
|
||||
auto* db = db_->get();
|
||||
if (!db)
|
||||
return std::unexpected(network::ActionLedgerError::unavailable);
|
||||
const auto found = persistence::find_region_action_record(
|
||||
*db, key_, *lease, account.bytes, action_id, timeout_);
|
||||
if (!found.has_value()) {
|
||||
const auto kind = found.error().kind;
|
||||
if (kind == persistence::LeaseStoreError::store ||
|
||||
kind == persistence::LeaseStoreError::unknown)
|
||||
db_->broken();
|
||||
return std::unexpected(network::ActionLedgerError::unavailable);
|
||||
}
|
||||
if (!found.value())
|
||||
return std::optional<network::DurableActionRecord>{};
|
||||
const auto& row = *found.value();
|
||||
const auto result = static_cast<network::ActionResult>(row.result);
|
||||
network::DurableActionRecord record{
|
||||
network::ActionOutcome{action_id, result, row.action.tick, row.action.commit_sequence},
|
||||
std::nullopt};
|
||||
if (row.cellular_input) {
|
||||
const auto input = network::decode_cellular_action_input(*row.cellular_input);
|
||||
if (!input || input->tick != row.action.tick ||
|
||||
result != network::ActionResult::committed)
|
||||
return std::unexpected(network::ActionLedgerError::unavailable);
|
||||
std::array<std::uint8_t, network::cellular_action_input_bytes> canonical{};
|
||||
std::ranges::copy(*row.cellular_input, canonical.begin());
|
||||
record.cellular_input = canonical;
|
||||
} else if (result != network::ActionResult::committed_no_effect) {
|
||||
return std::unexpected(network::ActionLedgerError::unavailable);
|
||||
}
|
||||
return std::optional<network::DurableActionRecord>{std::move(record)};
|
||||
}
|
||||
|
||||
std::expected<std::vector<std::optional<network::DurableActionRecord>>,
|
||||
network::ActionLedgerError>
|
||||
PostgresActionLedger::find_all_records(std::span<const network::ActionKey> keys) {
|
||||
std::vector<std::optional<network::DurableActionRecord>> out(keys.size());
|
||||
if (keys.empty())
|
||||
return out;
|
||||
const auto lease = lease_();
|
||||
if (!lease)
|
||||
return std::unexpected(network::ActionLedgerError::unavailable);
|
||||
auto* db = db_->get();
|
||||
if (!db)
|
||||
return std::unexpected(network::ActionLedgerError::unavailable);
|
||||
std::vector<persistence::ActionRef> refs;
|
||||
refs.reserve(keys.size());
|
||||
for (const auto& key : keys)
|
||||
refs.push_back({key.account.bytes, key.action_id});
|
||||
const auto found = persistence::find_region_action_records(*db, key_, *lease, refs, timeout_);
|
||||
if (!found.has_value()) {
|
||||
const auto kind = found.error().kind;
|
||||
if (kind == persistence::LeaseStoreError::store ||
|
||||
kind == persistence::LeaseStoreError::unknown)
|
||||
db_->broken();
|
||||
return std::unexpected(network::ActionLedgerError::unavailable);
|
||||
}
|
||||
if (found->size() != keys.size())
|
||||
return std::unexpected(network::ActionLedgerError::unavailable);
|
||||
for (std::size_t i = 0; i < keys.size(); ++i) {
|
||||
if (!(*found)[i])
|
||||
continue;
|
||||
const auto& row = *(*found)[i];
|
||||
const auto result = static_cast<network::ActionResult>(row.result);
|
||||
network::DurableActionRecord record{
|
||||
network::ActionOutcome{keys[i].action_id, result, row.action.tick,
|
||||
row.action.commit_sequence},
|
||||
std::nullopt};
|
||||
if (row.cellular_input) {
|
||||
const auto input = network::decode_cellular_action_input(*row.cellular_input);
|
||||
if (!input || input->tick != row.action.tick ||
|
||||
result != network::ActionResult::committed)
|
||||
return std::unexpected(network::ActionLedgerError::unavailable);
|
||||
std::array<std::uint8_t, network::cellular_action_input_bytes> canonical{};
|
||||
std::ranges::copy(*row.cellular_input, canonical.begin());
|
||||
record.cellular_input = canonical;
|
||||
} else if (result != network::ActionResult::committed_no_effect) {
|
||||
return std::unexpected(network::ActionLedgerError::unavailable);
|
||||
}
|
||||
out[i] = std::move(record);
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
std::expected<std::vector<std::optional<network::ActionOutcome>>, network::ActionLedgerError>
|
||||
PostgresActionLedger::find_all(std::span<const network::ActionKey> keys) {
|
||||
const auto lease = lease_();
|
||||
|
||||
Reference in New Issue
Block a user