connection.py 3.88 KB
Newer Older
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
#!/usr/bin/python
# -*- coding:utf-8 -*-
#
# Copyright 2010 Le Coz Florent <louizatakk@fedoraproject.org>
#
# This file is part of Poezio.
#
# Poezio is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, version 3 of the License.
#
# Poezio is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Poezio.  If not, see <http://www.gnu.org/licenses/>.

import sys

import xmpp
from config import config
from logging import log
from threading import Thread
from multiuserchat import MultiUserChat
from handler import Handler

class Connection(Thread):
    """
31 32
    Receives everything from Jabber and emits the
    appropriate signals
33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50
    """
    def __init__(self, server, resource):
        Thread.__init__(self)
        self.handler = Handler()

        self.server = server
        self.resource = resource
        self.online = 0         # 1:connected, 2:auth confirmed
        self.jid = ''           # we don't know our jid yet (anon account)
        if not self.server:
            log.error('You should set a server in the configuration file')
        self.port = int(config.get('port'))
        if not self.port:
            log.warning('No port set in configuration file, defaulting to 5222')
            self.port = 5222

    def run(self):
        """
51
        run in a thread
52 53
        connect to server
        """
54
        self.client = xmpp.Client(self.server, debug=[])
55 56 57 58 59 60 61 62 63
        if not self.connect_to_server(self.server, self.port):
            log.error('Could not connect to server')
            sys.exit(-1)
        if not self.authenticate():
            log.error('Could not authenticate to server')
            sys.exit(-1)
        self.client.sendInitPresence()
        self.online = 1      # 2 when confirmation of auth is received
        self.register_handlers()
64 65
        while 1:
            self.process()
66 67 68 69 70 71 72 73 74 75 76 77 78

    def connect_to_server(self, server, port):
        # TODO proxy stuff
        return self.client.connect((server, port))

    def authenticate(self, anon=True):
        if anon:
            return self.client.auth(None, None, self.resource)
        else:
            log.error('Non-anonymous connections not handled currently')
            return None

    def register_handlers(self):
79 80 81
        """
        register handlers from xmpppy signals
        """
82 83
        self.client.RegisterHandler('message', self.handler_message)
        self.client.RegisterHandler('presence', self.handler_presence)
84
        self.client.RegisterHandler('iq',         self.handler_iq)
85 86

    def handler_presence(self, connection, presence):
87
        fro = presence.getFrom()
88 89 90 91
        to = presence.getAttr('to')
        if fro == to:           # own presence
            self.online = 2
            self.jid = to
92
            self.handler.emit('on-connected')
93
            return
94
        self.handler.emit('room-presence', stanza=presence)
95

96 97
    def handler_message(self, connection, message):
        self.handler.emit('room-message', stanza=message)
98

99 100 101 102 103 104 105 106
    def handler_iq(self, connection, iq):
        pass

    def process(self, timeout=10):
        if self.online:
            self.client.Process(timeout)
        else:
            log.warning('disconnecting...')
107
            sys.exit()
108

109 110 111 112 113 114 115 116 117 118 119 120 121
if __name__ == '__main__':
    resource = config.get('resource')
    server = config.get('server')
    connection = Connection(server, resource)
    connection.start()
    rooms = config.get('rooms').split(':')
    from time import sleep
    print connection.online
    sleep(2)
    print connection.online
    for room in rooms:
        connection.send_join_room(room.split('/')[0], room.split('/')[1])
        i = 17