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)
w.init(self.timespec())
simple_event("wait","start",*w.name, end_time=ixtime(w.end,self.force), loglevel=TRACE)
try:
if w.job:
r = w.job.get()
else:
r = True
except Exception as ex:
simple_event("wait","error", *w.name, time=tm,loglevel=TRACE)
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)
else:
simple_event("wait","cancel", *w.name, loglevel=TRACE)
ctx.wait = tm
if not r:
raise DelayCancelled(w)
finally:
w.delete()
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 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) w.init(self.timespec()) process_event(Event(self.ctx(loglevel=TRACE),"wait","start",ixtime(w.end,self.force),*w.name)) try: if w.job: r = w.job.get() else: r = True except Exception as 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: # don't log 'done' if canceled process_event(Event(self.ctx(loglevel=TRACE),"wait","done",tm, *w.name)) ctx.wait = tm if not r: raise DelayCancelled(w)
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 _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("Setting up", ex)
self._teardown("retrying")
m = MsgClosed()
if self.q is not None:
self.q.put(m, block=False)
# except BaseException as ex:
# import pdb;pdb.set_trace()
# raise
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 process_failure(e):
"""\
Process a failure event. This is the internal procedure that
will mangle your errors.
"""
from homevent.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(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 homevent.logging import log_run,log_halted
try:
event = self.event
except Exception as ex:
fix_exception(ex)
event = ex
skipping = False
excepting = False
for w in self.work:
if w.prio >= MIN_PRIO and w.prio <= MAX_PRIO:
step += 1
if skipping:
continue
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 HaltSequence as ex:
fix_exception(ex)
r = ex
log_halted(self,w,step)
skipping = True
except TrySomethingElse:
pass
except Exception as ex:
fix_exception(ex)
r = ex
else:
if self.handle_conditional and w.prio >= MIN_PRIO:
skipping = True
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(r,Exception):
from homevent.logging import log_exc
log_exc("Unhandled nested exception", res)
from homevent.run import process_failure
process_failure(res)
res = r
if isinstance(res,Exception):
reraise(res)
