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 _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()