Ticket #107: c2s_crash.py

import sys
from twisted.words.protocols import jabber
from twisted.words.protocols.jabber import xmlstream, client, jid
from twisted.words.protocols.jabber.xmlstream import IQ
from twisted.words.xish import domish
from twisted.internet import reactor, protocol, threads
from twisted.python import log
from twisted.python.logfile import DailyLogFile
from twisted.names.srvconnect import SRVConnector
import time

# namespace constants
NS_CLIENT = 'jabber:client'
NS_MUC = 'http://jabber.org/protocol/muc'
NS_MUC_USER = 'http://jabber.org/protocol/muc#user'
NS_MUC_ADMIN = 'http://jabber.org/protocol/muc#admin'
NS_DELAY = 'jabber:x:delay'

class XMPPClientConnector(SRVConnector):
    """
    Use xmpp-client SRV records to connect.
    """
    def __init__(self, reactor, domain, factory):
        SRVConnector.__init__(self, reactor, 'xmpp-client', domain, factory)

class Bot:
    def __init__(self, jabberid, password, debug=False):
        self.jid = jid.internJID(jabberid)
        self.auth = client.XMPPAuthenticator(self.jid, password)
        self.loggedIn = False        
        self.debug = debug
        self.cpf = xmlstream.XmlStreamFactory(self.auth)
        self.cpf.addBootstrap(xmlstream.STREAM_AUTHD_EVENT, self._handleAuthd)
        self.cpf.addBootstrap(xmlstream.STREAM_CONNECTED_EVENT, self._handleConnected)
        self.cpf.addBootstrap(xmlstream.INIT_FAILED_EVENT, self._handleInitFailed)
        self.connector = XMPPClientConnector(reactor, self.jid.host, self.cpf)


    def connect(self):
        log.msg('%s connecting.' % (self.jid.user,))
        self.connector.connect()


    def _rawDataIn(self, buf):
        log.msg('%s RECV: %s' % (self.jid.user, unicode(buf, 'utf-8').encode('ascii', 'replace')))


    def _rawDataOut(self, buf):
        log.msg('%s SENT: %s' % (self.jid.user, unicode(buf, 'utf-8').encode('ascii', 'replace')))


    def disconnect(self):
        log.msg('%s disconnecting.' % (self.jid.user,))
        if self.connected:
            # send unavailable presence
            pres = domish.Element((NS_CLIENT, 'presence'))
            pres['type'] = 'unavailable'
            self.xmlstream.send(pres)    
            self.loggedIn = False
            
            # send </stream:stream> and disconnect
            self.xmlstream.sendFooter()
            self.connector.disconnect()
            log.msg('%s disconnected.' % (self.jid.user,))               
        else:
            log.msg('%s disconnected.' % (self.jid.user,))   


    def reconnect(self):
        self.disconnect()
        self.connect()
        
        
    def _handleConnected(self, xmlstream):
        self.connected = True
        self.xmlstream = xmlstream

        if self.debug:
            self.xmlstream.rawDataInFn = self._rawDataIn
            self.xmlstream.rawDataOutFn = self._rawDataOut
        log.msg('%s connected.' % (self.jid.user,))


                                                            
    def _handleAuthd(self, _):
        log.msg('%s authenticated.' % (self.jid.user,))
       
        # send initial presence
        pres = domish.Element((NS_CLIENT, 'presence'))
        self.xmlstream.send(pres)
        
        self.say("Hello there", USER_NOT_LOGGED_IN)
        self.reconnect()


    def _handleInitFailed(self, f):
        log.msg('%s failed init.' % (self.jid.user,))
        log.err(f)              


    def say(self, text, tojid):
        msg = domish.Element((None, 'message'))
        msg['from'] = self.jid.full()
        msg['to'] = tojid
        msg['type'] = 'chat'
        msg.addElement('body').addContent(text)
        self.xmlstream.send(msg)

#jid of some user not currently logged in
USER_NOT_LOGGED_IN = ""
user_jid = ""
user_passwd = ""
log.startLogging(sys.stdout)
bot = Bot(user_jid, user_passwd, True)
bot.connect()
reactor.addSystemEventTrigger('before', 'shutdown', bot.disconnect)
reactor.run()