최신 스냅샷의 전달 대기를 남기는 상태 모듈

"""In-memory teaching model for replaceable snapshots. No transport or scheduler."""
from dataclasses import dataclass
import re


@dataclass(frozen=True)
class Ticket:
    ordinal: int
    revision: int
    token: str


class SnapshotRelay:
    def __init__(self, initial_token, *, minimum_gap=2, retry_delay=3):
        self._validate_token(initial_token)
        for value in (minimum_gap, retry_delay):
            if type(value) is not int or value < 1:
                raise ValueError('INVALID_DELAY')
        self._token = initial_token
        self._latest = self._acked = self._serial = 0
        self._active = self._unknown = None
        self._clock = -1
        self._ready_at = 0
        self._gap, self._retry = minimum_gap, retry_delay
        self._last_outcome = 'not_attempted'

    @staticmethod
    def _validate_token(token):
        if type(token) is not str or not re.fullmatch(r'[A-Za-z0-9_-]{1,64}', token):
            raise ValueError('INVALID_SYNTHETIC_TOKEN')

    def _tick(self, now):
        if type(now) is not int or now < 0 or now < self._clock:
            raise ValueError('INVALID_OR_REVERSED_CLOCK')
        self._clock = now

    def observe(self, token):
        """Supply an alias, not a filesystem path or a content-authenticated digest."""
        self._validate_token(token)
        if token == self._token:
            return False
        self._token = token
        self._latest += 1
        return True

    def begin(self, now):
        """Reserve a local attempt; returning a ticket performs no transmission."""
        self._tick(now)
        if (self._latest == self._acked or self._active is not None
                or self._unknown is not None or now < self._ready_at):
            return None
        self._serial += 1
        self._active = Ticket(self._serial, self._latest, self._token)
        return self._active

    def finish(self, ticket, outcome, now):
        """Outcome is a caller declaration, never a verified remote receipt."""
        if ticket is not self._active or ticket is None:
            raise ValueError('NOT_THE_ACTIVE_TICKET')
        if type(outcome) is not str or outcome not in {'confirmed', 'not_applied', 'unknown'}:
            raise ValueError('INVALID_OUTCOME')
        self._tick(now)
        self._active = None
        self._last_outcome = outcome
        if outcome == 'confirmed':
            self._acked = ticket.revision
            self._ready_at = now + self._gap
        elif outcome == 'not_applied':
            self._ready_at = now + self._retry
        else:
            self._unknown = ticket

    def resolve(self, ticket, observation, now):
        """Host explicitly supplies reconciled outcome; this method reads no server."""
        if ticket is not self._unknown or ticket is None:
            raise ValueError('NOT_THE_UNKNOWN_TICKET')
        if type(observation) is not str or observation not in {'confirmed', 'not_applied'}:
            raise ValueError('INVALID_RECONCILIATION')
        self._tick(now)
        self._unknown = None
        self._last_outcome = 'reconciled_' + observation
        if observation == 'confirmed':
            self._acked = ticket.revision
            self._ready_at = now + self._gap
        else:
            self._ready_at = now + self._retry

    def inspect(self):
        return {'latest_revision': self._latest, 'declared_acked_revision': self._acked,
                'pending': self._latest != self._acked,
                'in_flight': self._active is not None,
                'needs_reconciliation': self._unknown is not None,
                'ready_at': self._ready_at, 'last_outcome': self._last_outcome,
                'attempt_reservations': self._serial,
                'network_operations': 0, 'durable_state_verified': False,
                'remote_receipt_authenticated': False, 'business_completion_proven': False}