feat(persistence): admit durable cellular environment profile
Foundation / checks (ecs) (push) Successful in 2m24s
Foundation / checks (deploy) (push) Successful in 4m51s
Foundation / checks (network) (push) Successful in 20m42s
Foundation / checks (client) (push) Successful in 21m53s
Foundation / postgres-tools (push) Canceled after 0s
Foundation / server-image (push) Canceled after 0s
Foundation / image (push) Canceled after 0s
Foundation / checks (checks) (push) Canceled after 40m19s
Foundation / checks (postgres) (push) Canceled after 40m9s
Foundation / checks (tsan) (push) Canceled after 37m53s
Foundation / checks (ecs) (push) Successful in 2m24s
Foundation / checks (deploy) (push) Successful in 4m51s
Foundation / checks (network) (push) Successful in 20m42s
Foundation / checks (client) (push) Successful in 21m53s
Foundation / postgres-tools (push) Canceled after 0s
Foundation / server-image (push) Canceled after 0s
Foundation / image (push) Canceled after 0s
Foundation / checks (checks) (push) Canceled after 40m19s
Foundation / checks (postgres) (push) Canceled after 40m9s
Foundation / checks (tsan) (push) Canceled after 37m53s
ADR-0174 and schema 56 add checkpoint profile 6, which stores the joint cell/environment envelope nesting population envelope 2 (bundles 10 and 11). Entry from a committed population head is explicit, one-way and no-tick, with the source commit, manifest and payload digests bound in immutable evidence. Joint intervals use schema 45's owned admission and settlement; conversions cannot overtake a pending interval. The fenced publisher validates the joint trace structurally, including the complete nested population batch, and records per-commit imported and radiated totals. Recovery replays the head's link and requires the payload exactly, refusing a forged but structurally valid trace. A trigger refuses profile-6 commits from every other publisher; profile 4/5 bytes, parsers and rules are unchanged. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
+7
-2
@@ -130,7 +130,7 @@ target_compile_features(evo_ops PUBLIC cxx_std_23)
|
||||
evo_owned_target(evo_ops)
|
||||
# Portable checkpoint manifest codec and environmental-v1 payload validation.
|
||||
add_library(evo_region_checkpoint STATIC src/persistence/region_checkpoint.cpp src/persistence/region_batch.cpp
|
||||
src/persistence/population_checkpoint.cpp)
|
||||
src/persistence/population_checkpoint.cpp src/persistence/environment_checkpoint.cpp)
|
||||
add_library(evo::region_checkpoint ALIAS evo_region_checkpoint)
|
||||
target_link_libraries(evo_region_checkpoint PUBLIC evo::region_lease evo::processes evo::lifecycle)
|
||||
evo_owned_target(evo_region_checkpoint)
|
||||
@@ -258,6 +258,7 @@ if(EVO_BUILD_POSTGRES)
|
||||
add_library(evo_region_store STATIC src/persistence/sha256.cpp src/persistence/object_store.cpp
|
||||
src/persistence/checkpoint_store.cpp src/persistence/primitive_checkpoint_store.cpp
|
||||
src/persistence/cellular_checkpoint_store.cpp src/persistence/population_checkpoint_store.cpp
|
||||
src/persistence/environment_checkpoint_store.cpp
|
||||
src/persistence/cellular_history_store.cpp
|
||||
src/persistence/cellular_census_snapshot.cpp
|
||||
src/persistence/region_clone.cpp src/persistence/cellular_migration_store.cpp)
|
||||
@@ -311,7 +312,7 @@ if(EVO_BUILD_POSTGRES)
|
||||
# Contention tests use one thread and one connection per contender.
|
||||
add_executable(evo-postgres-tests tests/postgres_tests.cpp tests/region_lease_store_tests.cpp
|
||||
tests/cellular_publication_tests.cpp
|
||||
tests/population_publication_tests.cpp
|
||||
tests/population_publication_tests.cpp tests/environment_publication_tests.cpp
|
||||
tests/fixtures/postgres_relay.cpp
|
||||
tests/account_control_store_tests.cpp tests/probe_handoff_store_tests.cpp
|
||||
tests/life_reservation_store_tests.cpp
|
||||
@@ -793,6 +794,10 @@ if(BUILD_TESTING)
|
||||
target_link_libraries(evo-population-checkpoint-tests PRIVATE evo::region_checkpoint)
|
||||
evo_owned_target(evo-population-checkpoint-tests)
|
||||
add_test(NAME population-checkpoint-contract COMMAND evo-population-checkpoint-tests)
|
||||
add_executable(evo-environment-checkpoint-tests tests/environment_checkpoint_tests.cpp)
|
||||
target_link_libraries(evo-environment-checkpoint-tests PRIVATE evo::region_checkpoint)
|
||||
evo_owned_target(evo-environment-checkpoint-tests)
|
||||
add_test(NAME environment-checkpoint-contract COMMAND evo-environment-checkpoint-tests)
|
||||
set_tests_properties(population-checkpoint-contract PROPERTIES TIMEOUT 180)
|
||||
endif()
|
||||
|
||||
|
||||
@@ -12,7 +12,7 @@ spec:
|
||||
env:
|
||||
- {name: REGION_SESSION, value: "dev"}
|
||||
- {name: REGION_SESSION_LISTEN, value: "0.0.0.0:7400"}
|
||||
- {name: REGION_SESSION_WINDOW, value: "dev-20261019T201509-a1dcbfd7:1792455309"}
|
||||
- {name: REGION_SESSION_WINDOW, value: "dev-20261019T210956-a2cdedf2:1792458596"}
|
||||
- {name: REGION_M10_MAX_GRANT_LIFETIME, value: "14400"}
|
||||
ports:
|
||||
# QUIC (ADR-0090): UDP only; nothing listens on TCP 7400.
|
||||
|
||||
+9
-3
@@ -17,9 +17,15 @@ the unchanged population batch plus each tick's recorded import and radiated hea
|
||||
Recorded unattended intervals equal the same live joint ticks; replay re-derives
|
||||
every flow and refuses forged flows, boundaries and cuts.
|
||||
|
||||
Both full Release suites pass **94/94**; see [Validation](engineering/VALIDATION.md).
|
||||
Producers (ADR-0136 step C), durable admission (12.5c), worker/census/migration
|
||||
integration (12.5d) and target-host qualification (12.5e) remain open.
|
||||
[ADR-0174](adr/0174-durable-cellular-environment-profile.md)/schema 56 makes the
|
||||
joint owner durable as checkpoint profile 6: an explicit one-way, no-tick entry from
|
||||
a population head, fenced joint publication with owned intervals and per-commit SQL
|
||||
totals of imported and radiated stock, and recovery that replays the head's link
|
||||
exactly. A forged but structurally valid trace is refused on recovery.
|
||||
|
||||
See [Validation](engineering/VALIDATION.md). Producers (ADR-0136 step C),
|
||||
executable/network joint fault drills, worker/census/migration integration (12.5d)
|
||||
and target-host qualification (12.5e) remain open.
|
||||
|
||||
## Portable retained-plan exact populations - 2026-10-19
|
||||
|
||||
|
||||
@@ -0,0 +1,57 @@
|
||||
# ADR-0174: Durable cellular environment profile
|
||||
|
||||
## Status and scope
|
||||
|
||||
Accepted M12.5c durable admission, 2026-10-19. Extends ADR-0142/0143 (population
|
||||
profile and owned intervals), ADR-0172 (joint owner) and ADR-0173 (joint batch).
|
||||
Schema 56. No automatic selection, worker scheduling, census/migration support,
|
||||
default/DEV opening, live upgrade or World0 operation.
|
||||
|
||||
## Decision
|
||||
|
||||
**Checkpoint profile 6** (`cellular_environment_v1`, history profile 6) stores the
|
||||
complete joint envelope `AEVOCEN1`. It nests population envelope 2 only (owner 7 with
|
||||
rules 8 or 9: cellular bundles 10 and 11). Bundle 12 retained-plan populations stay
|
||||
outside until their own durable population admission exists.
|
||||
|
||||
**Entry is explicit, no-tick and one-way.** `migrate_population_to_environment` takes
|
||||
a committed profile-5 head under the current lease, restores its population, wraps
|
||||
it with the declared environment and requires the nested population bytes to equal
|
||||
the source exactly. SQL binds the source commit, manifest digest and payload digest
|
||||
in `environment_profile_transitions`; the bundle, frame, tick quantum and tick are
|
||||
unchanged and a pending player mutation or interval blocks it. There is no reverse
|
||||
transition: unwrapping would discard environment state that has no other owner.
|
||||
Re-entering profile 5 needs a separately versioned decision.
|
||||
|
||||
**Publication** of a joint interval or whole-group conversion replays the batch from
|
||||
the committed predecessor before upload and requires the candidate bytes exactly.
|
||||
`publish_environment_checkpoint` validates the joint trace structurally, including
|
||||
the complete nested population batch contract bound to the same identity,
|
||||
predecessor and ticks, and records per-commit totals of imported energy/C/N/P/other
|
||||
and radiated heat. Intervals require schema 45's owned admission: admission now
|
||||
accepts profiles 5 and 6 and the same pending pointer and settlement journal apply.
|
||||
A conversion cannot overtake a pending interval. Exact retries return the original
|
||||
receipt; a reused identity with other bytes conflicts.
|
||||
|
||||
**Recovery** loads the head, its immutable evidence and its predecessor, then either
|
||||
verifies the transition's byte-identical nesting or replays the joint trace and
|
||||
requires the stored payload exactly. SQL flow totals are audit evidence only; a
|
||||
structurally valid but forged trace that reaches the database through the low-level
|
||||
publisher is refused on recovery, not trusted.
|
||||
|
||||
Every profile-6 commit requires its evidence: a trigger refuses the generic, raw and
|
||||
population publishers. History/census/migration readers refuse profile 6 explicitly
|
||||
until 12.5d integrates them; the region host does not select it.
|
||||
|
||||
## Consequences and qualification
|
||||
|
||||
Joint ownership now survives process and worker replacement with exact replay,
|
||||
retries and fenced authority, without changing any profile-4/5 byte or rule. The
|
||||
nested ledger's flows remain complete; recorded environmental totals separate them
|
||||
from migration flows for audit. Required evidence: durable bundle 9 -> 10 -> 11,
|
||||
profile 4 -> 5 -> 6, transition retry/conflict/resolution, unadmitted interval
|
||||
refusal, owned interval with matching SQL totals, conversion blocked by a pending
|
||||
interval, settled conversion, cohort interval, bypass-publisher refusal, forged-flow
|
||||
recovery refusal, the upgrade chain and legacy history-domain reconstruction.
|
||||
Executable/network fault drills, census and migration integration, producers and
|
||||
target-host qualification remain open.
|
||||
@@ -1,5 +1,7 @@
|
||||
# Architecture decision records
|
||||
|
||||
- [ADR-0174: Durable cellular environment profile](0174-durable-cellular-environment-profile.md) - schema 56 checkpoint profile 6 nesting population envelope 2; explicit one-way 5 -> 6 entry, fenced joint publication with owned intervals and SQL flow totals, exact replayed recovery.
|
||||
|
||||
- [ADR-0173: Cellular environment joint batch](0173-cellular-environment-batch.md) - portable `AEVOEBT1` wraps the unchanged population batch with per-tick recorded environmental flows; unattended recording runs the controller after each exchange and replay re-derives every flow exactly.
|
||||
|
||||
- [ADR-0172: Cellular environment ownership](0172-cellular-environment-ownership.md) - one owner per patch of space for cells and their local environment; reserves stay individual; open planet boundary with recorded imports/exports; portable envelope `AEVOCEN1` with finite infall entitlements and radiative heat export.
|
||||
|
||||
@@ -12,7 +12,7 @@ Commit and push each validated scoped segment separately.
|
||||
| 12.2 | Exact local model selected and paired qualification implemented (12.2d); production cost gate open | ADR-0139, exact canonical equality across 196,608 paired ticks per platform. Regional approximation disabled; no compression claim. Deployment-host capacity and fuller interaction coverage remain open. |
|
||||
| 12.3 | Exact population profile/trace/store and opt-in host integration implemented (12.3b) | ADR-0142, schema 44; exact publication/recovery, mutation race guards, ambiguous replies and process kills. Executable/network population fault drills and target-host qualification remain open. |
|
||||
| 12.4 | Owned intervals and durable paired migration/fault qualification implemented in scoped segments through 12.4l | ADR-0143–0149/schema 49; bounded admitted work, source freeze, staged ghost, atomic pair and exact recovery, local TLS and storage faults. Multi-host/orchestrator, linked ecology and integrated stock audits remain open. |
|
||||
| 12.5 | Ownership accepted; portable joint owner implemented (12.5a-b) | ADR-0172: one owner per patch, tagged water/dissolved compartments, finite infall entitlements and radiative export with exact raw/cohort, refusal and restart evidence. Producers (ADR-0136 step C), durable profile, worker integration and target-host qualification remain open. |
|
||||
| 12.5 | Ownership accepted; portable joint owner, joint batch and durable profile 6 implemented (12.5a-c) | ADR-0172-0174/schema 56: one owner per patch, tagged water/dissolved compartments, finite infall entitlements and radiative export, exact unattended replay, owned durable intervals and recovery. Producers (ADR-0136 step C), worker/census/migration integration and target-host qualification remain open. |
|
||||
| 12.6 | Regional queries, replayed history, scoped multi-region queries and consistent database head snapshots implemented (12.6a-d) | ADR-0150–0153; short read-only snapshot capture prevents atomic pairs from straddling declared head sets, with exact immutable replay. Durable world/branch coverage, outside transfer/viability reconciliation, target-host query/index costs and client path remain required. |
|
||||
| 12.7 | Evidence policy, registered coverage, history domains and verified pending handoff evidence implemented (12.7a-c) | ADR-0154–0156/schema 52 captures namespace/registry/heads/pending handoffs together, with exact capsule/ghost replay and supported restore forks. Cross-domain clone provenance, other viable-store coverage and durable accepted global reconciliation/freshness remain required. |
|
||||
| 12.8 | Bounded unscripted generation evidence; actual-days gate not qualified | ADR-0162 measures four real wildlife generations with exact raw/cohort recovery, predation and twins. Actual multi-day integrated ecology/restart/clone evidence remains required. |
|
||||
|
||||
@@ -66,7 +66,7 @@ or authorize production enablement.
|
||||
| 12.2 | Exact cellular model and paired matrix; local samples through 256 lives; bounded four-generation rules-9 predation/twin matrix | Deployment-host tail costs including publication; larger wildlife cohorts and fuller contention coverage; useful compression remains unimplemented. |
|
||||
| 12.3 | Dedicated population profile/trace/store/owning host; exact recovery and private PostgreSQL fault tests | Population-specific executable/network fault drills and target-host publication/capacity qualification. |
|
||||
| 12.4 | Owned intervals; exact transfer/accounting; durable atomic pair/recovery; independent loopback TLS path loss and owner expiry/replacement/heal; local object sync/read-failure matrix | Multi-host/kernel-network, storage-host and orchestrator drills, linked-boundary contracts and integrated ownership/stock audits at scale. |
|
||||
| 12.5 | ADR-0172 portable joint owner: one budget for cells and local environment, effective depth, tagged water/dissolved compartments, refused atmosphere, finite infall entitlements, radiative export; closed/source-off/open/exhaustion and raw/cohort comparisons; ADR-0173 joint batch with exact unattended replay | Producer process and coefficients (ADR-0136 step C), durable profile/trace/recovery (12.5c), worker/census/migration integration and escrowed cross-worker sources (12.5d), target-host qualification (12.5e). |
|
||||
| 12.5 | ADR-0172 portable joint owner: one budget for cells and local environment, effective depth, tagged water/dissolved compartments, refused atmosphere, finite infall entitlements, radiative export; closed/source-off/open/exhaustion and raw/cohort comparisons; ADR-0173 joint batch with exact unattended replay; ADR-0174/schema 56 durable profile 6 with owned intervals and exact recovery | Producer process and coefficients (ADR-0136 step C), executable/network joint fault drills, worker/census/migration integration and escrowed cross-worker sources (12.5d), target-host qualification (12.5e). |
|
||||
| 12.6 | Retained archive, regional census/lineage queries, replayed history, scoped multi-region queries and consistent database head snapshots (12.6a-d); registered coverage/history domains follow in 12.7a-b | Cross-domain clone provenance, retained historical coverage/other viable stores, target-host query/index qualification and client permission/presentation; no account power or invented precise statistical ancestry. |
|
||||
| 12.7 | Viability/unknown policy; consistent cuts, registered coverage, history domains/restore forks and verified pending handoff evidence (12.7a-c/schema 52) | Cross-domain clone provenance, other viable-store coverage and durable accepted global evidence records/freshness. Missing/stale/unsupported owners must prevent terminal extinction. |
|
||||
| 12.8 | Deterministic seed/regime drivers, separate-process exact continuation and bounded unscripted generations | Reproducible integrated worlds running for actual days, real restarts/clone comparisons and retained accounting/diversity/cost audits. Accelerated tests cannot supply elapsed days. |
|
||||
|
||||
@@ -1,5 +1,50 @@
|
||||
# Validation report
|
||||
|
||||
## 2026-10-19 - Durable cellular environment profile (M12.5c)
|
||||
|
||||
[ADR-0174](../adr/0174-durable-cellular-environment-profile.md)/schema 56 adds
|
||||
checkpoint profile 6. The manifest parser normalizes only profile, history, payload
|
||||
cap and nested trace length before reusing the population validator; joint traces
|
||||
are checked structurally, including the complete nested population batch. Schema
|
||||
45's interval admission now accepts profiles 5 and 6. Four runtime functions join
|
||||
the fenced allowlist. Profile-4/5 bytes, parsers and rules are unchanged.
|
||||
|
||||
Executed locally:
|
||||
|
||||
- GCC 14.2 private PostgreSQL qualification `--full` passes in **622 s**: the C++
|
||||
suite, migration partitions, life reservations, backup, DR, upgrade, migration
|
||||
history (through schema 56), permission audit and checksum drift. The first two runs
|
||||
failed only in the region migration test, whose hard-coded digests and expected
|
||||
history still ended at schema 55; both are updated.
|
||||
- Joint-only PostgreSQL suite (`--environment-only`) passes in a fresh disposable
|
||||
cluster: a funded rules-8 region with real wildlife and fully suspended players is
|
||||
upgraded durably to bundle 10 and 11, enters profile 5 and then profile 6 (head 108,
|
||||
tick 6,379; 38,700,000 pJ imported, 2,312 pJ radiated at the end).
|
||||
- GCC 14.2 Release full CTest **95/95, 4.87 s** and MSVC 19.44 Release full CTest
|
||||
**95/95, 6.43 s**, with NDEBUG.
|
||||
- Portable `environment-checkpoint-contract`: transition/successor/conversion
|
||||
manifests, round trip, payload restore, and refusals of raw or envelope-1 sources,
|
||||
re-entry, another frame's lease, traceless or 65-tick successors, a population head
|
||||
publishing a joint successor, history 5, bundle 12, genesis, another tick, a bare
|
||||
population and a rules mismatch.
|
||||
- clang-tidy 19 (warnings as errors, with libpq headers) and clang-format 19 on the
|
||||
new and changed persistence sources and tests.
|
||||
|
||||
Evidence in the PostgreSQL suite: exact transition retry returns the original
|
||||
receipt, a reused identity with other bytes is refused with EVL07 and resolution
|
||||
reports committed; recovery reproduces the nested population byte for byte with no
|
||||
crossing. An interval without its owned admission is refused with EVL18; after
|
||||
admission the published interval's SQL totals equal the trace's imported energy,
|
||||
carbon and radiated heat, exact retry returns the same head and recovery equals the
|
||||
recorded candidate. The population publisher refuses joint evidence. A conversion
|
||||
cannot overtake a pending interval (EVL18); after settlement it publishes and a
|
||||
cohort interval follows, each recovered exactly. A trace with one radiated picojoule
|
||||
forged commits through the low-level SQL publisher, which does not replay biology,
|
||||
and recovery refuses that head with `tail`.
|
||||
|
||||
No executable/network fault drill, census or migration support, worker scheduling,
|
||||
target-host cost, default opening, live upgrade or World0 operation.
|
||||
|
||||
## 2026-10-19 - Cellular environment joint batch (M12.5b)
|
||||
|
||||
[ADR-0173](../adr/0173-cellular-environment-batch.md) adds joint batch
|
||||
|
||||
@@ -0,0 +1,41 @@
|
||||
#pragma once
|
||||
|
||||
#include "evo/persistence/population_checkpoint_store.hpp"
|
||||
|
||||
namespace evo::persistence {
|
||||
// ADR-0174 / schema 56. Prepared joint commits reuse the population shape: an empty
|
||||
// trace is the no-tick profile 5 -> 6 transition, otherwise a joint batch.
|
||||
struct RecoveredEnvironmentCheckpoint {
|
||||
CommittedCheckpoint committed;
|
||||
CheckpointManifest manifest;
|
||||
std::unique_ptr<server::CellularEnvironment> state;
|
||||
};
|
||||
// Explicit, one-way and no-tick: wraps the identical committed population with its
|
||||
// declared environment under the same lease/head fence. No biology advances.
|
||||
[[nodiscard]] std::expected<CommittedCheckpoint, PopulationPublicationFailure>
|
||||
migrate_population_to_environment(Postgres&, const FilesystemObjectStore&, const LeaseGrant&,
|
||||
const CommittedCheckpoint& predecessor, Uuid commit,
|
||||
const Sha256Digest& build, server::CellularEnvironmentConfig,
|
||||
std::chrono::milliseconds timeout,
|
||||
const PublishHooks& hooks = {});
|
||||
// A joint interval (after an owned admission) or whole-group conversion. The batch is
|
||||
// replayed from the committed predecessor and must reproduce `candidate` exactly.
|
||||
[[nodiscard]] std::expected<CommittedCheckpoint, PopulationPublicationFailure>
|
||||
publish_environment_batch(Postgres&, const FilesystemObjectStore&, const LeaseGrant&,
|
||||
const CommittedCheckpoint& predecessor,
|
||||
const server::CellularEnvironmentBatch& batch,
|
||||
const server::CellularEnvironment& candidate, Uuid commit,
|
||||
const Sha256Digest& build, std::chrono::milliseconds timeout,
|
||||
const PublishHooks& hooks = {});
|
||||
[[nodiscard]] std::expected<CommittedCheckpoint, PopulationPublicationFailure>
|
||||
retry_environment_prepared(Postgres&, const PopulationPreparedCommit&,
|
||||
std::chrono::milliseconds timeout);
|
||||
[[nodiscard]] std::expected<ResolvedCommit, LeaseStoreFailure>
|
||||
resolve_environment_prepared(Postgres&, const PopulationPreparedCommit&,
|
||||
std::chrono::milliseconds timeout);
|
||||
// Loads the head, requires its complete evidence and replays its link exactly.
|
||||
[[nodiscard]] std::expected<RecoveredEnvironmentCheckpoint, RecoveryFailure>
|
||||
recover_environment_checkpoint(Postgres&, const FilesystemObjectStore&, RegionKey,
|
||||
const LeaseGrant&, std::span<const Sha256Digest> retained_builds,
|
||||
std::chrono::milliseconds timeout);
|
||||
} // namespace evo::persistence
|
||||
@@ -4,6 +4,7 @@
|
||||
#include "evo/processes/environmental_community.hpp"
|
||||
#include "evo/processes/lineage_region.hpp"
|
||||
#include "evo/server/lifecycle/cellular_batch.hpp"
|
||||
#include "evo/server/lifecycle/cellular_environment.hpp"
|
||||
#include "evo/server/lifecycle/cellular_lives.hpp"
|
||||
#include "evo/server/lifecycle/cellular_population_batch.hpp"
|
||||
#include "evo/server/lifecycle/primitive_batch.hpp"
|
||||
@@ -27,13 +28,22 @@ enum class CheckpointProfile : std::uint8_t {
|
||||
primitive_lives_v1 = 3, // Funded creation state; history_profile 2.
|
||||
cellular_lives_v1 = 4, // Complete cellular state; history_profile 3 or 4.
|
||||
cellular_population_v1 = 5, // Exact populations; cellular bundle 9, 10 or 11.
|
||||
cellular_environment_v1 = 6, // ADR-0174: cells with their environment; bundle 10 or 11.
|
||||
};
|
||||
// Profiles whose manifests carry a CellularVersionBundle.
|
||||
[[nodiscard]] constexpr bool cellular_profile(CheckpointProfile profile) noexcept {
|
||||
return profile == CheckpointProfile::cellular_lives_v1 ||
|
||||
profile == CheckpointProfile::cellular_population_v1 ||
|
||||
profile == CheckpointProfile::cellular_environment_v1;
|
||||
}
|
||||
// history_profile 1: lineage archive format 1 with genome schema 1.
|
||||
inline constexpr std::uint32_t lineage_history_profile = 1;
|
||||
// Archive format 1, genome schema 2, development 2, founder-life rules 1.
|
||||
inline constexpr std::uint32_t primitive_history_profile = 2;
|
||||
inline constexpr std::uint32_t cellular_history_profile = 3;
|
||||
inline constexpr std::uint32_t population_history_profile = 5;
|
||||
// ADR-0174: joint envelope 1 nesting population envelope 2 and its lineage archive.
|
||||
inline constexpr std::uint32_t environment_history_profile = 6;
|
||||
inline constexpr std::uint32_t cellular_revision_history_profile = 4;
|
||||
// Declared durability, verified at deployment. Development: one volume, no host-loss claim.
|
||||
enum class DurabilityPolicy : std::uint8_t { unknown = 0, single_volume_development = 1 };
|
||||
@@ -146,6 +156,8 @@ inline constexpr std::size_t max_lineage_payload_bytes = processes::max_lineage_
|
||||
: profile == CheckpointProfile::cellular_lives_v1 ? server::max_cellular_lives_bytes
|
||||
: profile == CheckpointProfile::cellular_population_v1
|
||||
? server::max_cellular_population_bytes
|
||||
: profile == CheckpointProfile::cellular_environment_v1
|
||||
? server::max_cellular_environment_bytes
|
||||
: 0;
|
||||
}
|
||||
inline constexpr std::uint64_t max_checkpoint_ticks = 64;
|
||||
@@ -263,6 +275,22 @@ cellular_inheritance_upgrade_manifest(const CheckpointManifest& predecessor,
|
||||
[[nodiscard]] std::expected<std::vector<std::uint8_t>, CheckpointError>
|
||||
cellular_inheritance_upgrade_payload(std::span<const std::uint8_t> payload,
|
||||
const CheckpointManifest& predecessor);
|
||||
// ADR-0174: explicit one-way, no-tick profile 5 -> 6 transition. The payload wraps the
|
||||
// identical population with its declared environment; bundle and policy are unchanged.
|
||||
[[nodiscard]] std::expected<CheckpointManifest, CheckpointError>
|
||||
environment_profile_transition_manifest(const CheckpointManifest& predecessor,
|
||||
const Sha256Digest& predecessor_digest, Uuid commit,
|
||||
const LeaseGrant& lease, const Sha256Digest& build,
|
||||
std::uint64_t payload_bytes,
|
||||
const Sha256Digest& payload_sha256);
|
||||
// Joint interval or whole-group conversion; a conversion keeps the tick with a trace.
|
||||
[[nodiscard]] std::expected<CheckpointManifest, CheckpointError> environment_successor_manifest(
|
||||
const CheckpointManifest& predecessor, const Sha256Digest& predecessor_digest, Uuid commit,
|
||||
const LeaseGrant& lease, std::uint64_t end_tick, const Sha256Digest& build,
|
||||
std::uint64_t payload_bytes, const Sha256Digest& payload_sha256, const BatchDigests& batch);
|
||||
[[nodiscard]] std::expected<std::unique_ptr<server::CellularEnvironment>, CheckpointError>
|
||||
restore_environment_payload(std::span<const std::uint8_t> payload,
|
||||
const CheckpointManifest& manifest);
|
||||
// Population manual conversion may publish at the same tick with a nonempty trace.
|
||||
[[nodiscard]] std::expected<CheckpointManifest, CheckpointError> population_successor_manifest(
|
||||
const CheckpointManifest& predecessor, const Sha256Digest& predecessor_digest, Uuid commit,
|
||||
|
||||
@@ -238,4 +238,19 @@ resolve_population_commit(Postgres&, RegionKey, const Uuid& commit,
|
||||
[[nodiscard]] std::expected<std::optional<PopulationEvidence>, LeaseStoreFailure>
|
||||
load_population_evidence(Postgres&, RegionKey, const LeaseGrant&, const Uuid& commit,
|
||||
std::chrono::milliseconds timeout);
|
||||
// ADR-0174 / schema 56: the joint profile's fenced publishers and immutable evidence.
|
||||
[[nodiscard]] std::expected<RegionHead, LeaseStoreFailure>
|
||||
publish_environment_checkpoint(Postgres&, std::span<const std::uint8_t> manifest,
|
||||
std::span<const std::uint8_t> trace,
|
||||
std::chrono::milliseconds timeout);
|
||||
[[nodiscard]] std::expected<RegionHead, LeaseStoreFailure>
|
||||
publish_environment_profile_transition(Postgres&, std::span<const std::uint8_t> manifest,
|
||||
std::chrono::milliseconds timeout);
|
||||
[[nodiscard]] std::expected<ResolvedCommit, LeaseStoreFailure>
|
||||
resolve_environment_commit(Postgres&, RegionKey, const Uuid& commit,
|
||||
std::span<const std::uint8_t> manifest,
|
||||
std::span<const std::uint8_t> trace, std::chrono::milliseconds timeout);
|
||||
[[nodiscard]] std::expected<std::optional<PopulationEvidence>, LeaseStoreFailure>
|
||||
load_environment_evidence(Postgres&, RegionKey, const LeaseGrant&, const Uuid& commit,
|
||||
std::chrono::milliseconds timeout);
|
||||
} // namespace evo::persistence
|
||||
|
||||
@@ -0,0 +1,321 @@
|
||||
-- ADR-0174: joint cellular/environment profile 6, immutable evidence and fenced publishers.
|
||||
-- Profiles 4/5 and every stored byte keep their meaning. Normalization is parser-local.
|
||||
ALTER FUNCTION evolution.parse_checkpoint_manifest(bytea) RENAME TO parse_checkpoint_manifest_v55;
|
||||
REVOKE ALL ON FUNCTION evolution.parse_checkpoint_manifest_v55(bytea) FROM PUBLIC, :"runtime_role";
|
||||
CREATE FUNCTION evolution.parse_checkpoint_manifest(m bytea)
|
||||
RETURNS evolution.checkpoint_manifest LANGUAGE plpgsql IMMUTABLE
|
||||
SET search_path = pg_catalog, pg_temp AS $$
|
||||
DECLARE
|
||||
r evolution.checkpoint_manifest; n bytea;
|
||||
tick_begin numeric; tick_end numeric; payload_size numeric; trace_size numeric; nested numeric;
|
||||
trace_digest bytea;
|
||||
zero32 constant bytea := decode(repeat('00',32),'hex');
|
||||
b10 constant bytea := '\x080000000700000002000000010000000100000004000000030000000200000001000000';
|
||||
b11 constant bytea := '\x090000000700000002000000010000000100000004000000030000000200000001000000';
|
||||
BEGIN
|
||||
IF m IS NULL OR octet_length(m) <> 360 OR evolution.manifest_uint(m,12,4) <> 6 THEN
|
||||
RETURN evolution.parse_checkpoint_manifest_v55(m);
|
||||
END IF;
|
||||
tick_begin := evolution.manifest_uint(m,112,8);
|
||||
tick_end := evolution.manifest_uint(m,120,8);
|
||||
payload_size := evolution.manifest_uint(m,240,8);
|
||||
trace_size := evolution.manifest_uint(m,280,8);
|
||||
trace_digest := substring(m FROM 289 FOR 32);
|
||||
-- Joint batch 1: 32-byte header, nested population batch, 48 bytes per tick.
|
||||
nested := trace_size - 32 - 48 * greatest(tick_end - tick_begin, 0);
|
||||
IF substring(m FROM 161 FOR 36) NOT IN (b10,b11) OR evolution.manifest_uint(m,232,4) <> 6
|
||||
OR evolution.manifest_uint(m,228,4) <> 0 OR evolution.manifest_uint(m,236,4) <> 1
|
||||
OR evolution.manifest_uint(m,56,8) = 0 OR tick_end < tick_begin OR tick_end - tick_begin > 64
|
||||
OR payload_size = 0 OR payload_size > 16782416 OR evolution.manifest_uint(m,320,4) <> 0
|
||||
OR substring(m FROM 329 FOR 32) <> zero32
|
||||
OR (trace_size = 0 AND (trace_digest <> zero32 OR tick_begin <> tick_end OR tick_end = 0))
|
||||
OR (trace_size > 0 AND (trace_size < 184 OR trace_size > 1971480 OR trace_size % 8 <> 0
|
||||
OR trace_digest = zero32 OR nested < 152)) THEN
|
||||
RAISE EXCEPTION 'unsupported or malformed environment manifest' USING ERRCODE = '22023';
|
||||
END IF;
|
||||
-- Reuse the population profile's common-field validation with only its profile,
|
||||
-- history, payload cap and nested trace length normalized. Stored bytes stay profile 6.
|
||||
n := overlay(m PLACING '\x05000000'::bytea FROM 13 FOR 4);
|
||||
n := overlay(n PLACING '\x05000000'::bytea FROM 233 FOR 4);
|
||||
n := overlay(n PLACING evolution.manifest_u64le(least(payload_size,16781400)) FROM 241 FOR 8);
|
||||
IF trace_size > 0 THEN
|
||||
n := overlay(n PLACING evolution.manifest_u64le(nested) FROM 281 FOR 8);
|
||||
END IF;
|
||||
r := evolution.parse_checkpoint_manifest_v55(n);
|
||||
r.profile := 6;
|
||||
r.payload_bytes := payload_size;
|
||||
r.trace_bytes := trace_size;
|
||||
r.trace_sha256 := trace_digest;
|
||||
RETURN r;
|
||||
END $$;
|
||||
REVOKE ALL ON FUNCTION evolution.parse_checkpoint_manifest(bytea) FROM PUBLIC;
|
||||
|
||||
-- Immutable evidence. Flow totals are derived from the trace for audit without replay;
|
||||
-- they distinguish environmental crossings from migration flows in the nested ledger.
|
||||
CREATE TABLE evolution.environment_publications (
|
||||
commit_id uuid PRIMARY KEY REFERENCES evolution.region_commits(commit_id) DEFERRABLE INITIALLY DEFERRED,
|
||||
trace bytea NOT NULL,
|
||||
imported_energy numeric NOT NULL CHECK (imported_energy >= 0),
|
||||
imported_carbon numeric NOT NULL CHECK (imported_carbon >= 0),
|
||||
imported_nitrogen numeric NOT NULL CHECK (imported_nitrogen >= 0),
|
||||
imported_phosphorus numeric NOT NULL CHECK (imported_phosphorus >= 0),
|
||||
imported_other numeric NOT NULL CHECK (imported_other >= 0),
|
||||
radiated_heat numeric NOT NULL CHECK (radiated_heat >= 0)
|
||||
);
|
||||
CREATE TABLE evolution.environment_profile_transitions (
|
||||
target_commit uuid PRIMARY KEY REFERENCES evolution.region_commits(commit_id) DEFERRABLE INITIALLY DEFERRED,
|
||||
source_commit uuid UNIQUE NOT NULL REFERENCES evolution.region_commits(commit_id),
|
||||
source_manifest_sha256 bytea NOT NULL CHECK (octet_length(source_manifest_sha256) = 32),
|
||||
source_payload_sha256 bytea NOT NULL CHECK (octet_length(source_payload_sha256) = 32),
|
||||
CHECK (source_commit <> target_commit)
|
||||
);
|
||||
REVOKE ALL ON evolution.environment_publications, evolution.environment_profile_transitions FROM PUBLIC;
|
||||
CREATE TRIGGER environment_publications_immutable BEFORE UPDATE OR DELETE ON evolution.environment_publications
|
||||
FOR EACH ROW EXECUTE FUNCTION evolution.refuse_history_rewrite();
|
||||
CREATE TRIGGER environment_publications_no_truncate BEFORE TRUNCATE ON evolution.environment_publications
|
||||
FOR EACH STATEMENT EXECUTE FUNCTION evolution.refuse_history_rewrite();
|
||||
CREATE TRIGGER environment_transitions_immutable BEFORE UPDATE OR DELETE ON evolution.environment_profile_transitions
|
||||
FOR EACH ROW EXECUTE FUNCTION evolution.refuse_history_rewrite();
|
||||
CREATE TRIGGER environment_transitions_no_truncate BEFORE TRUNCATE ON evolution.environment_profile_transitions
|
||||
FOR EACH STATEMENT EXECUTE FUNCTION evolution.refuse_history_rewrite();
|
||||
|
||||
-- Every profile-6 commit, including from the generic publisher, needs its evidence.
|
||||
CREATE FUNCTION evolution.refuse_unpublished_environment() RETURNS trigger
|
||||
LANGUAGE plpgsql SET search_path = pg_catalog, pg_temp AS $$
|
||||
BEGIN
|
||||
IF evolution.manifest_uint(NEW.manifest,12,4) = 6 AND (NEW.commit_sequence = 0 OR
|
||||
(NOT EXISTS (SELECT 1 FROM evolution.environment_publications x WHERE x.commit_id = NEW.commit_id)
|
||||
AND NOT EXISTS (SELECT 1 FROM evolution.environment_profile_transitions x WHERE x.target_commit = NEW.commit_id))) THEN
|
||||
RAISE EXCEPTION 'environment commit requires fenced publisher' USING ERRCODE = 'EVL06';
|
||||
END IF;
|
||||
RETURN NEW;
|
||||
END $$;
|
||||
REVOKE ALL ON FUNCTION evolution.refuse_unpublished_environment() FROM PUBLIC;
|
||||
CREATE TRIGGER region_environment_evidence BEFORE INSERT ON evolution.region_commits
|
||||
FOR EACH ROW EXECUTE FUNCTION evolution.refuse_unpublished_environment();
|
||||
|
||||
-- Structural validation and flow totals only. C++ recovery replays the complete joint
|
||||
-- biology and environment and requires exact payload equality.
|
||||
CREATE FUNCTION evolution.check_environment_trace(m bytea,t bytea)
|
||||
RETURNS TABLE(imported_energy numeric,imported_carbon numeric,imported_nitrogen numeric,
|
||||
imported_phosphorus numeric,imported_other numeric,radiated_heat numeric)
|
||||
LANGUAGE plpgsql IMMUTABLE SET search_path = pg_catalog, pg_temp AS $$
|
||||
DECLARE
|
||||
c evolution.checkpoint_manifest := evolution.parse_checkpoint_manifest(m);
|
||||
kind numeric; nested numeric; flows numeric; n bytea; inner_trace bytea; off integer;
|
||||
totals numeric[] := ARRAY[0,0,0,0,0,0]::numeric[];
|
||||
BEGIN
|
||||
IF c.profile <> 6 OR t IS NULL OR octet_length(t) <> c.trace_bytes OR c.trace_bytes = 0
|
||||
OR sha256(t) <> c.trace_sha256 OR substring(t FROM 1 FOR 8) <> '\x4145564f45425431'
|
||||
OR evolution.manifest_uint(t,8,4) <> 1 THEN
|
||||
RAISE EXCEPTION 'invalid environment trace binding' USING ERRCODE = '22023';
|
||||
END IF;
|
||||
kind := evolution.manifest_uint(t,12,4);
|
||||
nested := evolution.manifest_uint(t,16,8);
|
||||
flows := evolution.manifest_uint(t,24,4);
|
||||
IF kind > 1 OR (kind = 1) <> (c.begin_tick = c.end_tick) OR evolution.manifest_uint(t,28,4) <> 0
|
||||
OR flows <> c.end_tick - c.begin_tick OR octet_length(t) <> 32 + nested + 48 * flows THEN
|
||||
RAISE EXCEPTION 'malformed environment trace' USING ERRCODE = '22023';
|
||||
END IF;
|
||||
-- The nested population batch must satisfy its own complete structural contract,
|
||||
-- bound to the same identity, predecessor and ticks as this manifest.
|
||||
inner_trace := substring(t FROM 33 FOR nested::integer);
|
||||
n := overlay(m PLACING '\x05000000'::bytea FROM 13 FOR 4);
|
||||
n := overlay(n PLACING '\x05000000'::bytea FROM 233 FOR 4);
|
||||
n := overlay(n PLACING evolution.manifest_u64le(least(c.payload_bytes,16781400)) FROM 241 FOR 8);
|
||||
n := overlay(n PLACING evolution.manifest_u64le(nested) FROM 281 FOR 8);
|
||||
n := overlay(n PLACING sha256(inner_trace) FROM 289 FOR 32);
|
||||
PERFORM evolution.check_population_trace(n,inner_trace);
|
||||
off := 32 + nested::integer;
|
||||
FOR i IN 0 .. flows - 1 LOOP
|
||||
FOR j IN 0 .. 5 LOOP
|
||||
totals[j + 1] := totals[j + 1] + evolution.manifest_uint(t, off + 48 * i + 8 * j, 8);
|
||||
END LOOP;
|
||||
END LOOP;
|
||||
RETURN QUERY SELECT totals[1],totals[2],totals[3],totals[4],totals[5],totals[6];
|
||||
END $$;
|
||||
REVOKE ALL ON FUNCTION evolution.check_environment_trace(bytea,bytea) FROM PUBLIC;
|
||||
|
||||
-- Schema 45's owned interval admission also serves the joint profile: one pending
|
||||
-- bounded interval per region, settled atomically with its checkpoint.
|
||||
CREATE OR REPLACE FUNCTION evolution.admit_population_interval(w evolution.u64,r evolution.u64,holder uuid,epoch evolution.u64,
|
||||
source uuid,source_digest bytea,target_tick evolution.u64)
|
||||
RETURNS TABLE(source_commit uuid,source_manifest_sha256 bytea,begin_tick evolution.u64,end_tick evolution.u64,controller_version integer)
|
||||
LANGUAGE plpgsql SECURITY DEFINER SET search_path = pg_catalog, pg_temp AS $$
|
||||
DECLARE a evolution.population_interval_admissions%ROWTYPE; h evolution.region_heads%ROWTYPE;
|
||||
c evolution.checkpoint_manifest; m bytea;
|
||||
BEGIN
|
||||
IF source IS NULL OR source_digest IS NULL OR octet_length(source_digest) <> 32 OR target_tick IS NULL THEN
|
||||
RAISE EXCEPTION 'invalid population interval' USING ERRCODE = '22023';
|
||||
END IF;
|
||||
PERFORM evolution.check_region_lease(w,r,holder,epoch);
|
||||
SELECT * INTO a FROM evolution.population_interval_admissions x WHERE x.source_commit = source;
|
||||
IF FOUND THEN
|
||||
IF a.world_id <> w OR a.region_id <> r OR a.source_manifest_sha256 <> source_digest OR a.end_tick <> target_tick THEN
|
||||
RAISE EXCEPTION 'population interval identity reused' USING ERRCODE = 'EVL07';
|
||||
END IF;
|
||||
RETURN QUERY SELECT a.source_commit,a.source_manifest_sha256,a.begin_tick,a.end_tick,a.controller_version;
|
||||
RETURN;
|
||||
END IF;
|
||||
SELECT * INTO h FROM evolution.region_heads x WHERE x.world_id = w AND x.region_id = r FOR UPDATE;
|
||||
IF NOT FOUND OR h.commit_id <> source OR h.digest <> source_digest THEN
|
||||
RAISE EXCEPTION 'population interval head moved' USING ERRCODE = 'EVL03';
|
||||
END IF;
|
||||
SELECT x.manifest INTO m FROM evolution.region_commits x WHERE x.commit_id = source;
|
||||
c := evolution.parse_checkpoint_manifest(m);
|
||||
IF c.profile NOT IN (5,6) OR target_tick <= h.end_tick OR target_tick - h.end_tick > 64 THEN
|
||||
RAISE EXCEPTION 'unsupported population interval' USING ERRCODE = 'EVL06';
|
||||
END IF;
|
||||
IF EXISTS (SELECT 1 FROM evolution.population_interval_pending x WHERE x.world_id = w AND x.region_id = r) THEN
|
||||
RAISE EXCEPTION 'population interval already pending' USING ERRCODE = 'EVL18';
|
||||
END IF;
|
||||
INSERT INTO evolution.population_interval_admissions VALUES(source,w,r,source_digest,h.end_tick,target_tick,1,holder,epoch)
|
||||
RETURNING * INTO a;
|
||||
INSERT INTO evolution.population_interval_pending VALUES(w,r,source);
|
||||
RETURN QUERY SELECT a.source_commit,a.source_manifest_sha256,a.begin_tick,a.end_tick,a.controller_version;
|
||||
END $$;
|
||||
|
||||
CREATE FUNCTION evolution.publish_environment_checkpoint(m bytea,t bytea)
|
||||
RETURNS TABLE(region_frame evolution.u64,head_sequence evolution.u64,head_commit uuid,
|
||||
head_digest text,head_tick evolution.u64)
|
||||
LANGUAGE plpgsql SECURITY DEFINER SET search_path = pg_catalog, pg_temp AS $$
|
||||
DECLARE
|
||||
c evolution.checkpoint_manifest := evolution.parse_checkpoint_manifest(m);
|
||||
f record; a evolution.population_interval_admissions%ROWTYPE; existing bytea;
|
||||
BEGIN
|
||||
SELECT * INTO f FROM evolution.check_environment_trace(m,t);
|
||||
PERFORM evolution.check_region_lease(c.world_id,c.region_id,c.holder,c.epoch);
|
||||
SELECT p.trace INTO existing FROM evolution.environment_publications p WHERE p.commit_id = c.commit_id;
|
||||
IF FOUND THEN
|
||||
IF existing <> t THEN RAISE EXCEPTION 'environment identity reused' USING ERRCODE = 'EVL07'; END IF;
|
||||
RETURN QUERY SELECT * FROM evolution.publish_region_checkpoint_core(m,''::bytea);
|
||||
RETURN;
|
||||
END IF;
|
||||
IF EXISTS (SELECT 1 FROM evolution.region_commits x WHERE x.commit_id = c.commit_id) THEN
|
||||
RAISE EXCEPTION 'environment identity reused' USING ERRCODE = 'EVL07';
|
||||
END IF;
|
||||
IF c.end_tick > c.begin_tick THEN
|
||||
SELECT x.* INTO a FROM evolution.population_interval_pending p JOIN evolution.population_interval_admissions x
|
||||
ON x.source_commit = p.source_commit WHERE p.world_id = c.world_id AND p.region_id = c.region_id
|
||||
AND p.source_commit = c.predecessor_commit;
|
||||
IF NOT FOUND OR a.world_id <> c.world_id OR a.region_id <> c.region_id
|
||||
OR a.source_manifest_sha256 <> c.predecessor_digest OR a.begin_tick <> c.begin_tick OR a.end_tick <> c.end_tick
|
||||
OR EXISTS (SELECT 1 FROM evolution.population_interval_settlements s WHERE s.source_commit = a.source_commit) THEN
|
||||
RAISE EXCEPTION 'environment publication requires exact interval' USING ERRCODE = 'EVL18';
|
||||
END IF;
|
||||
INSERT INTO evolution.population_interval_settlements VALUES(a.source_commit,c.commit_id);
|
||||
DELETE FROM evolution.population_interval_pending p WHERE p.world_id = c.world_id AND p.region_id = c.region_id
|
||||
AND p.source_commit = a.source_commit;
|
||||
ELSIF EXISTS (SELECT 1 FROM evolution.population_interval_pending x
|
||||
WHERE x.world_id = c.world_id AND x.region_id = c.region_id) THEN
|
||||
RAISE EXCEPTION 'environment conversion waits for interval' USING ERRCODE = 'EVL18';
|
||||
END IF;
|
||||
INSERT INTO evolution.environment_publications VALUES(c.commit_id,t,f.imported_energy,f.imported_carbon,
|
||||
f.imported_nitrogen,f.imported_phosphorus,f.imported_other,f.radiated_heat);
|
||||
RETURN QUERY SELECT * FROM evolution.publish_region_checkpoint_core(m,''::bytea);
|
||||
END $$;
|
||||
REVOKE ALL ON FUNCTION evolution.publish_environment_checkpoint(bytea,bytea) FROM PUBLIC;
|
||||
GRANT EXECUTE ON FUNCTION evolution.publish_environment_checkpoint(bytea,bytea) TO :"runtime_role";
|
||||
|
||||
-- One-way, no-tick profile 5 -> 6 with the identical bundle. The source payload digest
|
||||
-- is bound; C++ recovery verifies the nested population is byte-identical.
|
||||
CREATE FUNCTION evolution.publish_environment_profile_transition(m bytea)
|
||||
RETURNS TABLE(region_frame evolution.u64,head_sequence evolution.u64,head_commit uuid,
|
||||
head_digest text,head_tick evolution.u64)
|
||||
LANGUAGE plpgsql SECURITY DEFINER SET search_path = pg_catalog, pg_temp AS $$
|
||||
DECLARE
|
||||
c evolution.checkpoint_manifest := evolution.parse_checkpoint_manifest(m);
|
||||
s evolution.checkpoint_manifest; p evolution.region_commits%ROWTYPE;
|
||||
h evolution.region_heads%ROWTYPE; old evolution.region_commits%ROWTYPE;
|
||||
d bytea := sha256(m); frame evolution.u64;
|
||||
BEGIN
|
||||
IF c.profile <> 6 OR c.commit_sequence = 0 OR c.begin_tick <> c.end_tick OR c.end_tick = 0
|
||||
OR c.trace_bytes <> 0 THEN
|
||||
RAISE EXCEPTION 'invalid environment profile transition' USING ERRCODE = '22023';
|
||||
END IF;
|
||||
PERFORM evolution.check_region_lease(c.world_id,c.region_id,c.holder,c.epoch);
|
||||
SELECT * INTO old FROM evolution.region_commits r WHERE r.commit_id = c.commit_id;
|
||||
IF FOUND THEN
|
||||
IF old.manifest <> m OR NOT EXISTS (SELECT 1 FROM evolution.environment_profile_transitions x
|
||||
WHERE x.target_commit = c.commit_id AND x.source_commit = c.predecessor_commit
|
||||
AND x.source_manifest_sha256 = c.predecessor_digest) THEN
|
||||
RAISE EXCEPTION 'environment transition identity reused' USING ERRCODE = 'EVL07';
|
||||
END IF;
|
||||
SELECT l.frame_id INTO frame FROM evolution.region_leases l WHERE l.world_id = c.world_id AND l.region_id = c.region_id;
|
||||
RETURN QUERY SELECT frame,old.commit_sequence,old.commit_id,encode(old.commit_digest,'hex'),old.end_tick;
|
||||
RETURN;
|
||||
END IF;
|
||||
IF EXISTS (SELECT 1 FROM evolution.population_interval_pending x
|
||||
WHERE x.world_id = c.world_id AND x.region_id = c.region_id) THEN
|
||||
RAISE EXCEPTION 'environment transition waits for interval' USING ERRCODE = 'EVL18';
|
||||
END IF;
|
||||
SELECT * INTO h FROM evolution.region_heads r WHERE r.world_id = c.world_id AND r.region_id = c.region_id FOR UPDATE;
|
||||
IF NOT FOUND OR h.commit_sequence = 18446744073709551615 OR c.commit_sequence <> h.commit_sequence + 1
|
||||
OR c.predecessor_commit <> h.commit_id OR c.predecessor_digest <> h.digest OR c.begin_tick <> h.end_tick THEN
|
||||
RAISE EXCEPTION 'environment transition head moved' USING ERRCODE = 'EVL03';
|
||||
END IF;
|
||||
SELECT * INTO p FROM evolution.region_commits r WHERE r.commit_id = h.commit_id;
|
||||
IF NOT FOUND THEN RAISE EXCEPTION 'missing environment source' USING ERRCODE = 'XX000'; END IF;
|
||||
s := evolution.parse_checkpoint_manifest(p.manifest);
|
||||
IF EXISTS (SELECT 1 FROM evolution.cellular_mutation_reservations x
|
||||
WHERE x.world_id = c.world_id AND x.region_id = c.region_id AND NOT EXISTS
|
||||
(SELECT 1 FROM evolution.cellular_mutation_action_publications a
|
||||
WHERE a.world_id = x.world_id AND a.account_id = x.account_id AND a.action_id = x.action_id)) THEN
|
||||
RAISE EXCEPTION 'pending player mutation blocks environment transition' USING ERRCODE = 'EVL18';
|
||||
END IF;
|
||||
IF s.profile <> 5 OR s.versions <> c.versions OR s.frame_id <> c.frame_id
|
||||
OR s.tick_microseconds <> c.tick_microseconds OR s.end_tick <> c.end_tick
|
||||
OR NOT EXISTS (SELECT 1 FROM evolution.retained_builds b WHERE b.build_identity = c.build_identity) THEN
|
||||
RAISE EXCEPTION 'unsupported environment source' USING ERRCODE = 'EVL06';
|
||||
END IF;
|
||||
INSERT INTO evolution.environment_profile_transitions VALUES(c.commit_id,p.commit_id,p.commit_digest,p.payload_sha256);
|
||||
INSERT INTO evolution.region_commits(world_id,region_id,commit_sequence,commit_id,commit_digest,manifest,
|
||||
begin_tick,end_tick,published_epoch,tick_microseconds,versions,build_identity,payload_bytes,payload_sha256)
|
||||
VALUES(c.world_id,c.region_id,c.commit_sequence,c.commit_id,d,m,c.begin_tick,c.end_tick,c.epoch,
|
||||
c.tick_microseconds,c.versions,c.build_identity,c.payload_bytes,c.payload_sha256);
|
||||
UPDATE evolution.region_heads r SET commit_sequence = c.commit_sequence,commit_id = c.commit_id,
|
||||
digest = d,end_tick = c.end_tick,published_epoch = c.epoch WHERE r.world_id = c.world_id AND r.region_id = c.region_id;
|
||||
RETURN QUERY SELECT c.frame_id,c.commit_sequence,c.commit_id,encode(d,'hex'),c.end_tick;
|
||||
END $$;
|
||||
REVOKE ALL ON FUNCTION evolution.publish_environment_profile_transition(bytea) FROM PUBLIC;
|
||||
GRANT EXECUTE ON FUNCTION evolution.publish_environment_profile_transition(bytea) TO :"runtime_role";
|
||||
|
||||
CREATE FUNCTION evolution.resolve_environment_commit(w evolution.u64,r evolution.u64,id uuid,m bytea,t bytea)
|
||||
RETURNS TABLE(status text,region_frame evolution.u64,head_sequence evolution.u64,head_commit uuid,
|
||||
head_digest text,head_tick evolution.u64)
|
||||
LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path = pg_catalog, pg_temp AS $$
|
||||
DECLARE c evolution.checkpoint_manifest := evolution.parse_checkpoint_manifest(m); result record;
|
||||
BEGIN
|
||||
IF c.world_id <> w OR c.region_id <> r OR c.commit_id <> id OR t IS NULL OR c.profile <> 6 THEN
|
||||
RAISE EXCEPTION 'invalid environment resolution' USING ERRCODE = '22023';
|
||||
END IF;
|
||||
IF octet_length(t) > 0 THEN PERFORM * FROM evolution.check_environment_trace(m,t);
|
||||
ELSIF c.trace_bytes <> 0 OR c.begin_tick <> c.end_tick THEN
|
||||
RAISE EXCEPTION 'invalid transition resolution' USING ERRCODE = '22023';
|
||||
END IF;
|
||||
SELECT * INTO result FROM evolution.resolve_region_commit(w,r,id,m,''::bytea);
|
||||
IF result.status = 'committed' AND
|
||||
((octet_length(t) = 0 AND NOT EXISTS (SELECT 1 FROM evolution.environment_profile_transitions x WHERE x.target_commit = id))
|
||||
OR (octet_length(t) > 0 AND NOT EXISTS (SELECT 1 FROM evolution.environment_publications x WHERE x.commit_id = id AND x.trace = t))) THEN
|
||||
RETURN QUERY SELECT 'conflict'::text,NULL::evolution.u64,NULL::evolution.u64,NULL::uuid,NULL::text,NULL::evolution.u64;
|
||||
ELSE
|
||||
RETURN QUERY SELECT result.status,result.region_frame,result.head_sequence,result.head_commit,result.head_digest,result.head_tick;
|
||||
END IF;
|
||||
END $$;
|
||||
REVOKE ALL ON FUNCTION evolution.resolve_environment_commit(evolution.u64,evolution.u64,uuid,bytea,bytea) FROM PUBLIC;
|
||||
GRANT EXECUTE ON FUNCTION evolution.resolve_environment_commit(evolution.u64,evolution.u64,uuid,bytea,bytea) TO :"runtime_role";
|
||||
|
||||
CREATE FUNCTION evolution.load_environment_evidence(w evolution.u64,r evolution.u64,holder uuid,epoch evolution.u64,id uuid)
|
||||
RETURNS TABLE(trace bytea,source_commit uuid,source_manifest_sha256 bytea,source_payload_sha256 bytea)
|
||||
LANGUAGE plpgsql SECURITY DEFINER SET search_path = pg_catalog, pg_temp AS $$
|
||||
BEGIN
|
||||
PERFORM evolution.check_region_lease(w,r,holder,epoch);
|
||||
RETURN QUERY SELECT p.trace,NULL::uuid,NULL::bytea,NULL::bytea FROM evolution.environment_publications p
|
||||
JOIN evolution.region_commits c ON c.commit_id = p.commit_id WHERE c.world_id = w AND c.region_id = r AND c.commit_id = id
|
||||
UNION ALL SELECT ''::bytea,p.source_commit,p.source_manifest_sha256,p.source_payload_sha256 FROM evolution.environment_profile_transitions p
|
||||
JOIN evolution.region_commits c ON c.commit_id = p.target_commit WHERE c.world_id = w AND c.region_id = r AND c.commit_id = id;
|
||||
END $$;
|
||||
REVOKE ALL ON FUNCTION evolution.load_environment_evidence(evolution.u64,evolution.u64,uuid,evolution.u64,uuid) FROM PUBLIC;
|
||||
GRANT EXECUTE ON FUNCTION evolution.load_environment_evidence(evolution.u64,evolution.u64,uuid,evolution.u64,uuid) TO :"runtime_role";
|
||||
|
||||
INSERT INTO evolution.schema_migrations(version,sha256) VALUES(56,:'migration_sha_56');
|
||||
+16
-3
@@ -131,6 +131,7 @@ SELECT EXISTS (SELECT 1 FROM pg_catalog.pg_namespace WHERE nspname='evolution')
|
||||
SELECT :'history_v52' || ',53:' || :'migration_sha_53' AS history_v53 \gset
|
||||
SELECT :'history_v53' || ',54:' || :'migration_sha_54' AS history_v54 \gset
|
||||
SELECT :'history_v54' || ',55:' || :'migration_sha_55' AS history_v55 \gset
|
||||
SELECT :'history_v55' || ',56:' || :'migration_sha_56' AS history_v56 \gset
|
||||
SELECT :'history' = :'history_v22' AS at_v22,
|
||||
:'history' = :'history_v23' AS at_v23,
|
||||
:'history' = :'history_v24' AS at_v24,
|
||||
@@ -164,8 +165,10 @@ SELECT EXISTS (SELECT 1 FROM pg_catalog.pg_namespace WHERE nspname='evolution')
|
||||
:'history' = :'history_v52' AS at_v52,
|
||||
:'history' = :'history_v53' AS at_v53,
|
||||
:'history' = :'history_v54' AS at_v54,
|
||||
:'history' = :'history_v55' AS at_v55 \gset
|
||||
\if :at_v55
|
||||
:'history' = :'history_v55' AS at_v55,
|
||||
:'history' = :'history_v56' AS at_v56 \gset
|
||||
\if :at_v56
|
||||
\elif :at_v55
|
||||
\elif :at_v54
|
||||
\elif :at_v53
|
||||
\elif :at_v52
|
||||
@@ -569,7 +572,8 @@ SELECT coalesce(max(version), 0) = 24 AS at_v24,
|
||||
coalesce(max(version), 0) = 52 AS at_v52,
|
||||
coalesce(max(version), 0) = 53 AS at_v53,
|
||||
coalesce(max(version), 0) = 54 AS at_v54,
|
||||
coalesce(max(version), 0) = 55 AS at_v55
|
||||
coalesce(max(version), 0) = 55 AS at_v55,
|
||||
coalesce(max(version), 0) = 56 AS at_v56
|
||||
FROM evolution.schema_migrations \gset
|
||||
\if :at_v24
|
||||
\ir 0025_cellular_v2_bundle.sql
|
||||
@@ -793,6 +797,7 @@ SELECT coalesce(max(version), 0) = 24 AS at_v24,
|
||||
\elif :at_v53
|
||||
\elif :at_v54
|
||||
\elif :at_v55
|
||||
\elif :at_v56
|
||||
\else
|
||||
\echo 'Unknown or changed migration history after v43'
|
||||
DO $$ BEGIN RAISE EXCEPTION 'unknown or changed migration history'; END $$;
|
||||
@@ -845,6 +850,10 @@ SELECT coalesce(max(version), 0) = 54 AS needs_v55 FROM evolution.schema_migrati
|
||||
\if :needs_v55
|
||||
\ir 0055_retained_cellular_plans.sql
|
||||
\endif
|
||||
SELECT coalesce(max(version), 0) = 55 AS needs_v56 FROM evolution.schema_migrations \gset
|
||||
\if :needs_v56
|
||||
\ir 0056_cellular_environment_publication.sql
|
||||
\endif
|
||||
-- Effective-privilege audit on every run, including no-ops (ADR-0060). Attributes
|
||||
-- alone are insufficient: predefined roles such as pg_write_all_data, PUBLIC
|
||||
-- grants or SET-able memberships would bypass the fenced functions. Checks the
|
||||
@@ -880,6 +889,10 @@ BEGIN
|
||||
('evolution.publish_population_profile_transition(bytea)'::regprocedure::oid),
|
||||
('evolution.resolve_population_commit(evolution.u64,evolution.u64,uuid,bytea,bytea)'::regprocedure::oid),
|
||||
('evolution.load_population_evidence(evolution.u64,evolution.u64,uuid,evolution.u64,uuid)'::regprocedure::oid),
|
||||
('evolution.publish_environment_checkpoint(bytea,bytea)'::regprocedure::oid),
|
||||
('evolution.publish_environment_profile_transition(bytea)'::regprocedure::oid),
|
||||
('evolution.resolve_environment_commit(evolution.u64,evolution.u64,uuid,bytea,bytea)'::regprocedure::oid),
|
||||
('evolution.load_environment_evidence(evolution.u64,evolution.u64,uuid,evolution.u64,uuid)'::regprocedure::oid),
|
||||
('evolution.publish_primitive_checkpoint(bytea,bytea)'::regprocedure::oid),
|
||||
('evolution.load_primitive_lives(evolution.u64,evolution.u64)'::regprocedure::oid),
|
||||
('evolution.query_primitive_life(evolution.u64,evolution.u64,uuid,evolution.u64,uuid,evolution.u64,evolution.u64)'::regprocedure::oid),
|
||||
|
||||
@@ -1,5 +1,13 @@
|
||||
# Region commit manifest contract v1 (M7.1 design, M7.4a encoding)
|
||||
|
||||
M12.5c/schema 56 adds profile 6, `cellular_environment_v1`, with history profile 6.
|
||||
Its payload is the [joint envelope](cellular-environment-v1.md) nesting population
|
||||
envelope 2 (bundles 10 and 11 only), capped at 16,782,416 bytes. A nonempty trace is
|
||||
a [joint batch](cellular-environment-batch-v1.md) of 184..1,971,480 bytes, a multiple
|
||||
of 8; an empty trace with equal ticks is the explicit one-way, no-tick 5 -> 6
|
||||
transition. Genesis and cloning are refused. Ordinary continuation keeps profile and
|
||||
bundle. See [ADR-0174](../docs/adr/0174-durable-cellular-environment-profile.md).
|
||||
|
||||
M12.4f adds the portable bundle-10 declaration `(8,7,2,1,1,4,3,2,1)` for
|
||||
owner-7 boundary accounting, with unchanged rules 8. Profile 4 uses raw owner 7
|
||||
and history 4; profile 5 uses population envelope 2, batch 2 and history 5.
|
||||
|
||||
@@ -0,0 +1,85 @@
|
||||
#include "evo/persistence/region_checkpoint.hpp"
|
||||
|
||||
namespace evo::persistence {
|
||||
namespace {
|
||||
bool leased(const CheckpointManifest& previous, const Sha256Digest& previous_digest, Uuid commit,
|
||||
const LeaseGrant& lease) noexcept {
|
||||
return supported(previous) && encode_manifest(previous).has_value() && previous.sequence > 0 &&
|
||||
previous.sequence != ~std::uint64_t{0} && previous.end_tick > 0 &&
|
||||
population_envelope_version(previous.cellular_versions) == 2 &&
|
||||
previous_digest != Sha256Digest{} && lease.frame == previous.frame && lease.epoch != 0 &&
|
||||
lease.holder != Uuid{} && commit != Uuid{} && commit != previous.commit;
|
||||
}
|
||||
CheckpointManifest link(const CheckpointManifest& previous, const Sha256Digest& previous_digest,
|
||||
Uuid commit, const LeaseGrant& lease, std::uint64_t end_tick,
|
||||
const Sha256Digest& build, std::uint64_t bytes, const Sha256Digest& digest,
|
||||
const BatchDigests& batch) {
|
||||
auto next = previous;
|
||||
next.commit = commit;
|
||||
++next.sequence;
|
||||
next.predecessor_commit = previous.commit;
|
||||
next.predecessor_digest = previous_digest;
|
||||
next.begin_tick = previous.end_tick;
|
||||
next.end_tick = end_tick;
|
||||
next.holder = lease.holder;
|
||||
next.epoch = lease.epoch;
|
||||
next.build = build;
|
||||
next.payload_bytes = bytes;
|
||||
next.payload_sha256 = digest;
|
||||
next.batch = batch;
|
||||
return next;
|
||||
}
|
||||
} // namespace
|
||||
|
||||
std::expected<CheckpointManifest, CheckpointError>
|
||||
environment_profile_transition_manifest(const CheckpointManifest& previous,
|
||||
const Sha256Digest& previous_digest, Uuid commit,
|
||||
const LeaseGrant& lease, const Sha256Digest& build,
|
||||
std::uint64_t bytes, const Sha256Digest& digest) {
|
||||
if (!leased(previous, previous_digest, commit, lease) ||
|
||||
previous.profile != CheckpointProfile::cellular_population_v1)
|
||||
return std::unexpected(CheckpointError::chain);
|
||||
auto next =
|
||||
link(previous, previous_digest, commit, lease, previous.end_tick, build, bytes, digest, {});
|
||||
next.profile = CheckpointProfile::cellular_environment_v1;
|
||||
next.history_profile = environment_history_profile;
|
||||
if (!encode_manifest(next))
|
||||
return std::unexpected(CheckpointError::format);
|
||||
return next;
|
||||
}
|
||||
|
||||
std::expected<CheckpointManifest, CheckpointError> environment_successor_manifest(
|
||||
const CheckpointManifest& previous, const Sha256Digest& previous_digest, Uuid commit,
|
||||
const LeaseGrant& lease, std::uint64_t end_tick, const Sha256Digest& build, std::uint64_t bytes,
|
||||
const Sha256Digest& digest, const BatchDigests& batch) {
|
||||
if (!leased(previous, previous_digest, commit, lease) ||
|
||||
previous.profile != CheckpointProfile::cellular_environment_v1 || batch.trace_bytes == 0 ||
|
||||
end_tick < previous.end_tick || end_tick - previous.end_tick > max_checkpoint_ticks)
|
||||
return std::unexpected(CheckpointError::chain);
|
||||
auto next =
|
||||
link(previous, previous_digest, commit, lease, end_tick, build, bytes, digest, batch);
|
||||
if (!encode_manifest(next))
|
||||
return std::unexpected(CheckpointError::format);
|
||||
return next;
|
||||
}
|
||||
|
||||
std::expected<std::unique_ptr<server::CellularEnvironment>, CheckpointError>
|
||||
restore_environment_payload(std::span<const std::uint8_t> payload, const CheckpointManifest& m) {
|
||||
if (!supported(m) || m.profile != CheckpointProfile::cellular_environment_v1)
|
||||
return std::unexpected(CheckpointError::unsupported);
|
||||
if (!encode_manifest(m) || payload.size() != m.payload_bytes)
|
||||
return std::unexpected(CheckpointError::format);
|
||||
auto state = server::CellularEnvironment::restore(payload, m.key.world, m.key.region, m.frame,
|
||||
m.end_tick);
|
||||
if (!state)
|
||||
return std::unexpected(state.error() == server::CellularEnvironmentError::unsupported
|
||||
? CheckpointError::unsupported
|
||||
: CheckpointError::payload);
|
||||
const auto& population = (*state)->population();
|
||||
if (population.format_version() != population_envelope_version(m.cellular_versions) ||
|
||||
population.state().format_version() != m.cellular_versions.envelope ||
|
||||
population.state().rules_version() != m.cellular_versions.rules)
|
||||
return std::unexpected(CheckpointError::unsupported);
|
||||
return std::move(*state);
|
||||
}
|
||||
} // namespace evo::persistence
|
||||
@@ -0,0 +1,249 @@
|
||||
#include "evo/persistence/environment_checkpoint_store.hpp"
|
||||
#include "evo/persistence/sha256.hpp"
|
||||
|
||||
#include <algorithm>
|
||||
#include <utility>
|
||||
|
||||
namespace evo::persistence {
|
||||
namespace {
|
||||
using std::chrono::milliseconds;
|
||||
PopulationPublicationFailure failure(PublicationError kind, ObjectError object = {},
|
||||
LeaseStoreFailure store = {},
|
||||
PopulationPreparedCommit prepared = {}) {
|
||||
return {kind, store, object, std::move(prepared)};
|
||||
}
|
||||
bool bound(const CommittedCheckpoint& checkpoint, const CheckpointManifest& m) {
|
||||
const auto digest = sha256(checkpoint.manifest);
|
||||
return digest && *digest == checkpoint.head.digest && m.commit == checkpoint.head.commit &&
|
||||
m.sequence == checkpoint.head.sequence && m.end_tick == checkpoint.head.end_tick &&
|
||||
m.frame == checkpoint.head.frame;
|
||||
}
|
||||
// The manifest, trace and their bindings agree before anything reaches the database.
|
||||
bool canonical(const PopulationPreparedCommit& prepared, const CheckpointManifest& m) {
|
||||
if (!supported(m) || m.profile != CheckpointProfile::cellular_environment_v1 ||
|
||||
m.key != prepared.key || m.commit != prepared.commit || m.sequence == 0 ||
|
||||
!encode_manifest(m))
|
||||
return false;
|
||||
if (prepared.trace.empty())
|
||||
return m.begin_tick == m.end_tick && m.batch == BatchDigests{};
|
||||
const auto trace = server::decode_environment_batch(prepared.trace);
|
||||
const auto digest = sha256(prepared.trace);
|
||||
if (!trace || !digest ||
|
||||
trace->population.format_version != population_envelope_version(m.cellular_versions) ||
|
||||
m.batch != BatchDigests{prepared.trace.size(), *digest, 0, {}})
|
||||
return false;
|
||||
const auto& h = trace->population.header;
|
||||
return h.world == m.key.world && h.region == m.key.region && h.frame == m.frame &&
|
||||
h.predecessor == m.predecessor_commit && h.predecessor_digest == m.predecessor_digest &&
|
||||
h.begin_tick == m.begin_tick && h.end_tick == m.end_tick;
|
||||
}
|
||||
std::expected<void, PopulationPublicationFailure> put(const FilesystemObjectStore& objects,
|
||||
std::span<const std::uint8_t> bytes) {
|
||||
const auto digest = sha256(bytes);
|
||||
if (!digest)
|
||||
return std::unexpected(failure(PublicationError::digest));
|
||||
auto object = objects.put(bytes);
|
||||
if (!object)
|
||||
return std::unexpected(failure(PublicationError::upload, object.error()));
|
||||
auto readback = objects.get(*object);
|
||||
if (!readback || object->bytes != bytes.size() || object->sha256 != *digest ||
|
||||
!std::ranges::equal(*readback, bytes))
|
||||
return std::unexpected(
|
||||
failure(PublicationError::verify, readback ? ObjectError::corrupt : readback.error()));
|
||||
return {};
|
||||
}
|
||||
} // namespace
|
||||
|
||||
std::expected<CommittedCheckpoint, PopulationPublicationFailure> migrate_population_to_environment(
|
||||
Postgres& db, const FilesystemObjectStore& objects, const LeaseGrant& lease,
|
||||
const CommittedCheckpoint& predecessor, Uuid commit, const Sha256Digest& build,
|
||||
server::CellularEnvironmentConfig config, milliseconds timeout, const PublishHooks& hooks) {
|
||||
auto previous = decode_manifest(predecessor.manifest);
|
||||
const auto previous_digest = sha256(predecessor.manifest);
|
||||
if (!previous || !previous_digest || !bound(predecessor, *previous) ||
|
||||
previous->profile != CheckpointProfile::cellular_population_v1 ||
|
||||
population_envelope_version(previous->cellular_versions) != 2)
|
||||
return std::unexpected(failure(PublicationError::predecessor));
|
||||
auto source = objects.get({previous->payload_sha256, previous->payload_bytes});
|
||||
if (!source)
|
||||
return std::unexpected(failure(PublicationError::predecessor, source.error()));
|
||||
auto population = restore_population_payload(*source, *previous);
|
||||
if (!population)
|
||||
return std::unexpected(failure(PublicationError::predecessor));
|
||||
auto joint = server::CellularEnvironment::create(std::move(*population), std::move(config));
|
||||
if (!joint || (*joint)->population().snapshot() != *source)
|
||||
return std::unexpected(failure(PublicationError::candidate));
|
||||
const auto payload = (*joint)->snapshot();
|
||||
const auto digest = sha256(payload);
|
||||
if (!digest)
|
||||
return std::unexpected(failure(PublicationError::digest));
|
||||
auto manifest = environment_profile_transition_manifest(*previous, *previous_digest, commit,
|
||||
lease, build, payload.size(), *digest);
|
||||
if (!manifest)
|
||||
return std::unexpected(failure(PublicationError::candidate));
|
||||
auto encoded = encode_manifest(*manifest);
|
||||
if (!encoded)
|
||||
return std::unexpected(failure(PublicationError::candidate));
|
||||
if (auto uploaded = put(objects, payload); !uploaded)
|
||||
return std::unexpected(uploaded.error());
|
||||
if (hooks.before_transaction)
|
||||
hooks.before_transaction();
|
||||
return retry_environment_prepared(db, {previous->key, commit, std::move(*encoded), {}},
|
||||
timeout);
|
||||
}
|
||||
|
||||
std::expected<CommittedCheckpoint, PopulationPublicationFailure>
|
||||
retry_environment_prepared(Postgres& db, const PopulationPreparedCommit& prepared,
|
||||
milliseconds timeout) {
|
||||
const auto m = decode_manifest(prepared.manifest);
|
||||
if (!m || !canonical(prepared, *m))
|
||||
return std::unexpected(failure(PublicationError::candidate));
|
||||
auto result =
|
||||
prepared.trace.empty()
|
||||
? publish_environment_profile_transition(db, prepared.manifest, timeout)
|
||||
: publish_environment_checkpoint(db, prepared.manifest, prepared.trace, timeout);
|
||||
if (!result)
|
||||
return std::unexpected(failure(result.error().kind == LeaseStoreError::unknown
|
||||
? PublicationError::unknown
|
||||
: PublicationError::rejected,
|
||||
{}, result.error(), prepared));
|
||||
const auto digest = sha256(prepared.manifest);
|
||||
if (!digest || result->digest != *digest || result->commit != m->commit ||
|
||||
result->sequence != m->sequence || result->end_tick != m->end_tick ||
|
||||
result->frame != m->frame)
|
||||
return std::unexpected(failure(PublicationError::receipt));
|
||||
return CommittedCheckpoint{*result, prepared.manifest};
|
||||
}
|
||||
|
||||
std::expected<ResolvedCommit, LeaseStoreFailure>
|
||||
resolve_environment_prepared(Postgres& db, const PopulationPreparedCommit& prepared,
|
||||
milliseconds timeout) {
|
||||
const auto manifest = decode_manifest(prepared.manifest);
|
||||
if (!manifest || !canonical(prepared, *manifest))
|
||||
return std::unexpected(LeaseStoreFailure{LeaseStoreError::invalid, {}});
|
||||
return resolve_environment_commit(db, prepared.key, prepared.commit, prepared.manifest,
|
||||
prepared.trace, timeout);
|
||||
}
|
||||
|
||||
std::expected<CommittedCheckpoint, PopulationPublicationFailure> publish_environment_batch(
|
||||
Postgres& db, const FilesystemObjectStore& objects, const LeaseGrant& lease,
|
||||
const CommittedCheckpoint& predecessor, const server::CellularEnvironmentBatch& batch,
|
||||
const server::CellularEnvironment& candidate, Uuid commit, const Sha256Digest& build,
|
||||
milliseconds timeout, const PublishHooks& hooks) {
|
||||
const auto previous = decode_manifest(predecessor.manifest);
|
||||
const auto previous_digest = sha256(predecessor.manifest);
|
||||
const auto trace = server::encode_environment_batch(batch);
|
||||
if (!previous || !previous_digest || !trace || !bound(predecessor, *previous) ||
|
||||
previous->profile != CheckpointProfile::cellular_environment_v1)
|
||||
return std::unexpected(failure(PublicationError::predecessor));
|
||||
auto source = objects.get({previous->payload_sha256, previous->payload_bytes});
|
||||
if (!source)
|
||||
return std::unexpected(failure(PublicationError::predecessor, source.error()));
|
||||
auto base = restore_environment_payload(*source, *previous);
|
||||
if (!base)
|
||||
return std::unexpected(failure(PublicationError::predecessor));
|
||||
auto replay = server::replay_environment_batch(**base, batch);
|
||||
const auto payload = candidate.snapshot();
|
||||
if (!replay || (*replay)->snapshot() != payload)
|
||||
return std::unexpected(failure(PublicationError::candidate));
|
||||
const auto payload_digest = sha256(payload), trace_digest = sha256(*trace);
|
||||
if (!payload_digest || !trace_digest)
|
||||
return std::unexpected(failure(PublicationError::digest));
|
||||
auto m = environment_successor_manifest(*previous, *previous_digest, commit, lease,
|
||||
batch.population.header.end_tick, build, payload.size(),
|
||||
*payload_digest, {trace->size(), *trace_digest, 0, {}});
|
||||
if (!m)
|
||||
return std::unexpected(failure(PublicationError::candidate));
|
||||
auto encoded = encode_manifest(*m);
|
||||
if (!encoded)
|
||||
return std::unexpected(failure(PublicationError::candidate));
|
||||
PopulationPreparedCommit prepared{previous->key, commit, std::move(*encoded), *trace};
|
||||
if (!canonical(prepared, *m))
|
||||
return std::unexpected(failure(PublicationError::candidate));
|
||||
if (auto uploaded = put(objects, payload); !uploaded)
|
||||
return std::unexpected(uploaded.error());
|
||||
if (auto uploaded = put(objects, *trace); !uploaded)
|
||||
return std::unexpected(uploaded.error());
|
||||
if (hooks.before_transaction)
|
||||
hooks.before_transaction();
|
||||
return retry_environment_prepared(db, prepared, timeout);
|
||||
}
|
||||
|
||||
std::expected<RecoveredEnvironmentCheckpoint, RecoveryFailure> recover_environment_checkpoint(
|
||||
Postgres& db, const FilesystemObjectStore& objects, RegionKey key, const LeaseGrant& lease,
|
||||
std::span<const Sha256Digest> retained_builds, milliseconds timeout) {
|
||||
const auto fail = [](RecoveryError kind) { return std::unexpected(RecoveryFailure{kind, {}}); };
|
||||
auto committed = load_region_checkpoint(db, key, timeout);
|
||||
if (!committed)
|
||||
return std::unexpected(
|
||||
RecoveryFailure{committed.error().kind == LeaseStoreError::not_provisioned
|
||||
? RecoveryError::not_provisioned
|
||||
: RecoveryError::store,
|
||||
committed.error()});
|
||||
auto m = decode_manifest(committed->manifest);
|
||||
if (!m || !bound(*committed, *m) || m->key != key)
|
||||
return fail(RecoveryError::manifest);
|
||||
if (!supported(*m) || m->profile != CheckpointProfile::cellular_environment_v1 ||
|
||||
lease.frame != m->frame ||
|
||||
std::ranges::find(retained_builds, m->build) == retained_builds.end())
|
||||
return fail(RecoveryError::unsupported);
|
||||
auto bytes = objects.get({m->payload_sha256, m->payload_bytes});
|
||||
if (!bytes)
|
||||
return fail(bytes.error() == ObjectError::io ? RecoveryError::store
|
||||
: bytes.error() == ObjectError::missing ? RecoveryError::missing_payload
|
||||
: RecoveryError::corrupt_payload);
|
||||
auto state = restore_environment_payload(*bytes, *m);
|
||||
if (!state)
|
||||
return fail(RecoveryError::payload);
|
||||
auto evidence = load_environment_evidence(db, key, lease, m->commit, timeout);
|
||||
if (!evidence)
|
||||
return std::unexpected(RecoveryFailure{RecoveryError::store, evidence.error()});
|
||||
const auto record_optional = std::move(*evidence);
|
||||
if (!record_optional.has_value())
|
||||
return fail(RecoveryError::history);
|
||||
const auto& record = *record_optional;
|
||||
auto predecessor = load_region_commit(db, key, m->sequence - 1, timeout);
|
||||
if (!predecessor)
|
||||
return std::unexpected(RecoveryFailure{RecoveryError::tail, predecessor.error()});
|
||||
auto previous = decode_manifest(predecessor->manifest);
|
||||
if (!previous || !bound(*predecessor, *previous) || !supported(*previous) ||
|
||||
previous->commit != m->predecessor_commit ||
|
||||
predecessor->head.digest != m->predecessor_digest || previous->key != key ||
|
||||
previous->frame != m->frame || previous->sequence + 1 != m->sequence ||
|
||||
previous->end_tick != m->begin_tick || previous->cellular_versions != m->cellular_versions)
|
||||
return fail(RecoveryError::tail);
|
||||
auto source = objects.get({previous->payload_sha256, previous->payload_bytes});
|
||||
if (!source)
|
||||
return fail(RecoveryError::tail);
|
||||
if (m->batch == BatchDigests{}) {
|
||||
// The transition: the joint payload nests the source population byte for byte.
|
||||
if (!record.trace.empty() || record.source_commit != previous->commit ||
|
||||
record.source_manifest_sha256 != predecessor->head.digest ||
|
||||
record.source_payload_sha256 != previous->payload_sha256 ||
|
||||
previous->profile != CheckpointProfile::cellular_population_v1 ||
|
||||
m->begin_tick != m->end_tick)
|
||||
return fail(RecoveryError::history);
|
||||
if (!restore_population_payload(*source, *previous) ||
|
||||
(*state)->population().snapshot() != *source)
|
||||
return fail(RecoveryError::history);
|
||||
} else {
|
||||
if (record.source_commit.has_value() ||
|
||||
previous->profile != CheckpointProfile::cellular_environment_v1)
|
||||
return fail(RecoveryError::history);
|
||||
auto trace_bytes = objects.get({m->batch.trace_sha256, m->batch.trace_bytes});
|
||||
if (!trace_bytes || *trace_bytes != record.trace)
|
||||
return fail(RecoveryError::tail);
|
||||
PopulationPreparedCommit prepared{key, m->commit, committed->manifest, *trace_bytes};
|
||||
if (!canonical(prepared, *m))
|
||||
return fail(RecoveryError::tail);
|
||||
auto base = restore_environment_payload(*source, *previous);
|
||||
auto trace = server::decode_environment_batch(*trace_bytes);
|
||||
if (!base || !trace)
|
||||
return fail(RecoveryError::tail);
|
||||
auto replay = server::replay_environment_batch(**base, *trace);
|
||||
if (!replay || (*replay)->snapshot() != *bytes)
|
||||
return fail(RecoveryError::tail);
|
||||
}
|
||||
return RecoveredEnvironmentCheckpoint{std::move(*committed), *m, std::move(*state)};
|
||||
}
|
||||
} // namespace evo::persistence
|
||||
@@ -61,7 +61,8 @@ bool structural(const CheckpointManifest& m) noexcept {
|
||||
const auto& b = m.batch;
|
||||
const bool primitive = m.profile == CheckpointProfile::primitive_lives_v1;
|
||||
const bool population = m.profile == CheckpointProfile::cellular_population_v1;
|
||||
const bool cellular = m.profile == CheckpointProfile::cellular_lives_v1 || population;
|
||||
const bool joint = m.profile == CheckpointProfile::cellular_environment_v1;
|
||||
const bool cellular = cellular_profile(m.profile);
|
||||
const bool cellular_migration = cellular && m.sequence > 0 &&
|
||||
(m.cellular_versions == cellular_v2_versions ||
|
||||
m.cellular_versions == cellular_v3_versions ||
|
||||
@@ -71,12 +72,21 @@ bool structural(const CheckpointManifest& m) noexcept {
|
||||
m.cellular_versions == cellular_v12_versions) &&
|
||||
m.begin_tick == m.end_tick && m.end_tick > 0 &&
|
||||
b == BatchDigests{};
|
||||
const bool population_conversion = population && m.begin_tick == m.end_tick && m.end_tick > 0 &&
|
||||
b.trace_bytes >= server::population_batch_header_bytes + 16;
|
||||
const auto joint_min =
|
||||
server::environment_batch_header_bytes + server::population_batch_header_bytes + 16;
|
||||
const bool population_conversion =
|
||||
m.begin_tick == m.end_tick && m.end_tick > 0 &&
|
||||
((population && b.trace_bytes >= server::population_batch_header_bytes + 16) ||
|
||||
(joint && b.trace_bytes >= joint_min));
|
||||
if (population && (m.sequence == 0 || population_envelope_version(m.cellular_versions) == 0 ||
|
||||
m.history_profile != population_history_profile || b.decision_count != 0 ||
|
||||
!zero(b.decisions_sha256)))
|
||||
return false;
|
||||
// ADR-0174: joint profile 6 nests population envelope 2 only (bundles 10 and 11).
|
||||
if (joint && (m.sequence == 0 || population_envelope_version(m.cellular_versions) != 2 ||
|
||||
m.history_profile != environment_history_profile || b.decision_count != 0 ||
|
||||
!zero(b.decisions_sha256)))
|
||||
return false;
|
||||
if ((!cellular && m.cellular_versions != cellular_v1_versions) ||
|
||||
(cellular && m.cellular_versions != cellular_v1_versions &&
|
||||
m.cellular_versions != cellular_v2_versions &&
|
||||
@@ -169,6 +179,8 @@ bool structural(const CheckpointManifest& m) noexcept {
|
||||
: population
|
||||
? b.trace_bytes >= server::population_batch_header_bytes + 16 &&
|
||||
b.trace_bytes <= server::max_population_batch_bytes && b.trace_bytes % 8 == 0
|
||||
: joint ? b.trace_bytes >= joint_min &&
|
||||
b.trace_bytes <= server::max_environment_batch_bytes && b.trace_bytes % 8 == 0
|
||||
: cellular ? (cellular_current_trace || cellular_v2_trace || cellular_legacy_trace)
|
||||
: b.trace_bytes == trace_bytes_for(ticks);
|
||||
return link && trace_shape && !zero(b.trace_sha256) &&
|
||||
@@ -178,6 +190,11 @@ bool structural(const CheckpointManifest& m) noexcept {
|
||||
} // namespace
|
||||
|
||||
bool supported(const CheckpointManifest& m) noexcept {
|
||||
if (m.profile == CheckpointProfile::cellular_environment_v1)
|
||||
return m.manifest_version == 2 && m.history_profile == environment_history_profile &&
|
||||
population_envelope_version(m.cellular_versions) == 2 &&
|
||||
m.versions == environmental_v1_versions && m.tick_microseconds == 50000 &&
|
||||
m.rng_streams == 0 && m.durability == DurabilityPolicy::single_volume_development;
|
||||
if (m.profile == CheckpointProfile::cellular_population_v1)
|
||||
return m.manifest_version == 2 && m.history_profile == population_history_profile &&
|
||||
population_envelope_version(m.cellular_versions) != 0 &&
|
||||
@@ -240,8 +257,7 @@ encode_manifest(const CheckpointManifest& m) {
|
||||
w.u(m.epoch, 8);
|
||||
w.u(m.tick_microseconds, 8);
|
||||
const auto versions =
|
||||
(m.profile == CheckpointProfile::cellular_lives_v1 ||
|
||||
m.profile == CheckpointProfile::cellular_population_v1)
|
||||
cellular_profile(m.profile)
|
||||
? std::array{m.cellular_versions.rules, m.cellular_versions.envelope,
|
||||
m.cellular_versions.habitat, m.cellular_versions.coordinate,
|
||||
m.cellular_versions.genome, m.cellular_versions.development,
|
||||
@@ -298,8 +314,7 @@ decode_manifest(std::span<const std::uint8_t> bytes) {
|
||||
std::array<std::uint32_t, 9> versions{};
|
||||
for (auto& v : versions)
|
||||
v = static_cast<std::uint32_t>(r.u(4));
|
||||
if (m.profile == CheckpointProfile::cellular_lives_v1 ||
|
||||
m.profile == CheckpointProfile::cellular_population_v1) {
|
||||
if (cellular_profile(m.profile)) {
|
||||
m.cellular_versions = {versions[0], versions[1], versions[2], versions[3], versions[4],
|
||||
versions[5], versions[6], versions[7], versions[8]};
|
||||
} else {
|
||||
@@ -360,8 +375,7 @@ clone_manifest(const CheckpointManifest& source, const Sha256Digest& source_dige
|
||||
RegionKey target, Uuid commit, std::uint64_t payload_bytes,
|
||||
const Sha256Digest& payload_sha256, const BatchDigests& inherited) {
|
||||
if (!supported(source) || source.profile == CheckpointProfile::primitive_lives_v1 ||
|
||||
source.profile == CheckpointProfile::cellular_lives_v1 ||
|
||||
source.profile == CheckpointProfile::cellular_population_v1)
|
||||
cellular_profile(source.profile))
|
||||
return std::unexpected{CheckpointError::unsupported};
|
||||
if (!structural(source) || target.world == source.key.world || commit == source.commit ||
|
||||
inherited.trace_bytes != 0 || !zero(inherited.trace_sha256))
|
||||
|
||||
@@ -1502,26 +1502,11 @@ std::expected<bool, AccountIdentityError> revoke_account_grants(Postgres& db, st
|
||||
return std::unexpected{AccountIdentityError::unknown};
|
||||
return *revoked == "true";
|
||||
}
|
||||
std::expected<RegionHead, LeaseStoreFailure>
|
||||
publish_population_checkpoint(Postgres& db, std::span<const std::uint8_t> manifest,
|
||||
std::span<const std::uint8_t> trace, milliseconds timeout) {
|
||||
const std::array<std::string, 2> parameters{bytea(manifest), bytea(trace)};
|
||||
auto rows =
|
||||
db.query("SELECT * FROM evolution.publish_population_checkpoint($1::bytea,$2::bytea)",
|
||||
parameters, timeout);
|
||||
if (!rows)
|
||||
return std::unexpected(classify(rows.error()));
|
||||
auto head = parse_head(*rows);
|
||||
if (!head)
|
||||
return std::unexpected(malformed(true));
|
||||
return *head;
|
||||
}
|
||||
std::expected<RegionHead, LeaseStoreFailure>
|
||||
publish_population_profile_transition(Postgres& db, std::span<const std::uint8_t> manifest,
|
||||
milliseconds timeout) {
|
||||
const std::array<std::string, 1> parameters{bytea(manifest)};
|
||||
auto rows = db.query("SELECT * FROM evolution.publish_population_profile_transition($1::bytea)",
|
||||
parameters, timeout);
|
||||
namespace {
|
||||
std::expected<RegionHead, LeaseStoreFailure> publish_query(Postgres& db, const char* sql,
|
||||
std::span<const std::string> parameters,
|
||||
milliseconds timeout) {
|
||||
auto rows = db.query(sql, parameters, timeout);
|
||||
if (!rows)
|
||||
return std::unexpected(classify(rows.error()));
|
||||
auto head = parse_head(*rows);
|
||||
@@ -1530,15 +1515,15 @@ publish_population_profile_transition(Postgres& db, std::span<const std::uint8_t
|
||||
return *head;
|
||||
}
|
||||
std::expected<ResolvedCommit, LeaseStoreFailure>
|
||||
resolve_population_commit(Postgres& db, RegionKey key, const Uuid& commit,
|
||||
std::span<const std::uint8_t> manifest,
|
||||
std::span<const std::uint8_t> trace, milliseconds timeout) {
|
||||
resolve_query(Postgres& db, std::string_view function, RegionKey key, const Uuid& commit,
|
||||
std::span<const std::uint8_t> manifest, std::span<const std::uint8_t> trace,
|
||||
milliseconds timeout) {
|
||||
const std::array<std::string, 5> parameters{std::to_string(key.world),
|
||||
std::to_string(key.region), uuid_text(commit),
|
||||
bytea(manifest), bytea(trace)};
|
||||
auto rows = db.query("SELECT * FROM evolution.resolve_population_commit($1::evolution.u64,"
|
||||
"$2::evolution.u64,$3::uuid,$4::bytea,$5::bytea)",
|
||||
parameters, timeout);
|
||||
const auto sql = std::string{"SELECT * FROM evolution."} + std::string{function} +
|
||||
"($1::evolution.u64,$2::evolution.u64,$3::uuid,$4::bytea,$5::bytea)";
|
||||
auto rows = db.query(sql, parameters, timeout);
|
||||
if (!rows)
|
||||
return std::unexpected(classify(rows.error()));
|
||||
if (rows->size() != 1 || (*rows)[0].size() != 6 || !(*rows)[0][0])
|
||||
@@ -1558,17 +1543,17 @@ resolve_population_commit(Postgres& db, RegionKey key, const Uuid& commit,
|
||||
return ResolvedCommit{Resolution::committed, *head};
|
||||
}
|
||||
std::expected<std::optional<PopulationEvidence>, LeaseStoreFailure>
|
||||
load_population_evidence(Postgres& db, RegionKey key, const LeaseGrant& lease, const Uuid& commit,
|
||||
milliseconds timeout) {
|
||||
evidence_query(Postgres& db, std::string_view function, RegionKey key, const LeaseGrant& lease,
|
||||
const Uuid& commit, milliseconds timeout) {
|
||||
const std::array<std::string, 5> parameters{std::to_string(key.world),
|
||||
std::to_string(key.region), uuid_text(lease.holder),
|
||||
std::to_string(lease.epoch), uuid_text(commit)};
|
||||
auto rows = db.query(
|
||||
"SELECT encode(trace,'hex'),source_commit::text,encode(source_manifest_sha256,'hex'),"
|
||||
"encode(source_payload_sha256,'hex') FROM "
|
||||
"evolution.load_population_evidence($1::evolution.u64,"
|
||||
"$2::evolution.u64,$3::uuid,$4::evolution.u64,$5::uuid)",
|
||||
parameters, timeout);
|
||||
const auto sql =
|
||||
std::string{"SELECT encode(trace,'hex'),source_commit::text,encode(source_manifest_sha256,"
|
||||
"'hex'),encode(source_payload_sha256,'hex') FROM evolution."} +
|
||||
std::string{function} +
|
||||
"($1::evolution.u64,$2::evolution.u64,$3::uuid,$4::evolution.u64,$5::uuid)";
|
||||
auto rows = db.query(sql, parameters, timeout);
|
||||
if (!rows)
|
||||
return std::unexpected(classify(rows.error()));
|
||||
if (rows->empty())
|
||||
@@ -1598,4 +1583,59 @@ load_population_evidence(Postgres& db, RegionKey key, const LeaseGrant& lease, c
|
||||
return std::unexpected(malformed(false));
|
||||
return std::optional<PopulationEvidence>{std::move(evidence)};
|
||||
}
|
||||
} // namespace
|
||||
std::expected<RegionHead, LeaseStoreFailure>
|
||||
publish_population_checkpoint(Postgres& db, std::span<const std::uint8_t> manifest,
|
||||
std::span<const std::uint8_t> trace, milliseconds timeout) {
|
||||
const std::array<std::string, 2> parameters{bytea(manifest), bytea(trace)};
|
||||
return publish_query(
|
||||
db, "SELECT * FROM evolution.publish_population_checkpoint($1::bytea,$2::bytea)",
|
||||
parameters, timeout);
|
||||
}
|
||||
std::expected<RegionHead, LeaseStoreFailure>
|
||||
publish_population_profile_transition(Postgres& db, std::span<const std::uint8_t> manifest,
|
||||
milliseconds timeout) {
|
||||
const std::array<std::string, 1> parameters{bytea(manifest)};
|
||||
return publish_query(db,
|
||||
"SELECT * FROM evolution.publish_population_profile_transition($1::bytea)",
|
||||
parameters, timeout);
|
||||
}
|
||||
std::expected<ResolvedCommit, LeaseStoreFailure>
|
||||
resolve_population_commit(Postgres& db, RegionKey key, const Uuid& commit,
|
||||
std::span<const std::uint8_t> manifest,
|
||||
std::span<const std::uint8_t> trace, milliseconds timeout) {
|
||||
return resolve_query(db, "resolve_population_commit", key, commit, manifest, trace, timeout);
|
||||
}
|
||||
std::expected<std::optional<PopulationEvidence>, LeaseStoreFailure>
|
||||
load_population_evidence(Postgres& db, RegionKey key, const LeaseGrant& lease, const Uuid& commit,
|
||||
milliseconds timeout) {
|
||||
return evidence_query(db, "load_population_evidence", key, lease, commit, timeout);
|
||||
}
|
||||
std::expected<RegionHead, LeaseStoreFailure>
|
||||
publish_environment_checkpoint(Postgres& db, std::span<const std::uint8_t> manifest,
|
||||
std::span<const std::uint8_t> trace, milliseconds timeout) {
|
||||
const std::array<std::string, 2> parameters{bytea(manifest), bytea(trace)};
|
||||
return publish_query(
|
||||
db, "SELECT * FROM evolution.publish_environment_checkpoint($1::bytea,$2::bytea)",
|
||||
parameters, timeout);
|
||||
}
|
||||
std::expected<RegionHead, LeaseStoreFailure>
|
||||
publish_environment_profile_transition(Postgres& db, std::span<const std::uint8_t> manifest,
|
||||
milliseconds timeout) {
|
||||
const std::array<std::string, 1> parameters{bytea(manifest)};
|
||||
return publish_query(
|
||||
db, "SELECT * FROM evolution.publish_environment_profile_transition($1::bytea)", parameters,
|
||||
timeout);
|
||||
}
|
||||
std::expected<ResolvedCommit, LeaseStoreFailure>
|
||||
resolve_environment_commit(Postgres& db, RegionKey key, const Uuid& commit,
|
||||
std::span<const std::uint8_t> manifest,
|
||||
std::span<const std::uint8_t> trace, milliseconds timeout) {
|
||||
return resolve_query(db, "resolve_environment_commit", key, commit, manifest, trace, timeout);
|
||||
}
|
||||
std::expected<std::optional<PopulationEvidence>, LeaseStoreFailure>
|
||||
load_environment_evidence(Postgres& db, RegionKey key, const LeaseGrant& lease, const Uuid& commit,
|
||||
milliseconds timeout) {
|
||||
return evidence_query(db, "load_environment_evidence", key, lease, commit, timeout);
|
||||
}
|
||||
} // namespace evo::persistence
|
||||
|
||||
@@ -0,0 +1,169 @@
|
||||
#include "evo/persistence/region_checkpoint.hpp"
|
||||
#include "fixtures/cellular_ecology.hpp"
|
||||
|
||||
namespace {
|
||||
using namespace evo;
|
||||
using namespace evo::server;
|
||||
using namespace evo::persistence;
|
||||
using namespace evo::fixture;
|
||||
template <std::size_t N> std::array<std::uint8_t, N> filled(std::uint8_t byte) {
|
||||
std::array<std::uint8_t, N> out{};
|
||||
out.fill(byte);
|
||||
return out;
|
||||
}
|
||||
std::unique_ptr<CellularEnvironment> joint() {
|
||||
auto state = opening(7, true);
|
||||
state = checked(state->migration_upgrade_candidate(), "boundary upgrade");
|
||||
state = checked(state->maturation_upgrade_candidate(), "maturation upgrade");
|
||||
auto population =
|
||||
checked(CellularPopulation::create(std::move(state), {false, 900, 1'600}), "population");
|
||||
CellularEnvironmentConfig config;
|
||||
config.geometry.box = {{0}, {0}, {0}, {6'000}, {6'000}, {10}};
|
||||
CellularInfallSource source;
|
||||
source.id = 1;
|
||||
source.width_um = 6'000;
|
||||
source.height_um = 6'000;
|
||||
source.start_tick = 1;
|
||||
source.end_tick = ~std::uint64_t{0};
|
||||
source.mean_interval_ticks = 20;
|
||||
source.per_bubble.energy.value = 1'000;
|
||||
source.entitlement.energy.value = 1'000'000;
|
||||
config.sources.push_back(source);
|
||||
config.radiation_cap = {5};
|
||||
return checked(CellularEnvironment::create(std::move(population), std::move(config)), "joint");
|
||||
}
|
||||
// A committed profile-5 head at the joint fixture's cut (bundle 11, population envelope 2).
|
||||
CheckpointManifest population_head(const CellularEnvironment& state) {
|
||||
CheckpointManifest m;
|
||||
m.profile = CheckpointProfile::cellular_population_v1;
|
||||
m.key = {state.state().world(), state.state().region()};
|
||||
m.frame = state.state().frame();
|
||||
m.commit = filled<16>(3);
|
||||
m.sequence = 4;
|
||||
m.predecessor_commit = filled<16>(2);
|
||||
m.predecessor_digest = filled<32>(5);
|
||||
m.begin_tick = state.tick();
|
||||
m.end_tick = state.tick();
|
||||
m.holder = filled<16>(6);
|
||||
m.epoch = 2;
|
||||
m.tick_microseconds = 50'000;
|
||||
m.versions = environmental_v1_versions;
|
||||
m.cellular_versions = cellular_v11_versions;
|
||||
m.build = filled<32>(7);
|
||||
m.history_profile = population_history_profile;
|
||||
const auto bytes = state.population().snapshot();
|
||||
m.payload_bytes = bytes.size();
|
||||
m.payload_sha256 = filled<32>(8);
|
||||
return m;
|
||||
}
|
||||
} // namespace
|
||||
|
||||
int main() {
|
||||
try {
|
||||
auto state = joint();
|
||||
const auto head = population_head(*state);
|
||||
require(encode_manifest(head) && supported(head), "profile-5 fixture head");
|
||||
const LeaseGrant lease{filled<16>(9), 3, head.frame, {}};
|
||||
const auto payload = state->snapshot();
|
||||
const auto transition = checked(
|
||||
environment_profile_transition_manifest(head, filled<32>(10), filled<16>(11), lease,
|
||||
filled<32>(12), payload.size(), filled<32>(13)),
|
||||
"profile transition");
|
||||
require(transition.profile == CheckpointProfile::cellular_environment_v1 &&
|
||||
transition.history_profile == environment_history_profile &&
|
||||
transition.cellular_versions == cellular_v11_versions &&
|
||||
transition.begin_tick == transition.end_tick &&
|
||||
transition.batch == BatchDigests{} &&
|
||||
transition.sequence == head.sequence + 1 && supported(transition),
|
||||
"transition changed bundle, tick or evidence");
|
||||
const auto encoded = checked(encode_manifest(transition), "encode transition");
|
||||
require(checked(decode_manifest(encoded), "decode transition") == transition,
|
||||
"transition manifest round trip");
|
||||
const auto restored =
|
||||
checked(restore_environment_payload(payload, transition), "restore joint payload");
|
||||
require(restored->snapshot() == payload, "joint payload restore changed bytes");
|
||||
|
||||
// Only a profile-5 owner-7 predecessor converts; there is no reverse transition.
|
||||
require(!environment_profile_transition_manifest(transition, filled<32>(10), filled<16>(14),
|
||||
lease, filled<32>(12), payload.size(),
|
||||
filled<32>(13)),
|
||||
"joint profile re-entered its own transition");
|
||||
auto raw = head;
|
||||
raw.profile = CheckpointProfile::cellular_lives_v1;
|
||||
raw.history_profile = cellular_revision_history_profile;
|
||||
require(!environment_profile_transition_manifest(raw, filled<32>(10), filled<16>(11), lease,
|
||||
filled<32>(12), payload.size(),
|
||||
filled<32>(13)),
|
||||
"raw profile skipped the population profile");
|
||||
auto old = head;
|
||||
old.cellular_versions = cellular_v9_versions;
|
||||
require(!environment_profile_transition_manifest(old, filled<32>(10), filled<16>(11), lease,
|
||||
filled<32>(12), payload.size(),
|
||||
filled<32>(13)),
|
||||
"population envelope 1 entered the joint profile");
|
||||
auto wrong_lease = lease;
|
||||
wrong_lease.frame += 1;
|
||||
require(!environment_profile_transition_manifest(head, filled<32>(10), filled<16>(11),
|
||||
wrong_lease, filled<32>(12),
|
||||
payload.size(), filled<32>(13)),
|
||||
"transition under another frame's lease");
|
||||
|
||||
const BatchDigests batch{server::environment_batch_header_bytes +
|
||||
server::population_batch_header_bytes + 16 + 48,
|
||||
filled<32>(15),
|
||||
0,
|
||||
{}};
|
||||
const auto next =
|
||||
checked(environment_successor_manifest(transition, filled<32>(16), filled<16>(17),
|
||||
lease, transition.end_tick + 1, filled<32>(12),
|
||||
payload.size(), filled<32>(18), batch),
|
||||
"joint successor");
|
||||
require(next.profile == transition.profile && next.batch == batch &&
|
||||
next.begin_tick == transition.end_tick && supported(next),
|
||||
"joint successor changed profile or evidence");
|
||||
const auto conversion =
|
||||
checked(environment_successor_manifest(transition, filled<32>(16), filled<16>(17),
|
||||
lease, transition.end_tick, filled<32>(12),
|
||||
payload.size(), filled<32>(18), batch),
|
||||
"joint conversion");
|
||||
require(conversion.begin_tick == conversion.end_tick, "conversion advanced its tick");
|
||||
require(!environment_successor_manifest(transition, filled<32>(16), filled<16>(17), lease,
|
||||
transition.end_tick + 1, filled<32>(12),
|
||||
payload.size(), filled<32>(18), {}),
|
||||
"joint successor without a trace");
|
||||
require(!environment_successor_manifest(transition, filled<32>(16), filled<16>(17), lease,
|
||||
transition.end_tick + 65, filled<32>(12),
|
||||
payload.size(), filled<32>(18), batch),
|
||||
"joint interval above 64 ticks");
|
||||
require(!environment_successor_manifest(head, filled<32>(16), filled<16>(17), lease,
|
||||
head.end_tick + 1, filled<32>(12), payload.size(),
|
||||
filled<32>(18), batch),
|
||||
"population head published a joint successor");
|
||||
|
||||
auto history = transition;
|
||||
history.history_profile = population_history_profile;
|
||||
require(!encode_manifest(history) && !supported(history), "joint history 5 accepted");
|
||||
auto bundle12 = transition;
|
||||
bundle12.cellular_versions = cellular_v12_versions;
|
||||
require(!supported(bundle12), "joint profile admitted bundle 12");
|
||||
auto genesis = transition;
|
||||
genesis.sequence = 0;
|
||||
require(!encode_manifest(genesis), "joint profile provisioned without a source");
|
||||
auto later = transition;
|
||||
later.end_tick += 1;
|
||||
later.begin_tick = later.end_tick;
|
||||
require(!restore_environment_payload(payload, later), "payload restored at another tick");
|
||||
require(!restore_environment_payload(state->population().snapshot(), transition),
|
||||
"bare population restored as a joint result");
|
||||
auto unsupported = transition;
|
||||
unsupported.cellular_versions = cellular_v10_versions;
|
||||
require(restore_environment_payload(payload, unsupported).error() ==
|
||||
CheckpointError::unsupported,
|
||||
"rules mismatch accepted");
|
||||
std::cout << "environment checkpoint contracts passed\n";
|
||||
return 0;
|
||||
} catch (const std::exception& error) {
|
||||
std::cerr << error.what() << '\n';
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,410 @@
|
||||
#include "evo/persistence/account_control_store.hpp"
|
||||
#include "evo/persistence/environment_checkpoint_store.hpp"
|
||||
#include "evo/persistence/population_interval_store.hpp"
|
||||
#include "evo/persistence/sha256.hpp"
|
||||
#include "fixtures/cellular_ecology.hpp"
|
||||
|
||||
#include <cstdlib>
|
||||
#include <type_traits>
|
||||
|
||||
void run_environment_publication_tests();
|
||||
namespace {
|
||||
using namespace evo;
|
||||
using namespace evo::server;
|
||||
using namespace evo::persistence;
|
||||
using namespace evo::fixture;
|
||||
using namespace std::chrono_literals;
|
||||
template <typename T, typename E> T take(std::expected<T, E> value, const char* where) {
|
||||
if (!value) {
|
||||
std::string message{where};
|
||||
if constexpr (requires { value.error().cause.sqlstate; })
|
||||
message += " SQLSTATE=" + std::string(value.error().cause.sqlstate.data(), 5);
|
||||
if constexpr (requires { value.error().store.cause.sqlstate; })
|
||||
message += " SQLSTATE=" + std::string(value.error().store.cause.sqlstate.data(), 5);
|
||||
throw std::runtime_error(message);
|
||||
}
|
||||
if constexpr (!std::is_void_v<T>)
|
||||
return std::move(*value);
|
||||
}
|
||||
std::string variable(const char* name) {
|
||||
const auto* value = std::getenv(name);
|
||||
require(value != nullptr, "missing private test environment");
|
||||
return value;
|
||||
}
|
||||
std::unique_ptr<Postgres> connection(bool owner = false) {
|
||||
return take(Postgres::connect({variable("PGHOST"),
|
||||
{},
|
||||
variable("PGPORT"),
|
||||
variable("PGDATABASE"),
|
||||
variable(owner ? "PGUSER" : "EVO_PG_RUNTIME_USER"),
|
||||
{},
|
||||
{}},
|
||||
5s),
|
||||
"environment connection");
|
||||
}
|
||||
// Mixed-byte identities, distinct from every other suite's commit namespace.
|
||||
Uuid identity(unsigned number) {
|
||||
Uuid id{};
|
||||
id[0] = 0xE6;
|
||||
id[1] = 0x56;
|
||||
id[7] = 0x3C;
|
||||
id[14] = static_cast<std::uint8_t>(number >> 8U);
|
||||
id[15] = static_cast<std::uint8_t>(number);
|
||||
return id;
|
||||
}
|
||||
std::string hexadecimal(std::span<const std::uint8_t> bytes) {
|
||||
std::string out = "\\x";
|
||||
constexpr char digits[] = "0123456789abcdef";
|
||||
for (const auto b : bytes) {
|
||||
out.push_back(digits[b >> 4U]);
|
||||
out.push_back(digits[b & 15U]);
|
||||
}
|
||||
return out;
|
||||
}
|
||||
struct Fixture {
|
||||
RegionKey key{30411, 1};
|
||||
std::unique_ptr<Postgres> owner = connection(true), db = connection();
|
||||
std::unique_ptr<FilesystemObjectStore> objects;
|
||||
LeaseGrant lease;
|
||||
Sha256Digest build{};
|
||||
CommittedCheckpoint head;
|
||||
std::unique_ptr<CellularLives> raw;
|
||||
std::unique_ptr<CellularEnvironment> joint;
|
||||
unsigned next_id = 1;
|
||||
Uuid id() {
|
||||
return identity(next_id++);
|
||||
}
|
||||
CellularBatchHeader header(std::uint64_t count) const {
|
||||
return {key.world,
|
||||
key.region,
|
||||
1,
|
||||
head.head.commit,
|
||||
head.head.digest,
|
||||
head.head.end_tick,
|
||||
head.head.end_tick + count};
|
||||
}
|
||||
[[nodiscard]] std::array<Sha256Digest, 1> builds() const {
|
||||
return {build};
|
||||
}
|
||||
};
|
||||
|
||||
// A real funded raw region with player-derived wildlife and fully suspended players.
|
||||
void funded_source(Fixture& f) {
|
||||
f.build.fill(0xE6);
|
||||
const std::array<std::string, 1> build{hexadecimal(f.build)};
|
||||
take(f.owner->query("INSERT INTO evolution.retained_builds(build_identity) VALUES($1::bytea) "
|
||||
"ON CONFLICT DO NOTHING",
|
||||
build, 5s),
|
||||
"retain test build");
|
||||
const std::array<std::string, 1> world{std::to_string(f.key.world)};
|
||||
take(f.owner->query("INSERT INTO evolution.life_allocators VALUES($1::evolution.u64,100)",
|
||||
world, 5s),
|
||||
"test allocator");
|
||||
f.objects =
|
||||
take(FilesystemObjectStore::open(variable("PGHOST"), f.key, max_cellular_environment_bytes),
|
||||
"environment object namespace");
|
||||
f.raw = opening(f.key.world - 200, true, 4, false, f.key.region);
|
||||
f.head =
|
||||
take(provision_cellular_region(*f.owner, *f.objects, f.key, 1, *f.raw, f.id(), f.build, 5s),
|
||||
"empty cellular genesis");
|
||||
f.lease =
|
||||
take(acquire_region_lease(*f.db, f.key, f.build, 60000ms, 5s), "environment test lease");
|
||||
CellularBatch birth{f.header(1), {{}}};
|
||||
for (std::uint8_t index = 1; index <= 4; ++index) {
|
||||
Uuid account{};
|
||||
account[0] = 0xE6;
|
||||
account.back() = index;
|
||||
const auto control =
|
||||
take(claim_account_control(*f.db, f.key, f.lease, account, 1, index, 60000ms, 5s),
|
||||
"founder account control");
|
||||
const auto reserved = take(
|
||||
reserve_primitive_life(*f.db, f.key, f.lease, account, control.generation, 1, 1, 5s),
|
||||
"funded founder reservation");
|
||||
birth.ticks.front().births.push_back({account, 1, control.generation, reserved.identity});
|
||||
}
|
||||
f.raw = take(replay_cellular_batch(*f.raw, birth), "funded founder replay");
|
||||
f.head = take(publish_cellular_batch(*f.db, *f.objects, f.lease, f.head, birth, *f.raw, f.id(),
|
||||
f.build, 5s),
|
||||
"funded founder publication")
|
||||
.committed;
|
||||
while (f.raw->next_bud_sequence() == 1 && f.raw->tick() < 20000) {
|
||||
CellularBatch batch{f.header(1), {}};
|
||||
for (unsigned tick = 0; tick < 64; ++tick) {
|
||||
auto intents =
|
||||
take(wildlife_intents(*f.raw, f.raw->tick() + 1), "funded source wildlife");
|
||||
for (const auto& life : f.raw->lives()) {
|
||||
if (life.account == LifeAccount{})
|
||||
continue;
|
||||
CellularLifeIntent intent{life.identity.life, {}};
|
||||
intent.intent.bud = (f.raw->tick() + life.identity.life) % 32 == 0;
|
||||
intents.push_back(intent);
|
||||
}
|
||||
std::ranges::sort(intents, {}, &CellularLifeIntent::life_id);
|
||||
take(f.raw->advance_tick(intents), "funded source biology");
|
||||
batch.ticks.push_back({intents, {}, {}});
|
||||
if (f.raw->next_bud_sequence() > 1)
|
||||
break;
|
||||
}
|
||||
batch.header.end_tick = f.raw->tick();
|
||||
f.head = take(publish_cellular_batch(*f.db, *f.objects, f.lease, f.head, batch, *f.raw,
|
||||
f.id(), f.build, 5s),
|
||||
"funded source batch")
|
||||
.committed;
|
||||
take(renew_region_lease(*f.db, f.key, f.lease, 60000ms, 5s), "source lease renewal");
|
||||
}
|
||||
require(std::ranges::any_of(f.raw->lives(),
|
||||
[](const auto& life) { return life.account == LifeAccount{}; }),
|
||||
"durable fixture has no funded player-derived wildlife");
|
||||
const auto suspended_at = f.raw->tick() + cellular_linger_ticks + 1;
|
||||
while (f.raw->tick() < suspended_at) {
|
||||
auto h = f.header(std::min(std::uint64_t{64}, suspended_at - f.raw->tick()));
|
||||
auto prefix = take(unattended_population_inputs(*f.raw, h), "raw linger inputs");
|
||||
f.raw = take(replay_cellular_batch(*f.raw, prefix), "raw linger biology");
|
||||
f.head = take(publish_cellular_batch(*f.db, *f.objects, f.lease, f.head, prefix, *f.raw,
|
||||
f.id(), f.build, 5s),
|
||||
"raw linger publication")
|
||||
.committed;
|
||||
std::vector<std::uint64_t> endings;
|
||||
for (const auto& corpse : f.raw->corpses())
|
||||
if (corpse.parent_life == 0)
|
||||
endings.push_back(corpse.life_id);
|
||||
if (!endings.empty())
|
||||
take(end_cellular_lives(*f.db, f.key, f.lease, f.head.head.commit, endings, 5s),
|
||||
"raw linger endings");
|
||||
}
|
||||
require(population_interval_safe(*f.raw), "joint source retained a vulnerable player");
|
||||
}
|
||||
|
||||
CellularEnvironmentConfig declared(const CellularLives& state) {
|
||||
CellularEnvironmentConfig config;
|
||||
config.geometry.voxel = {4, 0, -1};
|
||||
config.geometry.box = {{0}, {0}, {0}, {state.area().width_um}, {state.area().height_um}, {12}};
|
||||
config.water = {{9'000'000}, {40'000}, {6'000}};
|
||||
CellularInfallSource source;
|
||||
source.id = 3;
|
||||
source.width_um = static_cast<std::uint32_t>(state.area().width_um);
|
||||
source.height_um = static_cast<std::uint32_t>(state.area().height_um);
|
||||
source.start_tick = state.tick() + 1;
|
||||
source.end_tick = ~std::uint64_t{0};
|
||||
source.mean_interval_ticks = 9;
|
||||
source.per_bubble.energy.value = 300'000;
|
||||
source.per_bubble.matter[0].value = 30'000;
|
||||
source.entitlement.energy.value = 1ULL << 40;
|
||||
source.entitlement.matter[0].value = 1ULL << 40;
|
||||
config.sources.push_back(source);
|
||||
config.radiation_cap = {17};
|
||||
return config;
|
||||
}
|
||||
void recover(Fixture& f) {
|
||||
auto db = connection();
|
||||
const auto builds = f.builds();
|
||||
auto recovered =
|
||||
take(recover_environment_checkpoint(*db, *f.objects, f.key, f.lease, builds, 5s),
|
||||
"joint durable recovery");
|
||||
f.head = std::move(recovered.committed);
|
||||
f.joint = std::move(recovered.state);
|
||||
}
|
||||
struct Flows {
|
||||
std::uint64_t energy{}, carbon{}, radiated{};
|
||||
};
|
||||
Flows recorded(Fixture& f, const Uuid& commit) {
|
||||
const std::array<std::string, 1> id{[&] {
|
||||
std::string out;
|
||||
constexpr char digits[] = "0123456789abcdef";
|
||||
for (std::size_t i = 0; i < commit.size(); ++i) {
|
||||
if (i == 4 || i == 6 || i == 8 || i == 10)
|
||||
out.push_back('-');
|
||||
out.push_back(digits[commit[i] >> 4U]);
|
||||
out.push_back(digits[commit[i] & 15U]);
|
||||
}
|
||||
return out;
|
||||
}()};
|
||||
const auto rows = take(f.owner->query("SELECT imported_energy::text,imported_carbon::text,"
|
||||
"radiated_heat::text FROM evolution.environment_"
|
||||
"publications WHERE commit_id=$1::uuid",
|
||||
id, 5s),
|
||||
"recorded environment flows");
|
||||
require(rows.size() == 1 && rows[0].size() == 3, "missing environment flow evidence");
|
||||
return {std::stoull(rows[0][0].value_or("x")), std::stoull(rows[0][1].value_or("x")),
|
||||
std::stoull(rows[0][2].value_or("x"))};
|
||||
}
|
||||
Flows sum(const CellularEnvironmentBatch& batch) {
|
||||
Flows total;
|
||||
for (const auto& flow : batch.flows) {
|
||||
total.energy += flow.imported.energy.value;
|
||||
total.carbon += flow.imported.matter[0].value;
|
||||
total.radiated += flow.exported.value;
|
||||
}
|
||||
return total;
|
||||
}
|
||||
bool rejected(const auto& result, std::string_view sqlstate) {
|
||||
if (result)
|
||||
return false;
|
||||
const auto& error = result.error();
|
||||
const std::string_view actual(error.store.cause.sqlstate.data(), 5);
|
||||
if (error.kind != PublicationError::rejected || actual != sqlstate)
|
||||
std::fprintf(stderr, "refusal kind %u, store %u, SQLSTATE %.5s\n",
|
||||
static_cast<unsigned>(error.kind), static_cast<unsigned>(error.store.kind),
|
||||
error.store.cause.sqlstate.data());
|
||||
return error.kind == PublicationError::rejected && actual == sqlstate;
|
||||
}
|
||||
|
||||
// The joint transition, owned intervals, conversions, retries and refusals.
|
||||
void joint_profile(Fixture& f) {
|
||||
f.head = take(
|
||||
migrate_cellular_boundary_profile(*f.db, *f.objects, f.lease, f.head, f.id(), f.build, 5s),
|
||||
"durable boundary upgrade");
|
||||
f.head = take(migrate_cellular_maturation_profile(*f.db, *f.objects, f.lease, f.head, f.id(),
|
||||
f.build, 5s),
|
||||
"durable maturation upgrade");
|
||||
require(!migrate_population_to_environment(*f.db, *f.objects, f.lease, f.head, f.id(), f.build,
|
||||
declared(*f.raw), 5s),
|
||||
"raw profile skipped the population profile");
|
||||
f.head = take(migrate_cellular_to_population(*f.db, *f.objects, f.lease, f.head, f.id(),
|
||||
f.build, {false, 900, 1'600}, 5s),
|
||||
"population entry");
|
||||
const auto builds = f.builds();
|
||||
auto population =
|
||||
take(recover_population_checkpoint(*f.db, *f.objects, f.key, f.lease, builds, 5s),
|
||||
"population recovery");
|
||||
const auto nested = population.state->snapshot();
|
||||
|
||||
const auto transition_id = f.id();
|
||||
const auto entered =
|
||||
take(migrate_population_to_environment(*f.db, *f.objects, f.lease, f.head, transition_id,
|
||||
f.build, declared(population.state->state()), 5s),
|
||||
"joint profile transition");
|
||||
const PopulationPreparedCommit exact{f.key, transition_id, entered.manifest, {}};
|
||||
const auto retried =
|
||||
take(retry_environment_prepared(*f.db, exact, 5s), "exact transition retry");
|
||||
require(retried.head == entered.head && retried.manifest == entered.manifest,
|
||||
"transition retry changed its receipt");
|
||||
auto reused = decode_manifest(entered.manifest).value();
|
||||
reused.payload_sha256.fill(0x44);
|
||||
const PopulationPreparedCommit conflicting{
|
||||
f.key, transition_id, encode_manifest(reused).value(), {}};
|
||||
require(rejected(retry_environment_prepared(*f.db, conflicting, 5s), "EVL07"),
|
||||
"transition identity reused with other bytes");
|
||||
require(take(resolve_environment_prepared(*f.db, exact, 5s), "resolve transition").status ==
|
||||
Resolution::committed,
|
||||
"committed transition unresolved");
|
||||
recover(f);
|
||||
require(f.joint->population().snapshot() == nested && f.joint->imported() == Inventory{} &&
|
||||
f.joint->tick() == population.state->state().tick(),
|
||||
"joint transition changed nested biology or crossed the boundary");
|
||||
|
||||
// An unattended interval needs its owned admission first.
|
||||
auto interval = take(prepare_environment_interval(*f.joint, f.header(64)), "joint interval");
|
||||
require(rejected(publish_environment_batch(*f.db, *f.objects, f.lease, f.head, interval.batch,
|
||||
*interval.state, f.id(), f.build, 5s),
|
||||
"EVL18"),
|
||||
"interval published without an owned admission");
|
||||
take(admit_population_interval(*f.db, f.key, f.lease, f.head.head, f.head.head.end_tick + 64,
|
||||
5s),
|
||||
"joint interval admission");
|
||||
const auto interval_id = f.id();
|
||||
const PopulationPreparedCommit pending{
|
||||
f.key, interval_id, {}, take(encode_environment_batch(interval.batch), "encode interval")};
|
||||
f.head = take(publish_environment_batch(*f.db, *f.objects, f.lease, f.head, interval.batch,
|
||||
*interval.state, interval_id, f.build, 5s),
|
||||
"joint interval publication");
|
||||
const auto flows = recorded(f, interval_id), expected = sum(interval.batch);
|
||||
require(flows.energy == expected.energy && flows.carbon == expected.carbon &&
|
||||
flows.radiated == expected.radiated && expected.energy > 0 && expected.radiated > 0,
|
||||
"SQL flow evidence disagrees with the joint trace");
|
||||
const PopulationPreparedCommit published{f.key, interval_id, f.head.manifest, pending.trace};
|
||||
require(take(retry_environment_prepared(*f.db, published, 5s), "exact interval retry").head ==
|
||||
f.head.head,
|
||||
"interval retry changed its receipt");
|
||||
recover(f);
|
||||
require(f.joint->snapshot() == interval.state->snapshot(), "recovered interval diverged");
|
||||
|
||||
// Bypass publishers cannot commit or reinterpret joint evidence.
|
||||
require(!publish_population_checkpoint(*f.db, f.head.manifest, pending.trace, 5s),
|
||||
"population publisher accepted joint evidence");
|
||||
|
||||
// Whole-group conversion, then a cohort interval, each recovered exactly.
|
||||
std::uint64_t genome = 0;
|
||||
for (const auto& life : f.joint->state().lives())
|
||||
if (life.account == LifeAccount{})
|
||||
genome = life.identity.genome;
|
||||
require(genome != 0, "no durable wildlife to convert");
|
||||
auto conversion = take(prepare_environment_conversion(*f.joint, f.header(0), {genome, true}),
|
||||
"joint conversion");
|
||||
take(
|
||||
admit_population_interval(*f.db, f.key, f.lease, f.head.head, f.head.head.end_tick + 8, 5s),
|
||||
"blocking admission");
|
||||
require(rejected(publish_environment_batch(*f.db, *f.objects, f.lease, f.head, conversion.batch,
|
||||
*conversion.state, f.id(), f.build, 5s),
|
||||
"EVL18"),
|
||||
"conversion overtook a pending interval");
|
||||
auto short_interval =
|
||||
take(prepare_environment_interval(*f.joint, f.header(8)), "short interval");
|
||||
f.head =
|
||||
take(publish_environment_batch(*f.db, *f.objects, f.lease, f.head, short_interval.batch,
|
||||
*short_interval.state, f.id(), f.build, 5s),
|
||||
"settle pending interval");
|
||||
recover(f);
|
||||
conversion = take(prepare_environment_conversion(*f.joint, f.header(0), {genome, true}),
|
||||
"joint conversion at the settled head");
|
||||
f.head = take(publish_environment_batch(*f.db, *f.objects, f.lease, f.head, conversion.batch,
|
||||
*conversion.state, f.id(), f.build, 5s),
|
||||
"joint conversion publication");
|
||||
recover(f);
|
||||
require(!f.joint->population().members().empty() &&
|
||||
f.joint->snapshot() == conversion.state->snapshot(),
|
||||
"recovered conversion diverged");
|
||||
take(admit_population_interval(*f.db, f.key, f.lease, f.head.head, f.head.head.end_tick + 64,
|
||||
5s),
|
||||
"cohort interval admission");
|
||||
auto cohort = take(prepare_environment_interval(*f.joint, f.header(64)), "cohort interval");
|
||||
f.head = take(publish_environment_batch(*f.db, *f.objects, f.lease, f.head, cohort.batch,
|
||||
*cohort.state, f.id(), f.build, 5s),
|
||||
"cohort interval publication");
|
||||
recover(f);
|
||||
require(f.joint->snapshot() == cohort.state->snapshot(), "recovered cohort interval diverged");
|
||||
std::printf("joint profile: head %llu at tick %llu, imported %llu pJ, radiated %llu pJ\n",
|
||||
static_cast<unsigned long long>(f.head.head.sequence),
|
||||
static_cast<unsigned long long>(f.head.head.end_tick),
|
||||
static_cast<unsigned long long>(f.joint->imported().energy.value),
|
||||
static_cast<unsigned long long>(f.joint->exported().value));
|
||||
}
|
||||
|
||||
// Structurally valid but forged flows commit through the low-level SQL publisher, which
|
||||
// does not replay biology; recovery replays the trace and refuses the head.
|
||||
void forged_evidence(Fixture& f) {
|
||||
take(
|
||||
admit_population_interval(*f.db, f.key, f.lease, f.head.head, f.head.head.end_tick + 4, 5s),
|
||||
"forged interval admission");
|
||||
auto interval = take(prepare_environment_interval(*f.joint, f.header(4)), "forged interval");
|
||||
interval.batch.flows[0].exported.value += 1;
|
||||
const auto trace = take(encode_environment_batch(interval.batch), "encode forged trace");
|
||||
const auto payload = interval.state->snapshot();
|
||||
const auto previous = decode_manifest(f.head.manifest).value();
|
||||
const auto previous_digest = sha256(f.head.manifest).value();
|
||||
const auto manifest =
|
||||
take(environment_successor_manifest(previous, previous_digest, f.id(), f.lease,
|
||||
f.head.head.end_tick + 4, f.build, payload.size(),
|
||||
sha256(payload).value(),
|
||||
{trace.size(), sha256(trace).value(), 0, {}}),
|
||||
"forged manifest");
|
||||
take(f.objects->put(payload), "forged payload object");
|
||||
take(f.objects->put(trace), "forged trace object");
|
||||
const auto bytes = take(encode_manifest(manifest), "encode forged manifest");
|
||||
take(publish_environment_checkpoint(*f.db, bytes, trace, 5s), "structural forged publication");
|
||||
auto db = connection();
|
||||
const auto builds = f.builds();
|
||||
const auto refused =
|
||||
recover_environment_checkpoint(*db, *f.objects, f.key, f.lease, builds, 5s);
|
||||
require(!refused && refused.error().kind == RecoveryError::tail,
|
||||
"recovery accepted forged environmental flows");
|
||||
}
|
||||
} // namespace
|
||||
|
||||
void run_environment_publication_tests() {
|
||||
Fixture fixture;
|
||||
funded_source(fixture);
|
||||
joint_profile(fixture);
|
||||
forged_evidence(fixture);
|
||||
std::puts("joint environment publication, intervals, conversions and recovery passed");
|
||||
}
|
||||
@@ -10,6 +10,7 @@ void run_life_reservation_store_tests();
|
||||
void run_primitive_publication_tests();
|
||||
void run_cellular_publication_tests();
|
||||
void run_population_publication_tests();
|
||||
void run_environment_publication_tests();
|
||||
void run_probe_handoff_store_tests();
|
||||
void run_region_action_tests();
|
||||
void run_region_checkpoint_store_tests();
|
||||
@@ -130,6 +131,10 @@ int main(int argc, char** argv) {
|
||||
run_population_publication_tests();
|
||||
return 0;
|
||||
}
|
||||
if (argc == 2 && std::string_view(argv[1]) == "--environment-only") {
|
||||
run_environment_publication_tests();
|
||||
return 0;
|
||||
}
|
||||
if (argc == 2 && std::string_view(argv[1]) == "--life-reservations-only") {
|
||||
run_life_reservation_store_tests();
|
||||
run_primitive_publication_tests();
|
||||
@@ -146,6 +151,7 @@ int main(int argc, char** argv) {
|
||||
run_primitive_publication_tests();
|
||||
run_cellular_publication_tests();
|
||||
run_population_publication_tests();
|
||||
run_environment_publication_tests();
|
||||
run_probe_handoff_store_tests();
|
||||
run_region_action_tests();
|
||||
std::puts("region lease fencing integration passed");
|
||||
|
||||
@@ -221,6 +221,7 @@ void upgrade_across_migration_and_barrier() {
|
||||
" -v migration_sha_53=$(s 0053_funded_cellular_maturation.sql)"
|
||||
" -v migration_sha_54=$(s 0054_maturing_cellular_migration.sql)"
|
||||
" -v migration_sha_55=$(s 0055_retained_cellular_plans.sql)"
|
||||
" -v migration_sha_56=$(s 0056_cellular_environment_publication.sql)"
|
||||
" -v runtime_role=evo_runtime_test -f migrations/apply.sql"
|
||||
" > /dev/null 2>&1") != 0);
|
||||
CHECK(history(*owner_db) == "1,2,3,4,5,6,7");
|
||||
@@ -238,7 +239,7 @@ void upgrade_across_migration_and_barrier() {
|
||||
"tools/migrate-postgres.sh\" > /dev/null") == 0);
|
||||
CHECK(history(*owner_db) == "1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,"
|
||||
"25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,"
|
||||
"47,48,49,50,51,52,53,54,55");
|
||||
"47,48,49,50,51,52,53,54,55,56");
|
||||
CHECK(scalar(*owner_db, "SELECT (c.condeferrable AND c.condeferred AND "
|
||||
"c.confrelid = 'evolution.region_commits'::regclass)::text "
|
||||
"FROM pg_catalog.pg_constraint c WHERE c.conrelid = "
|
||||
|
||||
@@ -58,15 +58,27 @@ for invalid in NULL "'00000000-0000-0000-0000-000000000000'"; do
|
||||
done
|
||||
# Reconstruct the exact pre-context metadata schema in this disposable database.
|
||||
# Restore the resulting real legacy backup through both supported workflows.
|
||||
# Undo schema 55's plan validators, schema 54's three replacements and schema 53;
|
||||
# backup must contain the actual pre-context function contracts and privileges.
|
||||
# Undo schema 56's joint profile, schema 55's plan validators, schema 54's three
|
||||
# replacements and schema 53; the backup must contain the actual pre-context
|
||||
# function contracts and privileges.
|
||||
awk '/^CREATE FUNCTION evolution\.admit_population_interval\(/ {capture=1; sub(/^CREATE FUNCTION/,"CREATE OR REPLACE FUNCTION")} capture {print} capture && /^END \$\$;/ {capture=0}' \
|
||||
"$root/migrations/0045_owned_population_intervals.sql" | sql > /dev/null
|
||||
awk '/^CREATE FUNCTION evolution\.(check_cellular_migration_trace|prepare_cellular_migration_freeze|publish_cellular_migration)\(/ {capture=1; sub(/^CREATE FUNCTION/,"CREATE OR REPLACE FUNCTION")} capture {print} capture && /^END \$\$;/ {capture=0}' \
|
||||
"$root/migrations/0047_cellular_migration_freeze.sql" \
|
||||
"$root/migrations/0049_cellular_migration_publication.sql" | sql > /dev/null
|
||||
awk '/^CREATE OR REPLACE FUNCTION evolution\.(cellular_mutation_selections|check_cellular_mutation_block)\(/ {capture=1} capture {print} capture && /^END \$\$;/ {capture=0}' \
|
||||
"$root/migrations/0040_cellular_mutation_decline.sql" | sql > /dev/null
|
||||
sql -v runtime_role="$EVO_PG_RUNTIME_ROLE" > /dev/null <<'SQL'
|
||||
DROP TRIGGER region_environment_evidence ON evolution.region_commits;
|
||||
DROP FUNCTION evolution.refuse_unpublished_environment();
|
||||
DROP FUNCTION evolution.load_environment_evidence(evolution.u64,evolution.u64,uuid,evolution.u64,uuid);
|
||||
DROP FUNCTION evolution.resolve_environment_commit(evolution.u64,evolution.u64,uuid,bytea,bytea);
|
||||
DROP FUNCTION evolution.publish_environment_profile_transition(bytea);
|
||||
DROP FUNCTION evolution.publish_environment_checkpoint(bytea,bytea);
|
||||
DROP FUNCTION evolution.check_environment_trace(bytea,bytea);
|
||||
DROP TABLE evolution.environment_publications, evolution.environment_profile_transitions;
|
||||
DROP FUNCTION evolution.parse_checkpoint_manifest(bytea);
|
||||
DROP FUNCTION evolution.parse_checkpoint_manifest_v55(bytea);
|
||||
DROP FUNCTION evolution.parse_checkpoint_manifest_v54(bytea);
|
||||
ALTER FUNCTION evolution.parse_checkpoint_manifest_v52(bytea) RENAME TO parse_checkpoint_manifest;
|
||||
DROP FUNCTION evolution.cellular_births(bytea,bytea);
|
||||
|
||||
@@ -3,6 +3,7 @@ set -euo pipefail
|
||||
# Usage: postgres-check.sh [--full|--sanitizer|--suite-only] <evo-postgres-tests>
|
||||
# postgres-check.sh --life-reservations-only [<evo-postgres-tests>]
|
||||
# postgres-check.sh --population-only <evo-postgres-tests>
|
||||
# postgres-check.sh --environment-only <evo-postgres-tests>
|
||||
# postgres-check.sh --migration-faults <evo-postgres-tests> (private loopback TLS)
|
||||
# --full (default) is the complete qualification: the C++ suite, the backup, DR and
|
||||
# upgrade process checks, then the SQL-only migration, permission and checksum checks.
|
||||
@@ -15,6 +16,7 @@ mode=full
|
||||
case "${1:-}" in
|
||||
--migration-faults) mode=migration-faults; shift ;;
|
||||
--population-only) mode=population; shift ;;
|
||||
--environment-only) mode=environment; shift ;;
|
||||
--full) shift ;;
|
||||
--sanitizer) mode=sanitizer; shift ;;
|
||||
--suite-only) mode=suite-only; shift ;;
|
||||
@@ -82,6 +84,11 @@ if [ "$mode" = population ] || [ "$mode" = migration-faults ]; then
|
||||
"$1" --population-only
|
||||
exit 0
|
||||
fi
|
||||
if [ "$mode" = environment ]; then
|
||||
phase environment
|
||||
"$1" --environment-only
|
||||
exit 0
|
||||
fi
|
||||
# M7.9 clone target: a separate database with its own runtime group and login,
|
||||
# so a clone shares neither the source's database nor its runtime credentials.
|
||||
psql -X -v ON_ERROR_STOP=1 -c 'CREATE ROLE evo_clone_runtime NOLOGIN' -c 'CREATE ROLE evo_clone_login LOGIN IN ROLE evo_clone_runtime'
|
||||
@@ -154,7 +161,7 @@ PGDATABASE=upgrade_path psql -X -v ON_ERROR_STOP=1 -1 -v "migration_sha=$v1_sha"
|
||||
-f "$root/migrations/0001_region_bootstrap.sql" > /dev/null
|
||||
test "$(PGDATABASE=upgrade_path psql -XAtc "SELECT string_agg(version::text, ',') FROM evolution.schema_migrations")" = 1
|
||||
PGDATABASE=upgrade_path bash "$root/tools/migrate-postgres.sh"
|
||||
test "$(PGDATABASE=upgrade_path psql -XAtc "SELECT string_agg(version::text, ',' ORDER BY version) FROM evolution.schema_migrations")" = 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55
|
||||
test "$(PGDATABASE=upgrade_path psql -XAtc "SELECT string_agg(version::text, ',' ORDER BY version) FROM evolution.schema_migrations")" = 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56
|
||||
# v2 heads have no payload binding: v2->v3 fails closed and leaves history at v2.
|
||||
v2_sha="$(sha256sum "$root/migrations/0002_region_fencing.sql")"
|
||||
v2_sha="${v2_sha%% *}"
|
||||
@@ -175,7 +182,7 @@ PGDATABASE=v3_commits psql -X -v ON_ERROR_STOP=1 \
|
||||
-c "INSERT INTO evolution.retained_builds VALUES (decode(repeat('b1', 32), 'hex'))" \
|
||||
-c "SELECT evolution.provision_region_checkpoint(decode('4145564f52434d31' || '01000000' || '01000000' || '0100000000000000' || '0100000000000000' || '0900000000000000' || repeat('11', 16) || repeat('00', 8) || repeat('00', 16) || repeat('00', 32) || repeat('00', 16) || repeat('00', 16) || repeat('00', 8) || '50c3000000000000' || '020000000200000001000000010000000100000001000000010000000100000001000000' || repeat('b1', 32) || '00000000' || '00000000' || '01000000' || '6400000000000000' || repeat('a0', 32), 'hex'))" > /dev/null
|
||||
PGDATABASE=v3_commits bash "$root/tools/migrate-postgres.sh"
|
||||
test "$(PGDATABASE=v3_commits psql -XAtc "SELECT count(*) || ':' || string_agg(version::text, ',' ORDER BY version) FROM evolution.schema_migrations")" = 55:1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55
|
||||
test "$(PGDATABASE=v3_commits psql -XAtc "SELECT count(*) || ':' || string_agg(version::text, ',' ORDER BY version) FROM evolution.schema_migrations")" = 56:1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56
|
||||
test "$(PGDATABASE=v3_commits psql -XAtc "SELECT count(*) FROM evolution.region_commits")" = 1
|
||||
# Review P1: a v4 database holding a published (possibly terminal) checkpoint has
|
||||
# no durable decisions for it. The v5 upgrade must refuse before changing anything.
|
||||
@@ -229,7 +236,7 @@ PGDATABASE=v6_populated psql -X -v ON_ERROR_STOP=1 \
|
||||
-c "INSERT INTO evolution.retained_builds VALUES (decode(repeat('b1', 32), 'hex'))" \
|
||||
-c "SELECT evolution.provision_region_checkpoint(decode('4145564f52434d31' || '02000000' || '01000000' || '0100000000000000' || '0100000000000000' || '0900000000000000' || repeat('11', 16) || repeat('00', 8) || repeat('00', 16) || repeat('00', 32) || repeat('00', 16) || repeat('00', 16) || repeat('00', 8) || '50c3000000000000' || '020000000200000001000000010000000100000001000000010000000100000001000000' || repeat('b1', 32) || '00000000' || '00000000' || '01000000' || '6400000000000000' || repeat('a0', 32) || repeat('00', 80), 'hex'))" > /dev/null
|
||||
PGDATABASE=v6_populated bash "$root/tools/migrate-postgres.sh"
|
||||
test "$(PGDATABASE=v6_populated psql -XAtc "SELECT string_agg(version::text, ',' ORDER BY version) FROM evolution.schema_migrations")" = 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55
|
||||
test "$(PGDATABASE=v6_populated psql -XAtc "SELECT string_agg(version::text, ',' ORDER BY version) FROM evolution.schema_migrations")" = 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56
|
||||
test "$(PGDATABASE=v6_populated psql -XAtc "SELECT count(*) FROM evolution.region_commits c, LATERAL evolution.parse_checkpoint_manifest(c.manifest) m WHERE m.commit_sequence = 0 AND m.predecessor_commit IS NULL")" = 1
|
||||
test "$(PGDATABASE=v6_populated psql -XAtc "SELECT string_agg(conname, ',') FROM pg_constraint WHERE conrelid = 'evolution.region_heads'::regclass AND contype = 'c' AND pg_get_constraintdef(oid) LIKE '%end_tick%'")" = region_heads_published_tick
|
||||
phase permission-audit
|
||||
@@ -287,9 +294,9 @@ expect_audit_failure 'REVOKE EXECUTE ON FUNCTION evolution.load_world_cellular_m
|
||||
expect_audit_failure 'GRANT EXECUTE ON FUNCTION evolution.fork_restored_history_v1(uuid) TO evo_runtime_test' 'REVOKE EXECUTE ON FUNCTION evolution.fork_restored_history_v1(uuid) FROM evo_runtime_test'
|
||||
phase checksum-drift
|
||||
# Unknown future versions and checksum drift must not be repaired silently.
|
||||
psql -X -v ON_ERROR_STOP=1 -c 'UPDATE evolution.schema_migrations SET version=56 WHERE version=55'
|
||||
psql -X -v ON_ERROR_STOP=1 -c 'UPDATE evolution.schema_migrations SET version=57 WHERE version=56'
|
||||
if bash "$root/tools/migrate-postgres.sh"; then exit 1; fi
|
||||
psql -X -v ON_ERROR_STOP=1 -c "UPDATE evolution.schema_migrations SET version=55 WHERE version=56"
|
||||
psql -X -v ON_ERROR_STOP=1 -c "UPDATE evolution.schema_migrations SET version=56 WHERE version=57"
|
||||
psql -X -v ON_ERROR_STOP=1 -c "UPDATE evolution.schema_migrations SET sha256=repeat('0',64) WHERE version=14"
|
||||
if bash "$root/tools/migrate-postgres.sh"; then exit 1; fi
|
||||
psql -X -v ON_ERROR_STOP=1 -c "UPDATE evolution.schema_migrations SET sha256=repeat('0',64) WHERE version=13"
|
||||
|
||||
@@ -122,6 +122,8 @@ digest_54="$(sha256sum "$root/migrations/0054_maturing_cellular_migration.sql")"
|
||||
digest_54="${digest_54%% *}"
|
||||
digest_55="$(sha256sum "$root/migrations/0055_retained_cellular_plans.sql")"
|
||||
digest_55="${digest_55%% *}"
|
||||
digest_56="$(sha256sum "$root/migrations/0056_cellular_environment_publication.sql")"
|
||||
digest_56="${digest_56%% *}"
|
||||
psql -X --no-password --set=ON_ERROR_STOP=1 --set="migration_sha=$digest" \
|
||||
--set="migration_sha_2=$digest_2" --set="migration_sha_3=$digest_3" \
|
||||
--set="migration_sha_4=$digest_4" --set="migration_sha_5=$digest_5" \
|
||||
@@ -168,6 +170,6 @@ psql -X --no-password --set=ON_ERROR_STOP=1 --set="migration_sha=$digest" \
|
||||
--set="migration_sha_51=$digest_51" \
|
||||
--set="migration_sha_52=$digest_52" \
|
||||
--set="migration_sha_53=$digest_53" --set="migration_sha_54=$digest_54" \
|
||||
--set="migration_sha_55=$digest_55" \
|
||||
--set="migration_sha_55=$digest_55" --set="migration_sha_56=$digest_56" \
|
||||
--set="runtime_role=$runtime_role" \
|
||||
--file="$root/migrations/apply.sql"
|
||||
|
||||
Reference in New Issue
Block a user