def test_stopService_no_factory(self):
service = FedoraMessagingService(None)
ss_path = ("fedora_messaging.twisted.service.service."
"MultiService.stopService")
with mock.patch(ss_path) as stopService:
service.stopService()
stopService.assert_not_called()
def test_connect(self):
service = FedoraMessagingService()
service.factory = mock.Mock()
service.connect()
self.assertEqual(len(service.services), 1)
serv = service.services[0]
self.assertTrue(serv.factory is service.factory)
self.assertTrue(serv.parent is service)
self.assertIsInstance(serv, TCPClient)
def test_connect_tls(self):
"""Assert connecting with amqps starts an SSLClient."""
service = FedoraMessagingService("amqps://")
service.factory = mock.Mock()
service.connect()
self.assertEqual(len(service.services), 1)
serv = service.services[0]
self.assertTrue(serv.factory is service.factory)
self.assertTrue(serv.parent is service)
self.assertIsInstance(serv, SSLClient)
def test_connect(self):
callback = mock.Mock()
service = FedoraMessagingService(callback)
factory = mock.Mock()
service.factoryClass = mock.Mock(side_effect=lambda *a: factory)
service.connect()
service.factoryClass.assert_called_once_with(service._parameters,
service._bindings)
self.assertEqual(len(service.services), 1)
serv = service.services[0]
self.assertTrue(serv.factory is factory)
self.assertTrue(serv.parent is service)
def test_init_client_props_override(self):
callback = mock.Mock()
service = FedoraMessagingService(
callback,
"amqp://?client_properties={'foo':'bar'}",
)
self.assertEqual(service._parameters.client_properties, {"foo": "bar"})
def test_startService(self):
service = FedoraMessagingService()
serv = mock.Mock()
service.addService(serv)
service.connect = mock.Mock()
service.startService()
service.connect.assert_called_once()
def test_startService_no_consume(self):
service = FedoraMessagingService(None)
serv = mock.Mock()
service.addService(serv)
service.connect = mock.Mock()
service.startService()
service.connect.assert_called_once()
serv.factory.consume.assert_not_called()
def test_startService(self):
callback = mock.Mock()
service = FedoraMessagingService(callback)
serv = mock.Mock()
service.addService(serv)
service.connect = mock.Mock()
service.startService()
service.connect.assert_called_once()
serv.factory.consume.assert_called_once_with(callback)
def test_init(self):
callback = mock.Mock()
service = FedoraMessagingService(callback, "amqp://example.com:4242",
{"binding": "value"})
self.assertTrue(isinstance(service._parameters, pika.URLParameters))
self.assertEqual(service._parameters.host, "example.com")
self.assertEqual(service._parameters.port, 4242)
self.assertEqual(getattr(service._parameters, "ssl", False), False)
self.assertEqual(service._parameters.client_properties,
config.conf["client_properties"])
self.assertEqual(service._bindings, {"binding": "value"})
self.assertTrue(service._on_message is callback)
def test_stopService(self):
callback = mock.Mock()
service = FedoraMessagingService(callback)
serv = mock.Mock()
service.addService(serv)
service.stopService()
serv.factory.stopTrying.assert_called_once()
def test_init_with_consumers(self):
"""Assert consumers are passed onto the factory object."""
cb = mock.Mock()
with mock.patch(
"fedora_messaging.twisted.service.FedoraMessagingService.factoryClass"
):
service = FedoraMessagingService(consumers={"my_queue": cb})
FedoraMessagingService.factoryClass.assert_called_once_with(
service._parameters,
exchanges=None,
queues=None,
bindings=None)
service.factory.consume.assert_called_once_with(cb, "my_queue")
def test_init(self):
service = FedoraMessagingService("amqp://example.com:4242",
queues=[{
"queue": "my_queue"
}])
self.assertTrue(isinstance(service._parameters, pika.URLParameters))
self.assertEqual(service._parameters.host, "example.com")
self.assertEqual(service._parameters.port, 4242)
self.assertEqual(getattr(service._parameters, "ssl", False), False)
self.assertEqual(service._parameters.client_properties,
config.conf["client_properties"])
self.assertEqual(service._queues, [{"queue": "my_queue"}])
self.assertIsInstance(service.factory, FedoraMessagingFactory)
def test_init_client_props_override(self):
service = FedoraMessagingService(
"amqp://?client_properties={'foo':'bar'}")
self.assertEqual(service._parameters.client_properties, {"foo": "bar"})
def test_init_tls(self):
"""Assert creating the service with an amqps URL configures TLS."""
service = FedoraMessagingService("amqps://")
self.assertTrue(isinstance(service._parameters, pika.URLParameters))
self.assertIsNotNone(service._parameters.ssl_options)
def __init__(self):
service.MultiService.__init__(self)
self.email_producer = None
self.irc_producer = None
self.irc_client = None
# Map queue names to service instances
self._queues = {}
self._irc_queues = {}
self._email_queues = {}
self._irc_services = []
self._email_services = []
db.initialize(config.conf)
if config.conf["IRC_ENABLED"]:
queues, bindings = self.get_queues(db.DeliveryType.irc)
consumers = {q["queue"]: self._dispatch_irc for q in queues}
producer = FedoraMessagingService(
queues=queues, bindings=bindings, consumers=consumers)
producer.setName("irc-{}".format(len(self._irc_services)))
self._irc_services.append(producer)
for queue in queues:
self._queues[queue["queue"]] = producer
self.addService(producer)
if config.conf["EMAIL_ENABLED"]:
queues, bindings = self.get_queues(db.DeliveryType.email)
consumers = {q["queue"]: mail.deliver for q in queues}
producer = FedoraMessagingService(
queues=queues, bindings=bindings, consumers=consumers)
producer.setName("email-{}".format(len(self._email_services)))
self._email_services.append(producer)
for queue in queues:
self._queues[queue["queue"]] = producer
self.addService(producer)
amqp_endpoint = endpoints.clientFromString(
reactor, 'tcp:localhost:5672'
)
params = pika.URLParameters('amqp://')
control_queue = {
"queue": "fedora-notifications-control-queue",
"durable": True,
}
factory = FedoraMessagingFactory(
params,
queues=[control_queue],
)
factory.consume(self._manage_service, control_queue["queue"])
self.amqp_service = internet.ClientService(amqp_endpoint, factory)
self.addService(self.amqp_service)
# TODO set up a listener for messages about new queues.
# Then we need an API to poke a message service to start a new subscription
# or stop an existing one.
if self._irc_services:
irc_endpoint = endpoints.clientFromString(
reactor, config.conf["IRC_ENDPOINT"]
)
irc_factory = protocol.Factory.forProtocol(irc.IrcProtocol)
self.irc_client = internet.ClientService(irc_endpoint, irc_factory)
self.addService(self.irc_client)
