#include "evo/persistence/region_lease.hpp" #include #include #include #include #include namespace { using namespace evo::persistence; using namespace std::chrono_literals; using Time = LeaseClock::time_point; void check(bool ok, std::source_location at = std::source_location::current()) { if (!ok) throw std::runtime_error("region lease line " + std::to_string(at.line())); } #define CHECK(...) check(static_cast(__VA_ARGS__)) constexpr Time at(std::chrono::milliseconds t) { return Time{t}; } LeaseGrant grant(std::uint64_t epoch) { return {{1}, epoch, 7, LeasePolicy{}.duration}; } void policies() { CHECK(valid(LeasePolicy{})); CHECK(valid(LeasePolicy{1000ms, 200ms, 100ms, 100ms, 300ms})); const auto invalid = [](auto change) { LeasePolicy p; change(p); return !valid(p); }; CHECK(invalid([](LeasePolicy& p) { p.duration = 999ms; })); CHECK(invalid([](LeasePolicy& p) { p.duration = 60001ms; })); CHECK(invalid([](LeasePolicy& p) { p.safety_margin = 1999ms; })); // under 10% CHECK(invalid([](LeasePolicy& p) { p.safety_margin = 20000ms; })); CHECK(invalid([](LeasePolicy& p) { p.renew_interval = 0ms; })); CHECK(invalid([](LeasePolicy& p) { p.renew_timeout = -1ms; })); CHECK(invalid([](LeasePolicy& p) { p.renew_timeout = 30001ms; })); CHECK(invalid([](LeasePolicy& p) { p.commit_timeout = 18000ms; })); // Two complete renewal attempts must fit before local fencing: 2*(7+2.5) > 18. CHECK(invalid([](LeasePolicy& p) { p.renew_interval = 7000ms; p.renew_timeout = 2500ms; })); CHECK(!valid(LeasePolicy{2000ms, 400ms, 200ms, 200ms, 1800ms})); LeaseAuthority broken(LeasePolicy{999ms, 200ms, 100ms, 100ms, 300ms}); CHECK(!broken.acquired({{1}, 1, 7, 999ms}, at(0ms), at(1ms))); CHECK(broken.state(at(1ms)) == LeaseState::absent); } void deadlines_follow_send_time() { LeaseAuthority a{LeasePolicy{}}; CHECK(a.state(at(0ms)) == LeaseState::absent && !a.may_originate(at(0ms))); // Reply arrival does not move the deadline: the DB clock started after sending. CHECK(a.acquired(grant(1), at(1000ms), at(4000ms))); CHECK(a.deadline() == at(19000ms)); CHECK(a.state(at(5999ms)) == LeaseState::active); CHECK(a.state(at(6000ms)) == LeaseState::renew_due && a.may_originate(at(6000ms))); CHECK(a.may_begin_commit(at(14000ms)) && !a.may_begin_commit(at(14001ms))); CHECK(a.may_originate(at(18999ms))); CHECK(a.state(at(19000ms)) == LeaseState::fenced && !a.may_originate(at(19000ms))); // A renewal answered after the local deadline cannot revive authority. CHECK(!a.renewed(1, 20000ms, at(18000ms), at(19000ms))); CHECK(a.state(at(18500ms)) == LeaseState::fenced); } void renewals() { LeaseAuthority a{LeasePolicy{}}; CHECK(a.acquired(grant(4), at(0ms), at(10ms))); CHECK(a.renewed(4, 20000ms, at(5000ms), at(5100ms))); CHECK(a.deadline() == at(23000ms) && a.state(at(9999ms)) == LeaseState::active); CHECK(a.state(at(10000ms)) == LeaseState::renew_due); // Ambiguous renewal keeps the earlier bound; retries still fit before fencing. a.renewal_unknown(20000ms, at(10000ms)); CHECK(a.deadline() == at(23000ms) && a.state(at(14999ms)) == LeaseState::active); a.renewal_unknown(5000ms, at(15000ms)); // Could have shortened: take the earlier. CHECK(a.deadline() == at(18000ms)); CHECK(a.renewed(4, 20000ms, at(16000ms), at(16500ms)) && a.deadline() == at(34000ms)); CHECK(!a.renewed(4, 20000ms, at(15000ms), at(16600ms))); // Out of order: fence. CHECK(a.state(at(16600ms)) == LeaseState::fenced); CHECK(!a.renewed(4, 20000ms, at(17000ms), at(17001ms))); // Sticky. LeaseAuthority b{LeasePolicy{}}; CHECK(b.acquired(grant(2), at(0ms), at(1ms))); CHECK(!b.renewed(3, 20000ms, at(1000ms), at(1001ms))); // Foreign epoch. CHECK(b.state(at(1001ms)) == LeaseState::fenced); LeaseAuthority c{LeasePolicy{}}; CHECK(c.acquired(grant(2), at(0ms), at(1ms))); CHECK(!c.renewed(2, 19000ms, at(1000ms), at(1001ms))); // Unexpected duration. LeaseAuthority d{LeasePolicy{}}; CHECK(d.acquired(grant(2), at(0ms), at(1ms))); d.fence(); CHECK(d.state(at(2ms)) == LeaseState::fenced && !d.may_begin_commit(at(2ms))); } void epochs_are_never_reused() { LeaseAuthority a{LeasePolicy{}}; CHECK(!a.acquired(grant(0), at(0ms), at(1ms))); CHECK(!a.acquired({{1}, 1, 0, 20000ms}, at(0ms), at(1ms))); // Zero frame. CHECK(!a.acquired({{1}, 1, 7, 10000ms}, at(0ms), at(1ms))); // Not the policy. CHECK(!a.acquired(grant(1), at(10ms), at(9ms))); // Reply before send. CHECK(!a.acquired(grant(1), at(0ms), at(18000ms))); // Too late to use. CHECK(a.acquired(grant(3), at(0ms), at(1ms))); CHECK(!a.acquired(grant(3), at(2ms), at(3ms))); CHECK(a.state(at(3ms)) == LeaseState::fenced); CHECK(!a.acquired(grant(2), at(4ms), at(5ms))); // Only a strictly newer database epoch clears fencing (followed by recovery). CHECK(a.acquired(grant(4), at(6ms), at(7ms)) && a.state(at(7ms)) == LeaseState::active); const auto& current = a.grant(); CHECK(current && current->epoch == 4); } // Extreme values must be rejected without signed overflow (checked under UBSan). void extreme_durations_are_rejected_without_overflow() { constexpr auto most = std::chrono::milliseconds::max(); constexpr auto least = std::chrono::milliseconds::min(); for (const auto extreme : {most, least}) { for (int field = 0; field < 5; ++field) { LeasePolicy p; std::array terms{&p.duration, &p.renew_interval, &p.safety_margin, &p.renew_timeout, &p.commit_timeout}; *terms[static_cast(field)] = extreme; CHECK(!valid(p)); LeaseAuthority a{p}; CHECK(!a.acquired(grant(1), at(0ms), at(1ms))); CHECK(a.state(at(1ms)) == LeaseState::absent && !a.may_begin_commit(at(1ms))); } } LeasePolicy interval; interval.renew_interval = 20000ms; // Equal to the duration: no room to renew. CHECK(!valid(interval)); LeaseAuthority a{LeasePolicy{}}; CHECK(!a.acquired({{1}, 1, 7, most}, at(0ms), at(1ms))); CHECK(!a.acquired({{1}, 1, 7, least}, at(0ms), at(1ms))); CHECK(a.acquired(grant(2), at(0ms), at(1ms))); CHECK(!a.renewed(2, most, at(1000ms), at(1001ms))); CHECK(a.acquired(grant(3), at(2000ms), at(2001ms))); a.renewal_unknown(most, at(3000ms)); // Database would reject: deadline unchanged. CHECK(a.deadline() == at(20000ms) && a.may_originate(at(3000ms))); a.renewal_unknown(least, at(3000ms)); // Caller error: fence. CHECK(a.state(at(3000ms)) == LeaseState::fenced); } void clock_is_monotonic() { const auto first = LeaseClock::now(); const auto second = LeaseClock::now(); CHECK(second >= first && first.time_since_epoch().count() > 0); } } // namespace int main() { try { policies(); deadlines_follow_send_time(); renewals(); epochs_are_never_reused(); extreme_durations_are_rejected_without_overflow(); clock_is_monotonic(); std::puts("region lease contracts passed"); return 0; } catch (const std::exception& e) { std::fprintf(stderr, "%s\n", e.what()); return 1; } }