hung.py

   1 #!/usr/bin/python
   2 # -*- coding:utf8 -*-
   3
   4 # Codé par 20-100 le 23/04/12
   5
   6 # Un test de bot irc, parce que c'est cool
   7
   8 import threading
   9 import random
  10 import time
  11 import socket, ssl, json
  12 import pickle
  13 import re
  14 import os
  15 import signal
  16 import sys
  17 from commands import getstatusoutput as ex
  18
  19 # Oui, j'ai recodé ma version d'irclib pour pouvoir rattrapper les SIGHUP
  20 sys.path.insert(0, "/home/vincent/scripts/python-myirclib")
  21 import irclib
  22 import ircbot
  23
  24 import sys
  25 config_debug_stdout=True
  26 if "--quiet" in sys.argv:
  27     config_debug_stdout=False
  28
  29 config_irc_password="I'mAHungMan"
  30 config_irc_pseudo="hung"
  31 config_chanlist=["#bot","#flood"]
  32 config_stay_channels=["#bot","#flood"]
  33 config_play_channels=["#flood"]
  34 config_quiet_channels=[]
  35 config_logfile_template="hung.%s.log"
  36 def get_config_logfile(serveur):
  37     serveurs={"acoeur.crans.org":"acoeur","irc.crans.org":"crans","localhost":"localhost"}
  38     return config_logfile_template%(serveurs[serveur])
  39 config_overops=["[20-100]","[20-100]_","Petite-Peste","PEB"]
  40 config_ops=[]
  41 config_report_bugs_to=["[20-100]"]
  42
  43 config_dico_mots="mots.txt"
  44 config_dico_defs="definitions.txt"
  45
  46 config_scores_file="scores.pickle"
  47
  48 config_tag_triggers=[u"t(|a)g",u"ta gueule",u"la ferme",u"ferme( |-)la",u"tais-toi",u"chut"]
  49 config_tag_actions=[u"se tait",u"ferme sa gueule",u"se la ferme",u"la ferme"]
  50 config_tag_answers=[u"J'me tais si j'veux !",
  51 u"Je t'entends pas :°",
  52 u"Héhé, try again",
  53 u"Non, j'ai pas envie",
  54 u"Peut-être quand toi tu la fermeras, et encore…"]
  55
  56 config_quit_messages=[u"_ _ _, _ _ _ _ _   _ _ _ _ _!",
  57 u"_ _ E, _ _ _ E _   _ _ _ _ _!",
  58 u"_ _ E, _ _ _ E _   _ O _ _ _!",
  59 u"_ _ E, _ _ U E _   _ O _ _ _!",
  60 u"_ _ E, _ R U E _   _ O R _ _!",
  61 u"_ _ E, _ R U E L   _ O R L _!",
  62 u"B _ E, _ R U E L   _ O R L _!",
  63 u"B _ E, C R U E L   _ O R L _!",
  64 u"B _ E, C R U E L   _ O R L D!",
  65 u"B Y E, C R U E L   _ O R L D!",
  66 u"B Y E, C R U E L   W O R L D!",
  67 ]
  68 config_leave_messages=["On finira la partie plus tard :p"]
  69
  70 def log(serveur,channel,auteur=None,message=None):
  71     f=open(get_config_logfile(serveur),"a")
  72     if auteur==message==None:
  73         # alors c'est que c'est pas un channel mais juste une ligne de log
  74         chain="%s %s"%(time.strftime("%F %T"),channel)
  75     else:
  76         chain="%s [%s:%s] %s"%(time.strftime("%F %T"),channel,auteur,message)
  77     f.write(chain+"\n")
  78     if config_debug_stdout:
  79         print chain
  80     f.close()
  81
  82
  83 class UnicodeBotError(Exception):
  84     pass
  85 def bot_unicode(chain):
  86     try:
  87         unicode(chain,"utf8")
  88     except UnicodeDecodeError as exc:
  89         raise UnicodeBotError
  90
  91 def remplace_accents(chaine):
  92     chaine=chaine.lower()
  93     remplacements = {u"á":u"a",u"à":u"a",u"â":u"a",u"ä":u"a",u"é":u"e",u"è":u"e",u"ê":u"e",u"ë":u"e",u"í":u"i",u"ì":u"i",u"î":u"i",u"ï":u"i",u"ó":u"o",    u"ò":u"o",u"ô":u"o",u"ö":u"o",u"ú":u"u",u"ù":u"u",u"û":u"u",u"ü":u"u",u"ý":u"y",u"ỳ":u"y",u"ŷ":u"y",u"ÿ":u"y",u"œ":u"oe",u"æ":u"ae"}
  94     for avant,apres in remplacements.items():
  95         chaine=chaine.replace(avant,apres)
  96     return chaine
  97
  98 def is_something(chain,matches,avant=u".*(?:^| )",apres=u"(?:$|\.| |,|;).*",case_sensitive=False,debug=False):
  99     if case_sensitive:
 100         chain=unicode(chain,"utf8")
 101     else:
 102         chain=unicode(chain,"utf8").lower()
 103     allmatches="("+"|".join(matches)+")"
 104     reg=(avant+allmatches+apres).lower()
 105     o=re.match(reg,chain)
 106     return o
 107
 108 def is_tag(chain):
 109     return is_something(chain,config_tag_triggers)
 110
 111 def is_mot(mot,liste):
 112     real_word = "".join([lettre[0] for lettre in liste])
 113     real_word = real_word.decode("utf8").lower()
 114     mot=remplace_accents(mot.decode("utf8"))
 115     return mot==real_word
 116
 117 class Hung(ircbot.SingleServerIRCBot):
 118     def __init__(self,serveur,debug=False):
 119         temporary_pseudo=config_irc_pseudo+str(random.randrange(10000,100000))
 120         ircbot.SingleServerIRCBot.__init__(self, [(serveur, 6667)],
 121                               temporary_pseudo,"Bot irc pour jouer au pendu", 10)
 122         self.debug=debug
 123         self.serveur=serveur
 124         self.overops=config_overops
 125         self.ops=self.overops+config_ops
 126         self.report_bugs_to=config_report_bugs_to
 127         self.chanlist=config_chanlist
 128         self.stay_channels=config_stay_channels
 129         self.play_channels=config_play_channels
 130         self.play_status={i:[None,None,None] for i in self.play_channels}
 131         self.quiet_channels=config_quiet_channels
 132
 133
 134     def give_me_my_pseudo(self,serv):
 135         serv.privmsg("NickServ","RECOVER %s %s"%(config_irc_pseudo,config_irc_password))
 136         serv.privmsg("NickServ","RELEASE %s %s"%(config_irc_pseudo,config_irc_password))
 137         time.sleep(0.3)
 138         serv.nick(config_irc_pseudo)
 139
 140     def on_welcome(self, serv, ev):
 141         self.serv=serv # ça serv ira :)
 142         self.give_me_my_pseudo(serv)
 143         serv.privmsg("NickServ","IDENTIFY %s"%(config_irc_password))
 144         log(self.serveur,"Connected")
 145         if self.debug:
 146             self.chanlist=["#bot"]
 147             self.play_channels=["#bot"]
 148         for c in self.chanlist:
 149             log(self.serveur,"JOIN %s"%(c))
 150             serv.join(c)
 151
 152     def pourmoi(self, serv, message):
 153         """renvoie (False,lemessage) ou (True, le message amputé de "pseudo: ")"""
 154         pseudo=serv.get_nickname()
 155         size=len(pseudo)
 156         if message[:size]==pseudo and len(message)>size and message[size]==":":
 157             return (True,message[size+1:].lstrip(" "))
 158         else:
 159             return (False,message)
 160
 161     def on_privmsg(self, serv, ev):
 162         message=ev.arguments()[0]
 163         auteur = irclib.nm_to_n(ev.source())
 164         try:
 165             test=bot_unicode(message)
 166         except UnicodeBotError:
 167             serv.privmsg(auteur,
 168               "Euh, tu fais de la merde avec ton encodage là, j'ai failli crasher…")
 169             return
 170         message=message.split()
 171         cmd=message[0].lower()
 172         notunderstood=False
 173         if cmd=="join":
 174             if auteur in self.ops:
 175                 if len(message)>1:
 176                     if message[1] in self.chanlist:
 177                         serv.privmsg(auteur,"Je suis déjà sur %s"%(message[1]))
 178                     else:
 179                         serv.join(message[1])
 180                         self.chanlist.append(message[1])
 181                         serv.privmsg(auteur,"Channels : "+" ".join(self.chanlist))
 182                         log(self.serveur,"priv",auteur," ".join(message))
 183                 else:
 184                     serv.privmsg(auteur,"Channels : "+" ".join(self.chanlist))
 185             else:
 186                 notunderstood=True
 187         elif cmd=="leave":
 188             if auteur in self.ops and len(message)>1:
 189                 if message[1] in self.chanlist:
 190                     if not (message[1] in self.stay_channels) or auteur in self.overops:
 191                         self.quitter(message[1]," ".join(message[2:]))
 192                         self.chanlist.remove(message[1])
 193                         log(self.serveur,"priv",auteur," ".join(message)+"[successful]")
 194                     else:
 195                         serv.privmsg(auteur,"Non, je reste !")
 196                         log(self.serveur,"priv",auteur," ".join(message)+"[failed]")
 197                 else:
 198                     serv.privmsg(auteur,"Je ne suis pas sur %s"%(message[1]))
 199             else:
 200                 notunderstood=True
 201         elif cmd=="play":
 202             if auteur in self.ops:
 203                 if len(message)>1:
 204                     if message[1] in self.play_channels:
 205                         serv.privmsg(auteur,"Je play déjà sur %s."%(message[1]))
 206                         log(self.serveur,"priv",auteur," ".join(message)+"[failed]")
 207                     else:
 208                         self.play_channels.append(message[1])
 209                         self.play_status[message[1]]=[None,None,None]
 210                         serv.privmsg(auteur,"Play channels : "+" ".join(self.play_channels))
 211                         log(self.serveur,"priv",auteur," ".join(message)+"[successful]")
 212                 else:
 213                     serv.privmsg(auteur,"Play channels : "+" ".join(self.play_channels))
 214             else:
 215                 notunderstood=True
 216         elif cmd=="noplay":
 217             if auteur in self.ops:
 218                 if len(message)>1:
 219                     if message[1] in self.play_channels:
 220                         self.play_channels.remove(message[1])
 221                         serv.privmsg(auteur,"Play channels : "+" ".join(self.play_channels))
 222                         log(self.serveur,"priv",auteur," ".join(message)+"[successful]")
 223                     else:
 224                         serv.privmsg(auteur,"Je ne play pas sur %s."%(message[1]))
 225                         log(self.serveur,"priv",auteur," ".join(message)+"[failed]")
 226             else:
 227                 notunderstood=True
 228         elif cmd=="stay":
 229             if auteur in self.overops:
 230                 if len(message)>1:
 231                     if message[1] in self.stay_channels:
 232                         log(self.serveur,"priv",auteur," ".join(message)+"[failed]")
 233                         serv.privmsg(auteur,"Je stay déjà sur %s."%(message[1]))
 234                     else:
 235                         log(self.serveur,"priv",auteur," ".join(message)+"[successful]")
 236                         self.stay_channels.append(message[1])
 237                         serv.privmsg(auteur,"Stay channels : "+" ".join(self.stay_channels))
 238                 else:
 239                     serv.privmsg(auteur,"Stay channels : "+" ".join(self.stay_channels))
 240             else:
 241                 notunderstood=True
 242         elif cmd=="nostay":
 243             if auteur in self.overops:
 244                 if len(message)>1:
 245                     if message[1] in self.stay_channels:
 246                         log(self.serveur,"priv",auteur," ".join(message)+"[successful]")
 247                         self.stay_channels.remove(message[1])
 248                         serv.privmsg(auteur,"Stay channels : "+" ".join(self.stay_channels))
 249                     else:
 250                         log(self.serveur,"priv",auteur," ".join(message)+"[failed]")
 251                         serv.privmsg(auteur,"Je ne stay pas sur %s."%(message[1]))
 252
 253             else:
 254                 notunderstood=True
 255         elif cmd in ["states","status"]:
 256             if auteur in self.overops:
 257                 for k in self.play_status.keys():
 258                     if self.play_status[k]==[None,None,None]:
 259                         serv.privmsg(auteur,"None")
 260                     else:
 261                         serv.privmsg(auteur,"%s : %s (%s) [%s]"%(k,"".join([str(i[0]) for i in self.play_status[k][0]])
 262                                                      ,self.play_status[k][1], self.play_status[k][2]))
 263         elif cmd=="die":
 264             if auteur in self.overops:
 265                 log(self.serveur,"priv",auteur," ".join(message)+"[successful]")
 266                 self.mourir()
 267             else:
 268                 notunderstood=True
 269         elif cmd=="quiet":
 270             if auteur in self.ops:
 271                 if len(message)>1:
 272                     if message[1] in self.quiet_channels:
 273                         serv.privmsg(auteur,"Je me la ferme déjà sur %s"%(message[1]))
 274                         log(self.serveur,"priv",auteur," ".join(message)+"[failed]")
 275                     else:
 276                         self.quiet_channels.append(message[1])
 277                         serv.privmsg(auteur,"Quiet channels : "+" ".join(self.quiet_channels))
 278                         log(self.serveur,"priv",auteur," ".join(message)+"[successful]")
 279                 else:
 280                     serv.privmsg(auteur,"Quiet channels : "+" ".join(self.quiet_channels))
 281             else:
 282                 notunderstood=True
 283         elif cmd=="noquiet":
 284             if auteur in self.ops:
 285                 if len(message)>1:
 286                     if message[1] in self.quiet_channels:
 287                         self.quiet_channels.remove(message[1])
 288                         serv.privmsg(auteur,"Quiet channels : "+" ".join(self.quiet_channels))
 289                         log(self.serveur,"priv",auteur," ".join(message)+"[successful]")
 290                     else:
 291                         serv.privmsg(auteur,"Je ne me la ferme pas sur %s."%(message[1]))
 292                         log(self.serveur,"priv",auteur," ".join(message)+"[failed]")
 293             else:
 294                 notunderstood=True
 295         elif cmd=="say":
 296             if auteur in self.overops and len(message)>2:
 297                 serv.privmsg(message[1]," ".join(message[2:]))
 298                 log(self.serveur,"priv",auteur," ".join(message))
 299             elif len(message)<=2:
 300                 serv.privmsg(auteur,"Syntaxe : SAY <channel> <message>")
 301             else:
 302                 notunderstood=True
 303         elif cmd=="do":
 304             if auteur in self.overops and len(message)>2:
 305                 serv.action(message[1]," ".join(message[2:]))
 306                 log(self.serveur,"priv",auteur," ".join(message))
 307             elif len(message)<=2:
 308                 serv.privmsg(auteur,"Syntaxe : DO <channel> <action>")
 309             else:
 310                 notunderstood=True
 311         elif cmd in ["score","scores"]:
 312             self.send_scores(serv,auteur)
 313         else:
 314             notunderstood=True
 315         if notunderstood:
 316             serv.privmsg(auteur,"Je n'ai pas compris. Essaye HELP…")
 317
 318     def affiche_mot(self, serv, canal, begin="Mot courant"):
 319         if self.play_status.has_key(canal):
 320             mot = self.play_status[canal][0]
 321             obfuskated=" ".join([lettre[0] if lettre[1] else "_" for lettre in mot])
 322             serv.privmsg(canal,"%s : %s"%(begin,obfuskated))
 323
 324     def start_partie(self, serv, canal):
 325         mots=[mot.strip() for mot in open(config_dico_mots).readlines()]
 326         defs=[defi.strip() for defi in open(config_dico_defs).readlines()]
 327         indice = random.randrange(0,len(mots))
 328         mot,definition=mots[indice],defs[indice]
 329         # ' et - sont considérés comme déjà devinés
 330         mot = [(lettre,lettre in "'-()") for lettre in list(mot)]
 331         self.play_status[canal]=[mot,definition,{}]
 332         self.affiche_mot(serv, canal, begin="Devinez")
 333
 334     def on_pubmsg(self, serv, ev):
 335         auteur = irclib.nm_to_n(ev.source())
 336         canal = ev.target()
 337         message = ev.arguments()[0]
 338         try:
 339             test=bot_unicode(message)
 340         except UnicodeBotError:
 341             if not canal in self.quiet_channels:
 342                 serv.privmsg(canal,
 343                   "%s: Euh, tu fais de la merde avec ton encodage là, j'ai failli crasher…"%(auteur))
 344             return
 345         pour_moi,message=self.pourmoi(serv,message)
 346         if pour_moi and message.split()!=[]:
 347             cmd=message.split()[0].lower()
 348             try:
 349                 args=" ".join(message.split()[1:])
 350             except:
 351                 args=""
 352             if cmd in ["meurs","die","crève"]:
 353                 if auteur in self.overops:
 354                     log(self.serveur,canal,auteur,message+"[successful]")
 355                     self.mourir()
 356                 else:
 357                     serv.privmsg(canal,"%s: crève !"%(auteur))
 358                     log(self.serveur,canal,auteur,message+"[failed]")
 359             elif cmd in ["part","leave","dégage"]:
 360                 if auteur in self.ops and (not (canal in self.stay_channels)
 361                                            or auteur in self.overops):
 362                     self.quitter(canal)
 363                     log(self.serveur,canal,auteur,message+"[successful]")
 364                     if canal in self.chanlist:
 365                         self.chanlist.remove(canal)
 366                 else:
 367                     serv.privmsg(canal,"%s: Non, je reste !"%(auteur))
 368                     log(self.serveur,canal,auteur,message+"[failed]")
 369             elif cmd in ["play","jeu","encore","again","partie","pendu","game","mot","go","allez"]:
 370                 if not canal in self.quiet_channels and canal in self.play_channels:
 371                     if self.play_status.has_key(canal):
 372                         if self.play_status[canal]==[None,None,None]:
 373                             self.start_partie(serv, canal)
 374                         else:
 375                             self.affiche_mot(serv, canal, begin="%s: Rappel"%(auteur))
 376                     else:
 377                         self.play_status[canal]=[None,None,None]
 378                         self.start_partie(serv, canal)
 379                 elif not canal in self.play_channels:
 380                     serv.privmsg(canal,"%s: pas ici…"%(auteur))
 381             elif (cmd in list("azertyuiopqsdfghjklmwxcvbn") and canal in self.play_channels
 382                   and self.play_status.has_key(canal) and self.play_status[canal]!=[None,None,None]):
 383                 giv_let=cmd.upper()
 384                 liste=self.play_status[canal][0]
 385                 listeapres=[(lettre[0],lettre[1] or lettre[0]==giv_let) for lettre in liste]
 386                 if liste!=listeapres:
 387                     nbtrouvees=(sum([lettre[1] for lettre in listeapres if not lettre[0] in "'-()"])
 388                                 - sum([lettre[1] for lettre in liste if not lettre[0] in "'-()"]))
 389                     if self.play_status[canal][2].has_key(auteur):
 390                         self.play_status[canal][2][auteur]+= nbtrouvees
 391                     else:
 392                         self.play_status[canal][2][auteur] = nbtrouvees
 393                     self.play_status[canal][0]=listeapres
 394                     self.affiche_mot(serv, canal, begin="%s placé"%(giv_let))
 395                 if all([lettre[1] for lettre in listeapres]):
 396                     self.gagne(serv, canal)
 397
 398             elif cmd in ["score","scores","!score","!scores"]:
 399                 self.send_scores(serv,auteur)
 400             if cmd in ["meur", "meurt","meurre","meurres"] and not canal in self.quiet_channels:
 401                 serv.privmsg(canal,'%s: Mourir, impératif, 2ème personne du singulier : "meurs" (de rien)'%(auteur))
 402             if is_tag(message) and not canal in self.quiet_channels:
 403                 if auteur in self.ops:
 404                     action=random.choice(config_tag_actions)
 405                     serv.action(canal,action.encode("utf8"))
 406                     self.quiet_channels.append(canal)
 407                 else:
 408                     answer=random.choice(config_tag_answers)
 409                     for ligne in answer.split("\n"):
 410                         serv.privmsg(canal,"%s: %s"%(auteur,ligne.encode("utf8")))
 411             # on essaye de voir si le mot fourni matche la partie en cours
 412             mot = cmd
 413             if self.play_status[canal][0]!=None and is_mot(mot, self.play_status[canal][0]):
 414                 # on a trouvé le mot
 415                 # on regarde combien de lettre il manquait
 416                 manquait = sum([not lettre[1] for lettre in self.play_status[canal][0]])
 417                 self.add_score({auteur: manquait})
 418                 if self.play_status[canal][2].has_key(auteur):
 419                     self.play_status[canal][2][auteur]+=manquait
 420                 else:
 421                     self.play_status[canal][2][auteur]=manquait
 422                 self.gagne(serv, canal, bonus=auteur, bonusvalue=manquait)
 423         else:
 424             pass
 425
 426
 427     def on_action(self, serv, ev):
 428         action = ev.arguments()[0]
 429         auteur = irclib.nm_to_n(ev.source())
 430         channel = ev.target()
 431         try:
 432             test=bot_unicode(action)
 433         except UnicodeBotError:
 434             serv.privmsg(channel,
 435               "%s : Euh, tu fais de la merde avec ton encodage là, j'ai failli crasher…"%(auteur))
 436             return
 437         mypseudo=serv.get_nickname()
 438
 439     def on_kick(self,serv,ev):
 440         auteur = irclib.nm_to_n(ev.source())
 441         channel = ev.target()
 442         victime = ev.arguments()[0]
 443         raison = ev.arguments()[1]
 444         if victime==self.nick:
 445             log(self.serveur,"%s kické de %s par %s (raison : %s)" %(victime,channel,auteur,raison))
 446             time.sleep(5)
 447             serv.join(channel)
 448             # on ne dit rien au rejoin
 449             #l1,l2=config_kick_answers,config_kick_actions
 450             #n1,n2=len(l1),len(l2)
 451             #i=random.randrange(n1+n2)
 452             #if i>=n1:
 453             #    serv.action(channel,l2[i-n1].format(auteur).encode("utf8"))
 454             #else:
 455             #    serv.privmsg(channel,l1[i].format(auteur).encode("utf8"))
 456
 457     def _getnick(self):
 458         return self.serv.get_nickname()
 459     nick = property(_getnick)
 460
 461     def quitter(self,chan,leave_message=None):
 462         if leave_message==None:
 463             leave_message=random.choice(config_leave_messages)
 464         self.serv.part(chan,message=leave_message.encode("utf8"))
 465
 466     def mourir(self):
 467         quit_message=random.choice(config_quit_messages)
 468         self.die(msg=quit_message.encode("utf8"))
 469
 470     def get_scores(self):
 471         f=open(config_scores_file)
 472         scores=pickle.load(f)
 473         f.close()
 474         return scores
 475     def save_scores(self,scores):
 476         f=open(config_scores_file,'w')
 477         pickle.dump(scores,f)
 478         f.close()
 479     def add_score(self,dico):
 480         scores=self.get_scores()
 481         for k,v in dico.items():
 482             if scores.has_key(k):
 483                 scores[k]+=v
 484             else:
 485                 scores[k]=v
 486         self.save_scores(scores)
 487     def send_scores(self, serv, destinataire):
 488         scores=self.get_scores()
 489         scores=scores.items()
 490         scores.sort(lambda x,y:cmp(x[1],y[1]))
 491         scores.reverse()
 492         serv.privmsg(destinataire,"Scores by score : "+" ; ".join(["%s %s"%(k,v) for (k,v) in scores]) )
 493         scores.sort(lambda x,y:cmp(x[0].lower(),y[0].lower()))
 494         serv.privmsg(destinataire,"Scores by pseudo : "+" ; ".join(["%s %s"%(k,v) for (k,v) in scores]) )
 495
 496     def gagne(self, serv, canal, bonus=None, bonusvalue=2):
 497         realword="".join([lettre[0] for lettre in self.play_status[canal][0]])
 498         definition = self.play_status[canal][1]
 499         serv.privmsg(canal,"Bravo ! C'était %s"%(realword))
 500         serv.privmsg(canal,definition)
 501         nlettre=float(len(realword.replace("'","").replace("-","")))
 502         contribs=["%s:%s%%%s"%(pseudo,str(int(100*contrib/nlettre)),("+bonus(%s)"%(bonusvalue))*(bonus==pseudo)) for pseudo,contrib in self.play_status[canal][2].items()]
 503         contribs_score={pseudo:int(10*contrib/nlettre) for pseudo,contrib in self.play_status[canal][2].items()}
 504         self.add_score(contribs_score)
 505         serv.privmsg(canal,"Contributions : %s"%("  ".join(contribs)) )
 506         self.play_status[canal]=[None,None,None]
 507
 508     def start_as_daemon(self, outfile):
 509         sys.stderr = Logger(outfile)
 510         self.start()
 511
 512
 513 class Logger(object):
 514     """Pour écrire ailleurs que sur stdout"""
 515     def __init__(self, filename="hung.full.log"):
 516         self.filename = filename
 517
 518     def write(self, message):
 519         f = open(self.filename, "a")
 520         f.write(message)
 521         f.close()
 522
 523
 524 if __name__=="__main__":
 525     import sys
 526     if len(sys.argv)==1:
 527         print "Usage : hung.py <serveur> [--debug] [--no-output] [--daemon [--pidfile]] [--outfile]"
 528         print "        --outfile sans --no-output ni --daemon n'a aucun effet"
 529         exit(1)
 530     serveur=sys.argv[1]
 531     if "--daemon" in sys.argv:
 532         thisfile = os.path.realpath(__file__)
 533         thisdirectory = thisfile.rsplit("/", 1)[0]
 534         os.chdir(thisdirectory)
 535         daemon = True
 536     else:
 537         daemon = False
 538     if "debug" in sys.argv or "--debug" in sys.argv:
 539         debug=True
 540     else:
 541         debug=False
 542     if "--no-output" in sys.argv or "--daemon" in sys.argv:
 543         outfile = "/var/log/bots/hung.full.log"
 544         for arg in sys.argv:
 545             arg = arg.split("=")
 546             if arg[0].strip('-') in ["out", "outfile", "logfile"]:
 547                 outfile = arg[1]
 548         sys.stdout = Logger(outfile)
 549     serveurs={"a♡":"acoeur.crans.org","acoeur":"acoeur.crans.org","acoeur.crans.org":"acoeur.crans.org",
 550               "irc":"irc.crans.org","crans":"irc.crans.org","irc.crans.org":"irc.crans.org",
 551               "localhost":"localhost"}
 552     try:
 553         serveur=serveurs[serveur]
 554     except KeyError:
 555         print "Server Unknown : %s"%(serveur)
 556         exit(404)
 557     hung=Hung(serveur,debug)
 558     if daemon:
 559         child_pid = os.fork()
 560         if child_pid == 0:
 561             os.setsid()
 562             hung.start_as_daemon(outfile)
 563         else:
 564             # on enregistre le pid de hung
 565             pidfile = "/var/run/bots/hung.pid"
 566             for arg in sys.argv:
 567                 arg = arg.split("=")
 568                 if arg[0].strip('-') in ["pidfile"]:
 569                     pidfile = arg[1]
 570             f = open(pidfile, "w")
 571             f.write("%s\n" % child_pid)
 572             f.close()
 573     else:
 574         hung.start()
 575