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