def sender_processor(self):
"""Override EventLink.sender_processor."""
while True:
event = yield from receive()
# print('Threading Event Adapter sending: {}'.format(event))
yield from self.after_send(event)
self.semaphore_to_send.release()
def incrementer_proceed(last_received=[None]):
"""Increment every received number."""
while True:
number = yield from receive()
yield from send(number + 1)
yield from proceed() # this basically does nothing
last_received[0] = number
def incrementer_wait(last_received=[None]):
"""Increment every received number."""
while True:
number = yield from receive()
yield from send(number + 1)
yield from wait(
) # wait until data is added to the receive queue before proceeding
last_received[0] = number
def sender_processor(self):
"""Event sender echo processor."""
while True:
event = yield from receive()
data_event = self.get_link_data(event, 'loopback')
data_event = self.make_link_data(data_event.data, 'loopback',
event)
self._event_link._receiver.send(data_event)
yield from self.after_receive(
data_event) # for correctness in automatic pipeline
def sender_processor(self, chunk_separator, begin_chunk_separator):
"""Event sender processor."""
while True:
event = yield from receive()
data_event = self.get_link_data(event, 'down')
event = data_event.data
if len(event) == 0:
continue
stream_contents = event + chunk_separator
if begin_chunk_separator:
stream_contents = chunk_separator + stream_contents
self._stream_link.write(stream_contents)
def sender_processor(self):
"""Event sender processor.
Make sure to yield from after_send() at the end of the loop to expose
any generated events for consumption by the layer below.
"""
while True:
event = yield from receive()
self.update_clock_time(event)
self._enqueue_data_event(event, 'down')
yield from self._flush_event_queue('down')
yield from self._issue_clock_request('down')
def receiver_processor(self):
"""Event receiver echo processor."""
while True:
event = yield from receive()
if isinstance(event, LinkException):
print('Ignoring exception: {}'.format(event))
continue
data_event = self.get_link_data(event, 'loopback')
# print('Echoing: {}'.format(data_event))
data_event = self.make_link_data(data_event.data, 'loopback',
event)
self._event_link._sender.send(data_event)
yield from self.after_send(
event) # for correctness in automatic pipeline
def sender_processor(self):
"""Event sender processor.
Make sure to yield from after_send() with any generated event to expose
it for consumption by the layer below.
"""
while True:
event = yield from receive()
if self.sender_event_passthrough:
# print('Event Link sending: {}'.format(event))
yield from self.after_send(event)
else:
data_event = self.get_link_data(event, 'down')
# print('Event Link sending: {}'.format(data_event))
data_event = self.make_link_data(data_event.data, 'down', event)
yield from self.after_send(data_event)
def receiver_processor(self):
"""Event receiver processor.
Make sure to yield from after_receive() with any generated event to expose
it for for consumption by the layer above.
"""
while True:
event = yield from receive()
if self.receiver_event_passthrough or isinstance(event, LinkException):
# print('Event Link received: {}'.format(event))
yield from self.after_receive(event)
else:
data_event = self.get_link_data(event, 'up')
# print('Event Link received: {}'.format(data_event))
data_event = self.make_link_data(data_event.data, 'up', event)
yield from self.after_receive(data_event)
def sender_processor(self, chunk_separator, begin_chunk_separator):
"""Override ChunkedStreamLink.sender_processor."""
while True:
event = yield from receive()
data_event = self.get_link_data(event, 'down')
if data_event.type not in self.SENDABLE_TYPES:
self.logger.error('{} cannot send data of type {}!'.format(
self.__class__.__qualname__, data_event.type_string))
continue
payload = data_event.data
if len(payload) == 0:
continue
self.sender_counter['send'] += 1
stream_contents = payload + chunk_separator
if begin_chunk_separator:
stream_contents = chunk_separator + stream_contents
self.logger.debug('Writing: {}'.format(hex_bytes(stream_contents)))
self._update_send_length_stats(stream_contents)
self._stream_link.write(stream_contents)
def sender_processor(self):
"""Event sender processor."""
while True:
try:
event = yield from receive()
try:
self.sender_counter['send'] += 1
for event in self.sender_process(event):
if isinstance(event, LinkException):
self.sender_counter['error'] += 1
else:
self.sender_counter['to_send'] += 1
yield from self.after_send(event)
except Exception as e:
self.logger.exception(
'Uncaught sender exception due to: {}'.format(event))
self.receiver_counter['error_uncaught'] += 1
except Exception as e:
self.logger.exception('Uncaught sender exception!')
self.sender_counter['error_uncaught'] += 1
def incrementer(last_received=[None]):
"""Increment every received number."""
while True:
number = yield from receive()
yield from send(number + 1)
last_received[0] = number
def invalid_late():
while True:
number = yield from receive()
yield number + 1
def incrementer_return():
"""Increment every received number."""
number = yield from receive()
yield from send(number + 1)
return 10 * number
