← Back to branch summary

~ubuntu-branches/ubuntu/precise/gozerbot/precise

« back to all changes in this revision

Viewing changes to gozerbot/jabberbot.py

  • Committer: Bazaar Package Importer
  • Author(s): Jeremy Malcolm
  • Date: 2008-06-02 19:26:39 UTC
  • mfrom: (1.1.3 upstream) (3.1.1 lenny)
  • Revision ID: james.westby@ubuntu.com-20080602192639-3rn65nx4q1sgd6sy
Tags: 0.8.1-1
New upstream release.

Show diffs side-by-side

added added

removed removed

Lines of Context:
gozerbot/jabberbot.py
27
27
from gozerbot.thr import start_new_thread
28
28
from gozerbot.fleet import fleet
29
29
from gozerbot.runner import runner
30
 
from gozerplugs.plugs.jcoll import jcheck
 
30
from gozerbot.botbase import BotBase
31
31
from xmpp.simplexml import Node
32
32
import xmpp, time, Queue, os, threading, thread, types, xml
33
33
 
36
36
outlocked = lockdec(jabberoutlock)
37
37
inlocked = lockdec(jabberinlock)
38
38
 
39
 
class Jabberbot(object):
 
39
class Jabberbot(BotBase):
40
40
 
41
41
    """ jabber bot class """
42
42
 
43
 
    def __init__(self, botname, owner=""):
 
43
    def __init__(self, name='jabbermain', owner=[]):
 
44
        BotBase.__init__(self, name, owner)
 
45
        self.type = 'jabber'
44
46
        self.outqueue = Queue.Queue()
45
 
        self.name = botname
46
 
        self.type = 'jabber'
47
47
        self.host = None
48
 
        self.port = None
49
48
        self.user = None
50
 
        self.password = None
51
49
        self.sock = None
52
50
        self.jid = None
53
 
        self.nick = None
54
51
        self.username = None
55
52
        self.me = None
56
53
        self.server = None
57
54
        self.lastin = None
58
 
        self.starttime = time.time()
59
 
        self.owner = owner or config['jabberowner']
60
55
        self.test = 0
61
 
        self.stopped = 0
62
56
        self.connecttime = 0
63
57
        self.connection = None
64
 
        self.channels = {}
65
58
        self.privwait = Jabberwait()
66
59
        self.errorwait = Jabbererrorwait()
67
60
        self.jabber = True
68
61
        self.connectok = threading.Event()
69
 
        self.less = Less(5)
70
 
        self.userhosts = {}
71
62
        self.jids = {}
72
63
        self.topics = {}
73
 
        self.userchannels = Dol()
74
64
        self.timejoined = {}
75
 
        self.state = Pdod(datadir + os.sep + '%s.state' % self.name)
76
 
        self.channels = Channels(datadir + os.sep + '%s.channels' % self.name)
77
 
        if not self.state.has_key('joinedchannels'):
78
 
            self.state['joinedchannels'] = []
79
65
        if not self.state.has_key('ratelimit'):
80
66
            self.state['ratelimit'] = 0
81
 
        self.nrevents = 0
82
 
        self.gcevents = 0
83
67
        
84
68
    def _resumedata(self): # stateful reboot request, just shutdown
85
69
        self.exit()
115
99
            if self.stopped or what == None:
116
100
                 break
117
101
            self.rawsend(what)
118
 
            time.sleep(0.1)
 
102
            sleeptime = config['jabberoutsleep']
 
103
            if sleeptime:
 
104
                time.sleep(sleeptime)
 
105
            else:
 
106
                time.sleep(0.1)
119
107
        rlog(10, self.name, 'stopping outputloop')
120
108
 
121
109
    def _keepalive(self):
128
116
                continue
129
117
            else:
130
118
                nrsec = 0
131
 
            self.say(self.jid, "")
 
119
            self.say(self.me, "")
132
120
 
133
121
    def _keepchannelsalive(self):
134
122
        """ channels keep alive method """
188
176
        self.connection.RegisterDisconnectHandler(self.disconnectHandler)
189
177
        self.connection.UnregisterHandlerOnce = self.UnregisterHandlerOnce
190
178
        self.stopped = 0
191
 
        runner.start()
192
 
        commandhandler.start()
193
179
        jabbermonitor.start()
194
180
        start_new_thread(self._doprocess, ())
195
181
        start_new_thread(self._keepalive, ())
200
186
        self.connectok.set()
201
187
        return 1
202
188
 
203
 
    def ownercheck(self, ievent, txt=None):
204
 
        if type(config['jabberowner']) == types.ListType:
205
 
            if ievent.userhost in config['jabberowner']: 
206
 
                return 1
207
 
        elif config['jabberowner'] == ievent.userhost:   
208
 
            return 1    
209
 
        else:
210
 
            if not txt:
