def __init__(self, g, func, a, k):
self.func = func
self.g = g
self.a = a
self.k = k
try:
self.name = SName("_" + str(g))
except UnicodeDecodeError:
try:
self.name = SName("_" + str(g)[:-5])
except UnicodeDecodeError:
self.name = SName("_" + str(g)[:-10])
def __init__(self, parent, *args):
self.parent = parent
if args:
self.args = SName(args)
for k in self.args:
if hasattr(k, 'startswith') and k.startswith('*'):
self._simple = False
break
name = SName(parent.name + self.args)
# use self.args because that won't do a multi-roundtrip iteration
else:
name = parent.name
super(EventCallback, self).__init__(name)
def on(self, *args, **kw):
doc = kw.pop('doc', None)
name = kw.pop('name', None)
if len(args) == 1:
args = args[0].split('.')
args = Name(*args)
if name is None:
name = SName(args)
elif isinstance(name, six.string_types):
name = SName(name.split(" "))
def dec(fn):
OnEventExec(self.parent, args, name, fn)
return fn
return dec
def _register(store, io, what):
if isinstance(io.typ, six.string_types):
io.typ = SName(io.typ)
if io.typ in store:
raise ValueError("An %sput handler for '%s' is already registered." % \
(what,io.typ))
store[io.typ] = io
def run(self, ctx, **k):
event = self.params(self.ctx)
if self.new_hc is None:
raise SyntaxError(
u"‹fs20 switch› without sub-statements does nothing!")
if self.hc is None:
if self.code is None:
raise SyntaxError(
u"A new ‹fs20 switch› needs a ‹code› sub-statement!")
self.hc = SwitchGroup(self.code, SName(event))
elif self.code is not None:
self.hc.code = self.code ## update
for s in self.old_sw:
if s.parent != self.hc:
raise RuntimeError(
"The named device has house code %d, not %d" %
(to_hc(s.parent.code), to_hc(self.hc.code)))
s.delete()
for s in self.new_sw:
if s.code in self.hc.devs:
raise RuntimeError(u"The code ‹%d› is already known in ‹%d›" %
(to_dev(s.code), to_hc(self.hc.code)))
s.parent = self.hc
s.add()
def run(self,ctx,**k): event = self.params(ctx) if not len(event): raise SyntaxError(u'Usage: pwm ‹name…›') if self.pwm is None: raise SyntaxError(u'Usage: pwm ‹name…›: requires ‹type›') self.pwm(self,SName(event), **self.attrs)
def run(self,ctx,**k): event = self.params(ctx) if len(event) < 1: raise SyntaxError(u"Usage: monitor input ‹name…›") self.name = SName(event) self.values["var"] = self.name super(MonitorMaker,self).run(ctx,**k)
def run(self,ctx,**k): event = self.params(self.ctx) if not len(event): raise SyntaxError(u"‹fs20 em› needs a name") if self.code is None: raise SyntaxError(u"‹fs20 em› needs a 'code' sub-statement") EM(SName(event), self.group,self.code,ctx, self.faktor,self.offset, self.slot)
def list(self):
yield (six.text_type(self), )
yield ("id", self.id)
if hasattr(self, "event"):
yield ("event", SName(self.event))
if self.name:
yield ("name", SName(self.name))
yield ("call count", str(self.call_count))
if self.last_call:
yield ("last call", self.last_call)
if self.last_args:
for a, b in self.last_args.items():
yield ("last", a, b)
for r in self.report(verbose=98):
yield ("code", r)
s = super(WorkItem, self)
if hasattr(s, 'list'): yield s
def run(self,ctx,**k): event = self.params(ctx) if len(event) == 0: raise SyntaxError(u'Usage: update timeslot ‹name…›') if not self.params: raise SyntaxError(u'update timeslot: You did not specify any changes?') timeslot = Timeslots[SName(event)] for p,v in self.params.items(): setattr(timeslot,p,v)
def __init__(self, code, name):
self.code = code
self.name = SName(name)
self.devs = {}
self.last_dgram = None
if self.code in codes:
raise RuntimeError("Device exists (%s)" % (to_hc(self.code), ))
super(SwitchGroup, self).__init__()
codes[self.code] = self
def run(self, ctx, **k):
event = self.params(ctx)
if len(event) < 1:
raise SyntaxError(u'Usage: listen amqp ‹conn…›')
conn = AMQPclients[SName(event)]
dest = self.dest
if dest is None:
global _seq
_seq += 1
dest = Name("_amqp", "a" + str(_seq))
AMQPrecv(self, dest, conn)
def start_block(self):
event = self.params(self.ctx)
if not len(event):
raise SyntaxError(u"Usage: fs20 switch ‹name…›")
try:
self.hc = SwitchGroups[SName(event)]
except KeyError:
self.new_hc = True
else:
self.new_hc = False
def run(self, ctx, **k):
event = self.params(ctx)
if not len(event):
raise SyntaxError(u"Usage: forget state ‹name…›")
name = SName(event)
global Db
if Db is None:
from moat.database import DbStore
Db = DbStore(category="state")
Db.delete(name)
def run(self,ctx,**k): event = self.params(ctx) if not len(event): raise SyntaxError(u'Usage: timeslot ‹name…›') m = Timeslot(self, SName(event)) if "interval" not in self.values: raise SyntaxError(u'Usage: timeslot ‹name…›: need to specify an interval') for p,v in self.values.items(): setattr(m,p,v) if not self.stopped: return m.up()
def run(self, ctx, **k):
event = self.params(ctx)
if len(event) == 0:
raise SyntaxError("Usage: scan onewire BUS")
else:
try:
dev = buses[SName(event)]
except KeyError:
raise RuntimeError("scan onewire: unknown bus ‹%s›" %
(event[0], ))
else:
return dev.run_watcher()
def run(self, ctx, **k):
event = self.params(ctx)
if not len(event):
raise SyntaxError(u"Usage: add ‹name…›")
name = SName(event)
if self.code is None:
raise SyntaxError(u"Usage: “add” needs a “code” sub-statement")
try:
handler = handler_names[self.handler]
except KeyError:
handler = None
self.parent.add_sw(Switch(self.code, name, handler=handler))
def __new__(cls):
self = dict.__new__(cls)
name = SName(self.name)
if name in collections:
return collections[name]
self.name = name
self._can_do = set()
self.does("list")
collections[name] = self
return self
def __init__(self,
code,
name,
parent=None,
handler=None,
can_do=None,
init=None):
self.parent = parent
self.code = code
self.name = SName(name)
self.handler = handler
self.does = set(can_do) if can_do is not None else set(("on", "off"))
self.state = None
self.ext = None
super(Switch, self).__init__()
def run(self,ctx,**k): event = self.params(ctx) if len(event) == 0: raise SyntaxError(u'Usage: update monitor ‹name…›') if not self.params: raise SyntaxError(u'update monitor: You did not specify any changes?') monitor = Monitors[SName(event)] active = monitor.job is not None if active: monitor.down() for p,v in self.params.items(): setattr(monitor,p,v) if active: monitor.up() return d
def __init__(self, event, worker):
super(WorkSequence, self).__init__()
self.work = []
self.event = event
self.worker = worker
# if hasattr(event,"id"):
# self.id = self.event.id
if hasattr(event, "ctx"):
self.ctx = event.ctx()
else:
self.ctx = Context()
if isinstance(self.event, Event):
en = SName(self.event)
else:
en = six.text_type(self.event)
self.info = u"Worker %d for ‹%s›" % (self.id, en)
def __init__(self, *name):
if not name:
name = self.name
if not name:
raise RuntimeError("Unnamed object of '%s'" %
(self.__class__.__name__, ))
if self.storage is None:
raise RuntimeError("You didn't declare a storage for '%s'" %
(self.__class__.__name__, ))
self.name = name = SName(name)
if name in self.storage:
self.dup_error(name)
super(Collected, self).__init__()
self.storage[name] = self
self._ectx = Context()
def register_statement(self,handler):
"""\
Register a handler for a token. handler.run() is called
with the rest of the words on the line. handler.name is the
first word on the line, which is used to find the handler.
If the statement is a multi-line section (the stuff after
colon-ized lines, above), handler.input_block() line is called
instead. It must return something where its words may be looked
up in. handler.end_block() will be called when the block is finished,
if it exists.
"""
handler.name = SName(handler.name)
if '_words' not in self.__dict__:
self._words = {}
if handler.name in self._words:
raise ValueError("A handler for '%s' is already registered. (%s)" % (handler.name,self._words[handler.name]))
self._words[handler.name] = handler
return handler
def __init__(self, conn, parent):
self.parent = conn
self.exchange = parent.exchange
self.strip = parent.strip
self.prefix = tuple(parent.prefix)
self._direct = parent.shunt
self.filter = parent.filter
if self._direct:
try:
i = self.filter.index('*')
except ValueError:
i = 999
try:
i = min(self.filter.index('*'), i)
except ValueError:
pass
if i < self.strip or self.strip and not self.filter:
raise RuntimeError(
"You can't use 'shunt' if you strip elements you can't restore!"
)
for k in self.filter:
if hasattr(k, 'startswith') and k.startswith('*'):
self._simple = False
break
name = parent.dest
if name is None:
global _seq
_seq += 1
name = SName(conn.name + ("f" + str(_seq), ))
self.channel = self.parent.conn.channel()
self.channel.exchange_declare(exchange=self.exchange,
type='topic',
auto_delete=False,
passive=False,
durable=True)
super(EventCallback, self).__init__(name)
register_worker(self, self._direct)
def run(self, ctx, **k):
event = self.params(ctx)
self.parent.dest = SName(event)
def run(self, ctx, **k):
event = self.params(ctx)
if not len(event):
raise SyntaxError(u'Usage: name "‹text›"')
self.parent.displayname = SName(event)
def run(self, ctx, **k):
event = self.params(ctx)
self.avg(self, SName(event), *self.settings)
def run(self, ctx, **k):
event = self.params(ctx)
if not len(event):
raise SyntaxError(u"Usage: del ‹name…›")
self.parent.handler = SName(event)
def run(self, ctx, **k):
event = self.params(ctx)
if not len(event):
raise SyntaxError(u"Usage: del ‹name…›")
name = SName(event)
self.parent.del_sw(Switches[name])
def __init__(self,parent=None, ctx=None): self.name = SName(self.name) self.parent = parent self.ctx = ctx or Context() self.args = None
