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() 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 _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 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 = "homevent.modules."+m[-1]+".py" c = compile(resource_string("homevent.modules", m[-1]+".py"), os.path.join('homevent','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 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 error(self,e): reraise(e)
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 homevent.logging import log_run,log_halted try: event = self.event except Exception as ex: fix_exception(ex) event = ex skipping = False excepting = False for w in self.work: if w.prio >= MIN_PRIO and w.prio <= MAX_PRIO: step += 1 if skipping: continue 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 HaltSequence as ex: fix_exception(ex) r = ex log_halted(self,w,step) skipping = True except TrySomethingElse: pass except Exception as ex: fix_exception(ex) r = ex else: if self.handle_conditional and w.prio >= MIN_PRIO: skipping = True 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(r,Exception): from homevent.logging import log_exc log_exc("Unhandled nested exception", res) from homevent.run import process_failure process_failure(res) res = r if isinstance(res,Exception): reraise(res)
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)
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 if self.max_open >= self.is_open: 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,parser,err): reraise(err)
def _rewrite(self,wval,wnextval): res = self.timer.q.get() if isinstance(res,BaseException): reraise(res) simple_event(Context(),"output","set",self.repr(wval),self.repr(wnextval),*self.name)