def _try_put(self, dest, src, buf, flags): try: args = None if not self._is_ready(dest, src, flags): self._check_list(dest, src) self._members[dest][src].append((buf, datetime.utcnow())) if self._check_timeout(dest): args = self._pop_args(dest) self._log('try_put: timeout, dest=%s, src=%s, args=%s' % (dest, src, str(args))) else: self._log('try_put: not ready, dest=%s, src=%s' % (dest, src)) else: args = self._get_args(dest, src, buf, flags) self._log('try_put: ready, dest=%s, src=%s, args=%s' % (dest, src, str(args))) if args: if self._filter.check(dest): args = self._filter.put(dest, args) if args and type(args) == dict: ret = self._proc(dest, args) self._log('try_put: dest=%s, src=%s, ret=%s' % (dest, src, str(ret))) return ret except: log_err(self, 'failed to put, dest=%s, src=%s' % (dest, src))
def _proc(self, cmd, buf): result = '' force = False if cmd == CMD_OPEN: result = self._driver.open() elif cmd == CMD_CLOSE: result = self._driver.close() elif cmd == CMD_GET: force = True ret = self._driver.get() if ret: result = ret elif cmd == CMD_PUT: force = True args, kwargs = self._check_args(buf) if args != None and kwargs != None: ret = self._driver.put(*args, **kwargs) if ret: result = ret else: log_err( self, 'failed to process, invalid command, driver=%s, cmd=%s' % (str(self._driver), str(cmd))) if result or force: if result: self._log(cmd=cmd) self._put(result)
def _proc_safe(self, cmd, buf): try: self._proc(cmd, buf) except: log_err( self, 'failed to process, driver=%s, cmd=%s' % (str(self._driver), str(cmd)))
def _get_vertex(self, buf): try: v = () cnt = 0 start = 0 items = [] length = len(buf) for i in range(length): if buf[i] == LBRACE: cnt += 1 elif buf[i] == RBRACE: cnt -= 1 if (buf[i:i + LEN_PTR] == PTR or i == length - 1) and cnt == 0: if i != length - 1: item = buf[start:i] start = i + LEN_PTR else: item = buf[start:] items.append(item.strip()) for i in range(len(items)): item = items[i] if item.startswith(LBRACE): if item.endswith(RBRACE): grp = self._get_grp(item[1:-1]) if not grp: return v += (grp, ) else: return else: v += (item, ) return v except: log_err(self, 'failed to get vertex') pass
def handle(self): device = None try: device = io.get(self.request, local=True) if not device: return typ = _get_type(device) name = _get_name(device) mode = _get_mode(device) if typ and name: driver = load_driver(typ, name) if not mode & MODE_CLONE: driver.setup() if driver: stub = Stub(self.request, driver) _devices.update({device: stub}) io.put(self.request, device, local=True) stub.start() else: log_err( self, 'failed to handle, cannot load driver, type=%s, name=%s' % (typ, name)) except: if _devices.has_key(device): _devices.pop(device)
def _proc(self, name, buf): try: if not self.has_handler(name): return self._handle(name, buf) else: return self.handle(name, buf) except: log_err(self, 'failed to process, name=%s' % name)
def parse(self, graph_file): try: graph = self._load_graph(graph_file) vertex = self._check_vertex(graph) edge = self._check_edge(graph) return (vertex, edge) except: log_err(self, 'failed to parse') return (None, None)
def _create(self, cmd, buf): try: if cmd == CMD_MOUNT: result = self._driver.get_info() self._put(result, index=False) self._active = True except: log_err( self, 'failed to create, driver=%s, cmd=%s' % (str(self._driver), str(cmd)))
def put(self, name, buf): try: code = self._get_code(name) if code == None: code = self._get_code(name) if not code: return return proc.put(self._addr, FILTER_PORT, code, buf) except: log_err(self, 'failed to put')
def _pop_args(self, name): try: args = {} for i in self._members[name]: if len(self._members[name][i]) > 0: args[i] = self._members[name][i][0][0] self._members[name][i].pop(0) self._set_event(name, i) return args except: log_err(self, 'failed to pop args, name=%s' % name)
def _inspect(self, name): try: if self._check_timeout(name): args = self._pop_args(name) if self._filter.check(name): args = self._filter.put(name, args) if args and type(args) == dict: res = self._proc(name, args) if res: self.dispatch(name, res) except: log_err(self, 'failed to inspect, name=%s' % str(name))
def _load_graph(self, graph_file): graph = () while True: line = graph_file.readline() if not line: break ret = self._get_vertex(line.strip()) if not ret: log_err(self, 'failed to load graph') return graph += (ret, ) return graph
def _get_args(self, dest, src, buf, flags): try: args = {} args[src] = buf if not flags & MODE_REFLECT: for i in self._members[dest]: if i != src and len(self._members[dest][i]) > 0: args[i] = self._members[dest][i][0][0] self._members[dest][i].pop(0) self._set_event(dest, i) return args except: log_err(self, 'failed to get args, dest=%s, src=%s' % (dest, src))
def _get_children(self, parent, info, local): devices = {} try: for i in info: device = self._create_device(info[i], local, i) child = self.get_name(parent, i) devices.update({child: device}) except: log_err(self, 'failed to get children') return for i in devices: devices[i].mount(self._uid, i, self._core) return devices
def _exec(device, code, **args): try: if device: return device.execute(code, **args) else: func = None res = compile_restricted(code, '<string>', 'exec') exec(res) if func: return func(**args) else: log_err(None, 'failed to execute, no function') except: log_err(None, 'failed to execute')
def _mount(self, sock, local, device, init): info = self._get_info(sock, local) if not info: log_err(self, 'failed to mount') return name = self.get_name(device) if info.has_key('None'): info = info['None'] if not info: log_err(self, 'failed to mount') return if local: parent = self._create_device(info, local) else: log_err(self, 'failed to mount, invalid device') return else: children = self._get_children(name, info, local) if not children: log_err(self, 'failed to mount, no device') return parent = UDO(children, local) if self.get_mode(device) & MODE_CLONE: sock = None parent.mount(self._uid, name, self._core, sock=sock, init=init) self._devices.update({name: parent}) return name
def d_freq(self): if not self._core or self._children: return self._freq else: for i in range(RETRY_MAX + 1): freq = self._core.get_freq(self.d_name) if freq != None: self._freq = freq return freq elif i < RETRY_MAX: time.sleep(SLEEP_TIME) log_err( self, 'failed to get freq, type=%s, name=%s' % (self.d_type, self.d_name)) return self._freq
def _poll(self): try: while True: time.sleep(POLL_INTERVAL) if self._children: for i in self._children: child = self._children[i] if child.can_poll(): self._check_device(child) elif self.can_poll(): self._check_device() except: log_err( self, 'failed to poll, type=%s, name=%s' % (self.d_type, self.d_name))
def _put_event(self, dest, src): if self._events.has_key(dest): if self._events[dest].has_key(src): cnt = self._events[dest][src][1] if cnt == 1: del self._events[dest][src] elif cnt > 1: self._events[dest][src][1] -= 1 else: log_err( self, 'failed to put event, dest=%s, src=%s' % (dest, src)) raise Exception(log_get(self, 'failed to put event')) if not self._events[dest]: del self._events[dest]
def _write_device(self, buf): if not buf: log_err( self, 'failed to write device, no data, type=%s, name=%s' % (self.d_type, self.d_name)) return self._write_lock.acquire() try: io.put(self._socket, buf, self._local) return True except: log_err( self, 'failed to write device, type=%s, name=%s' % (self.d_type, self.d_name)) finally: self._write_lock.release()
def _create(self, device, init=True): try: sock, local = self._proc(self.connect, (device, ), PAIR_INTERVAL) except: return if sock: name = self._proc(self._mount, (sock, local, device, init), MOUNT_TIMEOUT) if not name: log_err(self, 'failed to create') sock.close() else: mode = self.get_mode(device) if mode & MODE_CLONE or mode & MODE_VIRT: sock.close() return name
def check_output(self, output): for i in output: item = self._spec.get(i) if not item: continue try: val = output[i] typ = item['type'] if (type(val) == int or type(val) == float) and type(typ) == list and (val < typ[0] or val > typ[1]): log_err(self, 'failed to check output') return except: log_err(self, 'failed to check output') return return output
def d_mode(self): if not self._core or self._children: return self._mode else: cnt = RETRY_MAX while True: mode = self._core.get_mode(self.d_name) if mode != None: self._mode = mode return mode cnt -= 1 if cnt > 0: time.sleep(SLEEP_TIME) else: break log_err( self, 'failed to get mode, type=%s, name=%s' % (self.d_type, self.d_name)) return self._mode
def _listen(self): try: while True: device, buf = self._read_device() if device: try: self._handle(device, buf) except: log_err( self, 'failed to listen, cannot handle, type=%s, name=%s' % (self.d_type, self.d_name)) finally: device.set_idle() except: log_err( self, 'failed to listen, type=%s, name=%s' % (self.d_type, self.d_name)) io.close(self._socket)
def _deliver(self, dest, src, buf, flags): try: if ASYNC: if QUEUE_LEN: while True: ret = self._scheduler.select(dest, src, buf, flags) if ret == None: self._scheduler.wait() else: if not ret: self._scheduler.put(dest, src, buf, flags) break else: Thread(target=self._core.put, args=(dest, src, buf, flags)).start() else: self._core.put(dest, src, buf, flags) except: log_err(self, 'failed to deliver, dest=%s, src=%s' % (dest, src))
def _handle(self, device, buf): if not self._put(device, buf) and buf: mode = device.d_mode if not (mode & MODE_TRIG) or device.check_atime(): res = None name = device.d_name if mode & MODE_SYNC and UPLOAD: try: self._core.save(name, buf) except: log_err( self, 'failed to handle, cannot save, name=%s' % name) return if self._core.has_handler(name): try: res = self._core.handle(name, {name: buf}) except: log_err(self, 'failed to handle, name=%s' % name) return else: res = buf if res: try: self._core.dispatch(name, res) except: log_err( self, 'failed to handle, cannot dispatch, name=%s' % name)
def _check_timeout(self, name): if not self._members[name]: return timeout = None try: timeout = self._timeout.get(name) except: log_err(self, 'failed to check timeout') if not timeout: return t_min = None for i in self._members[name]: if len(self._members[name][i]) > 0: _, t = self._members[name][i][0] if not t_min: t_min = t elif t < t_min: t_min = t if t_min: t = datetime.utcnow() if (t - t_min).total_seconds() >= timeout: return True
def _create_device(self, info, local, index=None): if not info.has_key('type'): log_err(self, 'failed to create device') raise Exception(log_get(self, 'failed to create device')) device = UDO(local=local) if index != None: device.set_index(int(index)) device.set_type(str(info['type'])) if info.get('freq'): device.set_freq(float(info['freq'])) if info.get('mode'): mode = int(info['mode']) device.set_mode(mode) if info.get('spec'): device.set_spec(dict(info['spec'])) return device
def select(self, dest, src, buf, flags): if self._busy.has_key(src): return False pos = None length = None for i in range(POOL_SIZE): if src != self._dest.get(i): queue = self._pool.get(i) l = queue.length if l < QUEUE_LEN: if pos == None or length > l: length = l pos = i else: return False if pos != None: queue = self._pool.get(pos) if not queue.push((dest, src, buf, flags)): log_err(self, 'failed to select') raise Exception(log_get(self, 'failed to select')) return True
def _read_device(self): empty = (None, None) try: buf = io.get(self._socket, self._local) if len(buf) > OUTPUT_MAX or not buf: return empty output = ast.literal_eval(buf) if type(output) != dict: log_err( self, 'failed to read device, cannot parse, type=%s, name=%s' % (self.d_type, self.d_name)) return empty if len(output) != 1: log_err( self, 'failed to read device, invalid length, type=%s, name=%s' % (self.d_type, self.d_name)) return empty device = None index = output.keys()[0] output = output[index] if self._children: for i in self._children: if self._children[i].d_index == int(index): device = self._children[i] break elif 0 == index: device = self if not device: log_err( self, 'failed to read device, cannot get device, type=%s, name=%s' % (self.d_type, self.d_name)) return empty buf = device.check_output(output) return (device, buf) except: log_err( self, 'failed to read device, type=%s, name=%s' % (self.d_type, self.d_name)) return empty