Files
aevolution/include/evo/server/session_window.hpp
T
dingoandClaude Opus 5.5 46c106409e
Foundation / checks (checks) (push) Successful in 5s
Foundation / checks (client) (push) Successful in 5s
Foundation / checks (ecs) (push) Successful in 4s
Foundation / checks (network) (push) Successful in 4s
Foundation / checks (postgres) (push) Successful in 4s
Foundation / checks (tsan) (push) Successful in 5s
Foundation / checks (deploy) (push) Successful in 4m33s
Foundation / postgres-tools (push) Successful in 2m14s
Foundation / server-image (push) Successful in 5m21s
Foundation / image (push) Successful in 6m18s
feat(admin): session windows in SQL, opened from the admin portal (schema 62)
The dev session window moves from Git to SQL (ADR-0087 amendment): the admin
portal opens, extends (30 min to 4 h from now) and closes it, and the cellular
region re-reads it every 5 s with --session-window-source db. No push, sync or
restart per window; a closed window keeps the region running instead of
crash-looping.

- Schema 62: append-only session_windows (4 h cap, no rewrites),
  load_session_window_v1 for the runtime group, admin_set_session_window_v1
  and admin_session_windows_v1 for a dedicated admin group role, granted and
  audited each migration run when EVO_PG_ADMIN_ROLE is set (aevolution_admin in
  DEV). Schema 61's views are revoked from the runtime group.
- RegionSessions admission switch: while closed every Hello is refused before
  signature work and closing closes open sessions (new sessions were still
  admitted after expiry before).
- Admin API: GET/POST /api/regions/<n>/session-window, window state in the
  regions list; the portal's session-window card with history.
- Git: REGION_SESSION_WINDOW and the pre-push refresh rule are removed; the
  policy check requires the database source and refuses a committed window.

Needs the new image and the aevolution_admin role (with the portal's login in
aevolution-admin-pg) before a sync.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-27 15:13:02 -04:00

120 lines
4.6 KiB
C++

#pragma once
#include <charconv>
#include <cstdint>
#include <expected>
#include <optional>
#include <string>
#include <string_view>
#include <utility>
namespace evo::server {
// An operator-opened, absolute UTC session window. The serialized form is
// activation-id:expiry-unix-seconds. It deliberately contains no relative
// duration, so a delayed rollout or restart cannot extend the window.
class SessionWindow {
public:
enum class Error : std::uint8_t { malformed, expired, too_long };
static constexpr std::uint64_t max_duration_seconds = std::uint64_t{4} * 60 * 60;
static std::expected<SessionWindow, Error> open(std::string_view specification,
std::uint64_t now_seconds) {
const auto colon = specification.rfind(':');
if (colon == std::string_view::npos || colon == 0 || colon + 1 == specification.size())
return std::unexpected(Error::malformed);
const auto id = specification.substr(0, colon);
if (id.find_first_not_of(
"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz._-") !=
std::string_view::npos)
return std::unexpected(Error::malformed);
std::uint64_t deadline{};
const auto text = specification.substr(colon + 1);
const auto [end, ec] = std::from_chars(text.data(), text.data() + text.size(), deadline);
if (ec != std::errc{} || end != text.data() + text.size())
return std::unexpected(Error::malformed);
if (deadline <= now_seconds)
return std::unexpected(Error::expired);
if (deadline - now_seconds > max_duration_seconds)
return std::unexpected(Error::too_long);
return SessionWindow{std::string{id}, deadline};
}
[[nodiscard]] bool accepting(std::uint64_t now_seconds) noexcept {
if (closed_ || now_seconds >= deadline_seconds_) {
closed_ = true;
return false;
}
return true;
}
[[nodiscard]] bool closed() const noexcept {
return closed_;
}
[[nodiscard]] std::uint64_t deadline_seconds() const noexcept {
return deadline_seconds_;
}
[[nodiscard]] const std::string& activation_id() const noexcept {
return activation_id_;
}
void close() noexcept {
closed_ = true;
}
private:
SessionWindow(std::string activation_id, std::uint64_t deadline_seconds)
: activation_id_(std::move(activation_id)), deadline_seconds_(deadline_seconds) {}
std::string activation_id_;
std::uint64_t deadline_seconds_{};
bool closed_{};
};
// ADR-0087 amendment (2026-10-27): the window as the database records it, re-read every few
// seconds. A newer activation replaces the current window (sessions continue); a closed,
// expired, over-long or absent record closes it. Each admitted window keeps its own absolute
// deadline, and a window once closed never reopens: only a newer activation opens sessions
// again. While the database cannot be read the caller does not observe, so the current
// window keeps running to its deadline.
class SessionWindowFeed {
public:
struct Record {
std::string activation_id;
std::optional<std::uint64_t> expires_at; // nullopt: the record closes the window.
};
enum class Change : std::uint8_t { none, opened, closed, refused };
// `record` is the region's newest row, or nullopt when it has none.
Change observe(const std::optional<Record>& record, std::uint64_t now_seconds) {
if (!record) {
const bool had = window_.has_value();
window_.reset();
seen_.clear();
return had ? Change::closed : Change::none;
}
if (record->activation_id == seen_)
return Change::none;
seen_ = record->activation_id;
const bool had = window_.has_value();
window_.reset();
if (!record->expires_at)
return had ? Change::closed : Change::none;
auto opened = SessionWindow::open(
record->activation_id + ":" + std::to_string(*record->expires_at), now_seconds);
if (!opened)
return Change::refused;
window_ = std::move(*opened);
return Change::opened;
}
[[nodiscard]] bool accepting(std::uint64_t now_seconds) noexcept {
return window_ && window_->accepting(now_seconds);
}
[[nodiscard]] const std::optional<SessionWindow>& window() const noexcept {
return window_;
}
private:
std::optional<SessionWindow> window_;
std::string seen_; // The newest activation observed, admitted or not.
};
} // namespace evo::server