def __init__(self, name, host,port, socket=None):
self.socket = socket
self.host = host
self.port = port
self.name = name
storage2 = getattr(self,"storage2",{})
assert (host,port) not in storage2, "already known host/port tuple"
super(NetCommonConnector,self).__init__()
storage2[(host,port)] = self
external = (self.socket is not None)
if self.socket is None:
try:
self._connect()
except Exception as ex:
fix_exception(ex)
if isinstance(ex,EnvironmentError) and ex.errno in (errno.ECONNREFUSED,errno.EHOSTDOWN,errno.EHOSTUNREACH,errno.ENETDOWN,errno.ENETUNREACH,errno.ETIMEDOUT):
ex.no_backtrace = True
try:
del storage2[(host,port)]
except KeyError:
pass
else:
super(NetCommonConnector,self).delete()
try:
self.not_up_event(error=ex)
except Exception as ex2:
fix_exception(ex2)
process_failure(ex2)
reraise(ex)
self.handshake(False)
else:
self.handshake(True)
self.start_job("job",self._reader)
def _write(self, val):
msg = WAGOoutputRun(self.card, self.port, val)
WAGOservers[self.server].enqueue(msg)
res = msg.result.get()
if isinstance(res, Exception):
reraise(res)
return
def _connect(self): e = None for res in socket.getaddrinfo(self.host, self.port, socket.AF_UNSPEC, socket.SOCK_STREAM): af, socktype, proto, canonname, sa = res try: s = socket.socket(af, socktype, proto) except socket.error as err: fix_exception(err) if e is None: e = err s = None continue try: s.connect(sa) except socket.error as err: fix_exception(err) if e is None: e = err s.close() s = None continue break if s is None: reraise(e) self.socket = s
def _connect(self):
e = None
for res in socket.getaddrinfo(self.host, self.port, socket.AF_UNSPEC,
socket.SOCK_STREAM):
af, socktype, proto, canonname, sa = res
try:
s = socket.socket(af, socktype, proto)
except socket.error as err:
fix_exception(err)
if e is None:
e = err
s = None
continue
try:
s.connect(sa)
except socket.error as err:
fix_exception(err)
if e is None:
e = err
s.close()
s = None
continue
break
if s is None:
reraise(e)
self.socket = s
def _write(self,val): msg = WAGOoutputRun(self.card,self.port,val) WAGOservers[self.server].enqueue(msg) res = msg.result.get() if isinstance(res,Exception): reraise(res) return
def load_module(*m):
md = dict()
mod = None
p = None
for d in ModuleDirs:
p = os.path.join(d, m[-1]) + ".py"
try:
c = compile(open(p, "r").read(), p, "exec", 0, True)
except (OSError, IOError):
md = None
continue
else:
eval(c, md)
break
try:
if not md:
if TESTING:
if os.path.isdir("modules"):
p = "modules"
else:
p = os.path.join(os.pardir, "modules")
p = os.path.join(p, m[-1]) + ".py"
c = compile(open(p, "r").read(), p, "exec", 0, True)
else:
from pkg_resources import resource_string
p = "moat.modules." + m[-1] + ".py"
c = compile(resource_string("moat.modules", m[-1] + ".py"),
os.path.join('moat', 'modules', m[-1] + ".py"),
"exec", 0, True)
eval(c, md)
mod = md["init"]
if callable(mod):
mod = mod(*m)
elif len(event) > 1:
raise RuntimeError("You cannot parameterize this module.")
if not hasattr(mod, "load"):
mod.load = md["load"]
mod.unload = md["unload"]
try:
mod.load()
except BaseException as e:
fix_exception(e)
try:
mod.unload()
except Exception:
reraise(e)
else:
reraise(e)
# do not use finally: here
else:
mod.path = p
except BaseException:
if mod is not None and hasattr(mod, "name") and mod.name in Modules:
del Modules[mod.name]
raise
return mod
def _tmwrite(self, val, timer, nextval=None):
assert nextval is None, "setting a different next value is not supported yet"
msg = WAGOtimedOutputRun(self, val, timer)
WAGOservers[self.server].enqueue(msg)
res = msg.result.get()
if isinstance(res, Exception):
reraise(res)
return
def _tmwrite(self,val,timer,nextval=None): assert nextval is None,"setting a different next value is not supported yet" msg = WAGOtimedOutputRun(self,val,timer) WAGOservers[self.server].enqueue(msg) res = msg.result.get() if isinstance(res,Exception): reraise(res) return
def _rewrite(self, wval, wnextval):
res = self.timer.q.get()
if isinstance(res, BaseException):
reraise(res)
simple_event("output",
"change",
*self.name,
prev_value=self.repr(wval),
value=self.repr(wnextval))
def load_module(*m):
md = dict()
mod = None
p = None
for d in ModuleDirs:
p = os.path.join(d,m[-1])+".py"
try:
c = compile(open(p,"r").read(), p, "exec",0,True)
except (OSError,IOError):
md = None
continue
else:
eval(c,md)
break
try:
if not md:
if TESTING:
if os.path.isdir("modules"):
p = "modules"
else:
p = os.path.join(os.pardir,"modules")
p = os.path.join(p,m[-1])+".py"
c = compile(open(p,"r").read(), p, "exec",0,True)
else:
from pkg_resources import resource_string
p = "moat.modules."+m[-1]+".py"
c = compile(resource_string("moat.modules", m[-1]+".py"), os.path.join('moat','modules',m[-1]+".py"), "exec",0,True)
eval(c,md)
mod = md["init"]
if callable(mod):
mod = mod(*m)
elif len(event) > 1:
raise RuntimeError("You cannot parameterize this module.")
if not hasattr(mod,"load"):
mod.load = md["load"]
mod.unload = md["unload"]
try:
mod.load()
except BaseException as e:
fix_exception(e)
try:
mod.unload()
except Exception:
reraise(e)
else:
reraise(e)
# do not use finally: here
else:
mod.path = p
except BaseException:
if mod is not None and hasattr(mod,"name") and mod.name in Modules:
del Modules[mod.name]
raise
return mod
def _read(self): msg = WAGOoutputInRun(self.card,self.port) WAGOservers[self.server].enqueue(msg) res = msg.result.get() if isinstance(res,Exception): reraise(res) if res == "1": return True elif res == "0": return False raise WAGObadResult(res)
def up(self): """submit myself to the server""" assert self.msgid is None, "MsgID is %s in %s"%(self.msgid,repr(self)) msg = WAGOmonRun(self) WAGOservers[self.server].enqueue(msg) res = msg.result.get() self.last_msg = res if isinstance(res,Exception): self.msgid = None reraise(res) super(WAGOmon,self).up()
def _read(self):
msg = WAGOoutputInRun(self.card, self.port)
WAGOservers[self.server].enqueue(msg)
res = msg.result.get()
if isinstance(res, Exception):
reraise(res)
if res == "1":
return True
elif res == "0":
return False
raise WAGObadResult(res)
def up(self):
"""submit myself to the server"""
assert self.msgid is None, "MsgID is %s in %s" % (self.msgid,
repr(self))
msg = WAGOmonRun(self)
WAGOservers[self.server].enqueue(msg)
res = msg.result.get()
self.last_msg = res
if isinstance(res, Exception):
self.msgid = None
reraise(res)
super(WAGOmon, self).up()
def down(self):
"""remove myself to the server"""
if self.server not in WAGOservers:
self.msgid = None
elif self.msgid is not None:
msg = WAGOmonStop(msgid=self.msgid)
WAGOservers[self.server].enqueue(msg)
res = msg.result.get()
self.last_msg = res
if isinstance(res, Exception):
self.msgid = None
reraise(res)
super(WAGOmon, self).down()
def down(self): """remove myself to the server""" if self.server not in WAGOservers: self.msgid = None elif self.msgid is not None: msg = WAGOmonStop(msgid=self.msgid) WAGOservers[self.server].enqueue(msg) res = msg.result.get() self.last_msg = res if isinstance(res,Exception): self.msgid = None reraise(res) super(WAGOmon,self).down()
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 exposed_command(self,*args,**kwargs):
try:
sub = kwargs.get("sub",())
if sub:
cmd = CommandProcessor(parent=self,ctx=self.ctx)
proc = cmd.complex_statement(args)
for s in sub:
proc.simple_statement(s)
proc.done()
cmd.run()
else:
return CommandProcessor(parent=self,ctx=self.ctx).simple_statement(args)
except Exception as e:
fix_exception(e)
process_failure(e)
reraise(e)
def exposed_command(self, *args, **kwargs):
try:
sub = kwargs.get("sub", ())
if sub:
cmd = CommandProcessor(parent=self, ctx=self.ctx)
proc = cmd.complex_statement(args)
for s in sub:
proc.simple_statement(s)
proc.done()
cmd.run()
else:
return CommandProcessor(parent=self,
ctx=self.ctx).simple_statement(args)
except Exception as e:
fix_exception(e)
process_failure(e)
reraise(e)
def run(self,ctx,**k): event = self.params(ctx) name = self.dest if name is None: val = (event[0],) name = Name(*event[1:]) else: val = list(event) name = Name(*name.apply(ctx)) rrdf = RRDfiles[name] rrdf.last_sent = val rrdf.last_sent_at = now() msg = RRDsendUpdate(rrdf,val) res = msg.result.get() if isinstance(res,Exception): reraise(res)
def run(self):
self.init_state()
self.prompt()
if self.input is None:
self.p_gen = tokizer(self._do_parse,self.job,self.stop_client)
return
syn = AsyncResult()
self.start_job("job",self._run,syn)
self.p_gen = tokizer(self._do_parse,self.job)
syn.set(None)
try:
e = self.job.get()
if isinstance(e,BaseException):
reraise(e)
except StopParsing:
pass
self.p_gen.exit()
def run(self):
self.init_state()
self.prompt()
if self.input is None:
self.p_gen = tokizer(self._do_parse, self.job, self.stop_client)
return
syn = AsyncResult()
self.start_job("job", self._run, syn)
self.p_gen = tokizer(self._do_parse, self.job)
syn.set(None)
try:
e = self.job.get()
if isinstance(e, BaseException):
reraise(e)
except StopParsing:
pass
self.p_gen.exit()
def _command(self, args=(), sub=(),**kwargs): ctx = Context(**kwargs) ctx.out = Reporter() ctx.words = global_words() # self.ctx) try: if sub: cmd = CommandProcessor(parent=self,ctx=ctx) proc = cmd.complex_statement(args) for s in sub: proc.simple_statement(s) proc.done() cmd.run() else: CommandProcessor(parent=self,ctx=ctx).simple_statement(args) except Exception as e: fix_exception(e) process_failure(e) reraise(e) return ctx.out.data
def _command(self, args=(), sub=(), **kwargs):
ctx = Context(**kwargs)
ctx.out = Reporter()
ctx.words = global_words() # self.ctx)
try:
if sub:
cmd = CommandProcessor(parent=self, ctx=ctx)
proc = cmd.complex_statement(args)
for s in sub:
proc.simple_statement(s)
proc.done()
cmd.run()
else:
CommandProcessor(parent=self, ctx=ctx).simple_statement(args)
except Exception as e:
fix_exception(e)
process_failure(e)
reraise(e)
return ctx.out.data
def _writer(self): errs = 0 for r in self.q: try: if r is FlushMe: self._flush() else: self._log(*r) except Exception as ex: errs += 1 fix_exception(ex) from moat.run import process_failure process_failure(ex) if errs > 10: reraise(ex) else: if errs: errs -= 1 finally: self.q.task_done() self.q.task_done() # for the StopIter
def _writer(self):
errs = 0
for r in self.q:
try:
if r is FlushMe:
self._flush()
else:
self._log(*r)
except Exception as ex:
errs += 1
fix_exception(ex)
from moat.run import process_failure
process_failure(ex)
if errs > 10:
reraise(ex)
else:
if errs:
errs -= 1
finally:
self.q.task_done()
self.q.task_done() # for the StopIter
def __init__(self, name, host, port, socket=None):
self.socket = socket
self.host = host
self.port = port
self.name = name
storage2 = getattr(self, "storage2", {})
assert (host, port) not in storage2, "already known host/port tuple"
super(NetCommonConnector, self).__init__()
storage2[(host, port)] = self
external = (self.socket is not None)
if self.socket is None:
try:
self._connect()
except Exception as ex:
fix_exception(ex)
if isinstance(ex, EnvironmentError) and ex.errno in (
errno.ECONNREFUSED, errno.EHOSTDOWN,
errno.EHOSTUNREACH, errno.ENETDOWN, errno.ENETUNREACH,
errno.ETIMEDOUT):
ex.no_backtrace = True
try:
del storage2[(host, port)]
except KeyError:
pass
else:
super(NetCommonConnector, self).delete()
try:
self.not_up_event(error=ex)
except Exception as ex2:
fix_exception(ex2)
process_failure(ex2)
reraise(ex)
self.handshake(False)
else:
self.handshake(True)
self.start_job("job", self._reader)
def error(self,e): reraise(e)
def error(self,parser,err): reraise(err)
def _handler(self):
"""\
This is the receiver's main loop.
Processing of incoming and outgoing data is serialized so that
there will be no problems with concurrency.
"""
def doReOpen():
m = MsgReOpen()
if self.q is not None:
self.q.put(m, block=False)
state = "open" if self.state == "connected" else "closed" if self.channel is None else "connecting"
log("conn",TRACE,"setstate init %s" % (state,))
self.connect_timeout = self.initial_connect_timeout
self.attempts = 0
if not self.ondemand and state != "open":
doReOpen()
while True:
msg = self.q.get()
if isinstance(msg,MsgSender):
self.senders[msg.prio].append(msg)
elif isinstance(msg,MsgReceiver):
if msg.blocking:
self.receivers[msg.prio].insert(0,msg)
else:
self.receivers[msg.prio].append(msg)
elif isinstance(msg,MsgIncoming):
self._incoming(msg)
elif isinstance(msg,MsgOpenMarker):
log("conn",TRACE,"setstate %s %s" % (state,"connected"))
state = "connected"
self.connect_timeout = self.initial_connect_timeout
self.attempts = 0
elif isinstance(msg,MsgReOpen):
if self.channel is None:
log("conn",TRACE,"setstate %s %s" % (state,"want"))
state = "want"
elif isinstance(msg,MsgClosed):
if self.channel is not None:
if state != "waiting" and state != "connecting":
log("conn",TRACE,"setstate2 %s %s" % (state,"closed"))
state = "closed"
self._teardown("ReOpen",external=False)
if state == "closed" or state == "connecting":
log("conn",TRACE,"setstate %s %s: wait %.3f" % (state,"waiting",self.connect_timeout))
state = "waiting"
callLater(True,self.connect_timeout,doReOpen)
self._up_timeout()
elif isinstance(msg,MsgError):
self._error(msg.error)
else:
raise UnknownMessageType(msg)
if self.ondemand and not self.n_outq:
continue
if state == "want" or state == "closed" and self.ondemand and self.n_outq:
log("conn",TRACE,"setstate %s %s" % (state,"connecting"))
state = "connecting"
self._setup()
if self.state != "connected":
continue
log("msg",TRACE,"states at run",self.state,state)
done = False # marker for "don't send any more stuff"
for mq in self.receivers:
if done: break
for m in mq:
if m.blocking:
log("msg",TRACE,"blocked by",str(m))
done = True
if done: continue
for mq in self.senders:
if done: break
while len(mq):
if done:
break
if self.channel is None:
break
msg = mq.pop(0)
log("msg",TRACE,"send",str(msg))
try:
r = msg.send(self.channel)
except Exception as ex:
fix_exception(ex)
r = ex
else:
self.last_sent = msg
self.last_sent_at = now()
self.n_sent_now += 1
log("msg",TRACE,"send result",r)
if r is RECV_AGAIN:
if msg.blocking:
self.receivers[msg.prio].insert(0,msg)
else:
self.receivers[msg.prio].append(msg)
elif r is SEND_AGAIN:
if msg.blocking:
self.senders[msg.prio].insert(0,msg)
else:
self.senders[msg.prio].append(msg)
elif isinstance(r,SEND_LATER):
raise NotImplementedError("Queueing doesn't work yet")
elif isinstance(r,MSG_ERROR):
try:
raise r
except Exception as r:
fix_exception(r)
process_failure(r)
elif isinstance(r,Exception):
reraise(r)
else:
msg.done()
if msg.blocking:
done = True
break
# while setting up, only process PRIO_CONNECT messages
if state != "connected":
log(TRACE,"NotConn",self.senders)
break
def error(self, e):
reraise(e)
def _rewrite(self,wval,wnextval):
res = self.timer.q.get()
if isinstance(res,BaseException):
reraise(res)
simple_event("output","change",*self.name, prev_value=wval,value=wnextval)
