]> gitweb.pimeys.fr Git - bots/parrot.git/commitdiff
Init : bot IRC fonctionnel mais coquille vide
authorVincent Le Gallic <legallic@crans.org>
Fri, 31 Jan 2014 01:43:38 +0000 (02:43 +0100)
committerVincent Le Gallic <legallic@crans.org>
Fri, 31 Jan 2014 01:43:38 +0000 (02:43 +0100)
.gitignore [new file with mode: 0644]
config.py [new file with mode: 0644]
errors.py [new file with mode: 0644]
initscript [new file with mode: 0755]
parrot.py [new file with mode: 0755]

diff --git a/.gitignore b/.gitignore
new file mode 100644 (file)
index 0000000..c45d5ee
--- /dev/null
@@ -0,0 +1,32 @@
+# Custom #
+###################
+*~
+*.json
+
+# Compiled source #
+###################
+*.pyc
+
+# Packages #
+############
+# it's better to unpack these files and commit the raw source
+# git has its own built in compression methods
+*.7z
+*.dmg
+*.gz
+*.iso
+*.jar
+*.rar
+*.tar
+*.zip
+
+# Logs #
+######################
+*.log
+
+# OS generated files #
+######################
+.DS_Store*
+*ehthumbs.db
+Icon?
+*Thumbs.db
diff --git a/config.py b/config.py
new file mode 100644 (file)
index 0000000..c650d46
--- /dev/null
+++ b/config.py
@@ -0,0 +1,110 @@
+#!/usr/bin/python
+# -*- encoding: utf-8 -*-
+
+""" Configuration de Basile """
+
+#: Faut-il débuguer sur la sortie standard par défaut ?
+debug_stdout = True
+
+## La config irc-related
+#: Mot de passe NickServ. TODO : le mettre dans un secrets.py
+irc_password = "1iuh0HiJKWjuE"
+#: Pseudo IRC
+irc_pseudo = "Parrot"
+#: Liste des channels à rejoindre
+chanlist = ["#bot", "#flood"]
+#: Liste des channels à ne pas quitter
+stay_channels = ["#bot", "#flood"]
+#: Liste des channels où se taire
+quiet_channels = []
+
+#: Le template des noms de fichier de log
+logfile_template = "parrot.%s.log"
+
+#: Les OVEROPs, tous les droits sur le bot
+overops=["[20-100]","[20-100]_c"]
+#: Les OPs, moins de droits que les OVEROPs
+ops=[]
+#: À qui s'adresser (par IRC) quand le bot rencontre une erreur
+report_bugs_to=["[20-100]"]
+
+#: config UTF8-fail
+utf8_fail_answers = [u"« Encodings : you need to stop the pain » ~ Ned Batchelder"]
+#: Doit-on râler en cas de fial d'UTF-8
+utf8_trigger = True
+
+#: config "tais-toi"
+tag_triggers = [u"t(|a)g", u"ta gueule", u"la ferme", u"ferme( |-)la", u"tais-toi", u"chut", u"tu fais trop de bruit", u"tu parles trop"]
+tag_actions = [u"ne citera plus"]
+tag_answers = [
+u"« Un grand pouvoir implique de grandes responsabilités » ~ Oncle Ben.",
+]
+
+#: config on m'a demandé de mourir/partir
+quit_messages = [u"« » ~ "]
+leave_messages = quit_messages
+
+quit_fail_messages = [u" « » ~ "]
+leave_fail_messages = quit_fail_messages
+
+#: Aide sur les commandes
+helpdico = {
+"help" : [u"""HELP <commande>
+ Affiche de l'aide sur la commande""", None, None],
+
+"join" : [None, u"""JOIN <channel>
+ Me fait rejoindre le channel""", None],
+
+"leave" : [None, u"""LEAVE <channel>
+ Me fait quitter le channel (sauf s'il est dans ma stay_list).""", None],
+
+"quiet" : [None, u"""QUIET <channel>
+ Me rend silencieux sur le channel.""", None],
+
+"noquiet" : [None, u"""NOQUIET <channel>
+ Me rend la parole sur le channel.""", None],
+
+"lost" : [None, u"""LOST <channel>
+ Me fait perdre sur le channel.""", None],
+
+"reload" : [None, u"""RELOAD
+ Recharge la configuration.""", None],
+
+"say" : [None, None, u"""SAY <channel> <message>
+ Me fait parler sur le channel."""],
+
+"do" : [None, None, u"""DO <channel> <action>
+ Me fait faitre une action (/me) sur le channel."""],
+
+"stay" : [None, None, u"""STAY <channel>
+ Ajoute le channel à ma stay_list."""],
+
+"nostay" : [None, None, u"""NOSTAY <channel>
+ Retire le channel de ma stay_list."""],
+
+"ops" :  [None, None, u"""OPS
+ Affiche la liste des ops."""],
+
+"overops" : [None, None, u"""OVEROPS
+ Affiche la liste des overops."""],
+
+"kick" : [None, None, u"""KICK <channel> <pseudo> [<raison>]
+ Kicke <pseudo> du channel (Il faut bien entendu que j'y sois op)."""],
+
+"die" : [None, None, u"""DIE
+ Me déconnecte du serveur IRC."""],
+
+"crash" : [None, None, u"""CRASH
+ Me fait crasher"""]
+ }
+
+#: Message d'aide par défaut
+helpmsg_default = u"Liste des commandes disponibles :\nHELP"
+#: Message d'aide par défaut à ajouter pour les OPs
+helpmsg_ops = u" JOIN LEAVE QUIET NOQUIET RELOAD"
+#: Message d'aide par défaut à ajouter pour les OVEROPs
+helpmsg_overops = u" SAY DO STAY NOSTAY OPS OVEROPS KICK DIE CRASH"
+
+#: Liste de paires de masques ``[black, exceptlist]`` : on blacklistera ce qui match ``black``
+#: et aucun élément de ``exceptlist``
+blacklisted_masks = [("Flo!*@*", [])]
diff --git a/errors.py b/errors.py
new file mode 100644 (file)
index 0000000..6b5e87a
--- /dev/null
+++ b/errors.py
@@ -0,0 +1,13 @@
+#!/usr/bin/python
+# -*- encoding: utf-8 -*-
+
+""" Erreurs utilisables dans le code du bot """
+
+class UnicodeBotError(Exception):
+    """Erreur levée si quelqu'un fait du caca avec son encodage."""
+    pass
+
+class CrashError(Exception):
+    """Pour pouvoir faire crasher Basile, parce que ça a l'air drôle."""
+    def __init__(self, msg=""):
+        Exception.__init__(self, msg)
diff --git a/initscript b/initscript
new file mode 100755 (executable)
index 0000000..cf14e9c
--- /dev/null
@@ -0,0 +1,218 @@
+#! /bin/sh
+### BEGIN INIT INFO
+# Provides:          parrot
+# Required-Start:    $remote_fs $syslog
+# Required-Stop:     $remote_fs $syslog
+# Default-Start:     2 3 4 5
+# Default-Stop:      0 1 6
+# Short-Description: Parrot, le bot IRC
+# Description:       Parrot est un bot IRC codé par 20-100
+#                    Il retient et ressort des quotes
+### END INIT INFO
+
+# Author: Vincent Le Gallic <legallic@crans.org>
+
+# Do NOT "set -e"
+
+# PATH should only include /usr/* if it runs after the mountnfs.sh script
+PATH=/sbin:/usr/sbin:/bin:/usr/bin
+DESC="bot IRC quoter"
+PYTHON=/usr/bin/python
+BASENAME=parrot
+DIRECTORY=/home/parrot/parrot
+SCRIPT=$DIRECTORY/$BASENAME.py
+EXEC="$PYTHON $SCRIPT"
+USER=parrot
+SCRIPT_ARGS="crans --daemon"
+PIDDIR=/var/run/bots/
+PIDFILE=$PIDDIR$BASENAME.pid
+SCRIPTNAME=/etc/init.d/$BASENAME
+
+
+# Load the VERBOSE setting and other rcS variables
+. /lib/init/vars.sh
+
+# Define LSB log_* functions.
+# Depend on lsb-base (>= 3.2-14) to ensure that this file is present
+# and status_of_proc is working.
+. /lib/lsb/init-functions
+
+_repair()
+{
+       # Répare /var/run/bots si il était pas bon
+       mkdir -p $PIDDIR
+       chown root:bots $PIDDIR
+       chmod g+w $PIDDIR
+}
+
+# To check if the process is running
+_check_is_running()
+{
+       # On récupère le PID (écrit dans ce fichier par le script la dernière fois qu'il a été lancé)
+       pid=`cat $PIDFILE`
+       # On va voir si le process tourne toujours
+       test -x /proc/$pid || return 1 # aucun process de ce PID ne tourne
+       # On regarde si il a les bons arguments
+       egrep -q ^$PYTHON /proc/$pid/cmdline || return 1 # il y a bien un process de ce PID, mais ce n'est pas python
+       grep -q $SCRIPT /proc/$pid/cmdline || return 1 # il y a bien un PID, c'est bien python, mais il ne lance pas le bot
+       return 0
+}
+
+_is_running()
+{
+       test -x $PIDDIR
+        if [ $? -ne 0 ]
+        then
+               _repair
+       fi
+       if test -f $PIDFILE
+       then
+               _check_is_running
+               return $?
+       else
+               touch $PIDFILE 2>&1 >/dev/null
+               chown $USER:bots $PIDFILE 2>&1 >/dev/null
+               if test -f $PIDFILE
+               then
+                       _check_is_running
+                       return $?
+               else
+                       echo -n "Failed to read $PIDFILE"
+                       return 0
+               fi
+       fi
+}
+#
+# Function that starts the daemon
+#
+do_start()
+{
+       # Return
+       #   0 if daemon has been started
+       #   1 if daemon was already running
+       #   2 if daemon could not be started
+       if _is_running
+       then
+               return 1
+       else
+               sudo -u $USER $PYTHON $SCRIPT $SCRIPT_ARGS
+               [ "$?" = 0 ] || return 2
+       fi
+}
+
+#
+# Function that stops the daemon
+#
+do_stop()
+{
+       # Return
+       #   0 if daemon has been stopped
+       #   1 if daemon was already stopped
+       #   2 if daemon could not be stopped
+       #   other if a failure occurred
+       if _is_running
+       then
+               pid=`cat $PIDFILE`
+               kill -15 $pid
+               if [ "$?" = 0 ]
+               then
+                       return 0
+               else
+                       sleep 10
+                       kill -9 $pid
+               fi
+       else
+               return 1
+       fi
+}
+
+#
+# Function that sends a SIGHUP to the daemon
+#
+do_reload() {
+       # Return
+       #   0 if reload has been done
+       #   1 if daemon was not running
+       #   2 if reload could not be achieved
+       if _is_running
+       then
+               pid=`cat $PIDFILE`
+               kill -1 $pid
+               [ "$?" = 0 ] || return 2
+       else
+               return 1
+       fi
+}
+
+#
+# The actual initscript
+#
+case "$1" in
+  start)
+       log_daemon_msg "Starting $DESC" "$BASENAME"
+       do_start
+       case "$?" in
+               0) log_end_msg 0 ;;
+               1) echo -n " was already running"; log_end_msg 1 ;;
+               2) log_end_msg 1 ;;
+       esac
+       ;;
+  stop)
+       log_daemon_msg "Stopping $DESC" "$BASENAME"
+       do_stop
+       case "$?" in
+               0) log_end_msg 0 ;;
+               1) echo -n " was not running"; log_end_msg 1 ;;
+               2) log_end_msg 1 ;;
+       esac
+       ;;
+  status)
+       if _is_running
+       then
+               log_action_msg "$BASENAME is running"
+       else
+               log_action_msg "$BASENAME is NOT running"
+       fi
+       ;;
+  reload|force-reload)
+       log_daemon_msg "Reloading $DESC" "$BASENAME"
+       do_reload
+       case "$?" in
+               0) log_end_msg 0 ;;
+               1) echo -n " was not running"; log_end_msg 1 ;;
+               2) log_end_msg 1;;
+       esac
+       ;;
+  restart)
+       log_daemon_msg "Restarting $DESC" "$BASENAME"
+       do_stop
+       case "$?" in
+         0|1)
+               do_start
+               case "$?" in
+                       0) log_end_msg 0 ;;
+                       1) log_end_msg 1 ;; # Old process is still running
+                       *) log_end_msg 1 ;; # Failed to start
+               esac
+               ;;
+         *)
+               # Failed to stop
+               log_end_msg 1
+               ;;
+       esac
+       ;;
+  running)
+       if _is_running
+       then
+               echo "Running"
+       else
+               echo "Not running"
+       fi
+       ;;
+  *)
+       log_action_msg "Usage: $SCRIPTNAME {start|stop|status|restart|reload|force-reload}" >&2
+       exit 3
+       ;;
+esac
+
+true
diff --git a/parrot.py b/parrot.py
new file mode 100755 (executable)
index 0000000..6da8e7a
--- /dev/null
+++ b/parrot.py
@@ -0,0 +1,495 @@
+#!/usr/bin/python
+# -*- encoding: utf-8 -*-
+
+""" Un bot IRC qui enregistre et ressort des citations """
+
+import threading
+import random
+import time
+import json
+import re
+import os
+import signal
+import sys
+
+# Oui, j'ai recodé ma version d'irclib pour pouvoir rattrapper les SIGHUP
+sys.path.insert(0, "/home/vincent/scripts/python-myirclib")
+import irclib
+import ircbot
+
+from commands import getstatusoutput as ex
+
+#: Config du bot
+import config
+#: Module définissant les erreurs
+import errors
+
+
+def get_config_logfile(serveur):
+    """Renvoie le nom du fichier de log en fonction du ``serveur`` et de la config."""
+    serveurs = {"irc.crans.org" : "crans"}
+    return config.logfile_template % (serveurs[serveur],)
+
+def log(serveur, channel, auteur=None, message=None):
+    """Enregistre une ligne de log."""
+    if auteur == message == None:
+        # alors c'est que c'est pas un channel mais juste une ligne de log
+        chain = u"%s %s" % (time.strftime("%F %T"), channel)
+    else:
+        chain = u"%s [%s:%s] %s" % (time.strftime("%F %T"), channel, auteur, message)
+    f = open(get_config_logfile(serveur), "a")
+    f.write((chain + u"\n").encode("utf-8"))
+    f.close()
+    if config.debug_stdout:
+        print chain.encode("utf-8")
+
+def ignore_event(serv, ev):
+    """Retourne ``True`` si il faut ignorer cet évènement."""
+    for (blackmask, exceptlist) in config.blacklisted_masks:
+        usermask = ev.source()
+        blackit = bool(irclib.mask_matches(usermask, blackmask))
+        exceptit = any([bool(irclib.mask_matches(usermask, exceptmask)) for exceptmask in exceptlist])
+        if exceptit: # Il est exempté
+            return False
+        else:
+            if blackit: # Il n'est pas exempté et matche la blacklist
+                return True
+
+
+def bot_unicode(chain):
+    """Essaye de décoder ``chain`` en UTF-8.
+       Lève une py:class:`errors.UnicodeBotError` en cas d'échec."""
+    try:
+        return chain.decode("utf8")
+    except UnicodeDecodeError as exc:
+        raise errors.UnicodeBotError
+
+
+class Parrot(ircbot.SingleServerIRCBot):
+    """Classe principale : définition du bot."""
+    def __init__(self, serveur, debug=False):
+        temporary_pseudo = config.irc_pseudo + str(random.randrange(10000,100000))
+        ircbot.SingleServerIRCBot.__init__(self, [(serveur, 6667)],
+                              temporary_pseudo, "Parrot, le bot irc. [Codé par 20-100]", 10)
+        self.debug = debug
+        self.serveur = serveur
+        self.overops = config.overops
+        self.ops = self.overops + config.ops
+        self.report_bugs_to = config.report_bugs_to
+        self.chanlist = config.chanlist
+        self.stay_channels = config.stay_channels
+        self.quiet_channels = config.quiet_channels
+        self.last_perdu = 0
+    
+    ### Utilitaires
+    def _getnick(self):
+        """Récuère le nick effectif du bot sur le serveur."""
+        return self.serv.get_nickname()
+    nick = property(_getnick)
+    
+    def give_me_my_pseudo(self, serv):
+        """Récupère le pseudo auprès de NickServ."""
+        serv.privmsg("NickServ", "RECOVER %s %s" % (config.irc_pseudo, config.irc_password))
+        serv.privmsg("NickServ", "RELEASE %s %s" % (config.irc_pseudo, config.irc_password))
+        time.sleep(0.3)
+        serv.nick(config.irc_pseudo)
+    
+    def pourmoi(self, serv, message):
+        """Renvoie (False, lemessage) ou (True, le message amputé de "pseudo: ")"""
+        pseudo = self.nick
+        pseudo = pseudo.decode("utf-8")
+        size = len(pseudo)
+        if message[:size] == pseudo and len(message) > size and message[size] == ":":
+            return (True, message[size+1:].lstrip(" "))
+        else:
+            return (False, message)
+    
+    ### Exécution d'actions
+    def quitter(self, chan, leave_message=None):
+        """Quitter un channel avec un message customisable."""
+        if leave_message == None:
+            leave_message = random.choice(config.leave_messages)
+        self.serv.part(chan, message=leave_message.encode("utf8"))
+    
+    def mourir(self):
+        """Se déconnecter du serveur IRC avec un message customisable."""
+        quit_message = random.choice(config.quit_messages)
+        self.die(msg=quit_message.encode("utf8"))
+    
+    def execute_reload(self, auteur=None):
+        """Recharge la config."""
+        reload(config)
+        isit.regexp_compile()
+        if auteur in [None, "SIGHUP"]:
+            towrite = "Config reloaded" + " (SIGHUP received)" * (auteur == "SIGHUP")
+            for to in config.report_bugs_to:
+                self.serv.privmsg(to, towrite)
+            log(self.serveur, towrite)
+            return True, None
+        else:
+            return True, u"Config reloaded"
+    
+    def crash(self, who="nobody", chan="nowhere"):
+        """Fait crasher le bot."""
+        where = "en privé" if chan == "priv" else "sur le chan %s" % chan
+        raise errors.CrashError((u"Crash demandé par %s %s" % (who, where)).encode("utf-8"))
+    
+    ACTIONS = {
+        "reload" : execute_reload,
+        }
+    
+    def execute_something(self, something, params, place=None, auteur=None):
+        """Exécute une action et répond son résultat à ``auteur``
+           sur un chan ou en privé en fonction de ``place``"""
+        action = self.ACTIONS[something]
+        success, message = action(self, **params)
+        if message:
+            if irclib.is_channel(place):
+                message = "%s: %s" % (auteur, message.encode("utf-8"))
+            self.serv.privmsg(place, message)
+        log(self.serveur, place, auteur, something + "%r" % params + ("[successful]" if success else "[failed]"))
+    
+    ### Gestion des quotes
+    
+    
+    ### Surcharge des events du Bot
+    def on_welcome(self, serv, ev):
+        """À l'arrivée sur le serveur."""
+        self.serv = serv # ça serv ira :)
+        self.give_me_my_pseudo(serv)
+        serv.privmsg("NickServ", "IDENTIFY %s" % (config.irc_password))
+        log(self.serveur, "Connected")
+        if self.debug:
+            self.chanlist = ["#bot"]
+        for c in self.chanlist:
+            log(self.serveur, "JOIN %s" % (c))
+            serv.join(c)
+
+    def on_privmsg(self, serv, ev):
+        """À la réception d'un message en privé."""
+        if ignore_event(serv, ev):
+            return
+        message = ev.arguments()[0]
+        auteur = irclib.nm_to_n(ev.source())
+        try:
+            message = bot_unicode(message)
+        except errors.UnicodeBotError:
+            if config.utf8_trigger:
+                serv.privmsg(auteur, random.choice(config.utf8_fail_answers).encode("utf8"))
+            return
+        message = message.split()
+        cmd = message[0].lower()
+        notunderstood = False
+        if cmd == u"help":
+            op,overop=auteur in self.ops, auteur in self.overops
+            if len(message)==1:
+                helpmsg = config.helpmsg_default
+                if op:
+                    helpmsg += config.helpmsg_ops
+                if overop:
+                    helpmsg += config.helpmsg_overops
+            else:
+                helpmsgs = config.helpdico.get(message[1].lower(), ["Commande inconnue.", None, None])
+                helpmsg = helpmsgs[0]
+                if op and helpmsgs[1]:
+                    if helpmsg:
+                        helpmsg += "\n" + helpmsgs[1]
+                    else:
+                        helpmsg = helpmsgs[1]
+                if overop and helpmsgs[2]:
+                    if helpmsg:
+                        helpmsg += "\n" + helpmsgs[2]
+                    else:
+                        helpmsg = helpmsgs[2]
+            for ligne in helpmsg.split("\n"):
+                serv.privmsg(auteur, ligne.encode("utf-8"))
+        elif cmd == u"join":
+            if auteur in self.ops:
+                if len(message) > 1:
+                    if message[1] in self.chanlist:
+                        serv.privmsg(auteur, "Je suis déjà sur %s" % (message[1]))
+                    else:
+                        serv.join(message[1])
+                        self.chanlist.append(message[1])
+                        serv.privmsg(auteur, "Channels : " + " ".join(self.chanlist))
+                        log(self.serveur, "priv", auteur, " ".join(message))
+                else:
+                    serv.privmsg(auteur, "Channels : " + " ".join(self.chanlist))
+            else:
+                notunderstood = True
+        elif cmd == u"leave":
+            if auteur in self.ops and len(message) > 1:
+                if message[1] in self.chanlist:
+                    if not (message[1] in self.stay_channels) or auteur in self.overops:
+                        self.quitter(message[1].encode("utf-8"), " ".join(message[2:]))
+                        self.chanlist.remove(message[1])
+                        log(self.serveur, "priv", auteur, " ".join(message) + "[successful]")
+                    else:
+                        serv.privmsg(auteur, "Non, je reste !")
+                        log(self.serveur, "priv", auteur, " ".join(message) + "[failed]")
+                else:
+                    serv.privmsg(auteur, "Je ne suis pas sur %s" % (message[1]))
+            else:
+                notunderstood = True
+        elif cmd == u"stay":
+            if auteur in self.overops:
+                if len(message) > 1:
+                    if message[1] in self.stay_channels:
+                        log(self.serveur, "priv", auteur, " ".join(message) + "[failed]")
+                        serv.privmsg(auteur, "Je stay déjà sur %s." % (message[1]))
+                    else:
+                        log(self.serveur, "priv", auteur, " ".join(message) + "[successful]")
+                        self.stay_channels.append(message[1])
+                        serv.privmsg(auteur, "Stay channels : " + " ".join(self.stay_channels))
+                else:
+                    serv.privmsg(auteur, "Stay channels : " + " ".join(self.stay_channels))
+            else:
+                notunderstood = True
+        elif cmd == u"nostay":
+            if auteur in self.overops:
+                if len(message) > 1:
+                    if message[1] in self.stay_channels:
+                        log(self.serveur, "priv", auteur, " ".join(message) + "[successful]")
+                        self.stay_channels.remove(message[1])
+                        serv.privmsg(auteur, "Stay channels : " + " ".join(self.stay_channels))
+                    else:
+                        log(self.serveur, "priv", auteur, " ".join(message) + "[failed]")
+                        serv.privmsg(auteur, "Je ne stay pas sur %s." % (message[1]))
+            else:
+                notunderstood = True
+        elif cmd == u"die":
+            if auteur in self.overops:
+                log(self.serveur, "priv", auteur, " ".join(message) + "[successful]")
+                self.mourir()
+            else:
+                notunderstood = True
+        elif cmd == u"crash":
+            if auteur in self.overops:
+                log(self.serveur, "priv", auteur, " ".join(message) + "[successful]")
+                self.crash(auteur, "priv")
+            else:
+                notunderstood = True
+        elif cmd == u"reload":
+            if auteur in self.ops:
+                self.execute_something("reload", {"auteur" : auteur}, place=auteur, auteur=auteur)
+            else:
+                notunderstood = True
+        elif cmd == u"quiet":
+            if auteur in self.ops:
+                if len(message) > 1:
+                    if message[1] in self.quiet_channels:
+                        serv.privmsg(auteur, "Je me la ferme déjà sur %s" % (message[1]))
+                        log(self.serveur, "priv", auteur, " ".join(message) + "[failed]")
+                    else:
+                        self.quiet_channels.append(message[1])
+                        serv.privmsg(auteur, "Quiet channels : " + " ".join(self.quiet_channels))
+                        log(self.serveur, "priv", auteur, " ".join(message) + "[successful]")
+                else:
+                    serv.privmsg(auteur, "Quiet channels : " + " ".join(self.quiet_channels))
+            else:
+                notunderstood = True
+        elif cmd == u"noquiet":
+            if auteur in self.ops:
+                if len(message) > 1:
+                    if message[1] in self.quiet_channels:
+                        self.quiet_channels.remove(message[1])
+                        serv.privmsg(auteur, "Quiet channels : " + " ".join(self.quiet_channels))
+                        log(self.serveur, "priv", auteur, " ".join(message) + "[successful]")
+                    else:
+                        serv.privmsg(auteur, "Je ne me la ferme pas sur %s." % (message[1]))
+                        log(self.serveur, "priv", auteur, " ".join(message) + "[failed]")
+            else:
+                notunderstood = True
+        elif cmd == u"say":
+            if auteur in self.overops and len(message) > 2:
+                serv.privmsg(message[1].encode("utf-8"), (u" ".join(message[2:])).encode("utf-8"))
+                log(self.serveur, "priv", auteur, " ".join(message))
+            elif len(message) <= 2:
+                serv.privmsg(auteur, "Syntaxe : SAY <channel> <message>")
+            else:
+                notunderstood = True
+        elif cmd == u"do":
+            if auteur in self.overops and len(message) > 2:
+                serv.action(message[1], " ".join(message[2:]))
+                log(self.serveur, "priv", auteur, " ".join(message))
+            elif len(message) <= 2:
+                serv.privmsg(auteur, "Syntaxe : DO <channel> <action>")
+            else:
+                notunderstood = True
+        elif cmd == u"kick":
+            if auteur in self.overops and len(message) > 2:
+                serv.kick(message[1].encode("utf-8"), message[2].encode("utf-8"), " ".join(message[3:]).encode("utf-8"))
+                log(self.serveur, "priv", auteur, " ".join(message))
+            elif len(message) <= 2:
+                serv.privmsg(auteur, "Syntaxe : KICK <channel> <pseudo> [<raison>]")
+            else:
+                notunderstood = True
+        elif cmd == u"ops":
+            if auteur in self.overops:
+                serv.privmsg(auteur, " ".join(self.ops))
+            else:
+                notunderstood = True
+        elif cmd == u"overops":
+            if auteur in self.overops:
+                serv.privmsg(auteur, " ".join(self.overops))
+            else:
+                notunderstood = True
+        else:
+            notunderstood = True
+        if notunderstood:
+            serv.privmsg(auteur, "Je n'ai pas compris. Essayez HELP…")
+    
+    def on_pubmsg(self, serv, ev):
+        """À la réception d'un message sur un channel."""
+        if ignore_event(serv, ev):
+            return
+        auteur = irclib.nm_to_n(ev.source())
+        canal = ev.target()
+        message = ev.arguments()[0]
+        try:
+            message = bot_unicode(message)
+        except errors.UnicodeBotError:
+            if config.utf8_trigger and not canal in self.quiet_channels:
+                serv.privmsg(canal, (u"%s: %s"% ( auteur, random.choice(config.utf8_fail_answers))).encode("utf8"))
+            return
+        pour_moi, message = self.pourmoi(serv, message)
+        if pour_moi and message.split()!=[]:
+            cmd = message.split()[0].lower()
+            try:
+                args = " ".join(message.split()[1:])
+            except:
+                args = ""
+            if cmd in [u"meurs", u"die", u"crève"]:
+                if auteur in self.overops:
+                    log(self.serveur, canal, auteur, message + "[successful]")
+                    self.mourir()
+                else:
+                    serv.privmsg(canal,(u"%s: %s"%(auteur, random.choice(config.quit_fail_messages))).encode("utf8"))
+                    log(self.serveur, canal, auteur, message + "[failed]")
+            elif cmd == u"reload":
+                if auteur in self.ops:
+                    self.execute_something("reload", {"auteur" : auteur}, place=canal, auteur=auteur)
+            elif cmd == u"crash":
+                if auteur in self.overops:
+                    self.crash(auteur, canal)
+            elif cmd in [u"part", u"leave", u"dégage", u"va-t-en"]:
+                if auteur in self.ops and (not (canal in self.stay_channels)
+                                           or auteur in self.overops):
+                    self.quitter(canal)
+                    log(self.serveur, canal, auteur, message + "[successful]")
+                    if canal in self.chanlist:
+                        self.chanlist.remove(canal)
+                else:
+                    serv.privmsg(canal,(u"%s: %s" % (auteur, random.choice(config.leave_fail_messages))).encode("utf8"))
+                    log(self.serveur, canal, auteur, message + "[failed]")
+    
+            elif cmd in [u"ping"] and not canal in self.quiet_channels:
+                serv.privmsg(canal, "%s: pong" % (auteur))
+        else:
+            # Vu que ce bot est prévu pour parser des quotes il va falloir bosser ici
+            pass
+
+    def on_action(self, serv, ev):
+        """À la réception d'une action."""
+        if ignore_event(serv, ev):
+            return
+        action = ev.arguments()[0]
+        auteur = irclib.nm_to_n(ev.source())
+        channel = ev.target()
+        try:
+            action = bot_unicode(action)
+        except errors.UnicodeBotError:
+            if config.utf8_trigger and not channel in self.quiet_channels:
+                serv.privmsg(channel, (u"%s: %s"%(auteur,random.choice(config.utf8_fail_answers))).encode("utf8"))
+            return
+        mypseudo = self.nick
+        
+    def on_kick(self, serv, ev):
+        """À la réception d'une action."""
+        auteur = irclib.nm_to_n(ev.source())
+        channel = ev.target()
+        victime = ev.arguments()[0]
+        raison = ev.arguments()[1]
+        if victime == self.nick:
+            log(self.serveur, u"%s kické de %s par %s (raison : %s)" % (victime, channel.decode("utf-8"), auteur, raison))
+            time.sleep(2)
+            serv.join(channel)
+    
+    ### .fork trick
+    def start_as_daemon(self, outfile):
+        sys.stderr = Logger(outfile)
+        self.start()
+    
+
+class Logger(object):
+    """Pour écrire ailleurs que sur stdout"""
+    def __init__(self, filename="parrot.full.log"):
+        self.filename = filename
+
+    def write(self, message):
+        f = open(self.filename, "a")
+        f.write(message)
+        f.close()
+
+def main():
+    """Exécution principale : lecture des paramètres et lancement du bot."""
+    if len(sys.argv) == 1:
+        print "Usage : parrot.py <serveur> [--debug] [--no-output] [--daemon [--pidfile]] [--outfile]"
+        print "        --outfile sans --no-output ni --daemon n'a aucun effet"
+        exit(1)
+    serveur = sys.argv[1]
+    if "--daemon" in sys.argv:
+        thisfile = os.path.realpath(__file__)
+        thisdirectory = thisfile.rsplit("/", 1)[0]
+        os.chdir(thisdirectory)
+        daemon = True
+    else:
+        daemon = False
+    if "debug" in sys.argv or "--debug" in sys.argv:
+        debug = True
+    else:
+        debug = False
+    if "--quiet" in sys.argv:
+        config.debug_stdout = False
+    serveurs = {
+              "irc" : "irc.crans.org",
+              "crans" : "irc.crans.org",
+              "irc.crans.org" : "irc.crans.org"}
+    if "--no-output" in sys.argv or "--daemon" in sys.argv:
+        outfile = "/var/log/bots/parrot.full.log"
+        for arg in sys.argv:
+            arg = arg.split("=")
+            if arg[0].strip('-') in ["out", "outfile", "logfile"]:
+                outfile = arg[1]
+        sys.stdout = Logger(outfile)
+    try:
+        serveur = serveurs[serveur]
+    except KeyError:
+        print "Server Unknown : %s" % (serveur)
+        exit(404)
+    parrot = Parrot(serveur,debug)
+    # Si on reçoit un SIGHUP, on reload la config
+    def sighup_handler(signum, frame):
+        parrot.execute_reload(auteur="SIGHUP")
+    signal.signal(signal.SIGHUP, sighup_handler)
+    # Daemonization
+    if daemon:
+        child_pid = os.fork()
+        if child_pid == 0:
+            os.setsid()
+            parrot.start_as_daemon(outfile)
+        else:
+            # on enregistre le pid de parrot
+            pidfile = "/var/run/bots/parror.pid"
+            for arg in sys.argv:
+                arg = arg.split("=")
+                if arg[0].strip('-') in ["pidfile"]:
+                    pidfile = arg[1]
+            f = open(pidfile, "w")
+            f.write("%s\n" % child_pid)
+            f.close()
+    else:
+        parrot.start()
+
+if __name__ == "__main__":
+    main()