Source Code for Module gozerbot.plugins

  1  # gozerbot/plugins.py 
  2  # 
  3  # 
  4   
  5  """ provide plugin infrastructure """ 
  6   
  7  __copyright__ = 'this file is in the public domain' 
  8   
  9  from gozerbot.datadir import datadir 
 10  from gozerbot.users import users 
 11  from gozerbot.monitor import outmonitor, saymonitor, jabbermonitor 
 12  from gozerbot.generic import rlog, handle_exception, checkchan, lockdec, \ 
 13  plugnames, waitforqueue, uniqlist, makeoptions, makeargrest 
 14  from gozerbot.myimport import my_import 
 15  from gozerbot.persist import Persist 
 16  from gozerbot.persistconfig import PersistConfig 
 17  from gozerbot.config import config 
 18  from gozerbot.commands import cmnds 
 19  from gozerbot.callbacks import callbacks, jcallbacks 
 20  from gozerbot.redispatcher import rebefore, reafter 
 21  from gozerbot.ircevent import Ircevent 
 22  from gozerbot.aliases import aliascheck 
 23  from gozerbot.ignore import shouldignore 
 24  from gozerbot.thr import start_new_thread 
 25  from gozerbot.persiststate import PersistState 
 26  if config['jabberenable']: 
 27      from gozerbot.jabbermsg import Jabbermsg 
 28  import os, os.path, thread, time, Queue 
 29   
 30  loadlock = thread.allocate_lock() 
 31  locked = lockdec(loadlock) 
 32   
 33  plugstate = PersistState(datadir + os.sep + 'pluginsstate') 
 34  plugstate.define('plugallow', []) 
 35   
 36   
 37 -class ReloadRecurseError(Exception): 
 38   
 39       pass 
 40   
 41 -class Plugins(object): 
 42   
 43      """ hold all the plugins """ 
 44   
 45 -    def __init__(self): 
 46          self.plugs = {} 
 47          self.reloadlock = thread.allocate_lock() 
 48          self.plugdeny = Persist(datadir + os.sep + 'plugdeny') 
 49          if not self.plugdeny.data: 
 50              self.plugdeny.data = [] 
 51          self.loadlist = [] 
 52          self.avail = [] 
 53          self.ondisk = [] 
 54           
 55 -    def enableloadlist(self): 
 56          if config['loadlist']: 
 57              try: 
 58                  self.loadlist = [i.strip() for i in open(datadir + os.sep + \ 
 59  'loadlist').readlines()] 
 60              except: 
 61                  self.loadlist = [] 
 62          else: 
 63              self.loadlist = [] 
 64   
 65 -    def __getitem__(self, item): 
 66          """ return plugin """ 
 67          if self.plugs.has_key(item): 
 68              return self.plugs[item] 
 69          else: 
 70              return None 
 71   
 72 -    def whatperms(self): 
 73          """ return what permissions are possible """ 
 74          result = [] 
 75          for i in rebefore.whatperms(): 
 76              if not i in result: 
 77                  result.append(i) 
 78          for i in cmnds.whatperms(): 
 79              if not i in result: 
 80                  result.append(i) 
 81          for i in reafter.whatperms(): 
 82              if not i in result: 
 83                  result.append(i) 
 84          result.sort() 
 85          return result 
 86   
 87 -    def exist(self, name): 
 88          """ see if plugin <name> exists """ 
 89          if self.plugs.has_key(name): 
 90              return 1  
 91   
 92 -    def disable(self, name): 
 93          """ prevent plugins <name> to be loaded """ 
 94          if name not in self.plugdeny.data: 
 95              self.plugdeny.data.append(name) 
 96              self.plugdeny.save() 
 97   
 98 -    def enable(self, name): 
 99          """ enable plugin <name> """ 
