def process(self, **k): from moat.logging import log_run,log_halted,log_exc super(WorkSequence,self).process(**k) ## this is intentional assert self.work,"empty workqueue in "+repr(self) event = self.event jobs = [] 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) for w in self.work: #log_run(self,w,0) j = spawn(run,w.process,event=self.event, queue=self) jobs.append(j) for j,w in zip(jobs,self.work): with log_wait("JobStop",w): j.join()
def process(self, **k): from moat.logging import log_run, log_halted, log_exc super(WorkSequence, self).process(**k) ## this is intentional assert self.work, "empty workqueue in " + repr(self) event = self.event jobs = [] 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) for w in self.work: #log_run(self,w,0) j = spawn(run, w.process, event=self.event, queue=self) jobs.append(j) for j, w in zip(jobs, self.work): with log_wait("JobStop", w): j.join()
def retime(self, dest): simple_event("wait","update",*self.name,dest=dest, loglevel=TRACE, deprecated=True) simple_event("wait","state",*self.name, end_time=dest, loglevel=TRACE, state="update") with log_wait("wait","delete1",self.name): with self._lock: self.end = dest self._set_pling()
def delete(self,ctx=None): with log_wait("wait","delete2",self.name): with self._lock: if self._plinger: self.stop_job('_plinger') assert self._plinger is None #log(TRACE,"WaitDel",self.name) super(Waiter,self).delete(ctx=ctx) self.job.set(False)
def delete(self, ctx=None): with log_wait("wait", "delete2", self.name): with self._lock: if self._plinger: self.stop_job('_plinger') assert self._plinger is None #log(TRACE,"WaitDel",self.name) super(Waiter, self).delete(ctx=ctx) self.job.set(False)
def one_value(self, step): """\ Get one value from some "set monitor" command. Override this for active monitoring. """ if self.send_check_event and step==1: simple_event(self.ectx, "monitor","checking",*self.name) with log_wait("monitor","one_value",*self.name): return self.watcher.get(block=True, timeout=None)
def up(self): with log_wait("monitor up "+repr(self)): while self.job and self.job.dead: gevent.sleep(0.1) # link will clear if not self.job: self.value = None simple_event("monitor","start",*self.name) self.start_job("job",self._run_loop) self.state_change_at = now() def tell_ended(_): simple_event("monitor","stop",*self.name) self.job.link(tell_ended)
def retime(self, dest): simple_event("wait", "update", *self.name, dest=dest, loglevel=TRACE, deprecated=True) simple_event("wait", "state", *self.name, end_time=dest, loglevel=TRACE, state="update") with log_wait("wait", "delete1", self.name): with self._lock: self.end = dest self._set_pling()
def sleep(force,timeout,debugi=""): global current_slot,real_sleep from moat.twist import log_wait,callLater if force: real_sleep += 1 try: with log_wait("%s %s: %s timer wait for %s" % (now(False),debugi,"Forced" if force else "Fake", timeout)): t = now(force) while unixdelta(now(force) - t) < timeout: gevent.sleep(1/SLOT/real_sleep if real_sleep else 0.001) current_slot += 1/real_sleep+0.00001 if real_sleep else 1 global _log,TRACE if _log is None: from moat.logging import log as _log, TRACE _log(TRACE,"%s %s: %s timer done" % (now(False),debugi,"Forced" if force else "Fake")) finally: if force: real_sleep += -1
def _schedule(self): """Sleep until the next time this monitor should run""" s = self.stopped_at or now() if self.delay_for: if isinstance(self.delay_for,tuple): s = time_delta(self.delay_for, now=s) else: s += dt.timedelta(0,self.delay_for) if self.delay_until: if self.stopped_at: s = time_until(self.delay_until, now=s, invert=True) s = time_until(self.delay_until, now=s) if not self.delay_for and not self.delay_until: if isinstance(self.delay,tuple): s = time_delta(self.delay, now=s) else: s += dt.timedelta(0,self.delay) self.started_at = s with log_wait("monitor","sleep",*self.name): sleepUntil(False,s)
def sleep(force,timeout,debugi=""): import gevent global current_slot,real_sleep from moat.twist import log_wait,callLater if force: real_sleep += 1 try: with log_wait("%s %s: %s timer wait for %s" % (now(False),debugi,"Forced" if force else "Fake", timeout)): t = now(force) while unixdelta(now(force) - t) < timeout: gevent.sleep(1/SLOT/real_sleep if real_sleep else 0.001) current_slot += 1/real_sleep+0.00001 if real_sleep else 1 global _log,TRACE if _log is None: from moat.logging import log as _log, TRACE _log(TRACE,"%s %s: %s timer done" % (now(False),debugi,"Forced" if force else "Fake")) finally: if force: real_sleep += -1