summaryrefslogtreecommitdiff
path: root/sleekxmpp/plugins/xep_0199/ping.py
blob: d1e08e615c167f6bf02318938fe818b85a138faf (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
"""
    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