211
 
                ievent.reply("only jabberowner (see config file) is allowed \
212
 
to perform this command")
213
 
            else:
214
 
                ievent.reply("only jabberowner (see config file) %s" % txt)
215
 
            return 0
216
 
 
217
189
    def connect(self, host, user, password, port=5222, reconnect=True):
218
190
        res = 0
219
191
        try:
245
217
                rlog(10, self.name, 'failed to join %s: %s' % (i, result))
246
218
 
247
219
 
 
220
    def broadcast(self, txt):
 
221
        for i in self.state['joinedchannels']:
 
222
            self.say(i, txt)
 
223
 
248
224
    def sendpresence(self, to):
249
225
        """ send presence """
250
226
        presence = xmpp.Presence(to=to)
299
275
            m.txt = m.txt[1:]
300
276
        if go and not 'dojcoll' in str(m.id):
301
277
            try:
 
278
                if plugins.woulddispatch(self, m):
 
279
                    m.usercmnd = True
302
280
                plugins.trydispatch(self, m)
303
281
            except:
304
282
                handle_exception()
305
283
        nm = Jabbermsg(msg)
306
284
        nm.copyin(m)
307
285
        jcallbacks.check(self, nm)
308
 
        jcheck(self, nm)
 
286
        if nm.getType() == 'error':
 
287
            err = nm.getErrorCode()
 
288
            if err:
 
289
                rlog(10, self.name + '.error', "%s => %s: %s" % (nm.getFrom(),\
 
290
 err, nm.getError()))
 
291
                rlog(10, self.name + '.error', str(nm))
 
292
            self.errorwait.check(nm)
309
293
 
310
294
    def presenceHandler(self, conn, pres):
311
295
        """ overloaded presence handler """
358
342
                pass
359
343
        p.conn = conn
360
344
        jcallbacks.check(self, p)
361
 
        self.errorwait.check(p)
 
345
        if p.getType() == 'error':
 
346
            err = p.getErrorCode()
 
347
            if err:
 
348
                rlog(10, self.name + '.error', "%s => %s: %s" % (p.getFrom(),\
 
349
 err, p.getError()))
 
350
                rlog(10, self.name + '.error', str(p))
 
351
            self.errorwait.check(p)
362
352
 
363
353
    def reconnect(self):
364
354
        rlog(100, self.name, 'reconnecting .. sleeping 15 seconds')
378
368
 
379
369
    def send(self, what):
380
370
        self.outqueue.put(toenc(what))
 
371
        jabbermonitor.put(self, what)
381
372
 
382
373
    @outlocked
383
374
    def rawsend(self, what):
402
393
        except:
403
394
            handle_exception()
404
395
 
405
 
    def action(self, printto, txt, groupchat=True):
 
396
    def action(self, printto, txt, fromm=None, groupchat=True):
406
397
        """ action txt to printto """
407
398
        txt = "/me " + txt
 
399
        if self.google:
 
400
            fromm = self.me
408
401
        if printto in self.state['joinedchannels'] and groupchat:
409
402
            message = xmpp.Message(to=printto, body=txt, typ='groupchat')
410
403
        else:
411
404
            message = xmpp.Message(to=printto, body=txt)
 
405
        if fromm:
 
406
            message.setFrom(fromm)
412
407
        self.send(message)
413
408
        
414
 
    def say(self, printto, txt, fromm=None, groupchat=True):
 
409
    def say(self, printto, txt, fromm=None, groupchat=True, speed=5):
415
410
        """ say txt to printto """
416
411
        txt = jabberstrip(txt)
 
412
        if self.google:
 
413
            fromm = self.me
417
414
        if printto in self.state['joinedchannels'] and groupchat:
418
 
            message = xmpp.Message(to=printto, body=txt, frm=self.jid, \
419
 
typ='groupchat')
 
415
            message = xmpp.Message(to=printto, body=txt, typ='groupchat')
420
416
        else:
421
 
            message = xmpp.Message(to=printto, body=txt, frm=self.jid, \
422
 
typ='chat')
 
417
            message = xmpp.Message(to=printto, body=txt, typ='chat')
 
418
        if fromm:
 
419
            message.setFrom(fromm)
423
420
        self.send(message)
424
421
 
425
 
    def saynocb(self, printto, txt, fromm=None, groupchat=True):
 
422
    def saynocb(self, printto, txt, fromm=None, groupchat=True, speed=5):
426
423
        """ say txt to printto """
427
424
        txt = jabberstrip(txt)
 
425
        if self.google:
 
426
            fromm = self.me
428
427
        if printto in self.state['joinedchannels'] and groupchat:
429
 
            message = xmpp.Message(to=printto, body=txt, frm=self.jid, \
430
 
typ='groupchat')
 
428
            message = xmpp.Message(to=printto, body=txt, typ='groupchat')
431
429
        else:
432
 
            message = xmpp.Message(to=printto, body=txt, frm=self.jid, \
433
 
typ='chat')
 
430
            message = xmpp.Message(to=printto, body=txt, typ='chat')
434
431
        self.sendnocb(message)
435
432
 
436
433
    def wait(self, msg, txt):
450
447
        """ send unavailable presence """
451
448
        try:
452
449
            presence = xmpp.Presence()
453
 
            presence.setFrom(self.me)
454
450
        except ValueError:
455
451
            return
456
452
        presence.setType('unavailable')
486
482
        q = Queue.Queue()
487
483
        self.errorwait.register("409", q, 3)
488
484
        self.errorwait.register("401", q, 3)
 
485
        self.errorwait.register("400", q, 3)
489
486
        # do the actual join
490
487
        presence = xmpp.Presence(to=channel + '/' + nick)
491
 
        presence.setFrom(self.me)
 
488
        #presence.setFrom(self.me)
492
489
        if password:
493
490
            passnode = Node('password')
494
491
            passnode.addData(password)
520
517
    def part(self, channel):
521
518
        """ leace conference """
522
519
        presence = xmpp.Presence(to=channel)
523
 
        presence.setFrom(self.jid)
 
520
        presence.setFrom(self.me)
524
521
        presence.setType('unavailable')
525
522
        self.send(presence)
526
523
        if channel in self.state['joinedchannels']: