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
