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))