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)