def post_receive(self, alert):
body = Element("body")
body.text = "*[%s] %s %s - _%s on %s_* <%s/#/alert/%s|%s>" % (
alert.status.capitalize(), alert.environment,
alert.severity.capitalize(), alert.event, alert.resource,
DASHBOARD_URL, alert.id, alert.get_id(short=True))
yield room.send(body)
def emit(self, record):
try:
body = Element("body")
body.text = self.format(record)
self.room.send(body)
except (KeyboardInterrupt, SystemExit):
raise
except:
self.handleError(record)
def emit(self, record):
try:
event = getattr(record, "event", None)
body = Element("body")
body.text = self.format(record)
if event is not None:
self.room.send(event.to_elements(include_body=False), body)
else:
self.room.send(body)
except (KeyboardInterrupt, SystemExit):
raise
except:
self.handleError(record)
def _catch(self, jid, session_id):
try:
yield idiokit.consume()
finally:
end = Element("end", xmlns=SERVICE_NS, id=session_id)
self.xmpp.core.message(jid, end)
self._discard_session(jid, session_id)
def _start(self, iq, jid, service_id, element):
try:
service = self.services.get(service_id, None)
if service is None:
raise SessionError("service '%s' not available" % service_id)
path = None
for child in element.children("path").children():
path = serialize.load(child)
break
for child in element.children("config").children():
conf = serialize.load(child)
break
else:
raise SessionError("did not get session configuration")
session = yield service.open_session(path, conf)
session_id = uuid.uuid4().hex
sessions = self.jids.setdefault(jid, dict())
sessions[session_id] = session
session | self._catch(jid, session_id)
except SessionError as se:
msg = se.args[0]
error = self.xmpp.core.build_error("cancel", "session-failure", msg)
self.xmpp.core.iq_error(iq, error)
except BaseException as exc:
error = self.xmpp.core.build_error("cancel", "session-failure", repr(exc))
self.xmpp.core.iq_error(iq, error)
else:
result = Element("start", xmlns=SERVICE_NS, id=session_id)
self.xmpp.core.iq_result(iq, result)
def to_elements(self, include_body=True):
element = Element("event", xmlns=EVENT_NS)
for key, value in self.items():
key = _replace_non_xml_chars(key)
value = _replace_non_xml_chars(value)
attr = Element("attr", key=key, value=value)
element.add(attr)
if not include_body:
return element
body = Element("body")
body.text = _replace_non_xml_chars(unicode(self))
return Elements(body, element)
def dump_list(dump, name, obj):
element = Element(name)
for item in obj:
element.add(dump(item))
return element
def dump(self, obj, name, context):
return Element(name, _text=repr(obj))
def dump_str(dump, name, obj):
element = Element(name)
element.text = obj
return element
def _try_session(inner, self, service_id, *path, **conf):
matches = list()
for jid, service_ids in self.catalogue.items():
if service_id in service_ids:
matches.append(jid)
if matches:
jid = random.choice(matches)
else:
channel = threado.Channel()
self.waiters.setdefault(service_id, set()).add(channel)
try:
while not channel.was_source:
jid = yield inner, channel
finally:
waiters = self.waiters.get(service_id, set())
waiters.discard(channel)
if not waiters:
self.waiters.pop(service_id, None)
start = Element("start", xmlns=SERVICE_NS, id=service_id)
if path:
path_element = Element("path")
path_element.add(serialize.dump(path))
start.add(path_element)
conf_element = Element("config")
conf_element.add(serialize.dump(conf))
start.add(conf_element)
try:
result = yield inner.sub(self.xmpp.core.iq_set(start, to=jid))
except XMPPError, error:
if error.type != "cancel":
raise
inner.finish()
def dump(self, obj, name, context):
element = Element(name)
element.add(context.dump(obj.dump()))
return element
def dump(self, obj, name, context):
return Element(name, _text=unicode(int(bool(obj))))
def dump(self, obj, name, context):
return Element(name, _text=b64encode(obj))
def dump(self, obj, name, context):
return Element(name)
def dump_int(dump, name, obj):
element = Element(name)
element.text = unicode(obj)
return element
def dump_float(dump, name, obj):
element = Element(name)
element.text = repr(obj)
return element
def events_to_elements_with_delay_element(inner):
while True:
event = yield inner
stamp = event.value('start')
eid = event.value('id')
body = Element("body")
body.text = events._escape(unicode(event))
#set delay for faking the event arrival time
delay = Element("delay")
delay.text = "Greetings earthlings"
delay.set_attr("xmlns", 'urn:xmpp:delay')
strstamp = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.strptime(stamp,"%Y-%m-%d %H:%M:%S"))
delay.set_attr("stamp", strstamp)
inner.send(body, event.to_element(),delay)
stamp = event.value('end')
body = Element("body")
close_event = events.Event()
close_event.add('id',eid)
body.text = events._escape(unicode(close_event))
#set delay for faking the event arrival time
delay = Element("delay")
delay.text = "Greetings earthlings"
delay.set_attr("xmlns", 'urn:xmpp:delay')
strstamp = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.strptime(stamp,"%Y-%m-%d %H:%M:%S"))
delay.set_attr("stamp", strstamp)
inner.send(body, close_event.to_element(),delay)
def dump_b64(dump, name, obj):
element = Element(name)
element.text = b64encode(obj)
return element
def dump_rule(cls, dump, name, rule):
element = Element(name)
element.add(serialize.dump_list(dump, "keys", rule.keys))
element.add(serialize.dump_dict(dump, "key-values", rule.key_values))
return element
def events_to_elements_with_delay_element(inner):
while True:
event = yield inner
stamp = event.value('start')
eid = event.value('id')
body = Element("body")
body.text = events._escape(unicode(event))
#set delay for faking the event arrival time
delay = Element("delay")
delay.text = "Greetings earthlings"
delay.set_attr("xmlns", 'urn:xmpp:delay')
strstamp = time.strftime("%Y-%m-%dT%H:%M:%SZ",
time.strptime(stamp, "%Y-%m-%d %H:%M:%S"))
delay.set_attr("stamp", strstamp)
inner.send(body, event.to_element(), delay)
stamp = event.value('end')
body = Element("body")
close_event = events.Event()
close_event.add('id', eid)
body.text = events._escape(unicode(close_event))
#set delay for faking the event arrival time
delay = Element("delay")
delay.text = "Greetings earthlings"
delay.set_attr("xmlns", 'urn:xmpp:delay')
strstamp = time.strftime("%Y-%m-%dT%H:%M:%SZ",
time.strptime(stamp, "%Y-%m-%d %H:%M:%S"))
delay.set_attr("stamp", strstamp)
inner.send(body, close_event.to_element(), delay)
def dump_rule(cls, dump, name, rule):
element = Element(name, ip=rule.ip, bits=rule.bits)
if rule.keys is not None:
element.add(serialize.dump_list(dump, "keys", rule.keys))
return element
def _update_presence(self):
services = Element("services", xmlns=SERVICE_NS)
for service_id, service in self.services.items():
element = Element("service", id=service_id)
services.add(element)
self.xmpp.core.presence(services, to=self.room.jid)
def dump_rule(cls, dump, name, rule):
element = Element(name)
element.add(dump(rule.child))
return element
def _establish_session(self, jid, service_id, path, conf):
start = Element("start", xmlns=SERVICE_NS, id=service_id)
if path:
path_element = Element("path")
path_element.add(serialize.dump(path))
start.add(path_element)
conf_element = Element("config")
conf_element.add(serialize.dump(conf))
start.add(conf_element)
try:
result = yield self.xmpp.core.iq_set(start, to=jid)
except XMPPError as error:
if error.type != "cancel":
raise
if error.condition == "session-failure":
raise SessionError(
"session for service " + repr(service_id) +
" failed: " + error.text)
idiokit.stop()
except Unavailable:
idiokit.stop()
for start in result.children("start", SERVICE_NS).with_attrs("id"):
session_id = start.get_attr("id")
session = self._catch(jid, session_id)
idiokit.pipe(self.fork(), session)
sessions = self.jids.setdefault(jid, dict())
sessions[session_id] = session
idiokit.stop(session)
else:
raise SessionError(
"no session ID for service " + repr(service_id) + "received")
def dump(self, obj, name, context):
element = Element(name)
for item in obj:
element.add(context.dump(item))
return element