100          if name in self.plugdeny.data: 
101              self.plugdeny.data.remove(name) 
102              self.plugdeny.save() 
103   
104 -    def plugsizes(self): 
105          """ call the size() function in all plugins """ 
106          reslist = [] 
107          for i, j in self.plugs.iteritems(): 
108              try: 
109                  reslist.append("%s: %s" % (i, j.size())) 
110              except AttributeError: 
111                  pass 
112          return reslist 
113   
114 -    def list(self): 
115          """ list of registered plugins """ 
116          self.avail.sort() 
117          return self.avail 
118   
119 -    def plugimport(self, mod, name): 
120          modname = mod + '.' + name 
121          try: 
122              plug = my_import(modname) 
123              self.plugs[name] = plug   
124          except Exception, ex: 
125              self.unload(name) 
126              handle_exception() 
127              return 
128          # call init function in plugin 
129          try: 
130              rlog(0, 'plugins', 'calling %s init()' % name) 
131              result = plug.init() 
132              if not result: 
133                  return     
134          except AttributeError: 
135              pass 
136          except:  
137              handle_exception() 
138              self.unload(name) 
139              raise 
140          self.avail.append(name) 
141   
142 -    def regplugin(self, mod, name): 
143          """ register plugin """ 
144          name = name.lower() 
145          mod = mod.lower() 
146          modname = mod + '.' + name 
147          # see if plugin is in deny 
148          if name in self.avail: 
149              rlog(10, 'plugins', '%s already registered' % name) 
150              return 
151          if name in self.plugdeny.data: 
152              rlog(10, 'plugins', '%s.%s in deny .. not loading' % \ 
153  (mod, name)) 
154              return 0 
155          if self.loadlist and name not in self.loadlist and name not in \ 
156  plugstate['plugallow']: 
157              rlog(8, 'plugins', 'not loading %s.%s' % (mod, name)) 
158              return 0 
159          # if plugin is already registered unload it 
160          if self.plugs.has_key(name): 
161              rlog(10, 'plugins', 'overloading %s plugin with %s version' \ 
162  % (name, mod)) 
163              self.unloadnosave(name) 
164          # import the plugin 
165          self.plugimport(mod, name) 
166          rlog(0, 'plugins', "%s.%s registered" % (mod, name)) 
167          return name 
168   
169 -    def showregistered(self): 
170          time.sleep(7) 
171          self.avail.sort() 
172          rlog(10, 'plugins', 'registered %s' % ' .. '.join(self.avail)) 
173   
174 -    def regdir(self, dirname, exclude=[]): 
175          threads = [] 
176          plugs = [] 
177          for plug in plugnames(dirname): 
178              if plug in exclude or plug.startswith('.'): 
179                  continue 
180              try: 
181                  thr = start_new_thread(self.regplugin, (dirname, plug)) 
182                  threads.append(thr) 
183                  plugs.append(plug) 
184              except: 
185                  handle_exception() 
186          self.ondisk.extend(plugs) 
187          return plugs 
188   
189 -    def regcore(self):  
190          avail = []  
191          if config['dbenable']: 
192              dbplugs = my_import('gozerplugs.dbplugs') 
193              for i in dbplugs.__plugs__: 
194                  start_new_thread(self.regplugin, ('gozerplugs.dbplugs', i)) 
195                  avail.append(i) 
196          plugs = my_import('gozerplugs.plugs') 
197          for i in plugs.__plugs__: 
198              if i not in avail: 
199                  start_new_thread(self.regplugin, ('gozerplugs.plugs', i)) 
200                  avail.append(i) 
201          self.ondisk.extend(avail) 
202   
203 -    def regplugins(self): 
204          """ register plugins """ 
205          self.enableloadlist() 
206          self.regcore() 
207          if os.path.isdir('myplugs'): 
208              self.regdir('myplugs') 
209              for i in os.listdir('myplugs'): 
210                  if i.startswith('.'): 
211                      continue 
212                  if os.path.isdir('myplugs' + os.sep + i): 
213                      self.regdir('myplugs' + os.sep + i) 
214          start_new_thread(self.showregistered, ()) 
215          self.overload() 
216   
217 -    def overload(self): 
218          # see if there is a permoverload file and if so use it to overload 
219          # permissions based on function name 
220          try: 
221              overloadfile = open(datadir + '/permoverload','r') 
222          except IOError: 
223              return 
224          try: 
225              for i in overloadfile: 
226                  i = i.strip() 
227                  splitted = i.split(',') 
228                  try: 
229                      funcname = splitted[0].strip() 
230                      perms = [] 
231                      for j in splitted[1:]: 
232                          perms.append(j.strip()) 
233                  except IndexError: 
234                      rlog(10, 'plugins', "permoverload: can't set perms of %s" \ 
235  % i) 
236                      continue 
237                  if not funcname: 
238                      rlog(10, 'plugins', "permoverload: no function provided") 
239                      continue 
240                  if not perms: 
241                      rlog(10, 'plugins', "permoverload: no permissions \ 
242  provided for %s" % funcname) 
243                      continue 
244                  if self.permoverload(funcname, perms): 
245                      rlog(9, 'plugins', '%s permission set to %s' % \ 
246  (funcname, perms)) 
247                  else: 
248                      rlog(10, 'plugins', 'overload of %s failed' % funcname) 
249          except: 
250              handle_exception() 
251           
252 -    def available(self): 
253          """ available plugins not yet registered """ 
254          self.ondisk.sort() 
255          return self.ondisk 
256   
257 -    def saveplug(self, plugname): 
258          """ call save on items in plugins savelist """ 
259          try: 
260              self.save_cfgname(plugname) 
261              savelist = self.plugs[plugname].savelist 
262              for saveitem in savelist: 
263                  try: 
264                      saveitem.save() 
265                  except: 
266                      handle_exception() 
267          except AttributeError: 
268              pass 
269          except KeyError: 
270              pass 
271   
272 -    def save(self): 
273          """ call registered plugins save """ 
274          for plug in self.plugs.values(): 
275              try: 
276                  savelist = getattr(plug, 'savelist') 
277              except AttributeError: 
278                  continue 
279              for item in savelist: 
280                  try: 
281                      item.save() 
282                  except: 
283                      handle_exception() 
284   
285 -    def save_cfg(self): 
286          """ call registered plugins configuration save """ 
287          for plug in self.plugs.values(): 
288              try: 
289                  cfg = getattr(plug, 'cfg') 
290                  if isinstance(cfg, PersistConfig): 
291                      try: 
292                          cfg.save() 
293                      except: 
294                          handle_exception() 
295              except AttributeError: 
296                  continue 
297   
298 -    def save_cfgname(self, name): 
299          try: 
300              plug = self.plugs[name] 
301              cfg = getattr(plug, 'cfg') 
302              if isinstance(cfg, PersistConfig): 
303                  try: 
304                      cfg.save() 
305                  except: 
306                      handle_exception() 
307          except (AttributeError, KeyError): 
308              pass 
309           
310 -    def exit(self): 
311          """ call registered plugins save """ 
312          self.save() 
313          #self.save_cfg() 
314          threadlist = [] 
315          for name, plug in self.plugs.iteritems(): 
316              try: 
317                  shutdown = getattr(plug, 'shutdown') 
318                  thread = start_new_thread(shutdown, ()) 
319</