def add(self, cmnd, func, perms, threaded=False, wait=False, orig=None, how=None, *args, **kwargs): """ add a command. """ modname = calledfrom(sys._getframe()) try: prev = self[cmnd] except KeyError: prev = None target = Command(modname, cmnd, func, perms, threaded, wait, orig, how) if how == "regex": logging.info("regex command detected - %s" % cmnd) self.regex.append(target) target.regex = cmnd return self self[cmnd] = target try: c = cmnd.split('-')[1] if not self.subs: self.subs = LazyDict() if self.subs.has_key(c): if not self.subs[c]: self.subs[c] = [] if prev in self.subs[c]: self.subs[c].remove(prev) if target not in self.subs[c]: self.subs[c].append(target) else: self.subs[c] = [target, ] except IndexError: pass try: p = cmnd.split('-')[0] if not self.pre: self.pre = LazyDict() if self.pre.has_key(p): if not self.pre[p]: self.pre[p] = [] if prev in self.pre[p]: self.pre[p].remove(prev) if target not in self.pre[p]: self.pre[p].append(target) else: self.pre[p] = [target, ] except IndexError: pass return self
def __init__(self, filename=None, verbose=False, input={}, ddir=None, *args, **kw): LazyDict.__init__(self, input, *args, **kw) filename = filename or 'mainconfig' datadir = ddir or getdatadir() dir = datadir + os.sep + 'config' if datadir not in filename: cfile = dir + os.sep + filename else: cfile = filename logging.debug("config - filename is %s" % cfile) self.jsondb = None try: import waveapi ; self.isdb = True except ImportError: self.isdb = False if not self.comments: self.comments = {} try: try: self.fromfile(cfile) except IOError: logging.warn("can't read config from %s" % self.cfile) import waveapi from persist import Persist self.jsondb = Persist(cfile) self.update(self.jsondb.data) self.isdb = True logging.debug("config - fromdb - %s - %s" % (self.cfile, str(self))) except ImportError: handle_exception() self.isdb = False self.cfile = cfile self.dir = dir self.filename = filename self.init() if not self.owner: self.owner = [] if not self.uuid: self.uuid = str(uuid.uuid4())
def __init__(self, modname, cmnd, func, perms=[], threaded=False, wait=False, orig=None, how=None, speed=None, needcc=False): LazyDict.__init__(self) if not modname: raise Exception("modname is not set - %s" % cmnd) self.modname = cpy(modname) self.plugname = self.modname.split('.')[-1] self.cmnd = cpy(cmnd) self.orig = cpy(orig) self.func = func if type(perms) == types.StringType: perms = [ perms, ] self.perms = cpy(perms) self.plugin = self.plugname self.threaded = cpy(threaded) self.wait = cpy(wait) self.enable = True self.how = how or "overwrite" self.regex = None self.speed = speed self.needcc = needcc
def __init__(self, filename, verbose=False, input={}, ddir=None, *args, **kw): assert filename LazyDict.__init__(self, input, *args, **kw) self.filename = filename or 'mainconfig' self.datadir = ddir or getdatadir() self.dir = self.datadir + os.sep + 'config' self.cfile = self.dir + os.sep + self.filename logging.debug("filename is %s" % self.cfile) self.jsondb = None try: import waveapi ; self.isdb = True except ImportError: self.isdb = False if not self.comments: self.comments = {} try: try: self.fromfile(self.cfile) except IOError: logging.warn("can't read config from %s" % self.cfile) import waveapi from persist import Persist self.jsondb = Persist(self.cfile) self.update(self.jsondb.data) self.isdb = True logging.debug("fromdb - %s - %s" % (self.cfile, str(self))) except ImportError: handle_exception() self.isdb = False self.init() self.datadir = ddir or getdatadir() self.dir = self.datadir + os.sep + 'config' self.cfile = self.dir + os.sep + self.filename if not self.owner: self.owner = [] dosave = False if not self.uuid: self.uuid = str(uuid.uuid4()) ; dosave = True if not self.cfile: self.cfile = self.dir + os.sep + self.filename ; dosave = True if dosave: self.save() assert self.cfile
def dispatch(self, dom): """ dispatch a dom to the appropiate handler. """ res = LazyDict() parentname = dom.getName() data = dom.getData() if data: self.final[parentname] = data if parentname == 'body': self.final['txt'] = data attrs = dom.getAttributes() ns = dom.getNamespace() res[parentname] = LazyDict() res[parentname]['data'] = data res[parentname].update(attrs) if ns: res[parentname]['xmlns'] = ns for child in dom.getChildren(): name = child.getName() data = child.getData() if data: self.final[name] = data attrs = child.getAttributes() ns = child.getNamespace() res[parentname][name] = LazyDict() res[parentname][name]['data'] = data res[parentname][name].update(attrs) self.final.update(attrs) if ns: res[parentname][name]['xmlns'] = ns self.subelements.append(res)
def mini(response, input={}): """ display start html so that bot output can follow. """ inputdict = LazyDict({'version': getversion()}) if input: inputdict.update(input) temp = os.path.join(os.getcwd(), 'templates/mini.html') outstr = template.render(temp) response.out.write(outstr)
def __init__(self, filename, verbose=False, input={}, ddir=None, nolog=False, *args, **kw): assert filename LazyDict.__init__(self, input, *args, **kw) self.origname = filename self.origdir = ddir or getdatadir() self.setcfile(ddir, filename) self.jsondb = None if not self._comments: self._comments = {} try: import waveapi self.isdb = True self.isgae = True except ImportError: self.isgae = False self.isdb = False dodb = False try: logging.info("fromfile - %s from %s" % (self.origname, whichmodule(2))) self.fromfile(self.cfile) except IOError, ex: handle_exception() ; dodb = True if dodb or (self.isgae and not "mainconfig" in filename): try: from persist import Persist self.jsondb = Persist(self.cfile) if self.jsondb: self.merge(self.jsondb.data) logging.warn("fromdb - %s" % self.cfile) except ImportError: logging.warn("can't read config from %s - %s" % (self.cfile, str(ex))) self.init() if self.owner: logging.info("owner is %s" % self.owner) if not self.has_key("uuid"): self.setuuid() if not self.has_key("cfile"): self.cfile = self.setcfile(self.origdir, self.origname) assert self.cfile
def __init__(self, name=None): if not self.cfg: raise Exception("sxmpp - config is not set") self.cfg.name = name or self.cfg.name if not self.cfg.name: raise Exception("bot name is not set in config file %s" % self.cfg.filename) self.connection = None self.target = None self.streamid = None self.encoding = "utf-8" self.stopped = False self.failure = "" self.result = LazyDict() self.final = LazyDict() self.subelements = [] self.reslist = [] self.cur = u"" self.tags = [] self.features = [] self.handlers = LazyDict() self.addHandler('error', self.handle_error) self.addHandler('proceed', self.handle_proceed) self.addHandler('message', self.handle_message) self.addHandler('presence', self.handle_presence) self.addHandler('iq', self.handle_iq) self.addHandler('stream', self.handle_stream) self.addHandler('stream:stream', self.handle_stream) self.addHandler('stream:error', self.handle_streamerror) self.addHandler('stream:features', self.handle_streamfeatures) self.addHandler('challenge', self.handle_challenge) self.addHandler('failure', self.handle_failure) self.addHandler('success', self.handle_success)
def savecallbacktable(modname=None): """ save command -> plugin list to db backend. """ if modname: logging.warn("boot - module name is %s" % modname) global callbacktable assert callbacktable if not callbacktable.data: callbacktable.data = {} if modname: target = LazyDict(callbacktable.data) else: target = LazyDict() from jsb.lib.callbacks import first_callbacks, callbacks, last_callbacks, remote_callbacks for cb in [first_callbacks, callbacks, last_callbacks, remote_callbacks]: for type, cbs in cb.cbs.iteritems(): for c in cbs: if modname and c.modname != modname: continue if not target.has_key(type): target[type] = [] if not c.modname in target[type]: target[type].append(c.modname) logging.warn("saving callback table") assert callbacktable assert target callbacktable.data = target callbacktable.save()
def __init__(self, cfg=None, usersin=None, plugs=None, botname=None, nick=None, bottype=None, nocbs=None, *args, **kwargs): logging.debug("type is %s" % str(type(self))) if cfg: self.cfg = cfg ; botname = botname or self.cfg.name if not botname: botname = u"default-%s" % str(type(self)).split('.')[-1][:-2] if not botname: raise Exception("can't determine botname") self.fleetdir = u'fleet' + os.sep + stripname(botname) if not self.cfg: self.cfg = Config(self.fleetdir + os.sep + u'config') self.cfg.name = botname or self.cfg.name if not self.cfg.name: raise Exception("name is not set in %s config file" % self.fleetdir) logging.debug("name is %s" % self.cfg.name) LazyDict.__init__(self) logging.debug("created bot with config %s" % self.cfg.tojson(full=True)) self.ecounter = 0 self.ids = [] self.aliases = getaliases() self.reconnectcount = 0 self.plugs = coreplugs self.gatekeeper = GateKeeper(self.cfg.name) self.gatekeeper.allow(self.user or self.jid or self.cfg.server or self.cfg.name) self.starttime = time.time() self.type = bottype or "base" self.status = "init" self.networkname = self.cfg.networkname or self.cfg.name or "" from jsb.lib.datadir import getdatadir datadir = getdatadir() self.datadir = datadir + os.sep + self.fleetdir self.maincfg = getmainconfig() self.owner = self.cfg.owner if not self.owner: logging.debug(u"owner is not set in %s - using mainconfig" % self.cfg.cfile) self.owner = self.maincfg.owner self.users = usersin or getusers() logging.debug(u"owner is %s" % self.owner) self.users.make_owner(self.owner) self.outcache = outcache self.userhosts = LazyDict() self.nicks = LazyDict() self.connectok = threading.Event() self.reconnectcount = 0 self.cfg.nick = nick or self.cfg.nick or u'jsb' try: if not os.isdir(self.datadir): os.mkdir(self.datadir) except: pass self.setstate() self.outputlock = thread.allocate_lock() try: self.outqueue = Queue.PriorityQueue() self.eventqueue = Queue.PriorityQueue() except AttributeError: self.outqueue = Queue.Queue() self.eventqueue = Queue.Queue() self.laterqueue = Queue.Queue() self.encoding = self.cfg.encoding or "utf-8" self.cmndperms = getcmndperms() self.outputmorphs = outputmorphs self.inputmorphs = inputmorphs try: if nocbs: self.nocbs = nocbs.split(",") except ValueError: logging.error("cannot determine %s nocbs argument" % self.nocbs) self.lastiter = 0
def savecmndtable(modname=None, saveperms=True): """ save command -> plugin list to db backend. """ global cmndtable if not cmndtable.data: cmndtable.data = {} if modname: target = LazyDict(cmndtable.data) else: target = LazyDict() global cmndperms #if not cmndperms.data: cmndperms.data = {} from jsb.lib.commands import cmnds assert cmnds if cmnds.subs: for name, clist in cmnds.subs.iteritems(): if name: if clist and len(clist) == 1: target[name] = clist[0].modname for cmndname, c in cmnds.iteritems(): if modname and c.modname != modname or cmndname == "subs": continue if cmndname and c: target[cmndname] = c.modname cmndperms[cmndname] = c.perms logging.warn("saving command table") assert cmndtable assert target cmndtable.data = target cmndtable.save() if saveperms: logging.warn("saving command perms") cmndperms.save()
def __init__(self, url="", name=""): LazyDict.__init__(self) self.url = url self.name = name self.data = None self.error = None self.status = None self.reason = ""
def __init__(self, input={}, bot=None): LazyDict.__init__(self) if bot: self.bot = bot self.ctime = time.time() self.speed = self.speed or 5 self.nrout = self.nrout or 0 if input: self.copyin(input) if not self.token: self.setup()
def __init__(self, botname='default', i=0, nick="", ttime=time.time(), txt="", printto=None, d={}): if not d: LazyDict.__init__(self) else: LazyDict.__init__(self, d) self.botname = self.botname or botname self.idnr = self.idnr or i self.nick = self.nick or nick self.time = self.ttime or ttime self.txt = self.txt or txt self.printto = self.printto or printto or nick or ""
def __init__(self, input={}, bot=None): LazyDict.__init__(self) if bot: self.bot = bot self.threaded = False self.untildone = False self.ctime = time.time() self.speed = self.speed or 5 self.nrout = self.nrout or 0 if input: self.copyin(input) if not self.token: self.setup()
def login(response, input={}): """ display start html so that bot output can follow. """ try: host = socket.gethostname() except AttributeError: if os.environ.get('HTTP_HOST'): host = os.environ['HTTP_HOST'] else: host = os.environ['SERVER_NAME'] template = LazyDict({'version': getversion(), 'host': host, 'color': Config().color or "#C54848"}) if input: template.update(input) temp = os.path.join(os.getcwd(), 'templates/login.html') outstr = template.render(temp) response.out.write(outstr)
def login(response, input={}): """ display start html so that bot output can follow. """ try: host = socket.gethostname() except AttributeError: if os.environ.get('HTTP_HOST'): host = os.environ['HTTP_HOST'] else: host = os.environ['SERVER_NAME'] if 'localhost' in host: url = 'http://%s/dispatch' % host else: url = 'https://%s/dispatch' % host template = LazyDict({'url': url, 'version': getversion(), 'host': host, 'color': getmainconfig().color or "#4b7cc6"}) if input: template.update(input) temp = os.path.join(os.getcwd(), 'templates/login.html') outstr = template.render(temp) response.out.write(outstr)
def sync(): target = ";".join(state.data.watch) if not target: logging.warn("no channels started yet") ; return res = gettimeline(target) if not res: logging.warn("no result from %s" % id) ; return todo = [] for r in res: a = LazyDict(r) logging.debug("got %s" % a.tojson()) if a.creation_date not in state.data.seen: state.data.seen.insert(0, a.creation_date) ; todo.append(a) #todo.append(a) state.data.seen = state.data.seen[:100] state.save() logging.info("returned %s items" % len(todo)) return todo
def __init__(self, modname, cmnd, func, perms=[], threaded=False, wait=False, orig=None, how=None): LazyDict.__init__(self) if not modname: raise Exception("modname is not set - %s" % cmnd) self.modname = modname self.plugname = self.modname.split('.')[-1] self.cmnd = cmnd self.orig = orig self.func = func if type(perms) == types.StringType: perms = [perms, ] self.perms = perms self.plugin = self.plugname self.threaded = threaded self.wait = wait self.enable = True self.how = how or "channel"
def add(self, cmnd, func, perms, threaded=False, wait=False, orig=None, how=None, speed=None, regex=False, needcc=False, *args, **kwargs): """ add a command. """ modname = calledfrom(sys._getframe()) try: prev = self[cmnd] except KeyError: prev = None target = Command(modname, cmnd, func, perms, threaded, wait, orig, how, speed=speed, needcc=needcc) if regex: logging.info("regex command detected - %s" % cmnd) self.regex.append(target) target.regex = cmnd return self self[cmnd] = target try: p = cmnd.split('-')[0] if not self.pre: self.pre = LazyDict() if self.pre.has_key(p): if not self.pre[p]: self.pre[p] = [] if prev in self.pre[p]: self.pre[p].remove(prev) if target not in self.pre[p]: self.pre[p].append(target) else: self.pre[p] = [ target, ] except IndexError: pass return self
def login(response, input={}): """ display start html so that bot output can follow. """ try: host = socket.gethostname() except AttributeError: if os.environ.get('HTTP_HOST'): host = os.environ['HTTP_HOST'] else: host = os.environ['SERVER_NAME'] template = LazyDict({ 'version': getversion(), 'host': host, 'color': Config().color or "#C54848" }) if input: template.update(input) temp = os.path.join(os.getcwd(), 'templates/login.html') outstr = template.render(temp) response.out.write(outstr)
class Plugins(LazyDict): """ the plugins object contains all the plugins. """ loading = LazyDict() def size(self): return len(self) def exit(self): todo = cpy(self) for plugname in todo: self.unload(plugname) def reloadfile(self, filename, force=True): mlist = filename.split(os.sep) mod = [] for m in mlist[::-1]: mod.insert(0, m) if m == "myplugs": break modname = ".".join(mod)[:-3] if not isenabled(modname): logging.warn("%s is not enabled. not loading" % modname) return from boot import plugblacklist if modname in plugblacklist.data: logging.warn("%s is in blacklist .. not loading." % modname) return logging.debug("using %s" % modname) logging.info("reloading %s" % filename) try: self.reload(modname, force) except RequireError, ex: logging.info(str(ex))
def __init__(self, modname, cmnd, func, perms=[], threaded=False, wait=False, orig=None, how=None): LazyDict.__init__(self) if not modname: raise Exception("modname is not set - %s" % cmnd) self.modname = cpy(modname) self.plugname = self.modname.split('.')[-1] self.cmnd = cpy(cmnd) self.orig = cpy(orig) self.func = func if type(perms) == types.StringType: perms = [perms, ] self.perms = cpy(perms) self.plugin = self.plugname self.threaded = cpy(threaded) self.wait = cpy(wait) self.enable = True self.how = how or "overwrite" self.regex = None
def handle_forget(bot, event): """" arguments: <item> and <matchstring> - set an information item. """ if not event.rest: event.missing("<item> and <match>") return try: (what, match) = event.rest.split(" and ", 2) except ValueError: what = event.rest match = None what = what.lower() items = GlobalPersist("learndb") got = False if not items.data: items.data = LazyDict() if items.data.has_key(what): if match == None: del items.data[what] got = True else: for i in range(len(items.data[what])): if match in items.data[what][i]: del items.data[what][i] got = True break if got: items.save() event.reply("item removed from global database") else: event.reply("no %s item in global database" % what)
def __init__(self, ddir=None, filename=None): self.datadir = ddir or getdatadir() self.filename = filename or 'mainusers' self.udir = self.datadir + os.sep + self.filename Persist.__init__(self, self.udir) if not self.data: self.data = LazyDict() self.data.names = self.data.names or {} logging.warn("users object created from %s" % self.udir)
def __init__(self, filename, host): PlugPersist.__init__(self, filename) if not self.data: self.data = LazyDict() if not self.data.has_key('names'): self.data['names'] = [] if not self.data.has_key('urls'): self.data['urls'] = {} if not self.data.has_key('feeds'): self.data['feeds'] = {} if not self.data.has_key('host'): self.data['host'] = host self.feeds = {}
def savecmndtable(modname=None, saveperms=True): """ save command -> plugin list to db backend. """ global cmndtable if not cmndtable.data: cmndtable.data = {} if modname: target = LazyDict(cmndtable.data) else: target = LazyDict() global shorttable if not shorttable.data: shorttable.data = {} if modname: short = LazyDict(shorttable.data) else: short = LazyDict() global cmndperms from jsb.lib.commands import cmnds assert cmnds for cmndname, c in cmnds.iteritems(): if modname and c.modname != modname or cmndname == "subs": continue if cmndname and c: target[cmndname] = c.modname cmndperms[cmndname] = c.perms try: s = cmndname.split("-")[1] if not target.has_key(s): if not short.has_key(s): short[s] = [ cmndname, ] if cmndname not in short[s]: short[s].append(cmndname) except (ValueError, IndexError): pass logging.warn("saving command table") assert cmndtable assert target cmndtable.data = target cmndtable.save() logging.warn("saving short table") assert shorttable assert short shorttable.data = short shorttable.save() logging.warn("saving RE table") for command in cmnds.regex: retable.data[command.regex] = command.modname assert retable retable.save() if saveperms: logging.warn("saving command perms") cmndperms.save()
class Plugins(LazyDict): """ the plugins object contains all the plugins. """ loading = LazyDict() def size(self): return len(self) def exit(self): todo = cpy(self) for plugname in todo: self.unload(plugname) def reloadfile(self, filename, force=True): mlist = filename.split(os.sep) mod = [] for m in mlist[::-1]: mod.insert(0, m) if m == "myplugs": break modname = ".".join(mod)[:-3] if not isenabled(modname): logging.warn("%s is not enabled. not loading" % modname) ; return from boot import plugblacklist if modname in plugblacklist.data: logging.warn("%s is in blacklist .. not loading." % modname) ; return logging.debug("using %s" % modname) logging.info("reloading %s" % filename) try: self.reload(modname, force) except RequireError, ex: logging.info(str(ex)) def loadall(self, paths=[], force=True): """ load all plugins from given paths, if force is true .. otherwise load all plugins for default_plugins list. """ if not paths: paths = plugin_packages imp = None old = self.keys() new = [] logging.warn("loading all from paths %s" % paths) for module in paths: try: imp = _import(module) except ImportError, ex: #handle_exception() logging.warn("no %s plugin package found - %s" % (module, str(ex))) continue except Exception, ex: handle_exception() logging.debug("got plugin package %s" % module) try: for plug in imp.__plugs__: if "gae" in plug: continue mod = "%s.%s" % (module, plug) if not isenabled(mod): logging.warn("%s is not enabled. not loading" % mod) ; continue try: self.reload(mod, force=force, showerror=True) except RequireError, ex: logging.info(str(ex)) ; continue except KeyError: logging.debug("failed to load plugin package %s" % module) ; continue except Exception, ex: handle_exception() ; continue new.append(mod)
def __init__(self, filename, verbose=False, input={}, ddir=None, nolog=False, *args, **kw): assert filename LazyDict.__init__(self, input, *args, **kw) a = "%s%s" % (os.sep, os.sep) filename = filename.replace(a, os.sep) self.origname = filename self.origdir = ddir or getdatadir() self.setcfile(ddir or getdatadir(), filename) self.jsondb = None if not self._comments: self._comments = {} logging.info("fromfile - %s from %s" % (self.origname, whichmodule(2))) self.fromfile(self.cfile) self.origdir = ddir or getdatadir() self.setcfile(ddir or getdatadir(), filename) self.init() if self.owner: logging.info("owner is %s" % self.owner) if not self.has_key("uuid"): self.setuuid() if not self.has_key("cfile"): self.cfile = self.setcfile(self.origdir, self.origname) assert self.cfile if not self.origdir in self.cfile: raise WrongFileName("%s not in %s" % (self.origdir, self.cfile))
def handle_overflowsearch(bot, event): result = [] res = search(event.rest, 10) nritems = 10 for aa in res['questions'][:nritems]: a = LazyDict(aa) if not a.accepted_answer_id: continue url = "http://stackoverflow.com/questions/%s" % a.accepted_answer_id result.append("%s - %s - %s" % (a.title, ";".join(a.tags), url)) if result: event.reply("results: ", result, dot=" -=- ") else: event.reply("no result found")
def getaliases(ddir=None, force=True): """ return global aliases. """ global aliases if not aliases or force: from jsb.lib.persist import Persist from jsb.utils.lazydict import LazyDict d = ddir or getdatadir() p = Persist(d + os.sep + "run" + os.sep + "aliases") if not p.data: p.data = LazyDict() aliases = p.data return aliases
def sync(): target = ";".join(state.data.watch) if not target: logging.warn("no channels started yet") return res = gettimeline(target) if not res: logging.warn("no result from %s" % id) return todo = [] for r in res: a = LazyDict(r) logging.debug("got %s" % a.tojson()) if a.creation_date not in state.data.seen: state.data.seen.insert(0, a.creation_date) todo.append(a) #todo.append(a) state.data.seen = state.data.seen[:100] state.save() logging.info("returned %s items" % len(todo)) return todo
def __init__(self, input={}, bot=None): LazyDict.__init__(self) if bot: self.bot = bot self.txt = "" self.usercmnd = "" self.bottype = "botbase" self.relayed = [] self.path = [] self.cbs = [] self.result = [] self.waiting = [] self.threads = self.threads or [] self.queues = self.queues or [] self.finished = self.finished or threading.Event() self.resqueue = self.resqueue or Queue.Queue() self.inqueue = self.inqueue or Queue.Queue() self.outqueue = self.outqueue or Queue.Queue() self.stop = False self.bonded = False self.copyin(input) self.ctime = time.time()
def get(self): try: cont = self.request.get('continue') logging.info('openid - login form %s' % cont) urlstring = self.create_openid_url(cont) template_values = LazyDict({ 'cont': cont, 'urlstring': urlstring, 'appname': getversion() }) try: host = socket.gethostname() except AttributeError: if os.environ.get('HTTP_HOST'): host = os.environ['HTTP_HOST'] else: host = os.environ['SERVER_NAME'] inputdict = {'version': getversion(), 'host': host, 'loginurl': urlstring} template_values.update(inputdict) temp = os.path.join(os.getcwd(), 'templates/login.html') outstr = template_values.render(temp) self.response.out.write(outstr) except Exception, ex: handle_exception()
class FloodControl(object): def __init__(self): self.stats = StatDict() self.times = LazyDict() self.wait = LazyDict() self.warned = LazyDict() def reset(self, userhost): try: del self.times[userhost] except KeyError: pass try: del self.stats[userhost] except KeyError: pass try: del self.wait[userhost] except KeyError: pass try: del self.warned[userhost] except KeyError: pass def check(self, userhost, timetomonitor=60, threshold=10, wait=120, floodrate=1): u = userhost t = time.time() w = wait if self.times.has_key(u): if t - self.times[u] > w: self.reset(u) ; return False if (t - self.times[u] < timetomonitor): self.stats.upitem(u) if (self.stats.get(u) > threshold) or (t - self.times[u] < floodrate): self.wait[userhost] = wait ; return True else: self.times[u] = t ; return False if self.stats.get(u) <= threshold: return False return True def checkevent(self, event, dobind=True): if not event.iscommand: return False if getmainconfig().floodallow: return False if dobind: event.bind() if not event.user: got = False else: got = True t = got and event.user.data.floodtime or 60 if t < 60: t = 60 threshold = got and event.user.data.floodthreshold or 20 if threshold < 20: threshold = 20 wait = got and event.user.data.floodwait or 120 if wait < 120: wait = 120 floodrate = got and event.user.data.floodrate or 0.1 if floodrate < 0.1: floodrate = 0.1 if not self.check(event.userhost, t, threshold, wait, floodrate): return False if event.user and "OPER" in event.user.data.perms: return False logging.warn("floodcontrol block on %s" % event.userhost) if event.userhost not in self.warned: logging.warn("floodcontrol block on %s" % event.userhost) event.reply("floodcontrol enabled (%s seconds)" % wait) self.warned[event.userhost] = time.time() return True
def get(self): try: cont = self.request.get('continue') logging.info('openid - login form %s' % cont) urlstring = self.create_openid_url(cont) template_values = LazyDict({ 'continue': cont, 'urlstring': urlstring, 'appname': getversion() }) try: host = socket.gethostname() except AttributeError: if os.environ.get('HTTP_HOST'): host = os.environ['HTTP_HOST'] else: host = os.environ['SERVER_NAME'] inputdict = {'version': getversion(), 'host': host} template_values.update(inputdict) temp = os.path.join(os.getcwd(), 'templates/login.html') outstr = template_values.render(temp) self.response.out.write(outstr) except Exception, ex: handle_exception()
class Pdod(Persist): """ pickled dicts of dicts """ def __init__(self, filename): Persist.__init__(self, filename) if not self.data: self.data = LazyDict() def __getitem__(self, name): """ return item with name """ if self.data.has_key(name): return self.data[name] def save(self): Persist.save(self) def __delitem__(self, name): """ delete name item """ if self.data.has_key(name): return self.data.__delitem__(name) def __setitem__(self, name, item): """ set name item """ self.data[name] = item def __contains__(self, name): return self.data.__contains__(name) def setdefault(self, name, default): """ set default of name """ return self.data.setdefault(name, default) def has_key(self, name): """ has name key """ return self.data.has_key(name) def has_key2(self, name1, najsb): """ has [name1][najsb] key """ if self.data.has_key(name1): return self.data[name1].has_key(najsb) def get(self, name1, najsb): """ get data[name1][najsb] """ try: result = self.data[name1][najsb] return result except KeyError: pass def set(self, name1, najsb, item): """ set name, najsb item """ if not self.data.has_key(name1): self.data[name1] = {} self.data[name1][najsb] = item
def __init__(self, host, port, name='sxmpp'): self.name = name self.connection = None self.encoding = "utf-8" self.stop = False self.result = LazyDict() self.final = LazyDict() self.subelements = [] self.reslist = [] self.cur = u"" self.tags = [] self.host = host self.port = port self.handlers = LazyDict() self.addHandler('proceed', self.handle_proceed) self.addHandler('message', self.handle_message) self.addHandler('presence', self.handle_presence) self.addHandler('iq', self.handle_iq) self.addHandler('stream', self.handle_stream) self.addHandler('stream:stream', self.handle_stream) self.addHandler('stream:error', self.handle_streamerror) self.addHandler('stream:features', self.handle_streamfeatures)
def add(self, cmnd, func, perms, threaded=False, wait=False, orig=None, how=None, *args, **kwargs): """ add a command. """ modname = calledfrom(sys._getframe()) target = Command(modname, cmnd, func, perms, threaded, wait, orig, how) self[cmnd] = target try: c = cmnd.split('-')[1] if not self.subs: self.subs = LazyDict() if self.subs.has_key(c): if not self.subs[c]: self.subs[c] = [] if target not in self.subs[c]: self.subs[c].append(target) else: self.subs[c] = [target, ] except IndexError: pass try: p = cmnd.split('-')[0] if not self.pre: self.pre = LazyDict() if self.pre.has_key(p): if not self.pre[p]: self.pre[p] = [] if target not in self.pre[p]: self.pre[p].append(target) else: self.pre[p] = [target, ] except IndexError: pass return self
def getplus(target): credentials = _import_byfile( "credentials", getdatadir() + os.sep + "config" + os.sep + "credentials.py") url = "https://www.googleapis.com/plus/v1/people/%s/activities/public?alt=json&pp=1&key=%s" % ( target, credentials.googleclient_apikey) result = geturl2(url) data = json.loads(result) res = [] for item in data['items']: i = LazyDict(item) res.append("%s - %s - %s" % (i.actor['displayName'], i['title'], item['url'])) return res
def boteventcb(inputdict, request, response): #logging.warn(inputdict) #logging.warn(dir(request)) #logging.warn(dir(response)) body = request.body #logging.warn(body) payload = json.loads(body) try: botjson = payload['bot'] logging.warn(botjson) cfg = LazyDict(json.loads(botjson)) #logging.warn(str(cfg)) bot = BotFactory().create(cfg.type, cfg) logging.warn("created bot: %s" % bot.tojson(full=True)) eventjson = payload['event'] #logging.warn(eventjson) event = EventBase() event.update(LazyDict(json.loads(eventjson))) logging.warn("created event: %s" % event.tojson(full=True)) event.notask = True bot.doevent(event) except Exception, ex: handle_exception()
def resume(self, sessionfile, exclude=[]): """ resume bot from session file. """ session = json.load(open(sessionfile, 'r')) chan = session.get("channel") for name, cfg in session['bots'].iteritems(): dont = False for ex in exclude: if ex in name: dont = True if dont: continue cfg = LazyDict(cfg) try: if not cfg.disable: logging.info("resuming %s" % cfg) start_new_thread(self.resumebot, (cfg, chan)) except: handle_exception() ; return time.sleep(10) self.startok.set()
def handle_learnchan(bot, event): """" arguments: <item> is <description> - set an information item. """ if not event.rest: event.missing("<item> is <description>") return try: (what, description) = event.rest.split(" is ", 1) except ValueError: event.missing("<item> is <description>") return what = what.lower() items = PlugPersist(event.channel) if not items.data: items.data = LazyDict() if not items.data.has_key(what): items.data[what] = [] if description not in items.data[what]: items.data[what].append(description) items.save() event.reply("%s item added to %s database" % (what, event.channel))
def savecmndtable(modname=None, saveperms=True): """ save command -> plugin list to db backend. """ global cmndtable if not cmndtable.data: cmndtable.data = {} if modname: target = LazyDict(cmndtable.data) else: target = LazyDict() global shorttable if not shorttable.data: shorttable.data = {} if modname: short = LazyDict(shorttable.data) else: short = LazyDict() global cmndperms from jsb.lib.commands import cmnds assert cmnds for cmndname, c in cmnds.iteritems(): if modname and c.modname != modname or cmndname == "subs": continue if cmndname and c: target[cmndname] = c.modname cmndperms[cmndname] = c.perms try: s = cmndname.split("-")[1] if not target.has_key(s): if not short.has_key(s): short[s] = [cmndname, ] if cmndname not in short[s]: short[s].append(cmndname) except (ValueError, IndexError): pass logging.warn("saving command table") assert cmndtable assert target cmndtable.data = target cmndtable.save() logging.warn("saving short table") assert shorttable assert short shorttable.data = short shorttable.save() logging.warn("saving RE table") for command in cmnds.regex: retable.data[command.regex] = command.modname assert retable retable.save() if saveperms: logging.warn("saving command perms") cmndperms.save()
def makeoptions(ievent, options={}): options = LazyDict(options) try: optargs = "" optlist = [] if not options.has_key('--filter'): options['--filter'] = "" if not options.has_key('--to'): options['--to'] = None if not options.has_key('--chan'): options['--chan'] = ievent.channel if not options.has_key('--how'): options['--how'] = "msg" if not options.has_key('--speed'): options['--speed'] = str(ievent.speed) else: options['--speed'] = str(options['--speed']) for i, j in options.iteritems(): if '--' in i: optlist.append("%s=" % i[2:]) if j: optlist.append(j) continue if '-' in i: if j: optargs += ":%s" % i[1:] else: optargs += i[1:] args = ievent.txt.split() try: (opts, rest) = getopt.getopt(args[1:], optargs, optlist) except AttributeError, ex: print "option not allowed: %s" % str(ex), ievent.txt, options return 0 except getopt.GetoptError, ex: return 0
class Commands(LazyDict): """ the commands object holds all commands of the bot. """ def add(self, cmnd, func, perms, threaded=False, wait=False, orig=None, how=None, *args, **kwargs): """ add a command. """ modname = calledfrom(sys._getframe()) target = Command(modname, cmnd, func, perms, threaded, wait, orig, how) self[cmnd] = target try: c = cmnd.split('-')[1] if not self.subs: self.subs = LazyDict() if self.subs.has_key(c): if not self.subs[c]: self.subs[c] = [] if target not in self.subs[c]: self.subs[c].append(target) else: self.subs[c] = [target, ] except IndexError: pass try: p = cmnd.split('-')[0] if not self.pre: self.pre = LazyDict() if self.pre.has_key(p): if not self.pre[p]: self.pre[p] = [] if target not in self.pre[p]: self.pre[p].append(target) else: self.pre[p] = [target, ] except IndexError: pass return self def woulddispatch(self, bot, event, cmnd=""): """ dispatch an event if cmnd exists and user is allowed to exec this command. """ event.bind(bot) cmnd = cmnd or event.usercmnd.lower() if not cmnd: return try: cmnd = event.chan.data.aliases[cmnd] except (KeyError, TypeError): try: cmnd = bot.aliases.data[cmnd] except (KeyError, TypeError): pass try: if cmnd: event.txt = cmnd + ' ' + ' '.join(event.txt.split()[1:]) event.usercmnd = cmnd.split()[0] event.prepare() except (TypeError, KeyError, AttributeError): pass logging.debug("commands - %s" % cmnd) bot.plugs.reloadcheck(bot, event) result = None cmnd = event.usercmnd try: result = self[cmnd] except KeyError: if self.subs and self.subs.has_key(cmnd): cmndlist = self.subs[cmnd] if len(cmndlist) == 1: result = cmndlist[0] else: event.reply("try one of: %s" % ", ".join([x.cmnd for x in cmndlist])) ; return else: if self.pre and self.pre.has_key(cmnd): cmndlist = self.pre[cmnd] if len(cmndlist) == 1: result = cmndlist[0] else: event.reply("try one of: %s" % ", ".join([x.cmnd for x in cmndlist])) ; return logging.debug("commands - woulddispatch result: %s" % result) return result def dispatch(self, bot, event, wait=0): """ dispatch an event if cmnd exists and user is allowed to exec this command. """ event.bind(bot) if event.groupchat: id = event.auth = event.userhost else: id = event.auth if not event.user: raise NoSuchUser(event.auth) c = self.woulddispatch(bot, event) if not c: raise NoSuchCommand() if bot.cmndperms and bot.cmndperms[c.cmnd]: perms = bot.cmndperms[c.cmnd] else: perms = c.perms if bot.allowall: return self.doit(bot, event, c, wait=wait) elif event.chan and event.chan.data.allowcommands and event.usercmnd in event.chan.data.allowcommands: if not 'OPER' in perms: return self.doit(bot, event, c, wait=wait) else: logging.warn("commands - %s is not in allowlist" % c) elif not bot.users or bot.users.allowed(id, perms, bot=bot): return self.doit(bot, event, c, wait=wait) elif bot.users.allowed(id, perms, bot=bot): return self.doit(bot, event, c, wait=wait) return event def doit(self, bot, event, target, wait=0): """ do the dispatching. """ if not target.enable: return if target.modname in event.chan.data.denyplug: logging.warn("commands - %s is denied in channel %s - %s" % (target.plugname, event.channel, event.userhost)) return id = event.auth or event.userhost event.iscommand = True event.how = target.how logging.warning('commands - dispatching %s for %s' % (event.usercmnd, id)) try: if bot.isgae: if not event.notask and (target.threaded or event.threaded) and not event.nothreads: logging.warn("commands - LAUNCHING AS TASK") from jsb.lib.gae.tasks import start_botevent event.txt = event.origtxt start_botevent(bot, event, event.speed) event.reply("task started for %s" % event.auth) else: target.func(bot, event) ; event.ready() ; return event else: if target.threaded and not event.nothreads: logging.warning("commands - launching thread for %s" % event.usercmnd) t = start_bot_command(target.func, (bot, event)) event.threads.append(t) else: event.dontclose = False; cmndrunner.put(target.modname, target.func, bot, event) except Exception, ex: logging.error('commands - %s - error executing %s' % (whichmodule(), str(target.func))) raise return event
def __init__(self, input={}, bot=None): LazyDict.__init__(self) if bot: self.bot = bot self.bottype = "botbase" self.relayed = [] self.copyin(input)
def formatevent(bot, ievent, channels, forwarded=False): m = { 'datetime': datetime.now(), 'separator': format_opt('separator'), 'event_prefix': format_opt('event_prefix'), 'network': bot.networkname, 'nick': ievent.nick, 'target': stripname(ievent.channel), 'botname': bot.name, 'txt': ievent.txt, 'type': ievent.cbtype } m = LazyDict(m) if ievent.cmnd == 'PRIVMSG': if ievent.txt.startswith('\001ACTION'): m.txt = '* %s %s' % (m.nick, ievent.txt[7:-1].strip()) else: if bot.type == "irc": m.txt = '<%s> %s' % (m.nick, striphtml(ievent.txt)) elif not forwarded: m.txt = '<%s> %s' % (m.nick, bot.normalize(ievent.txt)) else: m.txt = bot.normalize(ievent.txt) elif ievent.cmnd == 'NOTICE': m.target = ievent.arguments[0] m.txt = "-%s- %s"%(ievent.nick, ievent.txt) elif ievent.cmnd == 'TOPIC': m.txt = '%s changes topic to "%s"'%(ievent.nick, ievent.txt) elif ievent.cmnd == 'MODE': margs = ' '.join(ievent.arguments[1:]) m.txt = '%s sets mode: %s'% (ievent.nick, margs) elif ievent.cmnd == 'JOIN': m.txt = '%s (%s) has joined %s'%(ievent.nick, ievent.userhost, ievent.channel) elif ievent.cmnd == 'KICK': m.txt = '%s was kicked by %s (%s)'% (ievent.arguments[1], ievent.nick, ievent.txt) elif ievent.cmnd == 'PART': m.txt = '%s (%s) has left %s'% (ievent.nick, ievent.userhost, ievent.channel) elif ievent.cmnd in ('QUIT', 'NICK'): if not ievent.user or not ievent.user.data.channels: logging.debug("chatlog - can't find joined channels for %s" % ievent.userhost) return m cmd = ievent.cmnd nick = cmd == 'NICK' and ievent.txt or ievent.nick for c in event.user.channels: if [bot.name, c] in channels: if True: if cmd == 'NICK': m.txt = '%s (%s) is now known as %s'% (ievent.nick, ievent.userhost, ievent.txt) else: m.txt= '%s (%s) has quit: %s'% (ievent.nick, ievent.userhost, ievent.txt) m.type = ievent.cmnd.lower() m.target = c elif ievent.cbtype == 'PRESENCE': if ievent.type == 'unavailable': m.txt = "%s left" % ievent.nick else: m.txt = "%s joined" % ievent.nick return m
def __getitem__(self, item): """ accessor function. """ if not self.has_key(item): return None else: return LazyDict.__getitem__(self, item)
def set(self, item, value): """ set item to value. """ LazyDict.__setitem__(self, item, value)
def __init__(self): self.stats = StatDict() self.times = LazyDict() self.wait = LazyDict() self.warned = LazyDict()