Skip to content
Snippets Groups Projects
Commit 17baa940 authored by jkerdreu's avatar jkerdreu
Browse files

Ouch, that's a refactoring ! 

git-svn-id: https://redmine.imt-atlantique.fr/svn/xaal/code/Python/branches/0.7@2799 b32b6428-25c9-4566-ad07-03861ab6144f
parent 069cf27c
No related branches found
No related tags found
No related merge requests found
Show whitespace changes
Inline Side-by-side
apps/aiotools/xaal/aiotools/toolbox.py
+ 206
− 200
View file @ 17baa940
......@@ -18,24 +18,13 @@ import pprint
from optparse import OptionParser
parser = None
# xAAL bus devices
engine = None
dev = None
# devices list (alive / walker)
devices = []
# force exit (info)
exit_event = asyncio.Event()
# display time
start_time = None
# idle detector
last_msg_time = None
HIDE_ACTION=['get_attributes','get_description','get_keys_values','is_alive']
TABLE_STYLE='psql'
LINE="="*78
helper = None
class Colors(Enum):
DEFAULT = fore.WHITE
IS_ALIVE = fore.LIGHT_GREEN
......@@ -96,78 +85,87 @@ class DeviceInfo(object):
r.append([k,tmp])
print(tabulate(r,tablefmt=TABLE_STYLE))
def colorize(color,text):
return f"{color}{text}{style.RESET}"
def add_device(dev):
global devices
if dev.address:
if get_device(dev.address):
# device already know
return
devices.append(dev)
def get_device(addr):
for k in devices:
if k.address == addr:
return k
return None
def now():
return time.time()
#####################################################
# general functions
#####################################################
def init():
global engine,dev,start_time,parser
parser = OptionParser()
parser.add_option("-C", "--no-color", dest="no_color",help="disable color",action="store_true", default=False)
parser.add_option("-A" , "--mcast-addr", dest="mcast_addr",help="Multicast address",default=None)
parser.add_option("-P" , "--mcast-port", dest="mcast_port",help="Multicast port",default=None)
(options, args) = parser.parse_args()
class ToolboxHelper(object):
def __init__(self) -> None:
self.name = None # cmdline name
self.parser = None
self.engine = None # toolbox engine
self.device = None # current device
self.devices = [] # devices list (alive / walker)
# idle detector / force exit
self.exit_event = asyncio.Event()
self.last_msg_time = 0
# display time
self.start_time = 0
bus_addr = options.mcast_addr if options.mcast_addr else config.address
bus_port = int(options.mcast_port) if options.mcast_port else config.port
# Let's start
self.setup_name()
self.setup_parser()
def setup_name(self):
name = sys.argv[0].split('/')[-1]
helpers.set_console_title(name)
print()
self.name = name
return self.name
def setup_parser(self):
self.parser = OptionParser()
self.parser.add_option("-C", "--no-color", dest="no_color",help="disable color",action="store_true", default=False)
self.parser.add_option("-A" , "--mcast-addr", dest="mcast_addr",help="Multicast address",default=None)
self.parser.add_option("-P" , "--mcast-port", dest="mcast_port",help="Multicast port",default=None)
return self.parser
def setup_device(self):
# toolbox device
dev = Device("cli.experimental")
dev.address = tools.get_random_uuid()
dev.info = f'Aiotoolbox CLI {name}'
dev.info = f'Aiotoolbox CLI {self.name}'
self.device = dev
self.engine.add_device(self.device)
return self.device
def setup_engine(self):
# engine
engine = AsyncEngine(address=bus_addr,port=bus_port)
engine.disable_msg_filter()
engine.add_device(dev)
bus_addr = self.options.mcast_addr if self.options.mcast_addr else config.address
bus_port = int(self.options.mcast_port) if self.options.mcast_port else config.port
eng = AsyncEngine(address=bus_addr,port=bus_port)
eng.disable_msg_filter()
start_time = now()
engine.start()
# start the engine
self.engine = eng
self.start_time = now()
eng.start()
return eng
def _quit():
print()
print(LINE)
print(f"Found devices: {len(devices)}")
t = round(now() - start_time,2)
print(f"Total runtime: {t}s")
print(LINE)
engine.shutdown()
def setup_msg_parser(self):
self.engine.subscribe(self.parse_msg)
def parse(self):
self.options, self.args = self.parser.parse_args()
return self.options,self.args
def add_device(self,dev):
if dev.address:
if self.get_device(dev.address):
# device already know
return
self.devices.append(dev)
def engine_wait(timeout=1):
engine.add_timer(_quit,timeout)
engine.run()
def get_device(self,addr):
for k in self.devices:
if k.address == addr:
return k
return None
def parse_msg(msg):
def parse_msg(self,msg):
""" default parser used for info/walker"""
target = get_device(msg.source)
target = self.get_device(msg.source)
if target == None:
target = DeviceInfo()
target.address = msg.source
target.dev_type = msg.dev_type
add_device(target)
self.add_device(target)
if msg.is_get_attribute_reply():
target.attributes = msg.body
elif msg.is_get_description_reply():
......@@ -176,33 +174,57 @@ def parse_msg(msg):
target.alive = True
return target
def engine_wait(self,timeout=1):
""" run the engine until timeout """
self.engine.add_timer(self._quit,timeout)
self.engine.run()
#####################################################
# idle detection
#####################################################
def idle_callback(msg):
global last_msg_time
last_msg_time = now()
def idle_callback(self,msg):
self.last_msg_time = now()
async def idle_detector():
engine.subscribe(idle_callback)
async def idle_detector(self):
self.engine.subscribe(self.idle_callback)
while True:
await asyncio.sleep(0.1)
if now() - last_msg_time > 0.3:
if now() - self.last_msg_time > 0.3:
break
#print('idle detected')
_quit()
self._quit()
def _quit(self):
print()
print(LINE)
print(f"Found devices: {len(self.devices)}")
t = round(now() - self.start_time,2)
print(f"Total runtime: {t}s")
print(LINE)
self.engine.shutdown()
def colorize(color,text):
return f"{color}{text}{style.RESET}"
def now():
return time.time()
#####################################################
# general functions
#####################################################
def init():
print("Never call me again")
#####################################################
# dumper
#####################################################
def dumper():
global engine
parser = OptionParser()
parser.add_option("-C", "--no-color", dest="no_color",help="disable color",action="store_true", default=False)
parser.add_option("-a", "--filter-address", dest="filter_address",help="only show given address")
(options, args) = parser.parse_args()
#global helper
helper = ToolboxHelper()
helper.setup_parser()
helper.parser.add_option("-a", "--filter-address", dest="filter_address",help="only show given address")
(options,_) = helper.parse()
target = None
if options.filter_address:
......@@ -233,32 +255,19 @@ def dumper():
msg.dump()
if options.no_color == False: print(style.RESET,end='')
# we don't use default init() here because we don't
# want the dumper to be on bus.
engine=AsyncEngine()
engine.disable_msg_filter()
engine.subscribe(dumper_callback)
engine.run()
eng=helper.setup_engine()
eng.subscribe(dumper_callback)
eng.run()
#####################################################
# alive
#####################################################
async def alive_callback(msg):
await asyncio.sleep(0)
if (msg.source == dev.address) or (msg.is_alive() == False):
return
target = get_device(msg.source)
if target == None:
target = DeviceInfo()
target.address = msg.source
target.dev_type = msg.dev_type
target.alive = True
add_device(target)
print(f"{colorize(Colors.ADDR,msg.source)}: {colorize(Colors.DEV_TYPE,msg.dev_type)}")
def is_alive():
init()
helper = ToolboxHelper()
(options,_) = helper.parse()
eng = helper.setup_engine()
dev = helper.setup_device()
type_ = 'any.any'
if len(sys.argv) > 1:
type_ = sys.argv[-1]
......@@ -266,15 +275,27 @@ def is_alive():
print("Invalid device type: [%s]" % type_)
exit(1)
engine.subscribe(alive_callback)
async def alive_callback(msg):
await asyncio.sleep(0)
if (msg.source == dev.address) or (msg.is_alive() == False):
return
if helper.get_device(msg.source) == None:
helper.parse_msg(msg)
if options.no_color:
print(f"{msg.source}: {msg.dev_type}")
else:
print(f"{colorize(Colors.ADDR,msg.source)}: {colorize(Colors.DEV_TYPE,msg.dev_type)}")
def run():
print(LINE)
engine.send_is_alive(dev,dev_types=type_)
eng.send_is_alive(dev,dev_types=type_)
engine.on_start(run)
eng.subscribe(alive_callback)
eng.on_start(run)
# idle detection
engine.new_task(idle_detector())
engine_wait(2)
eng.new_task(helper.idle_detector())
helper.engine_wait(2)
#####################################################
......@@ -282,7 +303,11 @@ def is_alive():
#####################################################
def info():
init()
helper = ToolboxHelper()
helper.parse()
eng = helper.setup_engine()
dev = helper.setup_device()
target = tools.get_uuid(sys.argv[-1])
if target == None:
print("Invalid address")
......@@ -292,30 +317,33 @@ def info():
await asyncio.sleep(0)
if msg.source != addr:
return
target = parse_msg(msg)
target = helper.parse_msg(msg)
# Finish ?
if target.ready():
target.show()
exit_event.set()
helper.exit_event.set()
async def run():
engine.send_is_alive(dev,[target,])
engine.send_get_description(dev,[target,])
engine.send_get_attributes(dev,[target,])
eng.send_is_alive(dev,[target,])
eng.send_get_description(dev,[target,])
eng.send_get_attributes(dev,[target,])
# wait for device to complete
await exit_event.wait()
_quit()
await helper.exit_event.wait()
helper._quit()
engine.subscribe(info_callback)
engine.on_start(run)
eng.subscribe(info_callback)
eng.on_start(run)
# run engine at least x second
engine_wait(2)
helper.engine_wait(2)
#####################################################
# walker
#####################################################
def walker():
init()
helper = ToolboxHelper()
helper.parse()
eng = helper.setup_engine()
dev = helper.setup_device()
type_ = 'any.any'
if len(sys.argv) > 1:
......@@ -324,61 +352,38 @@ def walker():
print("Invalid device type: [%s]" % type_)
exit(1)
def start():
engine.send_is_alive(dev,dev_types=type_)
def walker_callback(msg):
if msg.source == dev.address:
return
target = parse_msg(msg)
target = helper.parse_msg(msg)
# FIXME: aliver is ready ??
# alive ?
if msg.is_alive():
if not target.ready():
engine.send_get_description(target,[msg.source,])
engine.send_get_attributes(target,[msg.source,])
eng.send_get_description(target,[msg.source,])
eng.send_get_attributes(target,[msg.source,])
if target.ready():
target.show()
engine.subscribe(walker_callback)
engine.on_start(start)
def start():
eng.send_is_alive(dev,dev_types=type_)
eng.subscribe(walker_callback)
eng.on_start(start)
# idle detection
engine.new_task(idle_detector())
engine_wait(2)
eng.new_task(helper.idle_detector())
helper.engine_wait(2)
#####################################################
# walker
# log
#####################################################
def walker_callback(msg):
if msg.source == dev.address:
return
target = parse_msg(msg)
# alive ?
if msg.is_alive():
if not target.ready():
engine.send_get_description(target,[msg.source,])
engine.send_get_attributes(target,[msg.source,])
if target.ready():
target.show()
def walker():
init()
engine.subscribe(walker_callback)
type_ = 'any.any'
if len(sys.argv) > 1:
type_ = sys.argv[-1]
if not tools.is_valid_dev_type(type_):
print("Invalid device type: [%s]" % type_)
exit(1)
def run():
engine.send_is_alive(dev,dev_types=type_)
engine.on_start(run)
# idle detection
engine.new_task(idle_detector())
engine_wait(2)
def log():
helper = ToolboxHelper()
(options,_)=helper.parse()
eng = helper.setup_engine()
#####################################################
# walker
#####################################################
def log_callback(msg):
if msg.is_alive() or (msg.action in HIDE_ACTION):
return
......@@ -389,10 +394,11 @@ def log_callback(msg):
elif msg.is_request(): color=Colors.REQUEST
elif msg.is_reply(): color=Colors.REPLY
if options.no_color == True:
dump = f"{time.ctime()} {msg.source} {msg.dev_type}\t{msg.action} {msg.body}"
else:
dump = f"{Colors.DEFAULT}{time.ctime()} {Colors.ADDR}{msg.source} {Colors.DEV_TYPE}{msg.dev_type}\t{color}{msg.action} {msg.body}{style.RESET}"
print(dump)
def log():
init()
engine.subscribe(log_callback)
engine.run()
eng.subscribe(log_callback)
eng.run()
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Please to comment