def check(r):
output = client.channel.sent
msg_perf = json.loads(output[0]["content"].body)
self.assertEqual(msg_perf["type"], "perf")
self.assertEqual(msg_perf["datasource"],
"changedsvc-dummykey")
msg_cmd = json.loads(output[1]["content"].body)
self.assertEqual(msg_cmd["type"], "nagios")
self.assertTrue(msg_cmd["value"].startswith(
"changedhost;changedsvc;"))
def check(r):
output = client.channel.sent
print output
self.assertEqual(len(output), 2)
msg_perf = json.loads(output[0]["content"].body)
self.assertEqual(msg_perf["type"], "perf")
self.assertEqual(msg_perf["host"], self.localhn)
self.assertEqual(msg_perf["datasource"], "testservice-dummykey")
self.assertEqual(msg_perf["value"], "dummyvalue")
msg_cmd = json.loads(output[1]["content"].body)
self.assertEqual(msg_cmd["type"], "nagios")
self.assertEqual(msg_cmd["cmdname"],
"PROCESS_SERVICE_CHECK_RESULT")
self.assertTrue(msg_cmd["value"].startswith(
"%s;testservice;0;OK:" % self.localhn))
def sendMessage(self, msg):
"""
Traite un message en l'envoyant sur le bus.
@param msg: message à traiter
@type msg: C{str} ou C{dict}
@return: le C{Deferred} avec la réponse, ou C{None} si cela n'a pas
lieu d'être (message envoyé en push)
"""
self._messages_sent += 1
if isinstance(msg, basestring):
msg = json.loads(msg)
try:
if isinstance(msg["timestamp"], datetime):
msg["timestamp"] = time.mktime(msg["timestamp"].timetuple())
except (KeyError, TypeError):
pass
# accumulation des messages de perf
msg = self._accumulate_perf_msgs(msg)
if msg is None:
return defer.succeed(None)
msg_text = json.dumps(msg)
msg_type = msg["type"]
exchange = msg_type
ttl = None
if msg_type in self._publications:
exchange, ttl = self._publications[msg_type]
routing_key = msg.get("routing_key", msg_type)
persistent = msg.get("persistent", True)
result = self.client.send(exchange, str(routing_key), msg_text,
persistent, content_type="application/json",
ttl=ttl)
return result
def write(self, msg):
"""
Méthode à appeler pour traiter un message en provenance du bus.
Si le traitement se passe bien (pas d'I{errback}), le message sera
acquitté, sinon il sera rejeté, puis le message suivant sera demandé au
bus.
@param msg: message à traiter
@type msg: C{txamqp.message.Message}
@deprecated: Remplacée par la fonction L{write_batch} qui prend en
charge une liste de messages.
"""
try:
content = json.loads(msg.content.body)
except ValueError:
LOGGER.warning(_("Received message is not JSON-encoded: %r"),
msg.content.body)
d = defer.succeed(None)
else:
if "messages" in content and content["messages"]:
d = self._processList(content["messages"])
else:
d = defer.maybeDeferred(self.processMessage, content)
d.addCallbacks(self.processingSucceeded, self.processingFailed,
callbackArgs=(msg, ), errbackArgs=(msg, ))
if self.keepProducing:
d.addBoth(lambda _x: self.producer.resumeProducing())
return d
def get_from_queue(msg):
if msg is not None:
return json.loads(msg) # le backup est prioritaire
# on dépile la file principale
try:
msg = self.queue.popleft()
except IndexError:
# plus de messages
return None
return msg
def check(r_):
output = client.channel.sent
print output
self.assertEqual(len(output), 3)
msg_out = [ json.loads(m["content"].body)
for m in output ]
msg_in = []
for k, v in stats.iteritems():
m = msg.copy()
m.update({"datasource": "testsvc-%s" % k, "value": v})
msg_in.append(m)
self.assertEqual(msg_in, msg_out)
def test_accumulate_perfs(self):
yield defer.succeed(None)
count = 42
self.bp.batch_send_perf = count
msg = {"type": "perf", "value": "dummy"}
# On se connecte
self.bp.client.stub_connect()
output = self.bp.client.channel.sent
# on traite n-1 message, ce qui ne doit rien envoyer sur le bus
for _i in range(count - 1):
yield self.bp.write(msg)
self.assertEqual(output, [])
# on en envoie un de plus, ce qui doit envoyer un message accumulé
self.bp.write(msg)
self.assertEqual(len(output), 1)
print repr(output[0])
sent = json.loads(output[0]["content"].body)
self.assertEqual(len(sent["messages"]), count)
def write_batch(self, msgs):
"""
Méthode à appeler pour traiter une liste de messages en provenance du
bus.
Si le traitement se passe bien (pas d'I{errback}), les messages seront
acquittés, sinon ils seront rejetés, puis les messages suivants seront
demandés au bus.
@param msgs: Liste de messages du type C{txamqp.message.Message}
à traiter.
@type msgs: C{list}
"""
contents = []
for msg in msgs:
try:
content = json.loads(msg.content.body)
except ValueError:
LOGGER.warning(_("Received message is not JSON-encoded: %r"),
msg.content.body)
else:
if "messages" in content and content["messages"]:
contents.extends(content["messages"])
else:
contents.append(content)
if contents:
d = self.processMessages(contents)
else:
d = defer.succeed(None)
d.addCallbacks(self.processingBatchSucceeded,
self.processingBatchFailed,
callbackArgs=(msgs, ), errbackArgs=(msgs, ))
if self.keepProducing:
d.addBoth(lambda _x: self.producer.resumeProducing())
return d
