""" SleekXMPP: The Sleek XMPP Library Copyright (C) 2010 Nathanael C. Fritz This file is part of SleekXMPP. See the file LICENSE for copying permission. """ import time import logging import sleekxmpp from sleekxmpp import Iq from sleekxmpp.xmlstream import register_stanza_plugin from sleekxmpp.xmlstream.matcher import StanzaPath from sleekxmpp.xmlstream.handler import Callback from sleekxmpp.plugins.base import base_plugin from sleekxmpp.plugins.xep_0199 import stanza, Ping log = logging.getLogger(__name__) class xep_0199(base_plugin): """ XEP-0199: XMPP Ping Given that XMPP is based on TCP connections, it is possible for the underlying connection to be terminated without the application's awareness. Ping stanzas provide an alternative to whitespace based keepalive methods for detecting lost connections. Also see <http://www.xmpp.org/extensions/xep-0199.html>. Attributes: keepalive -- If True, periodically send ping requests to the server. If a ping is not answered, the connection will be reset. frequency -- Time in seconds between keepalive pings. Defaults to 300 seconds. timeout -- Time in seconds to wait for a ping response. Defaults to 30 seconds. Methods: send_ping -- Send a ping to a given JID, returning the round trip time. """ def plugin_init(self): """ Start the XEP-0199 plugin. """ self.description = 'XMPP Ping' self.xep = '0199' self.stanza = stanza self.keepalive = self.config.get('keepalive', False) self.frequency = float(self.config.get('frequency', 300)) self.timeout = self.config.get('timeout', 30) register_stanza_plugin(Iq, Ping) self.xmpp.register_handler( Callback('Ping', StanzaPath('iq@type=get/ping'), self._handle_ping)) if self.keepalive: self.xmpp.add_event_handler('session_start', self._handle_keepalive, threaded=True) def post_init(self): """Handle cross-plugin dependencies.""" base_plugin.post_init(self) self.xmpp['xep_0030'].add_feature(Ping.namespace) def _handle_keepalive(self, event): """ Begin periodic pinging of the server. If a ping is not answered, the connection will be restarted. The pinging interval can be adjused using self.frequency before beginning processing. Arguments: event -- The session_start event. """ def scheduled_ping(): """Send ping request to the server.""" log.debug("Pinging...") resp = self.send_ping(self.xmpp.boundjid.host, self.timeout) if resp is None or resp is False: log.debug("Did not recieve ping back in time." + \ "Requesting Reconnect.") self.xmpp.reconnect() self.xmpp.schedule('Ping Keep Alive', self.frequency, scheduled_ping, repeat=True) def _handle_ping(self, iq): """ Automatically reply to ping requests. Arguments: iq -- The ping request. """ log.debug("Pinged by %s" % iq['from']) iq.reply().enable('ping').send() def send_ping(self, jid, timeout=None, errorfalse=False, ifrom=None, block=True, callback=None): """ Send a ping request and calculate the response time. Arguments: jid -- The JID that will receive the ping. timeout -- Time in seconds to wait for a response. Defaults to self.timeout. errorfalse -- Indicates if False should be returned if an error stanza is received. Defaults to False. ifrom -- Specifiy the sender JID. block -- Indicate if execution should block until a pong response is received. Defaults to True. callback -- Optional handler to execute when a pong is received. Useful in conjunction with the option block=False. """ log.debug("Pinging %s" % jid) if timeout is None: timeout = self.timeout iq = self.xmpp.Iq() iq['type'] = 'get' iq['to'] = jid if ifrom: iq['from'] = ifrom iq.enable('ping') start_time = time.clock() resp = iq.send(block=block, timeout=timeout, callback=callback) end_time = time.clock() delay = end_time - start_time if not block: return None if not resp or resp['type'] == 'error': return False log.debug("Pong: %s %f" % (jid, delay)) return delay # Backwards compatibility for names xep_0199.sendPing = xep_0199.send_ping