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 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 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, 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 __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 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()
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()
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
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 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()
