From fe9d5506f786c9f5010a287daad6cdeb5dbe0e8c Mon Sep 17 00:00:00 2001 From: Vincent Le Gallic Date: Sun, 6 Mar 2016 16:33:48 +0100 Subject: [PATCH 1/1] Bootstrap repo from Basile's code --- .gitignore | 32 ++++ config.py | 106 +++++++++++ initscript | 217 ++++++++++++++++++++++ isit.py | 42 +++++ josh.py | 514 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 5 files changed, 911 insertions(+) create mode 100644 .gitignore create mode 100644 config.py create mode 100755 initscript create mode 100644 isit.py create mode 100755 josh.py 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..d9e3007 --- /dev/null +++ b/config.py @@ -0,0 +1,106 @@ +#!/usr/bin/python +# -*- coding:utf8 -*- + +""" Bot configuration """ + +#: 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 = "Ke5ckiigakX1I" +#: Pseudo IRC +irc_pseudo = "Josh" +#: 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 = "josh.%s.log" + +#: Les OVEROPs, tous les droits sur le bot +overops=["[20-100]", "[20-100]_", "[20-100]_p"] +#: 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 "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", +"shut up", "quiet"] +tag_actions = [u"shuts up"] +tag_answers = [ +u"Access denied"] + +#: config pour "on m'a demandé de partir" +quit_messages = [u"Goodbye."] +leave_messages = quit_messages + +quit_fail_messages = [u"Access denied"] +leave_fail_messages = quit_fail_messages +pas_programme_pour_tobeir = [u"Encore eût-il fallu que je fusse programmé pour vous obéir !"] + +#: Allah regexp +allah_triggers = [".*is not doing allah is doing"] + +#: 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], + +"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"List of available commands:\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 = [] diff --git a/initscript b/initscript new file mode 100755 index 0000000..12b9b75 --- /dev/null +++ b/initscript @@ -0,0 +1,217 @@ +#! /bin/sh +### BEGIN INIT INFO +# Provides: josh +# Required-Start: $remote_fs $syslog +# Required-Stop: $remote_fs $syslog +# Default-Start: 2 3 4 5 +# Default-Stop: 0 1 6 +# Short-Description: Josh, IRC bot +# Description: Josh is an IRC bot to kickban spammers on c3 channels +### 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 NK2015" +PYTHON=/usr/bin/python +BASENAME=josh +DIRECTORY=/home/josh/josh +SCRIPT=$DIRECTORY/$BASENAME.py +EXEC="$PYTHON $SCRIPT" +USER=josh +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/isit.py b/isit.py new file mode 100644 index 0000000..07c81dc --- /dev/null +++ b/isit.py @@ -0,0 +1,42 @@ +#!/usr/bin/python +# -*- coding:utf8 -*- + +""" Des fonctions utilitaire pour savoir si on est dans tel ou tel cas. """ + +import re +import time + +import config + +def regex_join(liste, avant=u".*(?:^| )", apres=u"(?:$|\.| |,|;).*"): + """Fabrique une regexp à partir d'une liste d'éléments à matcher.""" + return avant + u"(" + u"|".join(liste) + u")" + apres + +def is_something(chain, regexp=None, matches=[], avant=u".*(?:^| )", apres=u"(?:$|\.| |,|;).*", + case_sensitive=False): + """Vérifie si chain contient un des éléments de ``matches``. + Si ``regexp`` est fournie, c'est simplement elle qui est testée""" + if not case_sensitive: + chain = chain.lower() + apres = apres.lower() + avant = avant.lower() + if regexp == None: + regexp = regex_join(matches, avant, apres) + regexp = re.compile(regexp) + o = regexp.match(chain) + return o + +def regexp_compile(): + """Compilation des regexp à partir de la conf. + Place les résultats dans le namespace de ``config``""" + config.allah_regexp = regex_join(config.allah_triggers, avant=".*", apres="$") + config.allah_regexp_compiled = re.compile(config.allah_regexp) + + config.tag_regexp = regex_join(config.tag_triggers, avant=".*", apres="$") + config.tag_regexp_compiled = re.compile(config.tag_regexp) + + +regexp_compile() +def is_tag(chain): + """Vérifie si ``chain`` demande de fermer sa gueule.""" + return is_something(chain, config.tag_regexp_compiled) diff --git a/josh.py b/josh.py new file mode 100755 index 0000000..e4c4da1 --- /dev/null +++ b/josh.py @@ -0,0 +1,514 @@ +#!/usr/bin/python +# -*- coding:utf8 -*- + +""" IRC bot to kickban spammers on c3 channels """ + +import threading +import random +import time +import json +import re +import os +import signal +import sys + +# Yup, I'va tweaked irclib to handle SIGHUP +sys.path.insert(0, "/home/vincent/scripts/python-myirclib") +import irclib +import ircbot + +#: Bot configuration +import config +#: Module de réponse aux questions de base +import isit + +# la partie qui réfère au fichier lui-même est mieux ici +# sinon on réfère la config et pas le fichier lui-même +config.thisfile = os.path.realpath(__file__) + +def get_config_logfile(serveur): + """Renvoie le nom du fichier de log en fonction du ``serveur`` et de la config.""" + serveurs = {"irc.hackint.org" : "hackint", + "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 Josh(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, "Basile, 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]")) + + ### 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, (u"Je suis déjà sur %s" % (message[1])).encode("utf-8")) + 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 + if notunderstood: + serv.privmsg(auteur, "I don't understand what you're saying. Try 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"deviens", u"pseudo", u"become", u"nick"]: + if auteur in self.ops: + become = args + serv.nick(become) + log(self.serveur, canal, auteur, message + "[successful]") + + elif cmd in [u"ping"] and not canal in self.quiet_channels: + serv.privmsg(canal, "%s: pong" % (auteur)) + + if isit.is_tag(message) and not canal in self.quiet_channels: + if auteur in self.ops: + action = random.choice(config.tag_actions) + serv.action(canal, action.encode("utf8")) + self.quiet_channels.append(canal) + else: + answer = random.choice(config.tag_answers) + for ligne in answer.split("\n"): + serv.privmsg(canal, "%s: %s" % (auteur, ligne.encode("utf8"))) + + 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, ("%s kické de %s par %s (raison : %s)" % (victime, channel, auteur, raison)).decode("utf-8")) + time.sleep(10) + serv.join(channel) +# l1, l2 = config.kick_answers, config.kick_actions +# n1, n2 = len(l1), len(l2) +# i = random.randrange(n1 + n2) +# if i >= n1: +# serv.action(channel, l2[i-n1].format(auteur).encode("utf8")) +# else: +# serv.privmsg(channel, l1[i].format(auteur).encode("utf8")) + + ### .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="basile.full.log"): + self.filename = filename + + def write(self, message): + f = open(self.filename, "a") + f.write(message) + f.close() + +def main(): + """Exécution principal : lecture des paramètres et lancement du bot.""" + if len(sys.argv) == 1: + print "Usage : josh.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 = { + "crans" : "irc.crans.org", + "irc.crans.org" : "irc.crans.org", + "hackint" : "irc.hackint.org", + "irc.hackint.org" : "irc.hackint.org", + } + if "--no-output" in sys.argv or "--daemon" in sys.argv: + outfile = "/var/log/bots/josh.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) + josh = Josh(serveur,debug) + # Si on reçoit un SIGHUP, on reload la config + def sighup_handler(signum, frame): + basile.execute_reload(auteur="SIGHUP") + signal.signal(signal.SIGHUP, sighup_handler) + # Daemonization + if daemon: + child_pid = os.fork() + if child_pid == 0: + os.setsid() + basile.start_as_daemon(outfile) + else: + # on enregistre le pid du bot + pidfile = "/var/run/bots/josh.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: + josh.start() + +if __name__ == "__main__": + main() -- 2.39.2