def test_on_message(self):
#send a sleep command
#send an echo command
#watch the response queue for state changes
response_queue = 'test_response_queue'
cmd_msg1 = CommandMessage(['sleep', '1'], response_queue, 1, timeout=2)
msg1 = pack_message(cmd_msg1)
cmd_msg2 = CommandMessage(['echo', 'foo'],
response_queue,
1,
timeout=1)
msg2 = pack_message(cmd_msg2)
task_broker = _task_broker_factory()
channel = task_broker.channel
_init_queue(channel, response_queue, response_queue, response_queue)
# Send some commands
for message in [msg1, msg2]:
channel.basic_publish(message,
mandatory=True,
exchange="test",
routing_key="test")
#Set to Consume
task_broker._start_consume()
channel.wait()
time.sleep(1)
channel.wait()
time.sleep(1)
# We should have 0 tasks in the queue and STARTED and FINISHED for both
# tasks in response queue
self.assertEquals(_queue_size("test"), 0)
self.assertEquals(_queue_size(response_queue), 8)
def test_consume_from_2_queues(self):
"""
Check that worker consumes messages from 2 queues properly
"""
self.counter = 0
def show_queues():
queues = get_queues(_get_properties())
total_messages = 0
for queue in queues:
print "queue %s: %s messages" % (queue, _queue_size(queue))
total_messages += _queue_size(queue)
print "total messages: %s" % total_messages
def check_queue_size(*args, **kwargs):
"""
Closure to attach to _dispatch
counts how many messages processed
"""
self.counter += 1
#SetUp the TaskBroker but override _dispatch
task_broker = _task_broker_factory(dispatch_func=check_queue_size)
#Publish a Couple of Messages to both queues
channel = task_broker.channel
properties = {DEVICE_GROUP: "test", DEVICE_NAME: "testname"}
queues = get_queues(properties)
self.assertEquals(len(queues), 2)
for queue in queues:
foo_cmd_msg = CommandMessage(['foo'], '', 1, timeout=1)
foo_msg = pack_message(foo_cmd_msg)
channel.basic_publish(foo_msg,
mandatory=True,
exchange=queue,
routing_key=queue)
#
bar_cmd_msg = CommandMessage(['bar'], '', 1, timeout=1)
bar_msg = pack_message(bar_cmd_msg)
channel.basic_publish(bar_msg,
mandatory=True,
exchange=queue,
routing_key=queue)
#
baz_cmd_msg = CommandMessage(['bar'], '', 1, timeout=1)
baz_msg = pack_message(baz_cmd_msg)
channel.basic_publish(baz_msg,
mandatory=True,
exchange=queue,
routing_key=queue)
#Set to Consume
task_broker._start_consume()
while self.counter < 6: # Process all messages
channel.wait()
for queue in queues: # Make sure all queues are empty
self.assertEquals(_queue_size(queue), 0)
def _dispatch_tasks(self):
"""
Publish the Tasks to the RabbitMQ
"""
self.timeout_handler.start_queue_timeout()
for task in self._tasks:
log_msg = "Sending command '%s' with key '%s'" \
% (task.command, self._routing_key)
LOGGER.debug(log_msg)
#Send task in queue event with task id
send_monitor_event(MonitorType.TASK_INQUEUE, __name__,
task.task_id)
cmd_msg = CommandMessage(
task.command,
self._testrun_queue,
task.task_id,
timeout=self._execution_timeout,
xml_file=task.xml_file,
min_worker_version=self._min_worker_version)
message = pack_message(cmd_msg)
self._channel.basic_publish(message,
exchange=self._services_exchange,
routing_key=self._routing_key)
def test_is_version_compatible(self):
task_broker = _task_broker_factory()
cmd_msg = CommandMessage(["ls"],
"foo",
111,
timeout=2,
min_worker_version=100)
packed_msg = pack_message(cmd_msg)
self.assertFalse(task_broker._is_version_compatible(packed_msg))
cmd_msg = CommandMessage(["ls"],
"foo",
111,
timeout=2,
min_worker_version=0.7)
packed_msg = pack_message(cmd_msg)
self.assertTrue(task_broker._is_version_compatible(packed_msg))
def test_dispatch_failing_command(self):
task_broker = _task_broker_factory()
channel = task_broker.channel
# Try to keep under timeouts
cmd_fail = CommandMessage(["cat", "/not/existing/file"],
"test",
1,
timeout=1)
self.assertRaises(CommandFailed, task_broker._dispatch, cmd_fail)
def test_dispatch(self):
task_broker = _task_broker_factory()
channel = task_broker.channel
# Try to keep under timeouts
cmd_ignore = CommandMessage(["ignore"], "test", 1, timeout=1)
self.assertFalse(task_broker._dispatch(cmd_ignore))
cmd_quit = CommandMessage(["quit"], "test", 1, timeout=1)
self.assertFalse(task_broker._dispatch(cmd_quit))
cmd_ls = CommandMessage(["ls -la"], "test", 1, timeout=1)
self.assertFalse(task_broker._dispatch(cmd_ls))
xml_file = StringIO("foo bar")
xml_file.name = "test_xml.xml"
cmd_with_file = CommandMessage(["cat /tmp/test_xml.xml"],
"test",
1,
timeout=1,
xml_file=xml_file)
self.assertFalse(task_broker._dispatch(cmd_with_file))
def test_consume(self):
"""
Check that the consume sets the prefetch correctly
"""
def check_queue_size(*args, **kwargs):
"""
Closure to attach to _dispatch
to check the queue size
"""
self.assertEquals(self.expected_size, _queue_size("test"))
self.assertTrue(_queue_size("test") is None)
#SetUp the TaskBroker but override _dispatch
task_broker = _task_broker_factory(dispatch_func=check_queue_size)
#Publish a Couple of Messages
channel = task_broker.channel
foo_cmd_msg = CommandMessage(['foo'], '', 1, timeout=1)
foo_msg = pack_message(foo_cmd_msg)
channel.basic_publish(foo_msg,
mandatory=True,
exchange="test",
routing_key="test")
bar_cmd_msg = CommandMessage(['bar'], '', 1, timeout=1)
bar_msg = pack_message(bar_cmd_msg)
channel.basic_publish(bar_msg,
mandatory=True,
exchange="test",
routing_key="test")
self.assertEquals(2, _queue_size("test"))
task_broker._start_consume()
self.expected_size = 1
channel.wait()
self.expected_size = 0
channel.wait()
time.sleep(5)
def send_quit(self):
cmd_msg = CommandMessage(["quit"], self.queue, 111)
message = pack_message(cmd_msg)
conn = amqp.Connection(host="localhost",
userid="guest",
password="******",
virtual_host="/",
insist=False)
channel = conn.channel()
channel.basic_publish(message,
exchange=ROUTING_KEY,
routing_key=ROUTING_KEY)
def test_on_message_not_version_compatible(self):
"""
Check that incompatible versions dont
pull messages from the queue
"""
#self.assertTrue(_queue_size("test_v") is None)
cmd_msg = CommandMessage(['echo', 'foo'], 'test', 1, timeout=1)
msg = pack_message(cmd_msg)
task_broker = _task_broker_factory()
channel = task_broker.channel
channel.basic_publish(msg,
mandatory=True,
exchange="test",
routing_key="test")
self.assertEquals(1, _queue_size("test"))
task_broker._start_consume()
channel.wait()
self.assertEquals(3, _queue_size("test"))
#Check that the message can be pulled by another consumer
connection = amqp.Connection(host="localhost",
userid="guest",
password="******",
virtual_host="/",
insist=False)
channel = connection.channel()
self.received = False
def cb(message):
channel.basic_ack(delivery_tag=message.delivery_tag)
self.received = True
channel.basic_consume("test", callback=cb)
channel.wait()
self.assertTrue(self.received)
self.assertEquals(0, _queue_size("test"))