def run(self, ctx, **k):
event = self.params(ctx)
if not len(event):
raise SyntaxError(u"Usage: trigger error NAME…")
err = RaisedError(*event[:])
logging.log_exc(msg="Triggered:", err=err, level=logging.TRACE)
raise err
def run(self,ctx,**k): event = self.params(ctx) if not len(event): raise SyntaxError(u"Usage: trigger error NAME…") err = RaisedError(*event[:]) logging.log_exc(msg="Triggered:", err=err, level=logging.TRACE) raise err
def run(p,*a,**k): try: p(*a,**k) except TrySomethingElse: pass except Exception as exc: from moat.logging import log_exc from moat.run import process_failure print_exc() fix_exception(exc) log_exc(msg="Unhandled exception", err=exc) process_failure(exc)
def run(self, ctx, **k):
event = self.params(ctx)
if not len(event):
level = logging.DEBUG
elif len(event) == 1:
try:
level = getattr(logging, event[0].upper())
except AttributeError:
raise SyntaxError("unknown severity", event[0])
else:
raise SyntaxError("Usage: log error [severity]")
logging.log_exc(msg="Logged:", err=ctx.error_, level=level)
def run(p, *a, **k):
try:
p(*a, **k)
except TrySomethingElse:
pass
except Exception as exc:
from moat.logging import log_exc
from moat.run import process_failure
print_exc()
fix_exception(exc)
log_exc(msg="Unhandled exception", err=exc)
process_failure(exc)
def run(self,ctx,**k):
event = self.params(ctx)
if not len(event):
level = logging.DEBUG
elif len(event) == 1:
try:
level = getattr(logging,event[0].upper())
except AttributeError:
raise SyntaxError("unknown severity",event[0])
else:
raise SyntaxError("Usage: log error [severity]")
logging.log_exc(msg="Logged:", err=ctx.error_, level=level)
def process(self, **k): super(WorkSequence,self).process(**k) assert self.work,"empty workqueue in "+repr(self) self.in_step = step = 0 self.in_worker = None res = None from moat.logging import log_run,log_halted try: event = self.event except Exception as ex: fix_exception(ex) event = ex excepting = False for w in self.work: step += 1 self.in_step = step self.in_worker = w r = None try: if not excepting or isinstance(w,ExcWorker): log_run(self,w,step) r = w.process(event=self.event, queue=self) except TrySomethingElse: pass except Exception as ex: fix_exception(ex) r = ex if isinstance(r,Exception): excepting = True if not hasattr(r,"within"): r.within=[w] r.within.append(self) if res is None: res = r elif isinstance(res,Exception): from moat.logging import log_exc log_exc(msg="Unhandled nested exception", err=res) from moat.run import process_failure process_failure(res) res = r if isinstance(res,Exception): reraise(res)
def process(self, **k):
super(WorkSequence, self).process(**k)
assert self.work, "empty workqueue in " + repr(self)
self.in_step = step = 0
self.in_worker = None
res = None
from moat.logging import log_run, log_halted
try:
event = self.event
except Exception as ex:
fix_exception(ex)
event = ex
excepting = False
for w in self.work:
step += 1
self.in_step = step
self.in_worker = w
r = None
try:
if not excepting or isinstance(w, ExcWorker):
log_run(self, w, step)
r = w.process(event=self.event, queue=self)
except TrySomethingElse:
pass
except Exception as ex:
fix_exception(ex)
r = ex
if isinstance(r, Exception):
excepting = True
if not hasattr(r, "within"):
r.within = [w]
r.within.append(self)
if res is None:
res = r
elif isinstance(res, Exception):
from moat.logging import log_exc
log_exc(msg="Unhandled nested exception", err=res)
from moat.run import process_failure
process_failure(res)
res = r
if isinstance(res, Exception):
reraise(res)
def process_failure(e):
"""\
Process a failure event. This is the internal procedure that
will mangle your errors.
"""
from moat.logging import log_event, ERROR, log_exc
log_event(event=e, level=ERROR)
if getattr(e, "_did_event", False):
if TESTING:
raise RuntimeError("you called process_failure twice on " + str(e))
return
e._did_event = True
try:
collect_failure(e).process(event=e)
except Exception as err:
fix_exception(err)
log_exc(msg="Error in failure handler", err=err, level=ERROR)
def process_failure(e):
"""\
Process a failure event. This is the internal procedure that
will mangle your errors.
"""
from moat.logging import log_event, ERROR, log_exc
log_event(event=e, level=ERROR)
if getattr(e, "_did_event", False):
if TESTING:
raise RuntimeError("you called process_failure twice on " + str(e))
return
e._did_event = True
try:
collect_failure(e).process(event=e)
except Exception as err:
fix_exception(err)
log_exc(msg="Error in failure handler", err=err, level=ERROR)
def _setup(self):
sends,self.senders = self.senders,[]
recvs,self.receivers = self.receivers,[]
for mq in recvs:
self.senders.append([])
self.receivers.append([])
for mq in sends+recvs:
for msg in mq:
try:
r = msg.retry()
if r is SEND_AGAIN:
self.senders[msg.prio].append(msg)
elif r is RECV_AGAIN:
self.receivers[msg.prio].append(msg)
elif r is not None:
raise RuntimeError("Strange retry(): %s %s" % (repr(msg),repr(r)))
except Exception as e:
fix_exception(e)
msg.error(e)
try:
self._set_state("connecting")
self.channel = self.factory(self.q)
self._set_state("setting up")
self.setup()
if self.state == "setting up":
self._set_state("connected")
except Exception as ex:
fix_exception(ex)
log_exc(msg="Setting up",err=ex)
self._teardown("retrying")
m = MsgClosed()
if self.q is not None:
self.q.put(m, block=False)
else:
self.n_rcvd += self.n_rcvd_now
self.n_rcvd_now = 0
self.n_sent += self.n_sent_now
self.n_sent_now = 0
self.n_processed += self.n_processed_now
self.n_processed_now = 0
def run(self,ctx,**k):
event = self.params(ctx)
if len(event):
self.displayname = SName(event)
if self.timespec is None:
raise SyntaxError(u'Usage: wait [name…]: for|until|next ‹timespec›')
if self.is_update:
return Waiters[self.displayname].retime(self.timespec())
w = Waiter(self, self.displayname, self.force, self.soft)
w.init(self.timespec())
simple_event("wait","start",*w.name, end_time=ixtime(w.end,self.force), loglevel=TRACE, deprecated=True)
simple_event("wait","state",*w.name, end_time=ixtime(w.end,self.force), loglevel=TRACE, state="start")
try:
if w.job:
r = w.job.get()
else:
r = True
except Exception as ex:
simple_event("wait","error",*w.name, end_time=ixtime(w.end,self.force), loglevel=TRACE, deprecated=True)
simple_event("wait","state",*w.name, end_time=ixtime(w.end,self.force), loglevel=TRACE, state="error", error=ex)
fix_exception(ex)
log_exc(msg=u"Wait %s died:"%(self.name,), err=ex, level=TRACE)
raise
else:
tm = ixtime(now(self.force),self.force)
if r:
simple_event("wait","done", *w.name, loglevel=TRACE, deprecated=True)
simple_event("wait","state",*w.name, loglevel=TRACE, end_time=ixtime(w.end,self.force), state="done")
else:
simple_event("wait","cancel", *w.name, loglevel=TRACE, deprecated=True)
simple_event("wait","state",*w.name, loglevel=TRACE, end_time=ixtime(w.end,self.force), state="cancel")
ctx.wait = tm
if self.soft is None:
if not r:
raise DelayCancelled(w)
elif not self.soft:
if r:
raise DelayReached(w)
finally:
w.delete()
def run(self, ctx, **k):
event = self.params(ctx)
if len(event):
self.displayname = SName(event)
if self.timespec is None:
raise SyntaxError(
u'Usage: wait [name…]: for|until|next ‹timespec›')
if self.is_update:
return Waiters[self.displayname].retime(self.timespec())
w = Waiter(self, self.displayname, self.force, self.soft)
w.init(self.timespec())
simple_event("wait",
"start",
*w.name,
end_time=ixtime(w.end, self.force),
loglevel=TRACE,
deprecated=True)
simple_event("wait",
"state",
*w.name,
end_time=ixtime(w.end, self.force),
loglevel=TRACE,
state="start")
try:
if w.job:
r = w.job.get()
else:
r = True
except Exception as ex:
simple_event("wait",
"error",
*w.name,
end_time=ixtime(w.end, self.force),
loglevel=TRACE,
deprecated=True)
simple_event("wait",
"state",
*w.name,
end_time=ixtime(w.end, self.force),
loglevel=TRACE,
state="error",
error=ex)
fix_exception(ex)
log_exc(msg=u"Wait %s died:" % (self.name, ), err=ex, level=TRACE)
raise
else:
tm = ixtime(now(self.force), self.force)
if r:
simple_event("wait",
"done",
*w.name,
loglevel=TRACE,
deprecated=True)
simple_event("wait",
"state",
*w.name,
loglevel=TRACE,
end_time=ixtime(w.end, self.force),
state="done")
else:
simple_event("wait",
"cancel",
*w.name,
loglevel=TRACE,
deprecated=True)
simple_event("wait",
"state",
*w.name,
loglevel=TRACE,
end_time=ixtime(w.end, self.force),
state="cancel")
ctx.wait = tm
if self.soft is None:
if not r:
raise DelayCancelled(w)
elif not self.soft:
if r:
raise DelayReached(w)
finally:
w.delete()
