def setup(self):
_log.debug('starting %s', self)
# handler_type determines queue name
service_name = self.container.service_name
if self.handler_type is SERVICE_POOL:
queue_name = "evt-{}-{}--{}.{}".format(self.source_service,
self.event_type,
service_name,
self.method_name)
elif self.handler_type is SINGLETON:
queue_name = "evt-{}-{}".format(self.source_service,
self.event_type)
elif self.handler_type is BROADCAST:
queue_name = "evt-{}-{}--{}.{}-{}".format(self.source_service,
self.event_type,
service_name,
self.method_name,
uuid.uuid4().hex)
exchange = get_event_exchange(self.source_service)
# auto-delete queues if events are not reliably delivered
auto_delete = not self.reliable_delivery
self.queue = Queue(queue_name,
exchange=exchange,
routing_key=self.event_type,
durable=True,
auto_delete=auto_delete)
super(EventHandler, self).setup()
def test_restricted_parameters(
self, mock_container, producer
):
""" Verify that providing routing parameters at instantiation
time has no effect.
"""
mock_container.config = {'AMQP_URI': 'memory://localhost'}
mock_container.service_name = "service"
worker_ctx = Mock()
worker_ctx.context_data = {}
exchange = Mock()
routing_key = Mock()
dispatcher = EventDispatcher(
exchange=exchange,
routing_key=routing_key,
).bind(mock_container, "dispatch")
dispatcher.setup()
dispatch = dispatcher.get_dependency(worker_ctx)
event_exchange = get_event_exchange("service")
event_type = "event-type"
dispatch(event_type, "event-data")
assert producer.publish.call_args[1]['exchange'] == event_exchange
assert producer.publish.call_args[1]['routing_key'] == event_type
def test_restricted_parameters(self, mock_container, producer):
""" Verify that providing routing parameters at instantiation
time has no effect.
"""
mock_container.config = {'AMQP_URI': 'memory://localhost'}
mock_container.service_name = "service"
worker_ctx = Mock()
worker_ctx.context_data = {}
exchange = Mock()
routing_key = Mock()
dispatcher = EventDispatcher(
exchange=exchange,
routing_key=routing_key,
).bind(mock_container, "dispatch")
dispatcher.setup()
dispatch = dispatcher.get_dependency(worker_ctx)
event_exchange = get_event_exchange("service", config={})
event_type = "event-type"
dispatch(event_type, "event-data")
assert producer.publish.call_args[1]['exchange'] == event_exchange
assert producer.publish.call_args[1]['routing_key'] == event_type
def setup(self):
_log.debug('starting %s', self)
# handler_type determines queue name
service_name = self.container.service_name
if self.handler_type is SERVICE_POOL:
queue_name = "evt-{}-{}--{}.{}".format(self.source_service,
self.event_type,
service_name,
self.method_name)
elif self.handler_type is SINGLETON:
queue_name = "evt-{}-{}".format(self.source_service,
self.event_type)
elif self.handler_type is BROADCAST:
queue_name = "evt-{}-{}--{}.{}-{}".format(self.source_service,
self.event_type,
service_name,
self.method_name,
uuid.uuid4().hex)
exchange = get_event_exchange(self.source_service)
# auto-delete queues if events are not reliably delivered
auto_delete = not self.reliable_delivery
self.queue = Queue(
queue_name, exchange=exchange, routing_key=self.event_type,
durable=True, auto_delete=auto_delete)
super(EventHandler, self).setup()
def setup(self):
_log.debug('starting %s', self)
# handler_type determines queue name and exclusive flag
exclusive = False
service_name = self.container.service_name
if self.handler_type is SERVICE_POOL:
queue_name = "evt-{}-{}--{}.{}".format(self.source_service,
self.event_type,
service_name,
self.method_name)
elif self.handler_type is SINGLETON:
queue_name = "evt-{}-{}".format(self.source_service,
self.event_type)
elif self.handler_type is BROADCAST:
broadcast_identifier = self.broadcast_identifier
queue_name = "evt-{}-{}--{}.{}-{}".format(self.source_service,
self.event_type,
service_name,
self.method_name,
broadcast_identifier)
exchange = get_event_exchange(self.source_service)
# queues for handlers without reliable delivery should be marked as
# auto-delete so they're removed when the consumer disconnects
auto_delete = self.reliable_delivery is False
# queues for broadcast handlers are exclusive (meaning that only one
# consumer may be connected) except when reliable delivery is enabled,
# because exclusive queues are always removed when the consumer
# disconnects, regardless of the value of auto_delete
exclusive = self.handler_type is BROADCAST
if self.reliable_delivery:
exclusive = False
if self.retry_delay:
queue_name = '{}-delayed'.format(queue_name)
self.queue = DelayedRetryQueue(queue_name,
exchange=exchange,
routing_key=self.event_type,
durable=True,
auto_delete=auto_delete,
exclusive=exclusive,
retry_delay=self.retry_delay)
else:
self.queue = Queue(queue_name,
exchange=exchange,
routing_key=self.event_type,
durable=True,
auto_delete=auto_delete,
exclusive=exclusive)
super(EventHandler, self).setup()
def setup(self):
_log.debug('starting %s', self)
# handler_type determines queue name and exclusive flag
exclusive = False
service_name = self.container.service_name
if self.handler_type is SERVICE_POOL:
queue_name = "evt-{}-{}--{}.{}".format(self.source_service,
self.event_type,
service_name,
self.method_name)
elif self.handler_type is SINGLETON:
queue_name = "evt-{}-{}".format(self.source_service,
self.event_type)
elif self.handler_type is BROADCAST:
broadcast_identifier = self.broadcast_identifier
queue_name = "evt-{}-{}--{}.{}-{}".format(self.source_service,
self.event_type,
service_name,
self.method_name,
broadcast_identifier)
exchange = get_event_exchange(self.source_service)
# queues for handlers without reliable delivery should be marked as
# auto-delete so they're removed when the consumer disconnects
auto_delete = self.reliable_delivery is False
# queues for broadcast handlers are exclusive (meaning that only one
# consumer may be connected) except when reliable delivery is enabled,
# because exclusive queues are always removed when the consumer
# disconnects, regardless of the value of auto_delete
exclusive = self.handler_type is BROADCAST
if self.reliable_delivery:
exclusive = False
self.queue = Queue(
queue_name, exchange=exchange, routing_key=self.event_type,
durable=True, auto_delete=auto_delete, exclusive=exclusive)
super(EventHandler, self).setup()
def test_restricted_parameters(self, mock_container, producer):
""" Verify that providing routing parameters at instantiation
time has no effect.
"""
config = {'AMQP_URI': 'memory://localhost'}
exchange = Mock()
routing_key = Mock()
dispatch = event_dispatcher(config,
exchange=exchange,
routing_key=routing_key)
service_name = "service-name"
event_exchange = get_event_exchange(service_name, config)
event_type = "event-type"
dispatch(service_name, event_type, "event-data")
assert producer.publish.call_args[1]['exchange'] == event_exchange
assert producer.publish.call_args[1]['routing_key'] == event_type
def setup(self):
self.service_name = self.container.service_name
self.config = self.container.config
self.exchange = get_event_exchange(self.service_name)
super(EventDispatcher, self).setup()
def test_auto_delete(config, expected_auto_delete):
service_name = "example"
exchange = get_event_exchange(service_name, config)
assert exchange.auto_delete is expected_auto_delete
def test_auto_declaration(config, expected_no_declare):
service_name = "example"
exchange = get_event_exchange(service_name, config)
assert exchange.no_declare is expected_no_declare
def publish(
self,
event_type: str = None,
event_data: dict = None,
extra_headers: dict = None,
):
self.publisher.publish(
event_data,
exchange=self.exchange,
routing_key=event_type,
extra_headers=extra_headers,
)
scheduler_publisher = SchedulerPublisher(
exchange=get_event_exchange(EXCHANGE_NAME))
class Scheduler(DependencyProvider):
background_scheduler = BackgroundScheduler()
def __init__(self):
self.extra_headers = None
def start(self):
self.background_scheduler.start()
def setup(self):
scheduler_config = config["APSCHDULER"]
self.background_scheduler.configure(gconfig=scheduler_config,
prefix="")
def setup(self):
self.service_name = self.container.service_name
self.config = self.container.config
self.exchange = get_event_exchange(self.service_name)
super(EventDispatcher, self).setup()
def _create_exchange(self) -> None:
with get_connection(self._dispatcher.amqp_uri) as connection:
exchange = get_event_exchange(self._name)
exchange.maybe_bind(connection)
exchange.declare()
def setup(self):
self.exchange = get_event_exchange(self.container.service_name)
self.declare.append(self.exchange)
super(EventDispatcher, self).setup()
def setup(self):
self.exchange = get_event_exchange(self.container.service_name,
self.container.config)
self.declare.append(self.exchange)
super(EventDispatcher, self).setup()
