Skip to content
Snippets Groups Projects
Commit 2ad3096d authored by jkerdreu's avatar jkerdreu
Browse files

- Mr Proper had a lot of works

- fixed walker issues


git-svn-id: https://redmine.imt-atlantique.fr/svn/xaal/code/Python/branches/0.7@2811 b32b6428-25c9-4566-ad07-03861ab6144f
parent e117eadd
Branches
No related tags found
No related merge requests found
......@@ -48,6 +48,8 @@ class DeviceInfo(object):
self.description = None
self.attributes = None
self.db = None
self.ready_event = asyncio.Event()
self.shown = False
def ready(self):
if self.address == None: return False
......@@ -56,8 +58,8 @@ class DeviceInfo(object):
if self.attributes == None: return False
return True
def display(self,display='color'):
if display=='color':
def display(self,color=True):
if color:
self.color_display()
else:
self.normal_display()
......@@ -144,7 +146,7 @@ class ToolboxHelper(object):
self.devices = [] # devices list (alive / walker)
# idle detector / force exit
self.exit_event = asyncio.Event()
self.last_msg_time = 0
self.last_msg_time = now()
# display time
self.start_time = 0
......@@ -243,6 +245,22 @@ class ToolboxHelper(object):
return k
return None
def new_device(self,addr):
dev = DeviceInfo()
dev.address = addr
self.add_device(dev)
return dev
def show_device(self,dev):
# show device only once
if dev.shown: return
if self.options.no_color:
dev.normal_display()
else:
dev.color_display()
dev.shown = True
def is_ready(self,dev):
if self.db_server:
if dev.db == None:
......@@ -267,10 +285,27 @@ class ToolboxHelper(object):
target.alive = True
return target
def parse_db_msg(self,msg):
found = msg.body.get('device',None)
found_map = msg.body.get('map',None)
tmp = self.get_device(found)
if not tmp:
tmp = self.new_device(found)
tmp.db = found_map
return tmp
def query_info(self,addr):
self.engine.send_get_description(self.device,[addr,])
self.engine.send_get_attributes(self.device,[addr,])
def query_isalive(self,addr=None,dev_type=None):
if addr:
self.engine.send_is_alive(self.device,[addr,])
elif dev_type:
self.engine.send_is_alive(self.device,dev_types=dev_type)
else:
self.engine.send_is_alive(self.device)
#####################################################
# db server
#####################################################
......@@ -288,12 +323,18 @@ class ToolboxHelper(object):
self.engine.unsubscribe(self.find_db_callback)
def query_db(self,addr):
self.engine.send_request(self.device,[self.db_server,],"get_keys_values",{'device':addr})
if self.db_server:
self.engine.send_request(self.device,[self.db_server,],"get_keys_values",{'device':addr})
#####################################################
# start/stop/idle
# start/stop/idle/error
#####################################################
async def wait_exit(self):
await asyncio.wait([self.exit_event.wait(),],timeout=0.3)
def update_idle(self):
self.last_msg_time = now()
async def idle_detector(self):
while True:
await asyncio.sleep(0.1)
......@@ -310,7 +351,11 @@ class ToolboxHelper(object):
self.engine.new_task(self.idle_detector())
self.engine.run()
def run_forever(self):
self.engine.run()
def quit(self):
self.engine.shutdown()
print()
print(LINE)
print(f"Found devices: {len(self.devices)}")
......@@ -319,8 +364,7 @@ class ToolboxHelper(object):
t = round(now() - self.start_time,2)
print(f"Total runtime: {t}s")
print(LINE)
self.engine.shutdown()
def error(self,error_msg):
print(f"error: {error_msg}")
self.parser.print_help()
......@@ -332,6 +376,18 @@ def colorize(color,text):
def now():
return time.time()
def match_dev_type(msg,dev_type):
if dev_type == 'any.any':
return True
if dev_type.endswith('.any'):
subtype = msg.dev_type.split('.')[0] + '.any'
if subtype == dev_type:
return True
else:
if msg.dev_type == dev_type:
return True
return False
#####################################################
# dumper
......@@ -343,44 +399,32 @@ def dumper():
eng=helper.setup_engine()
target = helper.get_filter_address()
color = not options.no_color
async def dumper_callback(msg):
if target!=None:
if (msg.source != target) and (target not in msg.targets):
return
color = Colors.DEFAULT
color_msg = Colors.DEFAULT
if msg.is_request_isalive():
color = Colors.IS_ALIVE
color_msg = Colors.IS_ALIVE
elif msg.is_alive():
color = Colors.ALIVE
color_msg = Colors.ALIVE
elif msg.is_attributes_change():
color = Colors.ATTRIBUTS
color_msg = Colors.ATTRIBUTS
elif msg.is_request():
color = Colors.REQUEST
color_msg = Colors.REQUEST
elif msg.is_reply():
color = Colors.REPLY
color_msg = Colors.REPLY
elif msg.is_notify():
color = Colors.NOTIFY
color_msg = Colors.NOTIFY
if options.no_color == False: print(color,end='')
if color: print(color_msg,end='')
msg.dump()
if options.no_color == False: print(style.RESET,end='')
if color: print(style.RESET,end='')
eng.subscribe(dumper_callback)
eng.run()
def match_dev_type(msg,dev_type):
if dev_type == 'any.any':
return True
if dev_type.endswith('.any'):
subtype = msg.dev_type.split('.')[0] + '.any'
if subtype == dev_type:
return True
else:
if msg.dev_type == dev_type:
return True
return False
helper.run_forever()
#####################################################
# alive
......@@ -388,37 +432,32 @@ def match_dev_type(msg,dev_type):
def is_alive():
helper = ToolboxHelper()
helper.parser.add_option("-t",dest="filter_type",help="only show given device type")
(options,args) = helper.parse()
(options,_) = helper.parse()
(eng,dev) = helper.setup_basic()
dev_type = helper.get_filter_devtype()
color = not options.no_color
async def alive_callback(msg):
asyncio.sleep(0)
if (msg.source == dev.address) or (msg.is_alive() == False):
return
if match_dev_type(msg,dev_type) == False:
return
if (msg.source == dev.address) or (msg.is_alive() == False): return
if match_dev_type(msg,dev_type) == False: return
# idle detectiong
helper.last_msg_time = now()
helper.update_idle()
if helper.get_device(msg.source) == None:
helper.parse_msg(msg)
if options.no_color:
print(f"{msg.source}: {msg.dev_type}")
else:
if color:
print(f"{colorize(Colors.ADDR,msg.source)}: {colorize(Colors.DEV_TYPE,msg.dev_type)}")
else:
print(f"{msg.source}: {msg.dev_type}")
def run():
def start():
print(LINE)
eng.send_is_alive(dev,dev_types=dev_type)
eng.send_is_alive(dev,)
helper.query_isalive(dev_type=dev_type)
eng.subscribe(alive_callback)
eng.on_start(run)
# idle detection
eng.new_task(helper.idle_detector())
eng.run()
eng.on_start(start)
helper.run_until_idle()
#####################################################
# info
......@@ -434,98 +473,82 @@ def info():
target = tools.get_uuid(args[0])
if target == None:
helper.error("Invalid address: %s" % args[0])
# color
color = helper.options.no_color or 'color'
device_ready = asyncio.Event()
def ready_to_show(dev):
if dev and helper.is_ready(dev):
helper.show_device(dev)
helper.exit_event.set()
def info_callback(msg,addr=target):
# collecting description and attributes
if msg.source != addr: return
found = helper.parse_msg(msg)
if found and helper.is_ready(found):
device_ready.set()
ready_to_show(found)
def query_db_callback(msg):
# collecting metadata
if not match_dev_type(msg,db_type):return
if msg.is_reply() and dev.address in msg.targets:
found = msg.body.get('device',None)
found_map = msg.body.get('map',None)
tmp = helper.get_device(found)
if not tmp:
tmp = DeviceInfo()
tmp.address = found
helper.add_device(tmp)
tmp.db = found_map
print("data: %s" % found_map)
if found and helper.is_ready(tmp):
device_ready.set()
found = helper.parse_db_msg(msg)
ready_to_show(found)
async def run():
await helper.find_db_server()
if helper.db_server:
helper.query_db(target)
eng.subscribe(query_db_callback)
eng.send_is_alive(dev,[target,])
helper.query_isalive(addr=target)
helper.query_info(target)
# wait for device to complete
await asyncio.wait([device_ready.wait(),],timeout=0.5)
helper.devices[0].display(color)
await helper.wait_exit()
helper.quit()
eng.subscribe(info_callback)
eng.on_start(run)
eng.run()
helper.run_forever()
#####################################################
# walker
#####################################################
def walker():
#helpers.setup_console_logger()
helper = ToolboxHelper()
helper.parser.add_option("-t",dest="filter_type",help="only show given device type")
(options,_)=helper.parse()
helper.parse()
(eng,dev) = helper.setup_basic()
dev_type = helper.get_filter_devtype()
color = options.no_color or 'color'
def ready_to_show(dev):
if dev and helper.is_ready(dev):
helper.show_device(dev)
async def walker_callback(msg):
await asyncio.sleep(0)
if msg.source == dev.address: return
if match_dev_type(msg,db_type):return
if match_dev_type(msg,dev_type) == False: return
helper.last_msg_time = now()
target = helper.parse_msg(msg)
found = helper.parse_msg(msg)
helper.update_idle()
if msg.is_alive():
if not target.ready():
#target.db = {}
if not found.ready():
helper.query_info(msg.source)
helper.query_db(msg.source)
if helper.is_ready(target):
target.display(color)
ready_to_show(found)
async def query_db_callback(msg):
await asyncio.sleep(0)
if not match_dev_type(msg,db_type):return
helper.last_msg_time = now()
if msg.is_reply() and dev.address in msg.targets:
found = msg.body.get('device',None)
found_map = msg.body.get('map',None)
tmp = helper.get_device(found)
if not tmp:
tmp = DeviceInfo()
tmp.address = found
helper.add_device(tmp)
tmp.db = found_map
if found and helper.is_ready(tmp):
tmp.display()
helper.update_idle()
found = helper.parse_db_msg(msg)
ready_to_show(found)
async def start():
await helper.find_db_server()
helper.update_idle()
if helper.db_server:
eng.subscribe(query_db_callback)
eng.subscribe(walker_callback)
eng.send_is_alive(dev,dev_types=dev_type)
helper.query_isalive(dev_type=dev_type)
eng.on_start(start)
helper.run_until_idle()
......@@ -568,7 +591,7 @@ def log():
print(dump)
eng.subscribe(log_callback)
eng.run()
helper.run_forever()
#####################################################
# query db
......@@ -585,7 +608,7 @@ def query_db():
if target == None:
helper.error("Invalid address: %s" % args[0])
# FIXME:
color = helper.options.no_color or 'color'
color = not helper.options.no_color
def query_db_callback(msg):
if not match_dev_type(msg,db_type):return
......@@ -596,12 +619,12 @@ def query_db():
r = []
r.append(['Metadata',''])
r.append(['========',''])
if color == 'color':
if color:
r.append(['Server:',colorize(Colors.ADDR,msg.source)])
else:
r.append(['Server:',msg.source])
for k,v in found_map.items():
if color == 'color':
if color:
v = colorize(Colors.DB,v)
r.append([k,v])
print(tabulate(r,tablefmt=TABLE_STYLE))
......@@ -610,28 +633,26 @@ def query_db():
async def run():
await helper.find_db_server()
if helper.db_server:
# found db server, send request and wait to complete
helper.query_db(target)
# wait for device to complete
await helper.exit_event.wait()
await helper.wait_exit()
else:
print("\nNo metadata server found")
helper.quit()
eng.subscribe(query_db_callback)
eng.on_start(run)
# idle detection
helper.run_until_timeout()
helper.run_forever()
def test():
helper = ToolboxHelper()
(options,args) = helper.parse()
(eng,dev) = helper.setup_basic()
helpers.setup_console_logger()
async def run():
await helper.find_db_server()
print("ready")
helper = ToolboxHelper()
helper.parser.add_option("-t",dest="filter_type",help="only show given device type")
(options,_)=helper.parse()
(eng,dev) = helper.setup_basic()
dev_type = helper.get_filter_devtype()
#eng.subscribe(test_callback)
eng.on_start(run)
eng.new_task(helper.idle_detector())
helper.run_until_timeout()
\ No newline at end of file
print("Test")
helper.run_until_idle()
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment