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
