Source Code for Module gozerbot.fleet

  1  # gozerbot/fleet.py 
  2  # 
  3  # 
  4   
  5  """ fleet is a list of bots """ 
  6   
  7  __copyright__ = 'this file is in the public domain' 
  8   
  9  from gozerbot.datadir import datadir 
 10  from gozerbot.generic import rlog, handle_exception, waitforqueue 
 11  from gozerbot.persist import Persist 
 12  from gozerbot.config import config 
 13  from gozerbot.plugins import plugins 
 14  from gozerbot.thr import start_new_thread 
 15  import Queue, os, types, threading, time, pickle 
 16   
 17 -class Fleet(object): 
 18   
 19      """ contains multiple bots (list of bots) """ 
 20   
 21 -    def __init__(self, fname): 
 22          if config['jabberenable']: 
 23              self.mainbotname = config['mainbotname'] or 'jabbermain' 
 24          else: 
 25              self.mainbotname = config['mainbotname'] or 'main' 
 26          self.startok = threading.Event() 
 27          self.bots = [] 
 28          self.botdata = Persist(fname) 
 29          if not self.botdata.data: 
 30              self.botdata.data = {} 
 31   
 32 -    def updatenick(self, name, nick): 
 33          try: 
 34              self.botdata.data[name][2] = nick 
 35              self.botdata.save() 
 36              return 1 
 37          except KeyError: 
 38              return 0 
 39   
 40 -    def getmainbot(self): 
 41          """ return the main bot of the fleet """ 
 42          return self.byname(self.mainbotname) 
 43   
 44 -    def getfirstbot(self): 
 45          """ return the main bot of the fleet """ 
 46          return self.bots[0] 
 47           
 48 -    def size(self): 
 49          """ return number of bots """ 
 50          return len(self.bots) 
 51   
 52 -    def start(self, mainbot=None): 
 53          """ startup the bots """ 
 54          got = False 
 55          if mainbot: 
 56              self.bots.append(mainbot) 
 57              start_new_thread(mainbot.joinchannels, ()) 
 58              got = True 
 59          for i in self.botdata.data: 
 60              if not config['jabberenable'] and \ 
 61  self.botdata.data[i][0] == 'jabber': 
 62                  rlog(10, 'fleet', 'jabber not enabled .. skipping %s' % i) 
 63                  continue 
 64              if config['ircdisable'] and \ 
 65  self.botdata.data[i][0] == 'irc': 
 66                  rlog(10, 'fleet', 'irc not enabled .. skipping %s' % i) 
 67                  continue 
 68              start_new_thread(self.startbot, (i, )) 
 69              got = True 
 70          if not got: 
 71              rlog(100, 'fleet', 'no bots enabled') 
 72          else: 
 73              time.sleep(5) 
 74              self.startok.set() 
 75   
 76 -    def resume(self, sessionfile): 
 77          session = pickle.load(open(sessionfile)) 
 78          for name in session['bots'].keys(): 
 79              reto = None 
 80              if name == session['name']: 
 81                  reto = session['channel'] 
 82              start_new_thread(self.resumebot, (name, session['bots'][name], reto)) 
 83          time.sleep(5) 
 84          self.startok.set() 
 85   
 86 -    def save(self): 
 87          """ save fleet data and call save on all the bots """ 
 88          try: 
 89              self.botdata.save() 
 90          except Exception, ex: 
 91              handle_exception() 
 92          for i in self.bots: 
 93              try: 
 94                  i.save() 
 95              except Exception, ex: 
 96                  handle_exception() 
 97   
 98 -    def list(self): 
 99          """ return list of bot names """ 
