basile.py

   1 #!/usr/bin/python
   2 # -*- coding:utf8 -*-
   3
   4 # Codé par 20-100 (commencé le 23/04/12)
   5
   6 """ Un bot IRC destiné à s'interfacer avec la Note Kfet 2015 """
   7
   8 import threading
   9 import random
  10 import time
  11 import json
  12 import re
  13 import os
  14 import signal
  15 import sys
  16
  17 # Oui, j'ai recodé ma version d'irclib pour pouvoir rattrapper les SIGHUP
  18 sys.path.insert(0, "/home/vincent/scripts/python-myirclib")
  19 import irclib
  20 import ircbot
  21
  22 from commands import getstatusoutput as ex
  23
  24 #: Config de basile
  25 import config
  26 #: Module responsable du dialogue avec la NoteKfet2015
  27 import nk
  28 #: Module de réponse aux questions de base
  29 import isit
  30 #: Module définissant les erreurs
  31 import errors
  32
  33 # la partie qui réfère au fichier lui-même est mieux ici
  34 # sinon on réfère la config et pas le fichier lui-même
  35 config.thisfile = os.path.realpath(__file__)
  36
  37 def get_config_logfile(serveur):
  38     """Renvoie le nom du fichier de log en fonction du ``serveur`` et de la config."""
  39     serveurs = {"acoeur.crans.org" : "acoeur",
  40                 "irc.crans.org" : "crans"}
  41     return config.logfile_template % (serveurs[serveur],)
  42
  43 def get_filesize():
  44     """Récupère la taille de ce fichier."""
  45     return ex("ls -s %s" % (config.thisfile))[1].split()[0]
  46
  47 def log(serveur, channel, auteur=None, message=None):
  48     """Enregistre une ligne de log."""
  49     if auteur == message == None:
  50         # alors c'est que c'est pas un channel mais juste une ligne de log
  51         chain = u"%s %s" % (time.strftime("%F %T"), channel)
  52     else:
  53         chain = u"%s [%s:%s] %s" % (time.strftime("%F %T"), channel, auteur, message)
  54     f = open(get_config_logfile(serveur), "a")
  55     f.write((chain + u"\n").encode("utf-8"))
  56     f.close()
  57     if config.debug_stdout:
  58         print chain.encode("utf-8")
  59
  60 def ignore_event(serv, ev):
  61     """Retourne ``True`` si il faut ignorer cet évènement."""
  62     for (blackmask, exceptlist) in config.blacklisted_masks:
  63         usermask = ev.source()
  64         blackit = bool(irclib.mask_matches(usermask, blackmask))
  65         exceptit = any([bool(irclib.mask_matches(usermask, exceptmask)) for exceptmask in exceptlist])
  66         if exceptit: # Il est exempté
  67             return False
  68         else:
  69             if blackit: # Il n'est pas exempté et matche la blacklist
  70                 return True
  71
  72
  73 def bot_unicode(chain):
  74     """Essaye de décoder ``chain`` en UTF-8.
  75        Lève une py:class:`errors.UnicodeBotError` en cas d'échec."""
  76     try:
  77         return chain.decode("utf8")
  78     except UnicodeDecodeError as exc:
  79         raise errors.UnicodeBotError
  80
  81
  82 class Basile(ircbot.SingleServerIRCBot):
  83     """Classe principale : définition du bot Basile."""
  84     def __init__(self, serveur, debug=False):
  85         temporary_pseudo = config.irc_pseudo + str(random.randrange(10000,100000))
  86         ircbot.SingleServerIRCBot.__init__(self, [(serveur, 6667)],
  87                               temporary_pseudo, "Basile, le bot irc. [Codé par 20-100]", 10)
  88         self.debug = debug
  89         self.serveur = serveur
  90         self.overops = config.overops
  91         self.ops = self.overops + config.ops
  92         self.report_bugs_to = config.report_bugs_to
  93         self.chanlist = config.chanlist
  94         self.identities = json.load(open(config.identities_file, "r"))
  95         self.stay_channels = config.stay_channels
  96         self.quiet_channels = config.quiet_channels
  97         self.last_perdu = 0
  98
  99     ### Communication NK
 100     def new_connection_NK(self, serv, username, password, typ="bdd"):
 101         """Renvoie (``True``, <une socket ouverte et authentifiée sur la NoteKfet2015>)
 102            ou bien (``False``, None)"""
 103         try:
 104             login_result, sock = nk.login(username, password, typ)
 105             info, retcode, errmsg = login_result["msg"], login_result["retcode"], login_result["errmsg"]
 106         except nk.NKRefused as exc:
 107             for report in self.report_bugs_to:
 108                 serv.privmsg(report, "Le Serveur NK2015 est down.")
 109             return (False, None, None)
 110         except nk.NKHelloFailed as exc:
 111             for report in self.report_bugs_to:
 112                 serv.privmsg(report,
 113                              "La version du protocole utilisée n'est pas supportée par le serveur NK2015.")
 114             return (False, None, None)
 115         except nk.NKUnknownError as exc:
 116             erreurs = ["Une fucking erreur inconnue s'est produite"]
 117             erreurs += str(exc).split("\n")
 118             for report in self.report_bugs_to:
 119                 for err in erreurs:
 120                     serv.privmsg(report, err)
 121             return (False, None, None)
 122         except Exception as exc:
 123             # Exception qui ne vient pas de la communication avec le serveur NK2015
 124             log(self.serveur, "Erreur dans new_connection_NK\n" + str(exc))
 125             return (False, None, None)
 126         if retcode == 0:
 127             return (True, info, sock)
 128         else:
 129             return (False, None, None)
 130
 131     ### Utilitaires
 132     def _getnick(self):
 133         """Récuère le nick effectif du bot sur le serveur."""
 134         return self.serv.get_nickname()
 135     nick = property(_getnick)
 136
 137     def give_me_my_pseudo(self, serv):
 138         """Récupère le pseudo auprès de NickServ."""
 139         serv.privmsg("NickServ", "RECOVER %s %s" % (config.irc_pseudo, config.irc_password))
 140         serv.privmsg("NickServ", "RELEASE %s %s" % (config.irc_pseudo, config.irc_password))
 141         time.sleep(0.3)
 142         serv.nick(config.irc_pseudo)
 143
 144     def pourmoi(self, serv, message):
 145         """Renvoie (False, lemessage) ou (True, le message amputé de "pseudo: ")"""
 146         pseudo = self.nick
 147         pseudo = pseudo.decode("utf-8")
 148         size = len(pseudo)
 149         if message[:size] == pseudo and len(message) > size and message[size] == ":":
 150             return (True, message[size+1:].lstrip(" "))
 151         else:
 152             return (False, message)
 153
 154     ### Exécution d'actions
 155     def lost(self, serv, channel, forced=False):
 156         """Réaction à un trigger de perdu.
 157            Annonce "J'ai perdu" sur le channel si on n'a pas perdu depuis un certain temps."""
 158         if self.last_perdu + config.time_between_perdu < time.time() or forced:
 159             if not channel in self.quiet_channels or forced:
 160                 serv.privmsg(channel, "J'ai perdu !")
 161             self.last_perdu=time.time()
 162             delay=config.time_between_perdu_trigger
 163             delta=config.time_between_perdu_trigger_delta
 164             serv.execute_delayed(random.randrange(delay-delta,delay+delta),self.lost,(serv,channel))
 165
 166     def quitter(self, chan, leave_message=None):
 167         """Quitter un channel avec un message customisable."""
 168         if leave_message == None:
 169             leave_message = random.choice(config.leave_messages)
 170         self.serv.part(chan, message=leave_message.encode("utf8"))
 171
 172     def mourir(self):
 173         """Se déconnecter du serveur IRC avec un message customisable."""
 174         quit_message = random.choice(config.quit_messages)
 175         self.die(msg=quit_message.encode("utf8"))
 176
 177     def execute_reload(self, auteur=None):
 178         """Recharge la config."""
 179         reload(config)
 180         isit.regexp_compile()
 181         if auteur in [None, "SIGHUP"]:
 182             towrite = "Config reloaded" + " (SIGHUP received)" * (auteur == "SIGHUP")
 183             for to in config.report_bugs_to:
 184                 self.serv.privmsg(to, towrite)
 185             log(self.serveur, towrite)
 186             return True, None
 187         else:
 188             return True, u"Config reloaded"
 189
 190     def crash(self, who="nobody", chan="nowhere"):
 191         """Fait crasher le bot."""
 192         where = "en privé" if chan == "priv" else "sur le chan %s" % chan
 193         raise errors.CrashError((u"Crash demandé par %s %s" % (who, where)).encode("utf-8"))
 194
 195     ACTIONS = {
 196         "reload" : execute_reload,
 197         }
 198
 199     def execute_something(self, something, params, place=None, auteur=None):
 200         """Exécute une action et répond son résultat à ``auteur``
 201            sur un chan ou en privé en fonction de ``place``"""
 202         action = self.ACTIONS[something]
 203         success, message = action(self, **params)
 204         if message:
 205             if irclib.is_channel(place):
 206                 message = "%s: %s" % (auteur, message.encode("utf-8"))
 207             self.serv.privmsg(place, message)
 208         log(self.serveur, place, auteur, something + "%r" % params + ("[successful]" if success else "[failed]"))
 209
 210     ### Surcharge des events du Bot
 211     def on_welcome(self, serv, ev):
 212         """À l'arrivée sur le serveur."""
 213         self.serv = serv # ça serv ira :)
 214         self.give_me_my_pseudo(serv)
 215         serv.privmsg("NickServ", "IDENTIFY %s" % (config.irc_password))
 216         log(self.serveur, "Connected")
 217         if self.debug:
 218             self.chanlist = ["#bot"]
 219         for c in self.chanlist:
 220             log(self.serveur, "JOIN %s" % (c))
 221             serv.join(c)
 222         # on ouvre la connexion note de Basile, special user
 223         self.nk = self.new_connection_NK(serv, config.note_pseudo, config.note_password, "special")[2]
 224         if self.nk == None:
 225             for report in self.report_bugs_to:
 226                 serv.privmsg(report, "Connection to NK2015 failed, invalid password ?")
 227
 228     def on_privmsg(self, serv, ev):
 229         """À la réception d'un message en privé."""
 230         if ignore_event(serv, ev):
 231             return
 232         message = ev.arguments()[0]
 233         auteur = irclib.nm_to_n(ev.source())
 234         try:
 235             message = bot_unicode(message)
 236         except errors.UnicodeBotError:
 237             if config.utf8_trigger:
 238                 serv.privmsg(auteur, random.choice(config.utf8_fail_answers).encode("utf8"))
 239             return
 240         message = message.split()
 241         cmd = message[0].lower()
 242         notunderstood = False
 243         if cmd == u"help":
 244             op,overop=auteur in self.ops, auteur in self.overops
 245             if len(message)==1:
 246                 helpmsg = config.helpmsg_default
 247                 if op:
 248                     helpmsg += config.helpmsg_ops
 249                 if overop:
 250                     helpmsg += config.helpmsg_overops
 251             else:
 252                 helpmsgs = config.helpdico.get(message[1].lower(), ["Commande inconnue.", None, None])
 253                 helpmsg = helpmsgs[0]
 254                 if op and helpmsgs[1]:
 255                     if helpmsg:
 256                         helpmsg += "\n" + helpmsgs[1]
 257                     else:
 258                         helpmsg = helpmsgs[1]
 259                 if overop and helpmsgs[2]:
 260                     if helpmsg:
 261                         helpmsg += "\n" + helpmsgs[2]
 262                     else:
 263                         helpmsg = helpmsgs[2]
 264             for ligne in helpmsg.split("\n"):
 265                 serv.privmsg(auteur, ligne.encode("utf-8"))
 266         elif cmd == u"identify":
 267             if len(message) == 1:
 268                 if self.identities.has_key(auteur):
 269                     serv.privmsg(auteur, "Je vous connais sous le pseudo note %s." % (
 270                                      self.identities[auteur]["pseudo"].encode("utf8")))
 271                 else:
 272                     serv.privmsg(auteur, "Je ne connais pas votre pseudo note.")
 273             elif len(message) >= 3:
 274                 username, password = message[1], " ".join(message[2:])
 275                 success, info, _ = self.new_connection_NK(serv, username, password)
 276                 if success:
 277                     log(self.serveur, "priv", auteur, " ".join(message) + "[successful]")
 278                     serv.privmsg(auteur, "Identité enregistrée.")
 279                     self.identities[auteur] = info
 280                     json.dump(self.identities, open(config.identities_file,"w"))
 281                 else:
 282                     log(self.serveur, "priv", auteur, " ".join(message) + "[failed]")
 283                     serv.privmsg(auteur, "Mot de passe invalide. (ou serveur down)")
 284             else:
 285                 serv.privmsg(auteur, "Syntaxe : IDENTIFY [<username> <password>]")
 286         elif cmd == u"drop":
 287             if len(message) > 1:
 288                 if self.identities.has_key(auteur):
 289                     password = " ".join(message[1:])
 290                     success, _, _ = self.new_connection_NK(serv, self.identities[auteur], password)
 291                     if success:
 292                         del self.identities[auteur]
 293                         log(self.serveur, "priv", auteur, " ".join(message) + "[successful]")
 294                         json.dump(self.identities, open(config.identities_file, "w"))
 295                         serv.privmsg(auteur, "Identité oubliée.")
 296                     else:
 297                         log(self.serveur, "priv", auteur, " ".join(message) + "[failed]")
 298                         serv.privmsg(auteur, "Mot de passe invalide. (ou serveur down)")
 299                 else:
 300                     serv.privmsg(auteur, "Je ne connais pas ton pseudo note.")
 301             else:
 302                 serv.privmsg(auteur, "Syntaxe : DROP <password>")
 303         elif cmd == u"join":
 304             if auteur in self.ops:
 305                 if len(message) > 1:
 306                     if message[1] in self.chanlist:
 307                         serv.privmsg(auteur, (u"Je suis déjà sur %s" % (message[1])).encode("utf-8"))
 308                     else:
 309                         serv.join(message[1])
 310                         self.chanlist.append(message[1])
 311                         serv.privmsg(auteur, "Channels : " + " ".join(self.chanlist))
 312                         log(self.serveur, "priv", auteur, " ".join(message))
 313                 else:
 314                     serv.privmsg(auteur, "Channels : " + " ".join(self.chanlist))
 315             else:
 316                 notunderstood = True
 317         elif cmd == u"leave":
 318             if auteur in self.ops and len(message) > 1:
 319                 if message[1] in self.chanlist:
 320                     if not (message[1] in self.stay_channels) or auteur in self.overops:
 321                         self.quitter(message[1].encode("utf-8"), " ".join(message[2:]))
 322                         self.chanlist.remove(message[1])
 323                         log(self.serveur, "priv", auteur, " ".join(message) + "[successful]")
 324                     else:
 325                         serv.privmsg(auteur, "Non, je reste !")
 326                         log(self.serveur, "priv", auteur, " ".join(message) + "[failed]")
 327                 else:
 328                     serv.privmsg(auteur, "Je ne suis pas sur %s" % (message[1]))
 329             else:
 330                 notunderstood = True
 331         elif cmd == u"stay":
 332             if auteur in self.overops:
 333                 if len(message) > 1:
 334                     if message[1] in self.stay_channels:
 335                         log(self.serveur, "priv", auteur, " ".join(message) + "[failed]")
 336                         serv.privmsg(auteur, "Je stay déjà sur %s." % (message[1]))
 337                     else:
 338                         log(self.serveur, "priv", auteur, " ".join(message) + "[successful]")
 339                         self.stay_channels.append(message[1])
 340                         serv.privmsg(auteur, "Stay channels : " + " ".join(self.stay_channels))
 341                 else:
 342                     serv.privmsg(auteur, "Stay channels : " + " ".join(self.stay_channels))
 343             else:
 344                 notunderstood = True
 345         elif cmd == u"nostay":
 346             if auteur in self.overops:
 347                 if len(message) > 1:
 348                     if message[1] in self.stay_channels:
 349                         log(self.serveur, "priv", auteur, " ".join(message) + "[successful]")
 350                         self.stay_channels.remove(message[1])
 351                         serv.privmsg(auteur, "Stay channels : " + " ".join(self.stay_channels))
 352                     else:
 353                         log(self.serveur, "priv", auteur, " ".join(message) + "[failed]")
 354                         serv.privmsg(auteur, "Je ne stay pas sur %s." % (message[1]))
 355             else:
 356                 notunderstood = True
 357         elif cmd == u"die":
 358             if auteur in self.overops:
 359                 log(self.serveur, "priv", auteur, " ".join(message) + "[successful]")
 360                 self.mourir()
 361             else:
 362                 notunderstood = True
 363         elif cmd == u"crash":
 364             if auteur in self.overops:
 365                 log(self.serveur, "priv", auteur, " ".join(message) + "[successful]")
 366                 self.crash(auteur, "priv")
 367             else:
 368                 notunderstood = True
 369         elif cmd == u"reload":
 370             if auteur in self.ops:
 371                 self.execute_something("reload", {"auteur" : auteur}, place=auteur, auteur=auteur)
 372             else:
 373                 notunderstood = True
 374         elif cmd == u"reconnect":
 375             if auteur in self.ops:
 376                 try:
 377                     self.nk = self.new_connection_NK(serv, config.note_pseudo,
 378                                             config.note_password, "special")[2]
 379                 except Exception as exc:
 380                     self.nk = None
 381                     log(self.serveur, 'Erreur dans on_pubmsg/"cmd in ["reconnect"]\n' + str(exc))
 382                 if self.nk != None:
 383                     serv.privmsg(auteur, "%s: done" % (auteur))
 384                     log(self.serveur, "priv", auteur, " ".join(message) + "[successful]")
 385                 else:
 386                     serv.privmsg(auteur, "%s: failed" % (auteur))
 387                     log(self.serveur, "priv", auteur, " ".join(message) + "[failed]")
 388                     for report in self.report_bugs_to:
 389                         serv.privmsg(report, "Connection to NK2015 failed, invalid password ? Server dead ?")
 390             else:
 391                 notunderstood = True
 392         elif cmd == u"quiet":
 393             if auteur in self.ops:
 394                 if len(message) > 1:
 395                     if message[1] in self.quiet_channels:
 396                         serv.privmsg(auteur, "Je me la ferme déjà sur %s" % (message[1]))
 397                         log(self.serveur, "priv", auteur, " ".join(message) + "[failed]")
 398                     else:
 399                         self.quiet_channels.append(message[1])
 400                         serv.privmsg(auteur, "Quiet channels : " + " ".join(self.quiet_channels))
 401                         log(self.serveur, "priv", auteur, " ".join(message) + "[successful]")
 402                 else:
 403                     serv.privmsg(auteur, "Quiet channels : " + " ".join(self.quiet_channels))
 404             else:
 405                 notunderstood = True
 406         elif cmd == u"noquiet":
 407             if auteur in self.ops:
 408                 if len(message) > 1:
 409                     if message[1] in self.quiet_channels:
 410                         self.quiet_channels.remove(message[1])
 411                         serv.privmsg(auteur, "Quiet channels : " + " ".join(self.quiet_channels))
 412                         log(self.serveur, "priv", auteur, " ".join(message) + "[successful]")
 413                     else:
 414                         serv.privmsg(auteur, "Je ne me la ferme pas sur %s." % (message[1]))
 415                         log(self.serveur, "priv", auteur, " ".join(message) + "[failed]")
 416             else:
 417                 notunderstood = True
 418         elif cmd == u"say":
 419             if auteur in self.overops and len(message) > 2:
 420                 serv.privmsg(message[1].encode("utf-8"), (u" ".join(message[2:])).encode("utf-8"))
 421                 log(self.serveur, "priv", auteur, " ".join(message))
 422             elif len(message) <= 2:
 423                 serv.privmsg(auteur, "Syntaxe : SAY <channel> <message>")
 424             else:
 425                 notunderstood = True
 426         elif cmd == u"do":
 427             if auteur in self.overops and len(message) > 2:
 428                 serv.action(message[1], " ".join(message[2:]))
 429                 log(self.serveur, "priv", auteur, " ".join(message))
 430             elif len(message) <= 2:
 431                 serv.privmsg(auteur, "Syntaxe : DO <channel> <action>")
 432             else:
 433                 notunderstood = True
 434         elif cmd == u"kick":
 435             if auteur in self.overops and len(message) > 2:
 436                 serv.kick(message[1].encode("utf-8"), message[2].encode("utf-8"), " ".join(message[3:]).encode("utf-8"))
 437                 log(self.serveur, "priv", auteur, " ".join(message))
 438             elif len(message) <= 2:
 439                 serv.privmsg(auteur, "Syntaxe : KICK <channel> <pseudo> [<raison>]")
 440             else:
 441                 notunderstood = True
 442         elif cmd == u"lost":
 443             if auteur in self.ops and len(message) > 1:
 444                 serv.privmsg(message[1], "J'ai perdu !")
 445                 log(self.serveur, "priv", auteur, " ".join(message))
 446             elif len(message) <= 1:
 447                 serv.privmsg(auteur, "Syntaxe : LOST <channel>")
 448             else:
 449                 notunderstood = True
 450         elif cmd == u"solde":
 451             if len(message) == 1:
 452                 if self.identities.has_key(auteur):
 453                     success, solde, pseudo = nk.get_solde(self.nk, self.identities[auteur]["idbde"], serv, auteur)
 454                     if success:
 455                         serv.privmsg(auteur, "%.2f (%s)" % (solde/100.0, pseudo.encode("utf8")))
 456                     log(self.serveur, "priv", auteur, " ".join(message) + ("[successful]" if success else "[failed]"))
 457                 else:
 458                     serv.privmsg(canal, "Je ne connais pas ton pseudo note.")
 459         elif cmd == u"ops":
 460             if auteur in self.overops:
 461                 serv.privmsg(auteur, " ".join(self.ops))
 462             else:
 463                 notunderstood = True
 464         elif cmd == u"overops":
 465             if auteur in self.overops:
 466                 serv.privmsg(auteur, " ".join(self.overops))
 467             else:
 468                 notunderstood = True
 469         else:
 470             notunderstood = True
 471         if notunderstood:
 472             serv.privmsg(auteur, "Je n'ai pas compris. Essayez HELP…")
 473
 474     def on_pubmsg(self, serv, ev):
 475         """À la réception d'un message sur un channel."""
 476         if ignore_event(serv, ev):
 477             return
 478         auteur = irclib.nm_to_n(ev.source())
 479         canal = ev.target()
 480         message = ev.arguments()[0]
 481         try:
 482             message = bot_unicode(message)
 483         except errors.UnicodeBotError:
 484             if config.utf8_trigger and not canal in self.quiet_channels:
 485                 serv.privmsg(canal, (u"%s: %s"% ( auteur, random.choice(config.utf8_fail_answers))).encode("utf8"))
 486             return
 487         pour_moi, message = self.pourmoi(serv, message)
 488         if pour_moi and message.split()!=[]:
 489             cmd = message.split()[0].lower()
 490             try:
 491                 args = " ".join(message.split()[1:])
 492             except:
 493                 args = ""
 494             if cmd in [u"meurs", u"die", u"crève"]:
 495                 if auteur in self.overops:
 496                     log(self.serveur, canal, auteur, message + "[successful]")
 497                     self.mourir()
 498                 else:
 499                     serv.privmsg(canal,(u"%s: %s"%(auteur, random.choice(config.quit_fail_messages))).encode("utf8"))
 500                     log(self.serveur, canal, auteur, message + "[failed]")
 501             elif cmd == u"reload":
 502                 if auteur in self.ops:
 503                     self.execute_something("reload", {"auteur" : auteur}, place=canal, auteur=auteur)
 504             elif cmd == u"crash":
 505                 if auteur in self.overops:
 506                     self.crash(auteur, canal)
 507             elif cmd in [u"part", u"leave", u"dégage", u"va-t-en", u"tut'tiresailleurs,c'estmesgalets"]:
 508                 if auteur in self.ops and (not (canal in self.stay_channels)
 509                                            or auteur in self.overops):
 510                     self.quitter(canal)
 511                     log(self.serveur, canal, auteur, message + "[successful]")
 512                     if canal in self.chanlist:
 513                         self.chanlist.remove(canal)
 514                 else:
 515                     serv.privmsg(canal,(u"%s: %s" % (auteur, random.choice(config.leave_fail_messages))).encode("utf8"))
 516                     log(self.serveur, canal, auteur, message + "[failed]")
 517
 518             elif cmd == u"reconnect":
 519                 if auteur in self.ops:
 520                     try:
 521                         self.nk = self.new_connection_NK(serv, config.note_pseudo,
 522                                               config.note_password, "special")[2]
 523                     except Exception as exc:
 524                         self.nk = None
 525                         log(self.serveur, 'Erreur dans on_pubmsg/"cmd in ["reconnect"]\n' + str(exc))
 526                     if self.nk != None:
 527                         serv.privmsg(canal, "%s: done" % (auteur))
 528                         log(self.serveur, canal, auteur, message + "[successful]")
 529                     else:
 530                         serv.privmsg(canal, "%s: failed" % (auteur))
 531                         log(self.serveur, canal, auteur, message + "[failed]")
 532                         for report in self.report_bugs_to:
 533                             serv.privmsg(report, "Connection to NK2015 failed, invalid password ? Server dead ?")
 534                 else:
 535                     serv.privmsg(canal, "%s: %s" % (auteur, random.choice(config.pas_programme_pour_tobeir).encode("utf8")))
 536                     log(self.serveur, canal, auteur, message + "[failed]")
 537
 538             elif cmd in [u"deviens", u"pseudo"]:
 539                 if auteur in self.ops:
 540                     become = args
 541                     serv.nick(become)
 542                     log(self.serveur, canal, auteur, message + "[successful]")
 543
 544             if cmd in [u"meur", u"meurt", u"meurre", u"meurres"] and not canal in self.quiet_channels:
 545                 serv.privmsg(canal, '%s: Mourir, impératif, 2ème personne du singulier : "meurs" (de rien)' % (auteur))
 546             elif cmd in [u"ping"] and not canal in self.quiet_channels:
 547                 serv.privmsg(canal, "%s: pong" % (auteur))
 548
 549             elif cmd in [u"solde", u"!solde", u"!coca"] or cmd.startswith("!"):
 550                 if self.identities.has_key(auteur):
 551                     idbde = self.identities[auteur]["idbde"]
 552                     if cmd in [u"solde", u"!solde"]:
 553                         success, solde, pseudo = nk.get_solde(self.nk, self.identities[auteur]["idbde"], serv, canal)
 554                         if success:
 555                             serv.privmsg(canal, "%s: %s (%s)" % (auteur, float(solde)/100, pseudo.encode("utf8")))
 556                     elif cmd in [u"!coca"] or cmd.startswith("!"):
 557                         success = nk.consomme(self.nk, self.identities[auteur]["idbde"], message[1:], serv, canal)
 558                     log(self.serveur, canal, auteur, message + ("[successful]" if success else "[failed]"))
 559                 else:
 560                     serv.privmsg(canal, "%s: Je ne connais pas votre pseudo note." % (auteur))
 561                     log(self.serveur, canal, auteur, message + "[unknown]")
 562             elif (re.match("(pain au chocolat|chocolatine)", message.lower())
 563                  and not canal in self.quiet_channels):
 564                 serv.action(canal, "sert un pain au chocolat à %s" % (auteur))
 565             elif re.match("manzana",message.lower()) and not canal in self.quiet_channels:
 566                 if auteur in config.manzana:
 567                     serv.action(canal, "sert une bouteille de manzana à %s" % (auteur))
 568                 elif auteur in config.manzana_bis:
 569                     serv.action(canal, "sert un grand verre de jus de pomme à %s : tout le monde sait qu'il ne boit pas." % (auteur))
 570                 else:
 571                     serv.action(canal, "sert un verre de manzana à %s" % (auteur))
 572             if isit.is_insult(message) and not canal in self.quiet_channels:
 573                 if isit.is_not_insult(message):
 574                     answer = random.choice(config.compliment_answers)
 575                     for ligne in answer.split("\n"):
 576                         serv.privmsg(canal, "%s: %s" % (auteur, ligne.encode("utf8")))
 577                 else:
 578                     answer = random.choice(config.insultes_answers)
 579                     for ligne in answer.split("\n"):
 580                         serv.privmsg(canal, "%s: %s" % (auteur, ligne.encode("utf8")))
 581             elif isit.is_compliment(message) and not canal in self.quiet_channels:
 582                 answer = random.choice(config.compliment_answers)
 583                 for ligne in answer.split("\n"):
 584                     serv.privmsg(canal, "%s: %s" % (auteur,ligne.encode("utf8")))
 585             gros_match = isit.is_gros(message)
 586             if gros_match and not canal in self.quiet_channels:
 587                 taille = get_filesize()
 588                 answer = u"Mais non, je ne suis pas %s, %sKo tout au plus…" % (gros_match.groups()[0], taille)
 589                 serv.privmsg(canal, "%s: %s"%(auteur, answer.encode("utf8")))
 590             if isit.is_tesla(message) and not canal in self.quiet_channels:
 591                 l1, l2 = config.tesla_answers, config.tesla_actions
 592                 n1, n2 = len(l1), len(l2)
 593                 i = random.randrange(n1 + n2)
 594                 if i >= n1:
 595                     serv.action(canal, l2[i - n1].encode("utf8"))
 596                 else:
 597                     serv.privmsg(canal, "%s: %s" % (auteur, l1[i].encode("utf8")))
 598             if isit.is_tamere(message) and not canal in self.quiet_channels:
 599                 answer = random.choice(config.tamere_answers)
 600                 for ligne in answer.split("\n"):
 601                     serv.privmsg(canal, "%s: %s"%(auteur, ligne.encode("utf8")))
 602             if isit.is_tag(message) and not canal in self.quiet_channels:
 603                 if auteur in self.ops:
 604                     action = random.choice(config.tag_actions)
 605                     serv.action(canal, action.encode("utf8"))
 606                     self.quiet_channels.append(canal)
 607                 else:
 608                     answer = random.choice(config.tag_answers)
 609                     for ligne in answer.split("\n"):
 610                         serv.privmsg(canal, "%s: %s" % (auteur, ligne.encode("utf8")))
 611             if isit.is_merci(message):
 612                 answer = random.choice(config.merci_answers)
 613                 for ligne in answer.split("\n"):
 614                     serv.privmsg(canal, "%s: %s"%(auteur, ligne.encode("utf8")))
 615             out = re.match(ur"^([A-Z[]|\\|[0-9]+|(¹|²|³|⁴|⁵|⁶|⁷|⁸|⁹|⁰)+)(?:| \?| !)$", message.upper())
 616             if re.match("ma bite dans ton oreille", message) and not canal in self.quiet_channels:
 617                 serv.privmsg(canal, "%s: Seul un olasd peut imiter un olasd dans un de ses grands jours !" % (auteur))
 618             if out and not canal in self.quiet_channels:
 619                 out = out.groups()[0]
 620                 try:
 621                     iout = int(out)
 622                     serv.privmsg(canal, "%s: %s !" % (auteur, iout + 1))
 623                     if iout == 2147483647:
 624                         serv.privmsg(canal, "%s: Ciel, un maxint ! Heureusement que je suis en python…" % (auteur))
 625                         return
 626                     if iout + 1 > 1000 and random.randrange(4) == 0:
 627                         serv.privmsg(canal, "%s: Vous savez, moi et les chiffres…" % (auteur))
 628                         return
 629                 except Exception as exc:
 630                     pass
 631                 if re.match("[A-Y]", out):
 632                     alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
 633                     serv.privmsg(canal, "%s: %s !"%(auteur, alphabet[alphabet.index(out) + 1]))
 634                 elif out == "Z":
 635                     serv.privmsg(canal, "%s: Je ne vous remercie pas, j'ai l'air idiot ainsi… [ ?" % (auteur))
 636                 elif out in "[\\":
 637                     serv.privmsg(canal, "%s: Nous devrions nous en tenir là, ça va finir par poser des problèmes…" % (auteur))
 638                 elif re.match(ur"(¹|²|³|⁴|⁵|⁶|⁷|⁸|⁹|⁰)+", out):
 639                     def translate(mess):
 640                         return "".join([{u"⁰¹²³⁴⁵⁶⁷⁸⁹0123456789"[i]:u"0123456789⁰¹²³⁴⁵⁶⁷⁸⁹"[i]
 641                                         for i in range(20)}[j]
 642                                        for j in mess])
 643                     out = int(translate(out))
 644                     serv.privmsg(canal,"%s: %s !" % (auteur, translate(str(out + 1)).encode("utf8")))
 645             if isit.is_bonjour(message) and not canal in self.quiet_channels:
 646                 if isit.is_night():
 647                     answer = random.choice(config.night_answers)
 648                 elif isit.is_day():
 649                     answer = random.choice(config.bonjour_answers)
 650                 else:
 651                     answer = random.choice(config.bonsoir_answers)
 652                 serv.privmsg(canal, answer.format(auteur).encode("utf8"))
 653             if isit.is_bonne_nuit(message) and not canal in self.quiet_channels:
 654                 answer = random.choice(config.bonne_nuit_answers)
 655                 serv.privmsg(canal, answer.format(auteur).encode("utf8"))
 656             if isit.is_pan(message) and not canal in self.quiet_channels:
 657                 serv.privmsg(canal, "%s: ce n'est pas sur moi qu'il faut tirer, même si je sais que j'attire l'œil !" % (auteur))
 658         else:
 659             if message in [u"!pain au chocolat", u"!chocolatine"] and not canal in self.quiet_channels:
 660                 serv.action(canal, "sert un pain au chocolat à %s" % (auteur))
 661             if message in [u"!manzana"] and not canal in self.quiet_channels:
 662                 if auteur in config.manzana:
 663                     serv.action(canal, "sert une bouteille de manzana à %s" % (auteur))
 664                 elif auteur in config.manzana_bis:
 665                     serv.action(canal, "sert un grand verre de jus de pomme à %s : tout le monde sait qu'il ne boit pas." % (auteur))
 666                 else:
 667                     serv.action(canal, "sert un verre de manzana à %s" % (auteur))
 668             if re.match(u'^ *(.|§|!|/|/|:|)(w|b) [0-9]+$', message) and not canal in self.quiet_channels:
 669                 failanswers = config.buffer_fail_answers
 670                 answer = random.choice(failanswers)
 671                 serv.privmsg(canal, ("%s: %s"%(auteur,answer)).encode("utf8"))
 672             if not canal in self.quiet_channels:
 673                 mypseudo = self.nick
 674                 if re.match((u"^(" + u"|".join(config.bonjour_triggers)
 675                                    + ur")( {}| all| tout le monde| (à )?tous)(\.| ?!)?$"
 676                              ).format(mypseudo).lower(), message.strip().lower()):
 677                     answer = random.choice(config.bonjour_answers)
 678                     serv.privmsg(canal, answer.format(auteur).encode("utf8"))
 679         if (isit.is_perdu(message) and not canal in self.quiet_channels):
 680             # proba de perdre sur trigger :
 681             #  avant 30min (enfin, config) : 0
 682             #  ensuite, +25%/30min, linéairement
 683             deltat = time.time() - self.last_perdu
 684             barre = (deltat - config.time_between_perdu)/(2*3600.0)
 685             if random.uniform(0, 1) < barre:
 686                 serv.privmsg(canal, "%s: J'ai perdu !" % (auteur))
 687                 self.last_perdu = time.time()
 688
 689     def on_action(self, serv, ev):
 690         """À la réception d'une action."""
 691         if ignore_event(serv, ev):
 692             return
 693         action = ev.arguments()[0]
 694         auteur = irclib.nm_to_n(ev.source())
 695         channel = ev.target()
 696         try:
 697             action = bot_unicode(action)
 698         except errors.UnicodeBotError:
 699             if config.utf8_trigger and not channel in self.quiet_channels:
 700                 serv.privmsg(channel, (u"%s: %s"%(auteur,random.choice(config.utf8_fail_answers))).encode("utf8"))
 701             return
 702         mypseudo = self.nick
 703
 704         if isit.is_bad_action_trigger(action, mypseudo) and not channel in self.quiet_channels:
 705             l1, l2 = config.bad_action_answers, config.bad_action_actions
 706             n1, n2 = len(l1), len(l2)
 707             i = random.randrange(n1 + n2)
 708             if i >= n1:
 709                 serv.action(channel, l2[i - n1].format(auteur).encode("utf8"))
 710             else:
 711                 serv.privmsg(channel, l1[i].format(auteur).encode("utf8"))
 712         if isit.is_good_action_trigger(action, mypseudo) and not channel in self.quiet_channels:
 713             l1, l2 = config.good_action_answers, config.good_action_actions
 714             n1, n2 = len(l1), len(l2)
 715             i = random.randrange(n1 + n2)
 716             if i >= n1:
 717                 serv.action(channel, l2[i-n1].format(auteur).encode("utf8"))
 718             else:
 719                 serv.privmsg(channel, l1[i].format(auteur).encode("utf8"))
 720
 721     def on_kick(self, serv, ev):
 722         """À la réception d'une action."""
 723         auteur = irclib.nm_to_n(ev.source())
 724         channel = ev.target()
 725         victime = ev.arguments()[0]
 726         raison = ev.arguments()[1]
 727         if victime == self.nick:
 728             log(self.serveur, u"%s kické de %s par %s (raison : %s)" % (victime, channel.decode("utf-8"), auteur, raison))
 729             time.sleep(2)
 730             serv.join(channel)
 731             l1, l2 = config.kick_answers, config.kick_actions
 732             n1, n2 = len(l1), len(l2)
 733             i = random.randrange(n1 + n2)
 734             if i >= n1:
 735                 serv.action(channel, l2[i-n1].format(auteur).encode("utf8"))
 736             else:
 737                 serv.privmsg(channel, l1[i].format(auteur).encode("utf8"))
 738
 739     ### .fork trick
 740     def start_as_daemon(self, outfile):
 741         sys.stderr = Logger(outfile)
 742         self.start()
 743
 744
 745 class Logger(object):
 746     """Pour écrire ailleurs que sur stdout"""
 747     def __init__(self, filename="basile.full.log"):
 748         self.filename = filename
 749
 750     def write(self, message):
 751         f = open(self.filename, "a")
 752         f.write(message)
 753         f.close()
 754
 755 def main():
 756     """Exécution principal : lecture des paramètres et lancement du bot."""
 757     if len(sys.argv) == 1:
 758         print "Usage : basile.py <serveur> [--debug] [--no-output] [--daemon [--pidfile]] [--outfile]"
 759         print "        --outfile sans --no-output ni --daemon n'a aucun effet"
 760         exit(1)
 761     serveur = sys.argv[1]
 762     if "--daemon" in sys.argv:
 763         thisfile = os.path.realpath(__file__)
 764         thisdirectory = thisfile.rsplit("/", 1)[0]
 765         os.chdir(thisdirectory)
 766         daemon = True
 767     else:
 768         daemon = False
 769     if "debug" in sys.argv or "--debug" in sys.argv:
 770         debug = True
 771     else:
 772         debug = False
 773     if "--quiet" in sys.argv:
 774         config.debug_stdout = False
 775     serveurs = {"a♡" : "acoeur.crans.org",
 776               "acoeur" : "acoeur.crans.org",
 777               "acoeur.crans.org" : "acoeur.crans.org",
 778               "irc" : "irc.crans.org",
 779               "crans" : "irc.crans.org",
 780               "irc.crans.org" : "irc.crans.org"}
 781     if "--no-output" in sys.argv or "--daemon" in sys.argv:
 782         outfile = "/var/log/bots/basile.full.log"
 783         for arg in sys.argv:
 784             arg = arg.split("=")
 785             if arg[0].strip('-') in ["out", "outfile", "logfile"]:
 786                 outfile = arg[1]
 787         sys.stdout = Logger(outfile)
 788     try:
 789         serveur = serveurs[serveur]
 790     except KeyError:
 791         print "Server Unknown : %s" % (serveur)
 792         exit(404)
 793     basile = Basile(serveur,debug)
 794     # Si on reçoit un SIGHUP, on reload la config
 795     def sighup_handler(signum, frame):
 796         basile.execute_reload(auteur="SIGHUP")
 797     signal.signal(signal.SIGHUP, sighup_handler)
 798     # Daemonization
 799     if daemon:
 800         child_pid = os.fork()
 801         if child_pid == 0:
 802             os.setsid()
 803             basile.start_as_daemon(outfile)
 804         else:
 805             # on enregistre le pid de basile
 806             pidfile = "/var/run/bots/basile.pid"
 807             for arg in sys.argv:
 808                 arg = arg.split("=")
 809                 if arg[0].strip('-') in ["pidfile"]:
 810                     pidfile = arg[1]
 811             f = open(pidfile, "w")
 812             f.write("%s\n" % child_pid)
 813             f.close()
 814     else:
 815         basile.start()
 816
 817 if __name__ == "__main__":
 818     main()