From: Vincent Le Gallic Date: Fri, 31 Jan 2014 01:43:38 +0000 (+0100) Subject: Init : bot IRC fonctionnel mais coquille vide X-Git-Url: http://gitweb.pimeys.fr/?a=commitdiff_plain;h=fe5896c741f4de89a661c74a6e5e8afec210ee0d;p=bots%2Fparrot.git Init : bot IRC fonctionnel mais coquille vide --- fe5896c741f4de89a661c74a6e5e8afec210ee0d diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..c45d5ee --- /dev/null +++ b/.gitignore @@ -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 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 + Affiche de l'aide sur la commande""", None, None], + +"join" : [None, u"""JOIN + Me fait rejoindre le channel""", None], + +"leave" : [None, u"""LEAVE + Me fait quitter le channel (sauf s'il est dans ma stay_list).""", None], + +"quiet" : [None, u"""QUIET + Me rend silencieux sur le channel.""", None], + +"noquiet" : [None, u"""NOQUIET + Me rend la parole sur le channel.""", None], + +"lost" : [None, u"""LOST + Me fait perdre sur le channel.""", None], + +"reload" : [None, u"""RELOAD + Recharge la configuration.""", None], + +"say" : [None, None, u"""SAY + Me fait parler sur le channel."""], + +"do" : [None, None, u"""DO + Me fait faitre une action (/me) sur le channel."""], + +"stay" : [None, None, u"""STAY + Ajoute le channel à ma stay_list."""], + +"nostay" : [None, None, u"""NOSTAY + 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 [] + Kicke 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 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 index 0000000..cf14e9c --- /dev/null +++ b/initscript @@ -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 + +# 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 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 ") + 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 ") + 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 []") + 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 [--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()