100          result = [] 
101          for i in self.bots: 
102              result.append(i.name) 
103          return result 
104   
105 -    def stopall(self): 
106          """ return bot by name """ 
107          for i in self.bots: 
108              try: 
109                  i.stop() 
110              except: 
111                  pass 
112   
113 -    def byname(self, name): 
114          """ return bot by name """ 
115          name = name.lower() 
116          for i in self.bots: 
117              if name == i.name: 
118                  return i 
119   
120 -    def replace(self, name, bot): 
121          """ replace bot """ 
122          name = name.lower() 
123          for i in range(len(self.bots)): 
124              if name == self.bots[i].name: 
125                  self.bots[i] = bot 
126   
127 -    def addbot(self, bot): 
128          """ add a irc or jabber bot based on bot type """ 
129          self.bots.append(bot) 
130          if bot.type == 'irc': 
131              datalist = ['irc', bot.owner, bot.nick, bot.server, bot.port, \ 
132  bot.password, bot.ipv6, bot.ssl] 
133          elif bot.type == 'jabber': 
134              datalist = ['jabber', bot.owner, bot.host, bot.user, \ 
135  bot.password, bot.port] 
136          self.botdata.data[bot.name.lower()] = datalist 
137          self.botdata.save() 
138   
139 -    def startbot(self, name): 
140          """ get a bot up and running .. create it if it is not in fleet """ 
141          name = name.lower() 
142          try: 
143              bd = self.botdata.data[name] 
144              got = False 
145              if bd[0] == 'irc' and not config['ircdisable']: 
146                  bot = self.byname(name) 
147                  if not bot: 
148                      from gozerbot.bot import Bot 
149                      bot = Bot(name, bd[1]) 
150                  start_new_thread(bot.connectwithjoin, bd[2:]) 
151                  got = True 
152              elif bd[0] == 'jabber' and config['jabberenable']: 
153                  bot = self.byname(name) 
154                  if not bot: 
155                      from gozerbot.jabberbot import Jabberbot 
156                      bot = Jabberbot(name) 
157                  start_new_thread(bot.connectwithjoin, bd[2:]) 
158                  got = True 
159              if got: 
160                  if bot not in self.bots: 
161                      self.bots.append(bot) 
162                  rlog(10, 'fleet', 'started %s bot' % bot.name) 
163              else: 
164                  rlog(10, 'fleet', 'failed to start %s bot' % bot.name) 
165          except Exception, ex: 
166              handle_exception() 
167   
168 -    def resumebot(self, name, data, reto): 
169          name = name.lower() 
170          try: 
171              bd = self.botdata.data[name] 
172              got = False 
173              if bd[0] == 'irc': 
174                  bot = self.byname(name) 
175                  if not bot: 
176                      from gozerbot.bot import Bot 
177                      bot = Bot(name, bd[1]) 
178                  if bot._resume(data, reto): 
179                      got = True 
180                  elif bot.connect(*bd[2:]): 
181                      got = True 
182              elif bd[0] == 'jabber' and config['jabberenable']: 
183                  bot = self.byname(name) 
184                  if not bot: 
185                      from gozerbot.jabberbot import Jabberbot 
186                      bot = Jabberbot(name) 
187                  if bot.connect(*bd[2:]): 
188                      got = True 
189              if got: 
190                  if bot not in self.bots: 
191                      self.bots.append(bot) 
192                  bot.joinchannels() 
193                  rlog(10, 'fleet', 'resumed %s bot' % bot.name) 
194              else: 
195                  rlog(10, 'fleet', 'failed to resume %s bot' % bot.name) 
196          except Exception, ex: 
197              handle_exception() 
198   
199 -    def connect(self, name): 
200          """ connect bot to irc server""" 
201          name = name.lower() 
202          for i in self.bots: 
203              if i.name == name: 
204                  try: 
205                      data = self.botdata.data[name] 
206                  except KeyError: 
207                      return 
208                  got = 0 
209                  if i.type == 'irc': 
210                      got = i._connect(*data[2:]) 
211                  elif i.type == 'jabber': 
212                      got = i.connect(*data[2:]) 
213                  if got: 
214                      i.joinchannels() 
215                      return 1 
216                  else: 
217                      return 0 
218   
219 -    def delete(self, name): 
220          """ delete bot with name from fleet """ 
221          for i in self.bots: 
222              if i.name == name: 
223                  i.exit() 
224                  self.remove(i) 
225                  try: 
226                      del self.botdata.data[name] 
227                      self.botdata.save() 
228                  except KeyError: 
229                      pass 
230                  rlog(10, 'fleet', '%s deleted' % i.name) 
231                  return 1 
232   
233 -    def remove(self, bot): 
234          """ delete bot by object """ 
235          self.bots.remove(bot) 
236   
237 -    def exit(self, name): 
238          """ call exit on all bots """ 
239          name = name.lower() 
240          for i in self.bots: 
241              if i.name == name: 
242                  try: 
243                      i.exit() 
244                  except: 
245                      handle_exception() 
246                  return 1 
247   
248 -    def exitall(self): 
249          """ call exit on all bots """ 
250          for i in self.bots: 
251              try: 
252                  i.exit() 
253              except Exception, ex: 
254                  handle_exception() 
255   
256 -    def cmnd(self, event, name, cmnd): 
257          """ do command on a bot by name """ 
258          name = name.lower() 
259          bot = self.byname(name) 
260          if not bot: 
261              return 0 
262          if bot.type == 'irc': 
263              from gozerbot.ircevent import Ircevent 
264              j = Ircevent() 
265          elif bot.type == 'jabber': 
266              from gozerbot.jabbermsg import Jabbermsg 
267              j = Jabbermsg() 
268          j.copyin(event) 
269          j.txt = cmnd 
270          q = Queue.Queue() 
271          j.queues = [q] 
272          j.speed = 3 
273          start_new_thread(plugins.trydispatch, (bot, j)) 
274          result = waitforqueue(q) 
275          if not result: 
276              return 
277          res = ["[%s]" % bot.name, ] 
278          res += result 
279          event.reply(res) 
280   
281 -    def cmndall(self, event, cmnd): 
282          """ do a command on all bots """ 
283          threads = [] 
284          for i in self.bots: 
285              thread = start_new_thread(self.cmnd, (event, i.name, cmnd)) 
286              threads.append(thread) 
287          for i in threads: 
288              i.join(10) 
289   
290 -    def broadcast(self, txt): 
291          for i in self.bots: 
292              start_new_thread(i.broadcast, (txt, )) 
293   
294  fleet = Fleet(datadir + os.sep + 'fleet') 
295