def run(self, **kwargs):
self.start()
self._timer._status = "ok"
self._timer._nrs.loops += 1
event = Event()
event.name = self._name
event.origin = "clock@bot"
self.func(event.parse())
def timer(event):
""" echo txt on a given time. """
if not event._parsed.rest: return
seconds = 0
line = ""
for word in event._parsed.args:
if word.startswith("+"):
try:
seconds = int(word[1:])
except:
event.reply("%s is not an integer" % seconds)
return
else:
line += word + " "
if seconds: target = time.time() + seconds
else:
try:
target = get_day(event._parsed.rest)
except ENODATE:
target = to_day(day())
hour = get_hour(event._parsed.rest)
if hour: target += hour
if not target or time.time() > target:
event.reply("already passed given time.")
return
e = Event()
e.services = "clock"
e.prefix = "timer"
e.txt = event._parsed.rest
e.time = target
e.done = False
e.save()
timer = Timer(target, e.reply, e.txt)
launcher.launch(timer.start)
event.ok(time.ctime(target))
def since(self, start, *args, **kwargs):
""" return all object since a given time. """
e = Event(**kwargs)
e.start = start
for fn in self.prefixed(*args, **e):
try:
obj = Object().load(fn)
except:
logging.warn("fail %s" % fn)
continue
if "deleted" in obj and obj.deleted: continue
yield obj
def re(event):
try: t = parse_time(event._parsed.rest)
except ValueError: t = None
if not t: event.reply("since when ?") ; return
for obj in storage.since("cblog", t):
e = Event(obj)
event.reply("%s %s %s" % (e.created.split()[3], e.nick or e.origin, e.txt))
def cmndrun(event):
cfg.workdir = "test.data"
for name in sorted(kernel.modules()):
if name in ["meds.plugs.test", "meds.plugs.rss"]: continue
mod = kernel.direct(name)
for n in dir(mod):
if n in exclude: continue
func = getattr(mod, n, None)
if func and type(func) in [types.FunctionType, types.MethodType]:
if "event" in func.__code__.co_varnames:
e = Event()
e.btype = event.btype
e._funcs.append(func)
e.workdir = "test.data"
e.origin = "test@bot"
kernel.put(e)
def init(event):
for fn in storage.prefixed("timer"):
e = Event().load(fn)
if e.done: continue
if "time" not in e: continue
if time.time() < int(e.time):
timer = Timer(int(e.time), e.announce, e.txt)
launcher.launch(timer.start)
def event(self):
e = Event()
e.server = self._cfg.server
e.btype = sname(self)
e.txt = input()
e.txt = e.txt.rstrip()
e.origin = "root@shell"
return e
def initialize(self, name):
""" initialze package. """
event = Event()
thrs = []
for modname in self.walk(name):
n = modname.split(".")[-1]
mod = self._table.get(modname, None)
if not mod:
mod = self.load(modname)
if n in self._cfg.default:
mod.init(event)
if self._cfg.all or n in self._cfg.init.split(","):
if n not in self._cfg.exclude.split(','):
logging.info("! init %s" % n)
thr = self.launch(mod.init,
event,
name="%s.initialize" % n)
thrs.append(thr)
event.ready()
return thrs
def test_cmnds(self):
for cmnd in sorted(cmnds.handlers.keys()):
if cmnd in ["test", "fetcher"]: continue
event = Event()
event.txt = cmnd + " arg1"
event._bot = bot
event.origin = "tester@bot"
event.parse()
logging.warn("< %s" % event.txt)
func = cmnds.get(event.cmnd)
if func: launcher.launch(func, event)
events.append(event)
for event in events: event.wait(3.0)
def last(self, *args, **kwargs):
""" return last record with a matching prefix. """
e = Event(**kwargs)
for fn in self.prefixed(*args, **kwargs)[::-1]:
try:
obj = Object().load(fn)
except:
logging.warn("fail %s" % fn)
continue
if "deleted" in obj and obj.deleted: continue
if len(args) > 1 and obj.get(args[0]) != args[1]: continue
return obj
def testcmnds(event):
cfg.workdir = "test.data"
for cmnd in sorted(kernel._handlers.keys()):
e = Event()
e.btype = event.btype
e.txt = "%s %s" % (cmnd, randomname())
e.origin = "test@bot"
e.parse()
event.reply("put %s" % e.txt)
kernel.put(e)
def scan(self, path, *args, **kwargs):
""" scan all files in the cfg.main.workdir directory. """
p = Event(**kwargs)
if not path.endswith(os.sep): path += os.sep
for root, dirs, files in os.walk(path, topdown=True):
if not os.path.isdir(root): continue
for fn in files:
fnn = j(root, fn)
timed = fn_time(fnn)
if timed and p.start and timed < p.start: continue
if timed and p.end and timed > p.end: continue
yield fnn
def dccloop(self, event, s):
sockfile = s.makefile('rw')
#s.setblocking(True)
self.register_fd(s)
while 1:
try:
res = sockfile.readline()
if not res: break
res = res.rstrip()
logging.info("< %s %s" % (event.origin, res))
e = Event()
e.btype = "DCC"
e.txt = res
e.outer = sockfile
e.origin = event.origin
super().dispatch(e)
except socket.timeout:
time.sleep(0.01)
except socket.error as ex:
if ex.errno in [
socket.EAGAIN,
]: continue
else: raise
except Exception as ex:
logging.error(get_exception())
sockfile.close()
def event(self):
event = Event()
event.btype = sname(self)
event.txt = str(os.read(fd, 512), "utf-8")
event.txt = event.txt.rstrip()
event.origin = "root@shell"
yield event
def event(self):
event = Event()
event._bot = self
event.txt = input(self.prompt())
event.origin = "root@shell"
event.parse()
return event
def event(self, txt=""):
e = Event(txt=txt)
e.txt = txt
e.origin = "test@bot"
e._bot = self
e.parse()
return e
def presenced(self, data):
from meds.mods import cmnds
logging.debug("< %s.read %s" % (self.type, data))
o = Event()
o.update(data)
o._bot = self
o["from"] = str(o["from"])
o.origin = o["from"]
if "txt" not in o: o.txt = ""
o.element = "presence"
if o.type == 'subscribe':
pres = Event({'to': o["from"], 'type': 'subscribed'})
self.client.send_presence(pres)
pres = Event({'to': o["from"], 'type': 'subscribe'})
self.client.send_presence(pres)
elif o.type == "unavailable" and o.origin in self.channels: self.channels.remove(o.origin)
elif o.origin != self.user and o.origin not in self.channels: self.channels.append(o.origin)
o.no_dispatch = True
logging.info("< %s.%s %s" % (self.type, o.type, o.origin))
o.parse()
func = cmnds.get(o.cmnd)
if func: func(o)
def cmndrun(event):
for cmnd in sorted(list(cmnds.handlers.keys())):
if cmnd in exclude: continue
e = Event()
e.txt = ("!" + cmnd)
e._bot = event._bot
e.workdir = "test.data"
e.origin = "test@bot"
e.parse()
logging.warn("< %s" % e.txt)
scheduler.dispatch(e)
def cmnd(self, txt):
event = Event()
event._server = self._cfg.server
event.btype = sname(self)
event.origin = "user@bot"
event.txt = txt
self.dispatch(event)
return event
def reload(self, name, force=False, event=None):
from meds.event import Event
e = event or Event()
if name not in self._table: self.load(name, True)
n = name.split(".")[-1]
if name in self._table and "shutdown" in dir(self._table[name]):
self._table[name].shutdown(e)
e.ready()
if name not in self._table or force: self.load(name, True)
else: self._table[name] = importlib.reload(self._table[name])
if "init" in dir(self._table[name]):
self._table[name].init(e)
e.ready()
return self._table[name]
def cmnd(self, txt, bot=None):
from meds.event import Event
event = Event()
event.origin = "user@bot"
event._bot = self
event.txt = txt
event.parse()
scheduler.put(event)
return event
def reboot(event):
""" reboot the bot, allowing statefull reboot (keeping connections alive). """
if not cfg.reboot:
event.reply("reboot is not enabled")
return
if not users.allowed(event.origin, "REBOOT"):
event.reply("you don't have reboot permissions.")
return
event.announce("rebooting")
resume = Object()
resume.kernel = kernel._resume
resume.fleet = fleet
resume.save("resume")
e = Event()
e._funcs.append(real_reboot)
print(e)
kernel.put(e)
def shutdown(self, close=True):
""" stop bots, services and plugins. """
logging.debug("shutdown")
event = Event()
thrs = []
for key, mod in self._table.items():
if "meds.run" not in key:
continue
if "shutdown" in dir(mod):
thr = self.launch(mod.shutdown, event)
thrs.append(thr)
for bot in meds.core.fleet:
if "stop" in dir(bot):
thr = self.launch(bot.stop)
thrs.append(thr)
if "exit" in dir(bot):
thr = self.launch(bot.exit)
thrs.append(thr)
bot.ready()
meds.core.launcher.waiter(thrs)
self.killall()
self.ready()
def stats(event, **kwargs):
e = Event(kwargs)
cfg = cfgs.get("stats", None)
if not cfg:
cfgs.stats = cfg = storage.last("cfg", "stats")
name = event._parsed.rest or e.name
if "." in name: name = name.split(".")[-1]
name = name.lower()
delta = time.time() - starttime
awake = time.time() - today()
needed = seconds(nr(name))
if needed:
nrtimes = int(delta / needed)
txt = "%s #%s" % (name.upper(), nrtimes)
if name in omschrijving: txt += " (%s)" % omschrijving.get(name)
txt += " elke %s" % elapsed(seconds(nr(name)))
if name in soort:
txt += " door een %s" % soort.get(name, "slachtoffer")
txt += " bijv. in %s" % random.choice(gemeenten)
if name in tags: txt += " %s" % tags.get(name)
if cfg and cfg.showurl and name in urls:
txt += " - %s" % urls.get(name)
event.announce(txt)
def dccloop(self, event, s):
from meds.mods import cmnds
sockfile = s.makefile('rw')
s.setblocking(True)
while 1:
try:
res = sockfile.readline()
if not res: break
res = res.rstrip()
logging.info("< %s.loop %s" % (self.type, event.origin))
e = Event()
e._bot = self
e.txt = res
e.outer = sockfile
e.origin = event.origin
e.parse()
func = cmnds.get(e.cmnd)
if func: func(e)
except socket.timeout: time.sleep(0.01)
except socket.error as ex:
if ex.errno in [socket.EAGAIN, ]: continue
else: raise
except Exception as ex: logging.error(get_exception())
sockfile.close()
def parse(self, txt):
rawstr = str(txt)
logging.debug("< %s/parse %s" % (self.type, rawstr))
obj = Event()
obj._bot = self
obj.arguments = rawstr.split(":")[0].split()
if not obj.arguments: obj.arguments = rawstr.split(":")[1].split()
obj.txt = rawstr.split(":", 2)[-1]
if rawstr[0] == ":": obj.origin = obj.arguments[0] ; obj.cmnd = obj.arguments[1]
else: obj.origin = self.server ; obj.cmnd = obj.arguments[0]
try: obj.nick, obj.userhost = obj.origin.split("!")
except: pass
obj.target = obj.arguments[-1]
if obj.target.startswith("#"): obj.channel = obj.target
return obj
def timer(event):
if not event.rest: return
day = get_day(event.rest) or today()
hour = get_hour(event.rest)
target = day + get_hour(event.rest)
if time.time() > target: event.reply("already passed given time.") ; return
event.reply("time is %s" % time.ctime(target))
e = Event()
e._bot = event._bot
e.services = "clock"
e.prefix = "timer"
e.txt = event.rest
e.time = target
e.done = False
e.save()
timer = Timer(target, e.parse())
launcher.launch(timer.start)
e.ok()
def messaged(self, data):
from meds.mods import cmnds
logging.debug("< %s.read %s" % (self.type, data))
m = Event()
m.update(data)
m._bot = self
if m.type == "error": logging.error("^ %s" % m.error) ; return
m.cc = self.cc
m["from"] = str(m["from"])
if self.user in m["from"]: logging.info("< %s.%s %s" % (self.type, m.type, m["from"])) ; return
m.origin = m["from"]
m.channel = m.origin
m.to = m.origin
m.element = "message"
m.txt = m["body"]
if '<delay xmlns="urn:xmpp:delay"' in str(data):
logging.info("# %s.ignore %s %s" % (self.type, m.type, m.origin))
return
logging.info("< %s.%s %s" % (self.type, m.type, m.origin))
m.parse()
func = cmnds.get(m.cmnd)
if func: func(m)
def parsing(self, txt):
rawstr = str(txt)
obj = Event()
obj.server = self._cfg.server
obj.cc = self.cc
obj.btype = sname(self)
obj.arguments = []
arguments = rawstr.split()
obj.origin = arguments[0]
if obj.origin.startswith(":"):
obj.origin = obj.origin[1:]
if len(arguments) > 1: obj.command = arguments[1]
if len(arguments) > 2:
txtlist = []
adding = False
for arg in arguments[2:]:
if arg.startswith(":"):
adding = True
txtlist.append(arg[1:])
continue
if adding: txtlist.append(arg)
else: obj.arguments.append(arg)
obj.txt = " ".join(txtlist)
else:
obj.command = obj.origin
obj.origin = self._cfg.server
try:
obj.nick, obj.userhost = obj.origin.split("!")
except:
pass
if obj.arguments: obj.target = obj.arguments[-1]
else: obj.target = ""
if obj.target.startswith("#"): obj.channel = obj.target
if not obj.txt and len(arguments) == 1: obj.txt = arguments[1]
if not obj.txt: obj.txt = rawstr.split(":")[-1]
return obj
def testcfg(event):
cfg.workdir = event._parsed.rest
e = Event()
path = e.save()
event.reply(path)
