async def success(self, result: proto.ReadStreamEventsCompleted,
output: Queue):
finished = False
events = []
for e in result.events:
event = _make_event(e)
events.append(event)
await self._yield_events(events)
self.next_event_number = result.next_event_number
# Todo: we should finish if the next event > subscription_start_pos
if result.is_end_of_stream:
finished = True
if not self.has_first_page:
self.subscription = VolatileSubscription(self.conversation_id,
self.stream, output, 0, 0,
self.iterator)
self.result.set_result(self.subscription)
self.has_first_page = True
if finished:
await self._move_to_next_phase(output)
else:
await output.put(self._fetch_page_message(result.next_event_number)
)
async def reply_from_live(self, response: InboundMessage, output: Queue):
if response.command == TcpCommand.PersistentSubscriptionConfirmation:
self.subscription.out_queue = output
return
self.expect_only(TcpCommand.PersistentSubscriptionStreamEventAppeared, response)
result = proto.StreamEventAppeared()
result.ParseFromString(response.payload)
await self.subscription.events.enqueue(_make_event(result.event))
async def reply_from_live(self, message, output):
if message.command == TcpCommand.SubscriptionDropped:
await self.drop_subscription(message)
return
self.expect_only(TcpCommand.StreamEventAppeared, message)
result = proto.StreamEventAppeared()
result.ParseFromString(message.payload)
await self._yield_events([_make_event(result.event)])
async def reply_from_live(self, message: InboundMessage) -> None:
self.expect_only(message, TcpCommand.StreamEventAppeared,
TcpCommand.SubscriptionConfirmation)
if message.command is TcpCommand.SubscriptionConfirmation:
return
result = proto.StreamEventAppeared()
result.ParseFromString(message.payload)
await self.subscription.events.enqueue(_make_event(result.event))
async def success(self, result: proto.ReadAllEventsCompleted,
output: Queue):
events = [_make_event(x) for x in result.events]
self.is_complete = True
self.result.set_result(
AllStreamSlice(
events,
Position(result.next_commit_position,
result.next_prepare_position),
Position(result.commit_position, result.prepare_position),
))
async def success(self, result: proto.ReadStreamEventsCompleted,
output: Queue):
events = [_make_event(x) for x in result.events]
self.is_complete = True
self.result.set_result(
StreamSlice(
events,
result.next_event_number,
result.last_event_number,
None,
result.last_commit_position,
result.is_end_of_stream,
))
async def success(self, result: proto.ReadStreamEventsCompleted, output: Queue):
if not result.is_end_of_stream:
await output.put(self._fetch_page_message(result.next_event_number))
events = [_make_event(x) for x in result.events]
await self.iterator.enqueue_items(events)
if not self.has_first_page:
self.result.set_result(self.iterator)
self.has_first_page = True
if result.is_end_of_stream:
self.is_complete = True
await self.iterator.asend(StopAsyncIteration())
async def reply_from_catch_up(self, message, output):
if message.command == TcpCommand.SubscriptionDropped:
await self.drop_subscription(message)
elif message.command == TcpCommand.SubscriptionConfirmation:
confirmation = proto.SubscriptionConfirmation()
confirmation.ParseFromString(message.payload)
self.subscribe_from = confirmation.last_event_number
self._logger.info(
"Subscribed successfully, catching up with missed events from %s",
self.next_event_number,
)
await output.put(self._fetch_page_message(self.next_event_number))
elif message.command == TcpCommand.StreamEventAppeared:
result = proto.StreamEventAppeared()
result.ParseFromString(message.payload)
self.buffer.append(_make_event(result.event))
else:
await ReadStreamEventsBehaviour.reply(self, message, output)
async def success(self, result: proto.ReadAllEventsCompleted,
output: Queue):
if not self.has_first_page:
self.result.set_result(self.iterator)
self.has_first_page = True
events = [_make_event(x) for x in result.events]
await self.iterator.enqueue_items(events)
at_end = result.commit_position == result.next_commit_position
if at_end:
self.is_complete = True
await self.iterator.asend(StopAsyncIteration())
return
await output.put(
self._fetch_page_message(
Position(result.next_commit_position,
result.next_prepare_position)))
async def success(self, response, output: Queue):
self.is_complete = True
self.result.set_result(_make_event(response.event))