classReadModelSynchronizer:
"""Keeps read models in sync with events."""def__init__(self, event_store, read_db, projections: List[Projection]):
self.event_store = event_store
self.read_db = read_db
self.projections = {p.name: p for p in projections}
asyncdefrun(self):
"""Continuously sync read models."""whileTrue:
for name, projection inself.projections.items():
awaitself._sync_projection(projection)
await asyncio.sleep(0.1)
asyncdef_sync_projection(self, projection: Projection):
checkpoint = awaitself._get_checkpoint(projection.name)
events = awaitself.event_store.read_all(
from_position=checkpoint,
limit=100
)
for event in events:
if event.event_type in projection.handles():
try:
await projection.apply(event)
except Exception as e:
# Log error, possibly retry or skip
logger.error(f"Projection error: {e}")
continueawaitself._save_checkpoint(projection.name, event.global_position)
asyncdefrebuild_projection(self, projection_name: str):
"""Rebuild a projection from scratch."""
projection = self.projections[projection_name]
# Clear existing dataawait projection.clear()
# Reset checkpointawaitself._save_checkpoint(projection_name, 0)
# RebuildwhileTrue:
checkpoint = awaitself._get_checkpoint(projection_name)
events = awaitself.event_store.read_all(checkpoint, 1000)
ifnot events:
breakfor event in events:
if event.event_type in projection.handles():
await projection.apply(event)
awaitself._save_checkpoint(
projection_name,
events[-1].global_position
)
Template 5: Eventual Consistency Handling
classConsistentQueryHandler:
"""Query handler that can wait for consistency."""def__init__(self, read_db, event_store):
self.read_db = read_db
self.event_store = event_store
asyncdefquery_after_command(
self,
query: Query,
expected_version: int,
stream_id: str,
timeout: float = 5.0):
"""
Execute query, ensuring read model is at expected version.
Used for read-your-writes consistency.
"""
start_time = time.time()
while time.time() - start_time < timeout:
# Check if read model is caught up
projection_version = awaitself._get_projection_version(stream_id)
if projection_version >= expected_version:
returnawaitself.execute_query(query)
# Wait a bit and retryawait asyncio.sleep(0.1)
# Timeout - return stale data with warningreturn {
"data": awaitself.execute_query(query),
"_warning": "Data may be stale"
}
asyncdef_get_projection_version(self, stream_id: str) -> int:
"""Get the last processed event version for a stream."""asyncwithself.read_db.acquire() as conn:
returnawait conn.fetchval(
"SELECT last_event_version FROM projection_state WHERE stream_id = $1",
stream_id
) or0