]> gitweb.pimeys.fr Git - bots/parrot.git/blob - parrot.py
Possibilité de dump et de restore dans un format lisible
[bots/parrot.git] / parrot.py
1 #!/usr/bin/python
2 # -*- encoding: utf-8 -*-
3
4 """ Un bot IRC qui enregistre et ressort des citations """
5
6 import threading
7 import random
8 import time
9 import json
10 import re
11 import os
12 import signal
13 import sys
14
15 # Oui, j'ai recodé ma version d'irclib pour pouvoir rattrapper les SIGHUP
16 sys.path.insert(0, "/home/vincent/scripts/python-myirclib")
17 import irclib
18 import ircbot
19
20 from commands import getstatusoutput as ex
21
22 #: Config du bot
23 import config
24 #: Module définissant les erreurs
25 import errors
26 #: Module de gestion des quotes
27 import quotes
28
29 quote_pattern = re.compile(config.quote_regexp, flags=re.UNICODE)
30
31 def get_config_logfile(serveur):
32 """Renvoie le nom du fichier de log en fonction du ``serveur`` et de la config."""
33 serveurs = {"irc.crans.org" : "crans"}
34 return config.logfile_template % (serveurs[serveur],)
35
36 def log(serveur, channel, auteur=None, message=None):
37 """Enregistre une ligne de log."""
38 if auteur == message == None:
39 # alors c'est que c'est pas un channel mais juste une ligne de log
40 chain = u"%s %s" % (time.strftime("%F %T"), channel)
41 else:
42 chain = u"%s [%s:%s] %s" % (time.strftime("%F %T"), channel, auteur, message)
43 f = open(get_config_logfile(serveur), "a")
44 f.write((chain + u"\n").encode("utf-8"))
45 f.close()
46 if config.debug_stdout:
47 print chain.encode("utf-8")
48
49 def ignore_event(serv, ev):
50 """Retourne ``True`` si il faut ignorer cet évènement."""
51 for (blackmask, exceptlist) in config.blacklisted_masks:
52 usermask = ev.source()
53 blackit = bool(irclib.mask_matches(usermask, blackmask))
54 exceptit = any([bool(irclib.mask_matches(usermask, exceptmask)) for exceptmask in exceptlist])
55 if exceptit: # Il est exempté
56 return False
57 else:
58 if blackit: # Il n'est pas exempté et matche la blacklist
59 return True
60
61
62 def bot_unicode(chain):
63 """Essaye de décoder ``chain`` en UTF-8.
64 Lève une py:class:`errors.UnicodeBotError` en cas d'échec."""
65 try:
66 return chain.decode("utf8")
67 except UnicodeDecodeError as exc:
68 raise errors.UnicodeBotError
69
70
71 class Parrot(ircbot.SingleServerIRCBot):
72 """Classe principale : définition du bot."""
73 def __init__(self, serveur, debug=False):
74 temporary_pseudo = config.irc_pseudo + str(random.randrange(10000,100000))
75 ircbot.SingleServerIRCBot.__init__(self, [(serveur, 6667)],
76 temporary_pseudo, "Parrot, le bot irc. [Codé par 20-100]", 10)
77 self.debug = debug
78 self.serveur = serveur
79 self.overops = config.overops
80 self.ops = self.overops + config.ops
81 self.report_bugs_to = config.report_bugs_to
82 self.chanlist = config.chanlist
83 self.stay_channels = config.stay_channels
84 self.quiet_channels = config.quiet_channels
85 self.last_perdu = 0
86
87 self.quotedb = quotes.QuoteDB()
88 self.reload_quotes()
89
90
91 ### Utilitaires
92 def _getnick(self):
93 """Récuère le nick effectif du bot sur le serveur."""
94 return self.serv.get_nickname()
95 nick = property(_getnick)
96
97 def give_me_my_pseudo(self, serv):
98 """Récupère le pseudo auprès de NickServ."""
99 serv.privmsg("NickServ", "GHOST %s %s" % (config.irc_pseudo, config.irc_password))
100 serv.privmsg("NickServ", "RELEASE %s %s" % (config.irc_pseudo, config.irc_password))
101 time.sleep(0.3)
102 serv.nick(config.irc_pseudo)
103
104 def pourmoi(self, serv, message):
105 """Renvoie (False, lemessage) ou (True, le message amputé de "pseudo: ")"""
106 pseudo = self.nick
107 pseudo = pseudo.decode("utf-8")
108 size = len(pseudo)
109 if message[:size] == pseudo and len(message) > size and message[size] == ":":
110 return (True, message[size+1:].lstrip(" "))
111 else:
112 return (False, message)
113
114 ### Exécution d'actions
115 def quitter(self, chan, leave_message=None):
116 """Quitter un channel avec un message customisable."""
117 if leave_message == None:
118 leave_message = random.choice(config.leave_messages)
119 self.serv.part(chan, message=leave_message.encode("utf8"))
120
121 def mourir(self):
122 """Se déconnecter du serveur IRC avec un message customisable."""
123 quit_message = random.choice(config.quit_messages)
124 self.die(msg=quit_message.encode("utf8"))
125
126 def reload_quotes(self):
127 """ Recharge la base de données des quotes et recompile la regexp de quote """
128 self.quotedb.load()
129 self.quote_pattern = re.compile(config.quote_regexp, flags=re.UNICODE)
130
131 def execute_reload(self, auteur=None):
132 """Recharge la config."""
133 reload(config)
134 self.reload_quotes()
135 if auteur in [None, "SIGHUP"]:
136 towrite = "Config reloaded" + " (SIGHUP received)" * (auteur == "SIGHUP")
137 for to in config.report_bugs_to:
138 self.serv.privmsg(to, towrite)
139 log(self.serveur, towrite)
140 return True, None
141 else:
142 return True, u"Config reloaded"
143
144 def crash(self, who="nobody", chan="nowhere"):
145 """Fait crasher le bot."""
146 where = "en privé" if chan == "priv" else "sur le chan %s" % chan
147 raise errors.CrashError((u"Crash demandé par %s %s" % (who, where)).encode("utf-8"))
148
149 ACTIONS = {
150 "reload" : execute_reload,
151 }
152
153 def execute_something(self, something, params, place=None, auteur=None):
154 """Exécute une action et répond son résultat à ``auteur``
155 sur un chan ou en privé en fonction de ``place``"""
156 action = self.ACTIONS[something]
157 success, message = action(self, **params)
158 if message:
159 if irclib.is_channel(place):
160 message = "%s: %s" % (auteur, message.encode("utf-8"))
161 self.serv.privmsg(place, message)
162 log(self.serveur, place, auteur, something + "%r" % params + ("[successful]" if success else "[failed]"))
163
164 ### Gestion des quotes
165 def enregistrer(self, author, content, timestamp):
166
167 quotes.save(self.quotelist, config.quote_file)
168
169
170 ### Surcharge des events du Bot
171 def on_welcome(self, serv, ev):
172 """À l'arrivée sur le serveur."""
173 self.serv = serv # ça serv ira :)
174 self.give_me_my_pseudo(serv)
175 serv.privmsg("NickServ", "IDENTIFY %s" % (config.irc_password))
176 log(self.serveur, "Connected")
177 if self.debug:
178 self.chanlist = ["#bot"]
179 for c in self.chanlist:
180 log(self.serveur, "JOIN %s" % (c))
181 serv.join(c)
182
183 def on_privmsg(self, serv, ev):
184 """À la réception d'un message en privé."""
185 if ignore_event(serv, ev):
186 return
187 message = ev.arguments()[0]
188 auteur = irclib.nm_to_n(ev.source())
189 try:
190 message = bot_unicode(message)
191 except errors.UnicodeBotError:
192 if config.utf8_trigger:
193 serv.privmsg(auteur, random.choice(config.utf8_fail_answers).encode("utf8"))
194 return
195 message = message.split()
196 cmd = message[0].lower()
197 notunderstood = False
198 if cmd == u"help":
199 op,overop=auteur in self.ops, auteur in self.overops
200 if len(message)==1:
201 helpmsg = config.helpmsg_default
202 if op:
203 helpmsg += config.helpmsg_ops
204 if overop:
205 helpmsg += config.helpmsg_overops
206 else:
207 helpmsgs = config.helpdico.get(message[1].lower(), ["Commande inconnue.", None, None])
208 helpmsg = helpmsgs[0]
209 if op and helpmsgs[1]:
210 if helpmsg:
211 helpmsg += "\n" + helpmsgs[1]
212 else:
213 helpmsg = helpmsgs[1]
214 if overop and helpmsgs[2]:
215 if helpmsg:
216 helpmsg += "\n" + helpmsgs[2]
217 else:
218 helpmsg = helpmsgs[2]
219 for ligne in helpmsg.split("\n"):
220 serv.privmsg(auteur, ligne.encode("utf-8"))
221 elif cmd == u"join":
222 if auteur in self.ops:
223 if len(message) > 1:
224 if message[1] in self.chanlist:
225 serv.privmsg(auteur, "Je suis déjà sur %s" % (message[1]))
226 else:
227 serv.join(message[1])
228 self.chanlist.append(message[1])
229 serv.privmsg(auteur, "Channels : " + " ".join(self.chanlist))
230 log(self.serveur, "priv", auteur, " ".join(message))
231 else:
232 serv.privmsg(auteur, "Channels : " + " ".join(self.chanlist))
233 else:
234 notunderstood = True
235 elif cmd == u"leave":
236 if auteur in self.ops and len(message) > 1:
237 if message[1] in self.chanlist:
238 if not (message[1] in self.stay_channels) or auteur in self.overops:
239 self.quitter(message[1].encode("utf-8"), " ".join(message[2:]))
240 self.chanlist.remove(message[1])
241 log(self.serveur, "priv", auteur, " ".join(message) + "[successful]")
242 else:
243 serv.privmsg(auteur, "Non, je reste !")
244 log(self.serveur, "priv", auteur, " ".join(message) + "[failed]")
245 else:
246 serv.privmsg(auteur, "Je ne suis pas sur %s" % (message[1]))
247 else:
248 notunderstood = True
249 elif cmd == u"stay":
250 if auteur in self.overops:
251 if len(message) > 1:
252 if message[1] in self.stay_channels:
253 log(self.serveur, "priv", auteur, " ".join(message) + "[failed]")
254 serv.privmsg(auteur, "Je stay déjà sur %s." % (message[1]))
255 else:
256 log(self.serveur, "priv", auteur, " ".join(message) + "[successful]")
257 self.stay_channels.append(message[1])
258 serv.privmsg(auteur, "Stay channels : " + " ".join(self.stay_channels))
259 else:
260 serv.privmsg(auteur, "Stay channels : " + " ".join(self.stay_channels))
261 else:
262 notunderstood = True
263 elif cmd == u"nostay":
264 if auteur in self.overops:
265 if len(message) > 1:
266 if message[1] in self.stay_channels:
267 log(self.serveur, "priv", auteur, " ".join(message) + "[successful]")
268 self.stay_channels.remove(message[1])
269 serv.privmsg(auteur, "Stay channels : " + " ".join(self.stay_channels))
270 else:
271 log(self.serveur, "priv", auteur, " ".join(message) + "[failed]")
272 serv.privmsg(auteur, "Je ne stay pas sur %s." % (message[1]))
273 else:
274 notunderstood = True
275 elif cmd == u"die":
276 if auteur in self.overops:
277 log(self.serveur, "priv", auteur, " ".join(message) + "[successful]")
278 self.mourir()
279 else:
280 notunderstood = True
281 elif cmd == u"crash":
282 if auteur in self.overops:
283 log(self.serveur, "priv", auteur, " ".join(message) + "[successful]")
284 self.crash(auteur, "priv")
285 else:
286 notunderstood = True
287 elif cmd == u"reload":
288 if auteur in self.ops:
289 self.execute_something("reload", {"auteur" : auteur}, place=auteur, auteur=auteur)
290 else:
291 notunderstood = True
292 elif cmd == u"quiet":
293 if auteur in self.ops:
294 if len(message) > 1:
295 if message[1] in self.quiet_channels:
296 serv.privmsg(auteur, "Je me la ferme déjà sur %s" % (message[1]))
297 log(self.serveur, "priv", auteur, " ".join(message) + "[failed]")
298 else:
299 self.quiet_channels.append(message[1])
300 serv.privmsg(auteur, "Quiet channels : " + " ".join(self.quiet_channels))
301 log(self.serveur, "priv", auteur, " ".join(message) + "[successful]")
302 else:
303 serv.privmsg(auteur, "Quiet channels : " + " ".join(self.quiet_channels))
304 else:
305 notunderstood = True
306 elif cmd == u"noquiet":
307 if auteur in self.ops:
308 if len(message) > 1:
309 if message[1] in self.quiet_channels:
310 self.quiet_channels.remove(message[1])
311 serv.privmsg(auteur, "Quiet channels : " + " ".join(self.quiet_channels))
312 log(self.serveur, "priv", auteur, " ".join(message) + "[successful]")
313 else:
314 serv.privmsg(auteur, "Je ne me la ferme pas sur %s." % (message[1]))
315 log(self.serveur, "priv", auteur, " ".join(message) + "[failed]")
316 else:
317 notunderstood = True
318 elif cmd == u"say":
319 if auteur in self.overops and len(message) > 2:
320 serv.privmsg(message[1].encode("utf-8"), (u" ".join(message[2:])).encode("utf-8"))
321 log(self.serveur, "priv", auteur, " ".join(message))
322 elif len(message) <= 2:
323 serv.privmsg(auteur, "Syntaxe : SAY <channel> <message>")
324 else:
325 notunderstood = True
326 elif cmd == u"do":
327 if auteur in self.overops and len(message) > 2:
328 serv.action(message[1], " ".join(message[2:]))
329 log(self.serveur, "priv", auteur, " ".join(message))
330 elif len(message) <= 2:
331 serv.privmsg(auteur, "Syntaxe : DO <channel> <action>")
332 else:
333 notunderstood = True
334 elif cmd == u"kick":
335 if auteur in self.overops and len(message) > 2:
336 serv.kick(message[1].encode("utf-8"), message[2].encode("utf-8"), " ".join(message[3:]).encode("utf-8"))
337 log(self.serveur, "priv", auteur, " ".join(message))
338 elif len(message) <= 2:
339 serv.privmsg(auteur, "Syntaxe : KICK <channel> <pseudo> [<raison>]")
340 else:
341 notunderstood = True
342 elif cmd == u"ops":
343 if auteur in self.overops:
344 serv.privmsg(auteur, " ".join(self.ops))
345 else:
346 notunderstood = True
347 elif cmd == u"overops":
348 if auteur in self.overops:
349 serv.privmsg(auteur, " ".join(self.overops))
350 else:
351 notunderstood = True
352 else:
353 notunderstood = True
354 if notunderstood:
355 serv.privmsg(auteur, "Je n'ai pas compris. Essayez HELP…")
356
357 def on_pubmsg(self, serv, ev):
358 """À la réception d'un message sur un channel."""
359 if ignore_event(serv, ev):
360 return
361 auteur = irclib.nm_to_n(ev.source())
362 canal = ev.target()
363 message = ev.arguments()[0]
364 try:
365 message = bot_unicode(message)
366 except errors.UnicodeBotError:
367 if config.utf8_trigger and not canal in self.quiet_channels:
368 serv.privmsg(canal, (u"%s: %s"% ( auteur, random.choice(config.utf8_fail_answers))).encode("utf8"))
369 return
370 pour_moi, message = self.pourmoi(serv, message)
371 if pour_moi and message.split()!=[]:
372 cmd = message.split()[0].lower()
373 try:
374 args = " ".join(message.split()[1:])
375 except:
376 args = ""
377 if cmd in [u"meurs", u"die", u"crève"]:
378 if auteur in self.overops:
379 log(self.serveur, canal, auteur, message + "[successful]")
380 self.mourir()
381 else:
382 serv.privmsg(canal,(u"%s: %s"%(auteur, random.choice(config.quit_fail_messages))).encode("utf8"))
383 log(self.serveur, canal, auteur, message + "[failed]")
384 elif cmd == u"reload":
385 if auteur in self.ops:
386 self.execute_something("reload", {"auteur" : auteur}, place=canal, auteur=auteur)
387 elif cmd == u"crash":
388 if auteur in self.overops:
389 self.crash(auteur, canal)
390 elif cmd in [u"part", u"leave", u"dégage", u"va-t-en"]:
391 if auteur in self.ops and (not (canal in self.stay_channels)
392 or auteur in self.overops):
393 self.quitter(canal)
394 log(self.serveur, canal, auteur, message + "[successful]")
395 if canal in self.chanlist:
396 self.chanlist.remove(canal)
397 else:
398 serv.privmsg(canal,(u"%s: %s" % (auteur, random.choice(config.leave_fail_messages))).encode("utf8"))
399 log(self.serveur, canal, auteur, message + "[failed]")
400
401 elif cmd in [u"ping"] and not canal in self.quiet_channels:
402 serv.privmsg(canal, "%s: pong" % (auteur))
403 else:
404 # Vu que ce bot est prévu pour parser des quotes il va falloir bosser ici
405 match = quote_pattern.match(message)
406 if match:
407 d = match.groupdict()
408 if self.quotedb.store(d["author"], d["content"]):
409 serv.privmsg(canal, (u"%s: Ce sera retenu, répété, amplifié" % (auteur,)).encode("utf-8"))
410 self.quotedb.save()
411 else:
412 serv.privmsg(canal, (u"%s: Je le savais déjà." % (auteur,)).encode("utf-8"))
413 if message.startswith(u"!quote"):
414 if message.strip() == u"!quote":
415 q = self.quotedb.random()
416 serv.privmsg(canal, str(q))
417 elif message.startswith("!quote "):
418 author = message[7:].strip()
419 try:
420 q = self.quotedb.randomfrom(author)
421 except IndexError:
422 serv.privmsg(canal, (u"Pas de quote de %s en mémoire." % author).encode("utf-8"))
423 return
424 serv.privmsg(canal, str(q))
425
426 def on_action(self, serv, ev):
427 """À la réception d'une action."""
428 if ignore_event(serv, ev):
429 return
430 action = ev.arguments()[0]
431 auteur = irclib.nm_to_n(ev.source())
432 channel = ev.target()
433 try:
434 action = bot_unicode(action)
435 except errors.UnicodeBotError:
436 if config.utf8_trigger and not channel in self.quiet_channels:
437 serv.privmsg(channel, (u"%s: %s"%(auteur,random.choice(config.utf8_fail_answers))).encode("utf8"))
438 return
439 mypseudo = self.nick
440
441 def on_kick(self, serv, ev):
442 """À la réception d'une action."""
443 auteur = irclib.nm_to_n(ev.source())
444 channel = ev.target()
445 victime = ev.arguments()[0]
446 raison = ev.arguments()[1]
447 if victime == self.nick:
448 log(self.serveur, "%s kické de %s par %s (raison : %s)" % (victime, channel, auteur, raison))
449 time.sleep(2)
450 serv.join(channel)
451
452 ### .fork trick
453 def start_as_daemon(self, outfile):
454 sys.stderr = Logger(outfile)
455 self.start()
456
457
458 class Logger(object):
459 """Pour écrire ailleurs que sur stdout"""
460 def __init__(self, filename="parrot.full.log"):
461 self.filename = filename
462
463 def write(self, message):
464 f = open(self.filename, "a")
465 f.write(message)
466 f.close()
467
468 def main():
469 """Exécution principale : lecture des paramètres et lancement du bot."""
470 if len(sys.argv) == 1:
471 print "Usage : parrot.py <serveur> [--debug] [--no-output] [--daemon [--pidfile]] [--outfile]"
472 print " --outfile sans --no-output ni --daemon n'a aucun effet"
473 exit(1)
474 serveur = sys.argv[1]
475 if "--daemon" in sys.argv:
476 thisfile = os.path.realpath(__file__)
477 thisdirectory = thisfile.rsplit("/", 1)[0]
478 os.chdir(thisdirectory)
479 daemon = True
480 else:
481 daemon = False
482 if "debug" in sys.argv or "--debug" in sys.argv:
483 debug = True
484 else:
485 debug = False
486 if "--quiet" in sys.argv:
487 config.debug_stdout = False
488 serveurs = {
489 "irc" : "irc.crans.org",
490 "crans" : "irc.crans.org",
491 "irc.crans.org" : "irc.crans.org"}
492 if "--no-output" in sys.argv or "--daemon" in sys.argv:
493 outfile = "/var/log/bots/parrot.full.log"
494 for arg in sys.argv:
495 arg = arg.split("=")
496 if arg[0].strip('-') in ["out", "outfile", "logfile"]:
497 outfile = arg[1]
498 sys.stdout = Logger(outfile)
499 try:
500 serveur = serveurs[serveur]
501 except KeyError:
502 print "Server Unknown : %s" % (serveur)
503 exit(404)
504 parrot = Parrot(serveur,debug)
505 # Si on reçoit un SIGHUP, on reload la config
506 def sighup_handler(signum, frame):
507 parrot.execute_reload(auteur="SIGHUP")
508 signal.signal(signal.SIGHUP, sighup_handler)
509 # Daemonization
510 if daemon:
511 child_pid = os.fork()
512 if child_pid == 0:
513 os.setsid()
514 parrot.start_as_daemon(outfile)
515 else:
516 # on enregistre le pid de parrot
517 pidfile = "/var/run/bots/parrot.pid"
518 for arg in sys.argv:
519 arg = arg.split("=")
520 if arg[0].strip('-') in ["pidfile"]:
521 pidfile = arg[1]
522 f = open(pidfile, "w")
523 f.write("%s\n" % child_pid)
524 f.close()
525 else:
526 parrot.start()
527
528 if __name__ == "__main__":
529 main()