def message_handler():
try:
event = Event.deserialize(body)
self.handler(event)
message.ack()
except:
logger.exception('failed to handle event from queue %r', self.handler.queue_name)
def test_stores_event(self):
index = EventIndex(self.es, 'index_test_name')
event = Event(
'test_event', {
'number': 3,
'string': 'hi',
'float': 3.4,
'dict': {
'one': 1,
'two': 'dos'
},
'date': datetime.date(2014, 5, 2),
'bool': True,
'list': [1, 2, 3]
})
with patch('uuid.uuid4', Mock(hex='testuuid')):
index.index(event)
es_event = self.es.get(index='index_test_name', id='testuuid')
self.assertEquals(es_event['_source']['s_string'], 'hi')
self.assertEquals(es_event['_source']['i_number'], 3)
self.assertEquals(es_event['_source']['f_float'], 3.4)
self.assertEquals(es_event['_source']['o_dict'], {
's_two': 'dos',
'i_one': 1
})
self.assertEquals(es_event['_source']['d_date'],
datetime.date(2014, 5, 2))
self.assertEquals(es_event['_source']['b_bool'], True)
self.assertEquals(es_event['_source']['l_list'], [1, 2, 3])
self.assertEquals(es_event['_source']['type'], 'test_event')
def message_handler():
event = Event.deserialize(body)
try:
self.handler(event)
except:
raise
else:
message.ack()
def emit_event(self, event_type, payload, headers=None, **kwargs):
headers = headers or {}
headers.setdefault('trace_id', trace.get_id())
event = Event(event_type,
payload,
source=self.identity,
headers=headers)
self.events.emit(event, **kwargs)
def on_kombu_message(self, body, message):
logger.debug("received kombu message %r", body)
event = Event.deserialize(body)
try:
self.container.handle_event(event)
except:
raise
else:
message.ack()
def on_kombu_message(self, body, message):
logger.debug("received kombu message %r", body)
event = Event.deserialize(body)
try:
self.container.handle_event(event)
except:
raise
else:
message.ack()
def _handle_message(self, body, message):
try:
event = Event.deserialize(body)
self.handler(event)
message.ack()
except:
self._handle_fail(message, event)
finally:
if self.handler.once:
self.event_system.unsubscribe(self.handler)
def _handle_message(self, body, message):
try:
event = Event.deserialize(body)
self.handler(event)
message.ack()
except:
self._handle_fail(message, event)
finally:
if self.handler.once:
self.event_system.unsubscribe(self.handler)
def event(self, channel, event_type=None, payload=None):
"""
Receive an event of type `event_type` with the given `payload`. This
is used by the simple event system in lymph.events.simple:Broker
"""
event = Event(event_type, payload)
try:
self.container.handle_event(event)
except:
raise
else:
channel.ack()
def _handle_message(self, body, message):
try:
event = Event.deserialize(body)
self.handler(event)
message.ack()
except:
logger.exception('failed to handle event from queue %r', self.handler.queue_name)
# FIXME: add requeue support here. Make sure what we don't requeue
# forever.
message.reject()
self.event_system.container.error_hook(sys.exc_info())
finally:
if self.handler.once:
self.event_system.unsubscribe(self.handler)
def test_method_descriptor(self):
self.dispatcher.register('foo', self.make_handler('foo'))
self.dispatcher.register('#', self.make_handler('hash'))
class StubInterface(object):
dispatcher = self.dispatcher
stub = StubInterface()
event = Event('foo', {'x': 42})
stub.dispatcher(event)
self.assertEqual(set(self.handler_log), {
('foo', (stub, event)),
('hash', (stub, event)),
})
def message_handler():
try:
event = Event.deserialize(body)
self.handler(event)
message.ack()
except:
logger.exception('failed to handle event from queue %r', self.handler.queue_name)
# FIXME: add requeue support here
message.reject()
# Since the message handler can be run sequentially, we are catching all exception
# and reporting them here.
self.event_system.container.error_hook(sys.exc_info())
finally:
if self.handler.once:
self.event_system.unsubscribe(self.handler)
def _handle_message(self, body, message):
try:
event = Event.deserialize(body)
self.handler(event)
message.ack()
except:
logger.exception('failed to handle event from queue %r',
self.handler.queue_name)
# FIXME: add requeue support here. Make sure what we don't requeue
# forever.
message.reject()
self.event_system.container.error_hook(sys.exc_info())
finally:
if self.handler.once:
self.event_system.unsubscribe(self.handler)
def message_handler():
try:
event = Event.deserialize(body)
self.handler(event)
message.ack()
except:
logger.exception('failed to handle event from queue %r',
self.handler.queue_name)
# FIXME: add requeue support here
message.reject()
# Since the message handler can be run sequentially, we are catching all exception
# and reporting them here.
self.event_system.container.error_hook(sys.exc_info())
finally:
if self.handler.once:
self.event_system.unsubscribe(self.handler)
def _consume(self, consumer, container, event_type):
for event in consumer:
event = Event.deserialize(json.loads(event.message.value))
container.handle_event(event)
def _consume(interface, event):
self.consumer_func(self.interface, Event.deserialize(event['event']))
def _consume(interface, event):
self.consumer_func(self.interface,
Event.deserialize(event['event']))
def emit_event(self, event_type, payload):
event = Event(event_type, payload, source=self.identity)
self.event_system.emit(self, event)
