diff --git a/utils/pycli/skyeye_cli.py b/utils/pycli/skyeye_cli.py index ded17a43304058bd09ad093950a84828ed288595..b9d3b6b0c6dc48e3ecb620249146ed3d8a5477c9 100755 --- a/utils/pycli/skyeye_cli.py +++ b/utils/pycli/skyeye_cli.py @@ -15,6 +15,7 @@ import mips import os import se import se_path +from se_system import system import pytimer import functools import operator @@ -22,923 +23,1514 @@ import fault_inject as sfi import skyeye_license as se_lic import coverage import network_control as NetCtrl - +import readline +import argparse cli_init.InitCommandList() sys.path.append(se_path.SkyEyeBin) -os_info = platform.system() -if operator.eq(os_info, "Linux"): - system = "Linux" -else: - system = "Windows" - -def help_info_open(): - print ("Usage:") - -def help_info_close(): - print ("Documentation:") - -def help_info_output(error, usage, info): - if(error != None): - print ("%s: %s" % ("Error", error)) - if(usage != None): - print ("%s: %s" % ("Usage", usage)) - if(info != None): - print ("%s: %s" % ("Documentation", info)) - - -def formot_output(op_list): - col_num = 5 - l_en = len(op_list) - row_num = l_en // col_num - for row in range(0, row_num + 1): - st = "" - for col in range(0, col_num): - index = row*col_num + col - if index < l_en: - st = "%s%s%-20s" % (st, " ", op_list[index]) - print (st) - -###########################global######################## - -########################################################### -def welcome_message(): - try: - config = tools.GetPackageConfig() - version = tools.GetBuildVersion(config) - date = tools.GetBuildDate(config) - except: - version = "unknown" - date = "unknown" - welcome_message = "SkyEye %s Copyright 2010-2022 Digiproto Corporation\n" % (version, date, system) - print (welcome_message) - -def cli_report(log): - print (log) - -class output_log(): - def __init__(self): - pass - def WriteText(self,data): - print (data) - -def checked_parameter(flag,*types): - def decorator(func): - @functools.wraps(func) - def wrapper(*argv,**kwargs): - arg=argv[1].strip() - while " " in arg: - arg=arg.replace(" "," ") - args=arg.split(" ") - while "" in args: - args.remove("") - if len(args)>len(types) and flag==False: - print ("too many arguments") - return False - elif len(args)0: - cmd, args, foo = self.parseline(line) - if cmd == '': - compfunc = self.completedefault - else: - try: - compfunc = getattr(self, 'complete_' + cmd) - except AttributeError: - compfunc = self.completedefault - else: - compfunc = self.completenames - self.completion_matches = compfunc(text, line, begidx, endidx) - try: - return self.completion_matches[state] - except IndexError: - return None - - def completenames(self, text, *ignored): - dotext = 'do_'+text - string = [a[3:] for a in self.get_names() if a.startswith(dotext)] - for index in range(len(string)): - string[index] = string[index].replace("_", "-") - return string - def exec_py_cmd(self, cmd): - try: - skyeye_bin = se_path.SkyEyeBin - exec('import sys') - exec('sys.path.append(\'%s\')'%skyeye_bin) - exec('import se') - exec('from se_system import system') - exec(cmd) - except: - import traceback - formatted_lines = traceback.format_exc().splitlines() - print (formatted_lines[0]) - print (formatted_lines[-1]) - - def onecmd(self, line): - if line.startswith('$'): - self.exec_py_cmd(line.strip('$')) - return - line = line.replace("-", "_") - cmd, arg, line = self.parseline(line) - if not line: - return self.emptyline() - if cmd is None: - return self.default(line) - self.lastcmd = line - if cmd == '': - return self.default(line) - else: - try: - func = getattr(self, 'do_' + cmd) - except AttributeError: - return self.default(line) - return func(arg) - -################ End cli init ############################# - - - -################ BEGIN COMMANDS DEFS############################# - -####list-module list-machines #### - def do_list_modules(self, arg): -# print ("In do_list_modules") - try: - SkyEyeListModules() - except Exception as e: - print (e) - - def do_list_machines(self, arg): - config = GetGlobalConfig() - if config == None: - return - list = config.get_mach_list() - print ("%-20s%-20s" % ("Id", "MachinesName")) - num = len(list) - for i in range(0, num): - print ("%-20s%-20s" % (i + 1, list[i])) - - def help_list_modules(self): - help_info_open() - print ("list-modules : List all the loaded module.") - help_info_close() - - def help_list_machines(self): - help_info_open() - print ("list-machines : List all the supported machines for SkyEye.") - help_info_close() - -####list-module , list-machines #### - - def do_run_script(self, arg): - cmd = cli.GetCommand("run-script") - if cmd == None: - print ("Can not find command: run-script") - return - if self.open_conf_flag == True: - LogReport("Do not reload until RESET is performed") - return False - list = ParseParameter(arg) - SetGlobalScript(list[0]) - try: - ret=cmd.run(list) - except Exception as e: - LogReportPack(errormessage.GetErrorInfo()) - ret = False - if ret == False: - return False - self.open_conf_flag = True - - def do_run_command(self, arg): - cmd = cli.GetCommand("run-command") - if cmd == None: - print ("Can not find command: run-command") - return - #list = ParseParameter(arg) - cmd.run(arg) - - - def help_run_script(self): - help_info_open() - cmd = cli.GetCommand("run-script") - if cmd == None: - print ("Can not find command: run-script") - return - help_info_output(None, cmd.synopses(), cmd.doc()) - - def help_run_command(self): - help_info_open() - cmd = cli.GetCommand("run-command") - if cmd == None: - print ("Can not find command: run-command") - return - help_info_output(None, cmd.synopses(), cmd.doc()) - -################## load-conf ########################## -################### breakpoint ########################## - - @checked_parameter(False,str,int) - def do_bp_create(self, arg): - try: - SkyEyeCreateBreakpoint(arg[0],arg[1]) - except: - print ("Insert breakpoint error") - - @checked_parameter(False,str,int) - def do_bp_delete(self, arg): - try: - SkyEyeDeleteBreakpointByAddr(arg[0],arg[1]) - except: - print ("Delete breakpoint error") - - @checked_parameter(False,str) - def do_bp_list(self, arg): - try: - temp=[] - ret=SkyEyeGetBpNumbers(arg[0]) - for i in range(0,ret): - temp.append(SkyEyeGetBreakpointAddrById(arg[0],i)) - print ("%-20s%-20s"%("CPU","Address(HEX)")) - for i in temp: - print ("%-20s%-20x"%(arg[0],i)) - except: - print ("Breakpoint get error") - - def help_bp_create(self): - help_info_open() - print ("bp_create : set breakpoint for an address.") - help_info_close() - - def help_bp_delete(self): - help_info_open() - print ("bp_delete : Delete some breakpoint.") - help_info_close() - - def help_bp_list(self): - help_info_open() - print ("bp_list : List all the breakpoint.") - help_info_close() - -################### breakpoint ########################## - - def do_list_cpu(self, arg): - config = GetGlobalConfig() - if config == None: - return - cpus = config.get_cpu_list() - print ("%-20s%-20s" % ("ID", "CpuName")) - count = 0 - for cpu in cpus: - count = count + 1 - print ("%-20d%-20s" % (count, cpu)) - - @checked_parameter(False,str,str) - def do_list_register(self, arg): - config = GetGlobalConfig() - if config == None: - return - ret=sfi.get_device_register_info(arg[0],arg[1]) - print ("%-20s%-20s%-20s" % ("Register", "Value(HEX)", "Address(HEX)")) - for i in ret.keys(): - print ("%-20s%-20x%-20x" % (i,ret[i]["value"],ret[i]["addr"])) - - @checked_parameter(True,str) - def do_list_device(self, arg): - config = GetGlobalConfig() - if config == None: - return - if len(arg) == 0: - print ("%-30s%-30s" % ("DeviceName", "BelongBoard")) - machlist = config.get_mach_list() - for mach in machlist: - mach_cls = config.get_mach_classname(mach) - if mach_cls == 'pc_mach': - cpu = config.get_cpuname_by_mach(mach) - if cpu == None: - continue - else: - x86_obj = x86(cpu) - for device in x86_obj.devices: - print ("%-30s%-30s" % (device.name, mach)) - else: - device_list = config.get_device_list_by_mach(mach) - for device in device_list: - print ("%-30s%-30s" % (device, mach)) - elif len(arg) == 1: - print ("%-30s%-30s" % ("ID", "DeviceName")) - device_list = config.get_device_list_by_mach(arg[0]) - num = len(device_list) - for i in range(0, num): - print ("%-30s%-30s" % (i + 1, device_list[i])) - - - @checked_parameter(False,str,str,str,int) - def do_set_register(self, arg): - try: - regid = SkyEyeGetDevRegIdByName(arg[0],arg[1],arg[2]) - ret = SkyEyeSetDevRegValueById(arg[0],arg[1],arg[3],regid) - except Exception as e: - print (e) - return - - - - def do_list_class(self, arg): - try: - cls_l = SkyEyeGetClassList() - cls_l.sort() - formot_output(cls_l) - except Exception as e: - print (e) - - @checked_parameter(False,str) - def do_list_iface(self, arg): - try: - cls_l = SkyEyeGetClassList() - if arg[0] not in cls_l: - print ("%s IFACE information was not found"%arg[0]) - return - iface_l = SkyEyeGetClassIfaceList(arg[0]) - iface_l.sort() - formot_output(iface_l) - except Exception as e: - print (e) - - @checked_parameter(False,str) - def do_list_connect(self, arg): - try: - cls_l = SkyEyeGetClassList() - if arg[0] not in cls_l: - print ("%s CONNECT information was not found"%arg[0]) - return - connect_l = SkyEyeGetClassConnectList(arg[0]) - connect_l.sort() - formot_output(connect_l) - except Exception as e: - print (e) - - - @checked_parameter(False,str) - def do_list_attr(self, arg): - attr_info_l = [] - try: - cls_l = SkyEyeGetClassList() - if arg[0] not in cls_l: - print ("%s ATTR information was not found"%arg[0]) - return - cls = arg[0] - attr_l = SkyEyeGetClassAttrList(arg[0]) - attr_l.sort() - attr_info_l = [] - for attr in attr_l: - info_l = SkyEyeGetClassAttrInfo(cls,attr) - attr_info_l.append(info_l) - except Exception as e: - print (e) - return - print ("%-20s%-20s%s" % ("AttrName", "Type", "Description")) - for info_l in attr_info_l: - if len(info_l) != 3: - destription = 'NULL' - else: - destription = info_l[2] - print ("%-20s%-20s%s" % (info_l[0], info_l[1], destription)) - - def help_list_cpu(self, arg): - help_info_output(None, "list-cpu", None) - - def help_list_device(self, arg): - help_info_output(None, "list-device [mach name]", None) - - def help_list_attr(self, arg): - help_info_output(None, "list-attr ", None) - - def help_list_iface(self, arg): - help_info_output(None, "list-iface ", None) - - def help_list_connect(self, arg): - help_info_output(None, "list-connect ", None) - - def help_list_class(self): - usage = "Print all classes that has been registered by loaded modules" - help_info_output(None, "list_class", usage) + cmds = [attr[3:] for attr in attrs if attr.startswith('do_')] + for cmd in cmds: + setattr(cls, 'help_'+cmd, create_help_method(cmd)) + return cls -##########################fault inject################################## - @checked_parameter(False,str,str,int,int,int) - def do_fj_set(self, arg): - ret=sfi.skyeye_set_fj(arg[0],arg[1],arg[2],arg[3],arg[4]) - if ret==True: - print ("Injection failure success") - else: - print ("Injection failure failed") - - - def do_fj_list(self, arg): - ret=sfi.skyeye_get_fj() - print ("%-20s%-20s%-20s%-20s%-10s%-10s" % ("Device","Mach","Register","Address(HEX)", "Bit(DEC)", "Mode(DEC)")) - for fj in ret: - print ("%-20s%-20s%-20s%-20x%-10d%-10d" % (fj[0],fj[1],fj[2],fj[3],fj[4],fj[5])) - - - @checked_parameter(False,str,str,int,int,int) - def do_fj_clear(self, arg): - ret=sfi.skyeye_clear_fj(arg[0],arg[1],arg[2],arg[3],arg[4]) - if ret==True: - print ("Failure deletion successful") - else: - print ("Failure deletion failed") - - def help_fj_set(self): - info = "set_fj [mach name] [device name] [address] [bit] [mode]" - help_info_output(None, info, None) - - def help_fj_list(self): - info = "list_fj" - help_info_output(None, info, None) - - def help_fj_clear(self): - info = "clear_fj [mach name] [device name] [address] [bit] [mode]" - help_info_output(None, info, None) -######################################################################## - - @checked_parameter(False,str,int) - def do_md(self, arg): - config = GetGlobalConfig() - if config == None: - return - try: - ret=SkyEyeReadMemory8(arg[0],arg[1]) - print ("%-20s%-20s" % ("Addr(HEX)", "Value(HEX)")) - print ("%-20x%-20x" % (arg[1],ret)) - except Exception as e: - print (e) - - @checked_parameter(False,str,int) - def do_disassemble(self, arg): - config = GetGlobalConfig() - if config == None: - return - #try: - disas_str =SkyEyeDisassemble(arg[0],arg[1]) - #except Exception as e: - # print (e) - print ("%-20s%-20s" % ("Addr(HEX)", "Value")) - print ("%-20x%-20s" % (arg[1], disas_str)) - - def help_disassemble(self): - help_info_output(None, "disassemble ", None) - - -#################### remote-gdb ######################## - - @checked_parameter(False,str,int,str) - def do_remote_gdb(self, arg): - if len(arg) == 2: - arg.append("0.0.0.0") - try: - ret=SkyEyeCreateRemoteGdb(arg[0],arg[1],arg[2]) - if ret != 1: - print ("Remote Gdb Start error, Target Cpu Name: %s, Port: %d, Ip: %s" % (arg[0], arg[1],arg[2])) - else: - print ("Remote Gdb Start OK!") - except: - print ("An error has occurred happend when remote gdb start!") - print ("Target CPU name: %s, Port: %d, Ip: %s" % (arg[0], arg[1], arg[2])) - - - def help_remote_gdb(self): - help_info_open() - print ("remote-gdb : Open remote gdb debugger.") - help_info_close() - -#################### remote-gdb ######################## - -#################### other COMMANDS #################### -# thread.start_new_thread( print_time, ("Thread-1", 2, ) ) - - @checked_parameter(False,int) - def do_set_mode(self, arg): - config = GetGlobalConfig() - if config == None: - return - print ("--%d--" % arg[0]) - SetAllToDyncom(arg[0]) - - def do_speed(self, arg): - mips_dic = mips.get() - for item in mips_dic.keys(): - print ("CPU:%20s SPEED:%d" % (item, mips_dic[item])) - - def help_speed(self, arg): - info = "speed" - help_info_output(None, info, None) - - def do_ls(self, arg): -# print ("outline ls") - if arg!= "" and not os.path.exists(arg): - print ("No such file or directory") - return - try: - SkyEyeListDir(arg) - except Exception as e: - print (e) - - def do_quit(self, arg): -# print ("outline quit") - if mips.mips_thread != None: - mips.mips_thread.stop() - coverage.kill_objdump_thread() - NetCtrl.server_stop() - try: - SkyEyeQuit() - except Exception as e: - print (e) - - do_q = do_quit - - def do_run(self, arg): -# print ("outline run") - try: - SkyEyeRun() - pytimer.set_running(True) - except Exception as e: - print (e) - - def do_stop(self, arg): -# print ("outline stop") - try: - SkyEyeStop() - pytimer.set_running(False) - except Exception as e: - print (e) - - @checked_parameter(False,str,int) - def do_stepi(self, arg): -# print ("outline stepi") - try: - SkyEyeStepi(arg[0],str(arg[1])) - except Exception as e: - print (e) - - def do_reset(self, arg): -# print ("outline reset") - try: - SkyEyeReset() - pytimer.set_running(False) - self.open_conf_flag = False - except Exception as e: - print (e) - - -########################### reverse ################################# - @checked_parameter(False,str,int) - def do_reverse(self, arg): - cmd = cli.GetCommand("reverse") - if cmd == None: - LogReport('reverse: Can not find command "reverse"') - return - try: - cmd.run([arg[0],str(arg[1])]) - except Exception as e: - help_info_output(e, cmd.synopses(), cmd.doc()) - - - def do_reverse_enable(self, arg): - cmd = cli.GetCommand("enable-reverse") - if cmd == None: - LogReport('reverse_enable: Can not find command "enable-reverse"') - return - try: - cmd.run([]) - except Exception as e: - help_info_output(e, cmd.synopses(), cmd.doc()) - - - def do_reverse_disable(self, arg): - cmd = cli.GetCommand("disable-reverse") - if cmd == None: - LogReport('reverse_disable: Can not find command "disable-reverse"') - return - try: - cmd.run([]) - except Exception as e: - help_info_output(e, cmd.synopses(), cmd.doc()) -########################### reverse ################################# - - @checked_parameter(False,str) - def do_disable_device_work(self,arg): - cmd = cli.GetCommand("disable-device-work") - if cmd == None: - LogReport('disable-device-work: Can not find command "disable-device-work"') - return - try: - cmd.run(arg) - except Exception as e: - help_info_output(e, cmd.synopses(), cmd.doc()) - - @checked_parameter(False,str) - def do_enable_device_work(self,arg): - cmd = cli.GetCommand("enable-device-work") - if cmd == None: - LogReport('enable-device-work: Can not find command "enable-device-work"') - return - try: - cmd.run(arg) - except Exception as e: - help_info_output(e, cmd.synopses(), cmd.doc()) - - @checked_parameter(False,str) - def do_configure_write(self,arg): - cmd = cli.GetCommand("write-configure") - if cmd == None: - LogReport('write-configure: Can not find command "write-configure"') - return - try: - cmd.run(arg) - except Exception as e: - help_info_output(e, cmd.synopses(), cmd.doc()) - - def help_configure_write(self): - help_info_output(None, "write-configure ", None) - - @checked_parameter(False,str) - def do_configure_read(self,arg): - cmd = cli.GetCommand("read-configure") - if cmd == None: - LogReport('read-configure: Can not find command "read-configure"') - return - try: - cmd.run(arg) - except Exception as e: - help_info_output(e, cmd.synopses(), cmd.doc()) - - def help_configure_read(self): - help_info_output(None, "read-configure ", None) - - def help_ls(self): - help_info_open() - print ("ls : Synonym for `list'") - help_info_close() - - def help_quit(self): - help_info_open() - print ("quit : Quit SkyEye ") - help_info_close() - - def help_q(self): - help_info_open() - print ("q : Quit SkyEye ") - help_info_close() - - def help_run(self): - help_info_open() - print ("run : Start the simulator.") - help_info_close() - - def help_stop(self): - help_info_open() - print ("stop : Stop the running of simulator.") - help_info_close() - - def help_stepi(self): - help_info_open() - print ("stepi : step into .") - help_info_close() - - def help_reset(self): - help_info_open() - print ("reset: reset simulator.") - help_info_close() - - -#################### open_instr_record COMMANDS #################### - @checked_parameter(False, str, str) - def do_open_instr_record(self,arg): - cmd = cli.GetCommand("open-instr-record") - if cmd == None: - LogReport('open-instr-record: Can not find command "open-instr-record"') - return - try: - cmd.run(arg) - except Exception as e: - help_info_output(e, cmd.synopses(), cmd.doc()) - def help_open_instr_record(self): - help_info_output(None, "open-instr-record ", None) -#################### open_instr_record COMMANDS END #################### - -#################### close_instr_record COMMANDS #################### - @checked_parameter(False, str) - def do_close_instr_record(self,arg): - cmd = cli.GetCommand("close-instr-record") - if cmd == None: - LogReport('close-instr-record: Can not find command "close-instr-record"') - return - try: - cmd.run(arg) - except Exception as e: - help_info_output(e, cmd.synopses(), cmd.doc()) - def help_close_instr_record(self): - help_info_output(None, "close-instr-record ", None) -#################### close_instr_record COMMANDS END #################### - -#################### set_pc COMMANDS #################### - @checked_parameter(False, str, int) - def do_set_pc(self,arg): - try: - ret = SkyEyeSetPC(arg[0], arg[1]) - if ret == 0: - print ("SkyEyeSetPC Failed!") - except: - print("set-pc: SkyEyeSetPC CALL ERROR!") - raise - def help_set_pc(self): - help_info_output(None, "set-pc ", None) -#################### set_pc COMMANDS END #################### - -#################### get_pc COMMANDS #################### - @checked_parameter(False, str) - def do_get_pc(self,arg): - cmd = cli.GetCommand("get-pc") - if cmd == None: - LogReport('get-pc: Can not find command "get-pc"') - return - try: - cmd.run(arg) - except Exception as e: - help_info_output(e, cmd.synopses(), cmd.doc()) - def help_get_pc(self): - help_info_output(None, "get-pc ", None) -#################### get_pc COMMANDS END #################### - -#################### other COMMANDS #################### -###################### Memory Test ##################### - @checked_parameter(False,str) - def do_mm_info(self, arg): - args="" - for i in arg: - args=args+" "+i - SkyEyeMemoryInfo(args.strip()) - - def help_mm_info(self): - help_info_open() - print ("1. mm-info output memory malloc and free information.") - print ("2. mm-info \n\tmm-info log: log saved when you exit.\n\tmm-info nolog: cancel save log.") - print ("3. mm-info ") - help_info_close() - -###################### Memory Test ##################### - -##### End with Class SkyEye ##### - -def ParseParameter(arg): - arglist = [] - if arg == "": - return arglist - arglist = arg.split(' ') - while 1: - try: - arglist.remove('') - except: - break - for index in range(0,len(arglist)): - arglist[index] = arglist[index].replace("%20"," ") - return arglist - - -def str_to_uint(str): - py_str = str - if operator.eq(py_str[0:2], "0x") == True: - py_uint = int(py_str, 16) - elif py_str.isdigit(): - py_uint = int(py_str, 10) - else: - return py_str - return py_uint +@add_help_method +class SkyEyeCli(cmd.Cmd): + Config = None + # skyeye prompt + prompt = '(skyeye) ' + + def __init__(self, args=[]): + cmd.Cmd.__init__(self) + self.args_list = args + welcome_message() + ret=se_lic.license_verify() + if ret[0]==False: + print (ret[1]) + #exit() + # log=output_log() + # se.log=log + self.open_conf_flag = False + #if "-gui" in self.args_list and tools.is_windows(): + # from skyeye_gui import * + # win_control() + RegisterLog(print) + mips.mips_thread = mips.mips() + mips.mips_thread.start() + if(os.path.exists('.skyeyeinit')): + tools.execute_skyeyeinit_file('.skyeyeinit') + if tools.is_windows(): + ws.load_module_from_ws() + try: + NetCtrl.server_init() + except: + print ("网络服务启动失败,检查GRPC服务是否配置正确!") + pytimer.PyTmrInit() + + # 为命令补齐配置readline + self.readline_cfg() + + # 命令参赛解析器 + self.cmd_parsers = {} + + def readline_cfg(self): + s = readline.get_completer_delims() + for c in '<>-': + s = s.replace(c, '') + s += '.' + readline.set_completer_delims(s) + + def quit_skyeye(self, arg): + libcommon.com_quit(arg) + + def preloop(self): + self.history_file = os.path.join(os.path.expanduser('~'), '.skyeye/cmd_history') + if not os.path.exists(self.history_file): + print('not exists') + with open(self.history_file, 'w'): + pass + readline.read_history_file(self.history_file) + + def postloop(self): + print('in postloop') + readline.write_history_file(self.history_file) + + def precmd(self, arg): + if arg: + arg_list = arg.split() + if arg_list: + arg_list[0] = arg_list[0].replace('-', '_') + return ' '.join(arg_list) + return arg + + def postcmd(self, stop, line): + time.sleep(0.01) + if libcommon.SIM_is_running(): + self.prompt = "(running) " + else: + self.prompt = "(skyeye) " + + # his_len = readline.get_current_history_length() + # print('len:"%s"' % his_len) + return stop + + def print_help(self, cmd): + parser = self.get_argparser(cmd) + parser.print_help() + + def completenames(self, text, *ignored): + # TODO: 补齐形如''对象名， + # if text.startswith('<'): + # pass + + # 支持"list-cpu" "list-device"带有"-"的命令 + hack = False + if '-' in text: + text = text.replace('-', '_') + hack = True + res = super().completenames(text, *ignored) + res = [s.replace('_', '-') for s in res] + return res + + def completedefault(self, text, line, begidx, endidx): + # TODO: 实现参数补齐功能 + pass + + def default(self, line): + print('*** Unknown command: %s\n'%line) + print('*** Get commands with \'help\' cmd\n') + + def get_argparser(self, cmd): + parser = self.cmd_parsers.get(cmd) + if not parser: + parser = getattr(self, 'create_argparser_'+cmd)() + return parser + + def create_argparser_help(self): + parser = self.cmd_parsers['help'] = argparse.ArgumentParser( + prog='help', + description='Print help info.', + add_help=False, + ) + + parser.add_argument( + 'cmd', + metavar='', + nargs='?', + help='command name', + ) + return parser + + def do_help(self, arg): + arg = arg.replace('-', '_') + return super().do_help(arg) + + def create_argparser_history(self): + parser = self.cmd_parsers['history'] = argparse.ArgumentParser( + prog='history', + description='Show command history.', + add_help=False) + return parser + + def do_history(self, arg): + parser = self.get_argparser('history') + try: + ns = parser.parse_args(arg.split()) + except: + return + + hist_len = readline.get_current_history_length() + for i in range(1, hist_len+1): + hist_item = readline.get_history_item(i) + print('%-5s %s' % (i, hist_item)) + + def create_argparser_list_modules(self): + parser = self.cmd_parsers['list_modules'] = argparse.ArgumentParser( + prog='list_modules', + description='List all the loaded module.', + add_help=False) + return parser + + def do_list_modules(self, arg): + '''list-modules : List all the loaded module.''' + parser = self.get_argparser('list_modules') + try: + ns = parser.parse_args(arg.split()) + except: + return + + try: + SkyEyeListModules() + except Exception as e: + print(e) + + def create_argparser_list_machines(self): + parser = self.cmd_parsers['list_machines'] = argparse.ArgumentParser( + prog='list_machines', + description='List all the supported machines for SkyEye.', + add_help=False) + return parser + + def do_list_machines(self, arg): + '''List all the supported machines for SkyEye.''' + parser = self.get_argparser('list_machines') + try: + arg_ns = parser.parse_args(arg.split()) + except: + return + + config = GetGlobalConfig() + if config: + ml = config.get_mach_list() + print("%-20s%-20s" % ("Id", "MachinesName")) + for i in range(len(ml)): + print("%-20s%-20s" % (i+1, ml[i])) + + def create_argparser_run_script(self): + parser = self.cmd_parsers['run_script'] = argparse.ArgumentParser( + prog='run_script', + description='Run skyeye script.', + add_help=False) + + parser.add_argument( + 'script_name', + metavar='', + help='name of skyeye-script', + ) + + return parser + + def do_run_script(self, arg): + parser = self.get_argparser('run_script') + try: + ns = parser.parse_args(arg.split()) + except: + return + + cmd = cli.GetCommand("run-script") + if not cmd: + print ("Can not find command: run-script") + return + if self.open_conf_flag: + LogReport("Do not reload until RESET is performed") + return False + + SetGlobalScript(ns.script_name) + try: + res = cmd.run([ns.script_name]) + except Exception as e: + LogReportPack(errormessage.GetErrorInfo()) + res = False + if res: + self.open_conf_flag = True + + def create_argparser_run_command(self): + parser = self.cmd_parsers['run_command'] = argparse.ArgumentParser( + prog='run_command', + description='Run a skyeye command.', + add_help=False) + + parser.add_argument( + 'script_name', + metavar='', + nargs='+', + help='part of skyeye-command', + ) + + return parser + + def do_run_command(self, arg): + parser = self.get_argparser('run_command') + try: + ns = parser.parse_args(arg.split()) + except: + return + + cmd = cli.GetCommand("run-command") + if not cmd: + print ("Can not find command: run-command") + return + cmd.run(arg) + + def create_argparser_bp_create(self): + parser = self.cmd_parsers['bp_create'] = argparse.ArgumentParser( + prog='bp_create', + description='Insert a break-point on a cpu-core.', + add_help=False) + + parser.add_argument( + 'cpu', + metavar='', + help='cpu-core name', + ) + + parser.add_argument( + 'bp_addr', + metavar='', + type=convert_int, + help='break-point address (int)', + ) + return parser + + def do_bp_create(self, arg): + parser = self.get_argparser('bp_create') + try: + ns = parser.parse_args(arg.split()) + except: + return + + try: + SkyEyeCreateBreakpoint(ns.cpu, ns.bp_addr) + except: + print ("Insert breakpoint error") + + def create_argparser_bp_delete(self): + parser = self.cmd_parsers['bp_create'] = argparse.ArgumentParser( + prog='bp_create', + description='Delete a break-point on a cpu-core.', + add_help=False) + + parser.add_argument( + 'cpu', + metavar='', + help='cpu-core name', + ) + + + parser.add_argument( + 'bp_addr', + metavar='', + type=convert_int, + help='break-point address (int)', + ) + return parser + + def do_bp_delete(self, arg): + parser = self.get_argparser('bp_delete') + try: + ns = parser.parse_args(arg.split()) + except: + return + + try: + SkyEyeDeleteBreakpointByAddr(ns.cpu, ns.bp_addr) + except: + print ("Delete breakpoint error") + + def create_argparser_bp_list(self): + parser = self.cmd_parsers['bp_list'] = argparse.ArgumentParser( + prog='bp_list', + description='Show all break-points.', + add_help=False) + parser.add_argument( + 'cpu', + metavar='', + help='cpu-core name', + ) + return parser + + def do_bp_list(self, arg): + parser = self.get_argparser('bp_list') + try: + ns = parser.parse_args(arg.split()) + except: + return + + try: + temp = [] + ret = SkyEyeGetBpNumbers(ns.cpu) + for i in range(0, ret): + temp.append(SkyEyeGetBreakpointAddrById(ns.cpu, i)) + print ("%-25s%-25s"%("CPU","Address(HEX)")) + for i in temp: + print ("%-25s0x%-25x"%(ns.cpu, i)) + except: + print ("Breakpoint get error") + + def create_argparser_list_cpu(self): + parser = self.cmd_parsers['list_cpu'] = argparse.ArgumentParser( + prog='list_cpu', + description='Show all available cpu.', + add_help=False) + return parser + + def do_list_cpu(self, arg): + parser = self.get_argparser('list_cpu') + try: + ns = parser.parse_args(arg.split()) + except: + return + + config = GetGlobalConfig() + if not config: + return + cpus = config.get_cpu_list() + print ("%-20s%-20s" % ("ID", "CpuName")) + count = 0 + for cpu in cpus: + count = count + 1 + print ("%-20d%-20s" % (count, cpu)) + + def create_argparser_list_register(self): + parser = self.cmd_parsers['list_register'] = argparse.ArgumentParser( + prog='list_register', + description='Show all registers of a device.', + add_help=False) + + parser.add_argument( + 'machine', + metavar='', + help='machine name', + ) + + parser.add_argument( + 'device', + metavar='', + help='device name', + ) + return parser + + def do_list_register(self, arg): + parser = self.get_argparser('list_register') + try: + ns = parser.parse_args(arg.split()) + except: + return + + config = GetGlobalConfig() + if not config: + return + ret = sfi.get_device_register_info(ns.machine, ns.device) + print ("%-20s%-20s%-20s" % ("Register", "Value(HEX)", "Address(HEX)")) + for i in ret.keys(): + print ("%-20s%-20x%-20x" % (i, ret[i]["value"], ret[i]["addr"])) + + def create_argparser_list_device(self): + parser = self.cmd_parsers['list_device'] = argparse.ArgumentParser( + prog='list_device', + description='Show all current device.', + add_help=False) + + parser.add_argument( + 'machine', + metavar='', + nargs='?', + help='machine name', + ) + return parser + + def do_list_device(self, arg): + parser = self.get_argparser('list_device') + try: + ns = parser.parse_args(arg.split()) + except: + return + + config = GetGlobalConfig() + if not config: + return + + if ns.machine is None: + print ("%-30s%-30s" % ("DeviceName", "BelongBoard")) + machlist = config.get_mach_list() + for mach in machlist: + mach_cls = config.get_mach_classname(mach) + if mach_cls == 'pc_mach': + cpu = config.get_cpuname_by_mach(mach) + if cpu: + x86_obj = x86(cpu) + for device in x86_obj.devices: + print ("%-30s%-30s" % (device.name, mach)) + else: + device_list = config.get_device_list_by_mach(mach) + for device in device_list: + print ("%-30s%-30s" % (device, mach)) + else: + print ("%-30s%-30s" % ("ID", "DeviceName")) + device_list = config.get_device_list_by_mach(ns.machine) + for i in range(0, len(device_list)): + print ("%-30s%-30s" % (i+1, device_list[i])) + + def create_argparser_set_register(self): + parser = self.cmd_parsers['set_register'] = argparse.ArgumentParser( + prog='set_register', + description='Set a value to a register.', + add_help=False) + + parser.add_argument( + 'machine', + metavar='', + help='machine name', + ) + + parser.add_argument( + 'device', + metavar='', + help='device name', + ) + + parser.add_argument( + 'register', + metavar='', + help='device name', + ) + + parser.add_argument( + 'value', + metavar='', + type=convert_int, + help='value of int', + ) + + return parser + + def do_set_register(self, arg): + parser = self.get_argparser('set_register') + try: + ns = parser.parse_args(arg.split()) + except: + return + + try: + regid = SkyEyeGetDevRegIdByName(ns.machine, ns.device, ns.register) + ret = SkyEyeSetDevRegValueById(ns.machine, ns.device, ns.value, regid) + except Exception as e: + print (e) + return + + def create_argparser_list_class(self): + parser = self.cmd_parsers['list_class'] = argparse.ArgumentParser( + prog='list_class', + description='Show all classes.', + add_help=False) + + return parser + + def do_list_class(self, arg): + parser = self.get_argparser('list_class') + try: + ns = parser.parse_args(arg.split()) + except: + return + + try: + cls_l = SkyEyeGetClassList() + cls_l.sort() + #formot_output(cls_l) + table_print(cls_l) + except Exception as e: + print (e) + + def create_argparser_list_iface(self): + parser = self.cmd_parsers['list_iface'] = argparse.ArgumentParser( + prog='list_iface', + description='Show the information of a class.', + add_help=False) + + parser.add_argument( + 'cls', + metavar='', + help='class name', + ) + + def do_list_iface(self, arg): + parser = self.get_argparser('list_iface') + try: + ns = parser.parse_args(arg.split()) + except: + return + + try: + cls_l = SkyEyeGetClassList() + if ns.cls not in cls_l: + print ("%s IFACE information was not found" % ns.cls) + return + iface_l = SkyEyeGetClassIfaceList(ns.cls) + iface_l.sort() + table_print(iface_l) + except Exception as e: + print (e) + + def create_argparser_list_connect(self): + parser = self.cmd_parsers['list_connect'] = argparse.ArgumentParser( + prog='list_connect', + description='Show the connect information of a class.', + add_help=False) + + parser.add_argument( + 'cls', + metavar='', + help='class name', + ) + + return parser + + def do_list_connect(self, arg): + parser = self.get_argparser('list_connect') + try: + ns = parser.parse_args(arg.split()) + except: + return + + try: + cls_l = SkyEyeGetClassList() + if ns.cls not in cls_l: + print ("%s CONNECT information was not found" % ns.cls) + return + connect_l = SkyEyeGetClassConnectList(ns.cls) + connect_l.sort() + #formot_output(connect_l) + table_print(connect_l) + except Exception as e: + print (e) + + + def create_argparser_list_attr(self): + parser = self.cmd_parsers['list_attr'] = argparse.ArgumentParser( + prog='list_attr', + description='Show attribute of a class.', + add_help=False) + + parser.add_argument( + 'cls', + metavar='', + help='class name', + ) + + return parser + + def do_list_attr(self, arg): + parser = self.get_argparser('list_attr') + try: + ns = parser.parse_args(arg.split()) + except: + return + + attr_info_l = [] + try: + cls_l = SkyEyeGetClassList() + if ns.cls not in cls_l: + print ("%s ATTR information was not found" % ns.cls) + return + attr_l = SkyEyeGetClassAttrList(ns.cls) + attr_l.sort() + attr_info_l = [] + for attr in attr_l: + info_l = SkyEyeGetClassAttrInfo(ns.cls, attr) + attr_info_l.append(info_l) + except Exception as e: + print (e) + return + print ("%-20s%-20s%s" % ("AttrName", "Type", "Description")) + for info_l in attr_info_l: + if len(info_l) != 3: + destription = 'NULL' + else: + destription = info_l[2] + print ("%-20s%-20s%s" % (info_l[0], info_l[1], destription)) +##########################fault inject################################## + def create_argparser_fj_set(self): + parser = self.cmd_parsers['fj_set'] = argparse.ArgumentParser( + prog='fj_set', + description='(xxxxxx)', + add_help=False) + + parser.add_argument( + 'machine', + metavar='', + help='machine name', + ) + + parser.add_argument( + 'device', + metavar='', + help='device name', + ) + + parser.add_argument( + 'device_addr', + metavar='', + type=convert_int, + help='device addr', + ) + + parser.add_argument( + 'bit_index', + metavar='', + type=convert_int, + help='bit index', + ) + + parser.add_argument( + 'mode', + metavar='', + type=convert_int, + choices=range(3), + help='mode', + ) + + return parser + + + def do_fj_set(self, arg): + parser = self.get_argparser('fj_set') + try: + ns = parser.parse_args(arg.split()) + except: + return + ret = sfi.skyeye_set_fj(ns.machine, ns.device, ns.device_addr, ns.bit_index, ns.mode) + if ret: + print("Injection failure success") + else: + print("Injection failure failed") + + def create_argparser_fj_list(self): + parser = self.cmd_parsers['fj_list'] = argparse.ArgumentParser( + prog='fj_list', + description='(xxxxxx)', + add_help=False) + return parser + + def do_fj_list(self, arg): + parser = self.get_argparser('fj_list') + try: + ns = parser.parse_args(arg.split()) + except: + return + + ret=sfi.skyeye_get_fj() + print ("%-20s%-20s%-20s%-20s%-10s%-10s" % ("Device","Mach","Register","Address(HEX)", "Bit(DEC)", "Mode(DEC)")) + for fj in ret: + print ("%-20s%-20s%-20s%-20x%-10d%-10d" % (fj[0],fj[1],fj[2],fj[3],fj[4],fj[5])) + + def create_argparser_fj_clear(self): + parser = self.cmd_parsers['fj_clear'] = argparse.ArgumentParser( + prog='fj_clear', + description='(xxxxxx)', + add_help=False) + + parser.add_argument( + 'machine', + metavar='', + help='machine name', + ) + + parser.add_argument( + 'device', + metavar='', + help='device name', + ) + + parser.add_argument( + 'device_addr', + metavar='', + type=convert_int, + help='device addr', + ) + + parser.add_argument( + 'bit_index', + metavar='', + type=convert_int, + help='bit index', + ) + + parser.add_argument( + 'mode', + metavar='', + type=convert_int, + choices=range(3), + help='mode', + ) + + return parser + + def do_fj_clear(self, arg): + parser = self.get_argparser('fj_clear') + try: + ns = parser.parse_args(arg.split()) + except: + return + + ret = sfi.skyeye_clear_fj(ns.machine, ns.device, ns.device_addr, ns.bit_index, ns.mode) + if ret: + print ("Failure deletion successful") + else: + print ("Failure deletion failed") + + def create_argparser_md(self): + parser = self.cmd_parsers['md'] = argparse.ArgumentParser( + prog='md', + description='Get the value at a address of memory.', + add_help=False) + + parser.add_argument( + 'cpu', + metavar='', + help='cpu name', + ) + + parser.add_argument( + 'addr', + metavar='', + type=convert_int, + help='memory address', + ) + + return parser + + def do_md(self, arg): + parser = self.get_argparser('md') + try: + ns = parser.parse_args(arg.split()) + except: + return + + config = GetGlobalConfig() + if not config: + return + try: + ret = SkyEyeReadMemory8(ns.cpu, ns.addr) + print ("%-20s%-20s" % ("Addr(HEX)", "Value(HEX)")) + print ("%-20x%-20x" % (ns.addr, ret)) + except Exception as e: + print (e) + + def create_argparser_disassemble(self): + parser = self.cmd_parsers['disassemble'] = argparse.ArgumentParser( + prog='md', + description='Show infomation of disassembleat a address.', + add_help=False) + + parser.add_argument( + 'cpu', + metavar='', + help='cpu name', + ) + + parser.add_argument( + 'addr', + metavar='', + type=convert_int, + help='memory address', + ) + + return parser + + def do_disassemble(self, arg): + parser = self.get_argparser('disassemble') + try: + ns = parser.parse_args(arg.split()) + except: + return + + config = GetGlobalConfig() + if not config: + return + + disas_str =SkyEyeDisassemble(ns.cpu, ns.addr) + print ("%-20s%-20s" % ("Addr(HEX)", "Value")) + print ("%-20x%-20s" % (ns.addr, disas_str)) + + def create_argparser_remote_gdb(self): + parser = self.cmd_parsers['remote_gdb'] = argparse.ArgumentParser( + prog='remote_gdb', + description='Connect remote gdb.', + add_help=False) + + parser.add_argument( + 'cpu', + metavar='', + help='cpu name', + ) + + parser.add_argument( + 'ip', + metavar='', + nargs='?', + default='0.0.0.0', + help='ip address', + ) + + parser.add_argument( + 'port', + metavar='', + type=convert_int, + help='port number', + ) + + return parser + + def do_remote_gdb(self, arg): + # FIXME: BUG + parser = self.get_argparser('remote_gdb') + try: + ns = parser.parse_args(arg.split()) + except: + return + + try: + ret = SkyEyeCreateRemoteGdb(ns.cpu, ns.port, ns.ip) + if ret != 1: + print("Remote Gdb Start error, Target Cpu Name: %s, Ip: %s, Port: %d" % (ns.cpu, ns.ip, ns.port)) + else: + print("Remote Gdb Start OK!") + except: + print("An error has occurred happend when remote gdb start!") + print("Target CPU name: %s, Ip: %s, Port: %d" % (ns.cpu, ns.ip, ns.port)) + + def create_argparser_set_mode(self): + parser = self.cmd_parsers['set_mode'] = argparse.ArgumentParser( + prog='set_mode', + description='Set the cpu running mode', + add_help=False) + + parser.add_argument( + 'mode', + metavar='', + type=convert_int, + choices=range(4), + help='mode (choose from 0, 1, 2, 3)', + ) + + return parser + + def do_set_mode(self, arg): + parser = self.get_argparser('set_mode') + try: + ns = parser.parse_args(arg.split()) + except: + return + + config = GetGlobalConfig() + if not config: + return + print ("--%d--" % ns.mode) + SetAllToDyncom(ns.mode) + + def create_argparser_speed(self): + parser = self.cmd_parsers['speed'] = argparse.ArgumentParser( + prog='speed', + description='Show the current running speed of the cpu.', + add_help=False) + + return parser + + def do_speed(self, arg): + parser = self.get_argparser('speed') + try: + ns = parser.parse_args(arg.split()) + except: + return + + mips_dic = mips.get() + for item in mips_dic.keys(): + print ("CPU:%20s SPEED:%d" % (item, mips_dic[item])) + + def create_argparser_ls(self): + parser = self.cmd_parsers['ls'] = argparse.ArgumentParser( + prog='ls', + description='list directory contents', + add_help=False) + + parser.add_argument( + 'path', + metavar='', + nargs='?', + default='', + help='the path of file or directory', + ) + + return parser + + def do_ls(self, arg): + parser = self.get_argparser('ls') + try: + ns = parser.parse_args(arg.split()) + except: + return + + if ns.path and not os.path.exists(ns.path): + print("No such file or directory") + return + try: + SkyEyeListDir(arg) + except Exception as e: + print (e) + + def create_argparser_quit(self): + parser = self.cmd_parsers['quit'] = argparse.ArgumentParser( + prog='quit', + description='Quit skyeye.', + add_help=False) + + return parser + + def do_quit(self, arg): + parser = self.get_argparser('quit') + try: + ns = parser.parse_args(arg.split()) + except: + return + + self.postloop() + + if mips.mips_thread != None: + mips.mips_thread.stop() + coverage.kill_objdump_thread() + NetCtrl.server_stop() + try: + SkyEyeQuit() + except Exception as e: + print (e) + do_q = do_quit + + def create_argparser_run(self): + parser = self.cmd_parsers['run'] = argparse.ArgumentParser( + prog='run', + description='Run.', + add_help=False) + + return parser + + def do_run(self, arg): + parser = self.get_argparser('run') + try: + ns = parser.parse_args(arg.split()) + except: + return + + try: + SkyEyeRun() + pytimer.set_running(True) + except Exception as e: + print (e) + + def create_argparser_stop(self): + parser = self.cmd_parsers['stop'] = argparse.ArgumentParser( + prog='stop', + description='Stop.', + add_help=False) + + return parser + + def do_stop(self, arg): + parser = self.get_argparser('stop') + try: + ns = parser.parse_args(arg.split()) + except: + return + + try: + SkyEyeStop() + pytimer.set_running(False) + except Exception as e: + print (e) + + def create_argparser_stepi(self): + parser = self.cmd_parsers['stepi'] = argparse.ArgumentParser( + prog='stepi', + description='Step one instruction exactly.', + add_help=False) + + parser.add_argument( + 'cpu', + metavar='', + help='cpu name', + ) + + parser.add_argument( + 'size', + metavar='', + type=convert_int, + help='step size', + ) + + return parser + + def do_stepi(self, arg): + parser = self.get_argparser('stepi') + try: + ns = parser.parse_args(arg.split()) + except: + return + + try: + SkyEyeStepi(ns.cpu, str(ns.size)) + except Exception as e: + print (e) + + def create_argparser_reset(self): + parser = self.cmd_parsers['reset'] = argparse.ArgumentParser( + prog='reset', + description='Reset.', + add_help=False) + + return parser + + def do_reset(self, arg): + parser = self.get_argparser('reset') + try: + ns = parser.parse_args(arg.split()) + except: + return + + try: + SkyEyeReset() + pytimer.set_running(False) + self.open_conf_flag = False + except Exception as e: + print (e) + + def create_argparser_reverse(self): + parser = self.cmd_parsers['reverse'] = argparse.ArgumentParser( + prog='reverse', + description='reverse', + add_help=False) + + parser.add_argument( + 'cpu', + metavar='', + help='cpu name', + ) + + parser.add_argument( + 'size', + metavar='', + type=convert_int, + help='step size', + ) + + return parser + + def do_reverse(self, arg): + parser = self.get_argparser('reverse') + try: + ns = parser.parse_args(arg.split()) + except: + return + + cmd = cli.GetCommand("reverse") + if not cmd: + LogReport('reverse: Can not find command "reverse"') + return + try: + cmd.run([ns.cpu, str(ns.size)]) + except Exception as e: + print(e, cmd.synopses(), cmd.doc()) + + def create_argparser_reverse_enable(self): + parser = self.cmd_parsers['reverse_enable'] = argparse.ArgumentParser( + prog='reverse_enable', + description='reverse_enable', + add_help=False) + + return parser + + def do_reverse_enable(self, arg): + parser = self.get_argparser('reverse_enable') + try: + ns = parser.parse_args(arg.split()) + except: + return + + cmd = cli.GetCommand("enable-reverse") + if not cmd: + LogReport('reverse_enable: Can not find command "enable-reverse"') + return + try: + cmd.run([]) + except Exception as e: + print(e, cmd.synopses(), cmd.doc()) + + def create_argparser_reverse_disable(self): + parser = self.cmd_parsers['reverse_disable'] = argparse.ArgumentParser( + prog='reverse_disable', + description='reverse_disable', + add_help=False) + + return parser + + def do_reverse_disable(self, arg): + parser = self.get_argparser('reverse_disable') + try: + ns = parser.parse_args(arg.split()) + except: + return + + cmd = cli.GetCommand("disable-reverse") + if not cmd: + LogReport('reverse_disable: Can not find command "disable-reverse"') + return + try: + cmd.run([]) + except Exception as e: + print(e, cmd.synopses(), cmd.doc()) + + def create_argparser_disable_device_work(self): + parser = self.cmd_parsers['disable_device_work'] = argparse.ArgumentParser( + prog='disable_device_work', + description='disable_device_work', + add_help=False) + + parser.add_argument( + 'device', + metavar='', + help='device name', + ) + + return parser + + def do_disable_device_work(self, arg): + parser = self.get_argparser('disable_device_work') + try: + ns = parser.parse_args(arg.split()) + except: + return + + cmd = cli.GetCommand("disable-device-work") + if not cmd: + LogReport('disable-device-work: Can not find command "disable-device-work"') + return + try: + cmd.run([ns.device]) + except Exception as e: + print(e, cmd.synopses(), cmd.doc()) + + def create_argparser_enable_device_work(self): + parser = self.cmd_parsers['enable_device_work'] = argparse.ArgumentParser( + prog='enable_device_work', + description='enable_device_work', + add_help=False) + + parser.add_argument( + 'device', + metavar='', + help='device name', + ) + + return parser + + def do_enable_device_work(self, arg): + parser = self.get_argparser('enable_device_work') + try: + ns = parser.parse_args(arg.split()) + except: + return + + cmd = cli.GetCommand("enable-device-work") + if not cmd: + LogReport('enable-device-work: Can not find command "enable-device-work"') + return + try: + cmd.run(arg_list) + except Exception as e: + print(e, cmd.synopses(), cmd.doc()) + + def create_argparser_configure_write(self): + parser = self.cmd_parsers['configure_write'] = argparse.ArgumentParser( + prog='configure_write', + description='configure_write', + add_help=False) + + parser.add_argument( + 'snapshot', + metavar='', + help='vmware snapshot', + ) + + return parser + + def do_configure_write(self, arg): + parser = self.get_argparser('configure_write') + try: + ns = parser.parse_args(arg.split()) + except: + return + + cmd = cli.GetCommand("write-configure") + if not cmd: + LogReport('write-configure: Can not find command "write-configure"') + return + try: + cmd.run([ns.snapshot]) + except Exception as e: + print(e, cmd.synopses(), cmd.doc()) + + def create_argparser_configure_read(self): + parser = self.cmd_parsers['configure_read'] = argparse.ArgumentParser( + prog='configure_read', + description='configure_read', + add_help=False) + + parser.add_argument( + 'snapshot', + metavar='', + help='snapshot', + ) + + return parser + + def do_configure_read(self, arg): + parser = self.get_argparser('configure_read') + try: + ns = parser.parse_args(arg.split()) + except: + return + + cmd = cli.GetCommand("read-configure") + if not cmd: + LogReport('read-configure: Can not find command "read-configure"') + return + try: + cmd.run([ns.snapshot]) + except Exception as e: + print(e, cmd.synopses(), cmd.doc()) + + def create_argparser_open_instr_record(self): + parser = self.cmd_parsers['open_instr_record'] = argparse.ArgumentParser( + prog='open_instr_record', + description='configure_read', + add_help=False) + + parser.add_argument( + 'cpu', + metavar='', + help='cpu name', + ) + + parser.add_argument( + 'log_file', + metavar='', + help='the log file path', + ) + + return parser + + def do_open_instr_record(self, arg): + parser = self.get_argparser('open_instr_record') + try: + ns = parser.parse_args(arg.split()) + except: + return + + cmd = cli.GetCommand("open-instr-record") + if not cmd: + LogReport('open-instr-record: Can not find command "open-instr-record"') + return + try: + cmd.run([ns.cpu, ns.log_file]) + except Exception as e: + print(e, cmd.synopses(), cmd.doc()) + + def create_argparser_close_instr_record(self): + parser = self.cmd_parsers['close_instr_record'] = argparse.ArgumentParser( + prog='close_instr_record', + description='close_instr_record', + add_help=False) + + parser.add_argument( + 'cpu', + metavar='', + help='cpu name', + ) + + return parser + + def do_close_instr_record(self,arg): + parser = self.get_argparser('close_instr_record') + try: + ns = parser.parse_args(arg.split()) + except: + return + + cmd = cli.GetCommand("close-instr-record") + if not cmd: + LogReport('close-instr-record: Can not find command "close-instr-record"') + return + try: + cmd.run([ns.cpu]) + except Exception as e: + print(e, cmd.synopses(), cmd.doc()) + + def create_argparser_set_pc(self): + parser = self.cmd_parsers['set_pc'] = argparse.ArgumentParser( + prog='set_pc', + description='set_pc', + add_help=False) + + parser.add_argument( + 'cpu', + metavar='', + help='cpu name', + ) + + parser.add_argument( + 'value', + metavar='', + type=convert_int, + help='value', + ) + + return parser + + def do_set_pc(self,arg): + parser = self.get_argparser('set_pc') + try: + ns = parser.parse_args(arg.split()) + except: + return + + try: + ret = SkyEyeSetPC(ns.cpu, ns.value) + if ret == 0: + print ("SkyEyeSetPC Failed!") + except: + print("set-pc: SkyEyeSetPC CALL ERROR!") + raise + + def create_argparser_get_pc(self): + parser = self.cmd_parsers['get_pc'] = argparse.ArgumentParser( + prog='get_pc', + description='get_pc', + add_help=False) + + parser.add_argument( + 'cpu', + metavar='', + help='cpu name', + ) + + return parser + + def do_get_pc(self,arg): + parser = self.get_argparser('get_pc') + try: + ns = parser.parse_args(arg.split()) + except: + return + + cmd = cli.GetCommand("get-pc") + if cmd == None: + LogReport('get-pc: Can not find command "get-pc"') + return + try: + cmd.run([ns.cpu]) + except Exception as e: + print(e, cmd.synopses(), cmd.doc()) + + def create_argparser_mm_info(self): + parser = self.cmd_parsers['mm_info'] = argparse.ArgumentParser( + prog='mm_info', + description='mm_info', + add_help=False) + + parser.add_argument( + 'func', + nargs='?', + default='', + metavar='', + help='function name', + ) + + return parser + + def do_mm_info(self, arg): + parser = self.get_argparser('mm_info') + try: + ns = parser.parse_args(arg.split()) + except: + return + + SkyEyeMemoryInfo(ns.func) + + def do_shell(self, arg): + return self.exec_py_cmd(arg) + + def exec_py_cmd(self, cmd): + try: + exec(cmd) + except: + import traceback + print(traceback.format_exc()) + +################################################################################ +# util func +def convert_int(x): + return int(x, 0) +convert_int.__name__ = 'int' + +def table_print(l): + COL_NUM = 5 + ITEM_WIDTH = 20 + for i in range(0, len(l), COL_NUM): + print(' '.join([item.ljust(ITEM_WIDTH) for item in l[i:i+COL_NUM]])) +def welcome_message(): + os_info = platform.system() + if operator.eq(os_info, "Linux"): + system = "Linux" + else: + system = "Windows" + + try: + config = tools.GetPackageConfig() + version = tools.GetBuildVersion(config) + date = tools.GetBuildDate(config) + except: + version = "unknown" + date = "unknown" + welcome_message = "SkyEye %s Copyright 2010-2022 Digiproto Corporation\n" % (version, date, system) + print(welcome_message)