lightweight console

1 files changed, 946 insertions, 0 deletions

diff --git a/scripts/automation/trex_control_plane/console/old_console.py b/scripts/automation/trex_control_plane/console/old_console.py
new file mode 100644
index 00000000..93c7e3f4
--- /dev/null
+++ b/scripts/automation/trex_control_plane/console/old_console.py
@@ -0,0 +1,946 @@
+
+# main console object
+class TRexConsole1(cmd.Cmd):
+    """Trex Console"""
+
+    def __init__(self, stateless_client, verbose):
+        cmd.Cmd.__init__(self)
+
+        self.stateless_client = stateless_client
+
+        self.do_connect("")
+
+        self.intro  = "\n-=TRex Console v{ver}=-\n".format(ver=__version__)
+        self.intro += "\nType 'help' or '?' for supported actions\n"
+
+        self.verbose = False
+        self._silent = True
+
+        self.postcmd(False, "")
+
+        self.user_streams = {}
+        self.streams_db = CStreamsDB()
+
+
+    # a cool hack - i stole this function and added space
+    def completenames(self, text, *ignored):
+        dotext = 'do_'+text
+        return [a[3:]+' ' for a in self.get_names() if a.startswith(dotext)]
+
+
+    # set verbose on / off
+    def do_verbose(self, line):
+        '''Shows or set verbose mode\n'''
+        if line == "":
+            print "\nverbose is " + ("on\n" if self.verbose else "off\n")
+
+        elif line == "on":
+            self.verbose = True
+            self.stateless_client.set_verbose(True)
+            print green("\nverbose set to on\n")
+
+        elif line == "off":
+            self.verbose = False
+            self.stateless_client.set_verbose(False)
+            print green("\nverbose set to off\n")
+
+        else:
+            print magenta("\nplease specify 'on' or 'off'\n")
+
+    # query the server for registered commands
+    def do_query_server(self, line):
+        '''query the RPC server for supported remote commands\n'''
+
+        res_ok, msg = self.stateless_client.get_supported_cmds()
+        if not res_ok:
+            print format_text("[FAILED]\n", 'red', 'bold')
+            return
+        print "\nRPC server supports the following commands:\n"
+        for func in msg:
+            if func:
+                print func
+        print ''
+        print format_text("[SUCCESS]\n", 'green', 'bold')
+        return
+
+    def do_ping(self, line):
+        '''Pings the RPC server\n'''
+
+        print "\n-> Pinging RPC server"
+
+        res_ok, msg = self.stateless_client.ping()
+        if res_ok:
+            print format_text("[SUCCESS]\n", 'green', 'bold')
+        else:
+            print "\n*** " + msg + "\n"
+            return
+
+    def do_force_acquire(self, line):
+        '''Acquires ports by force\n'''
+
+        self.do_acquire(line, True)
+
+    def complete_force_acquire(self, text, line, begidx, endidx):
+        return self.port_auto_complete(text, line, begidx, endidx, acquired=False)
+
+    def extract_port_ids_from_line(self, line):
+        return {int(x) for x in line.split()}
+
+    def extract_port_ids_from_list(self, port_list):
+        return {int(x) for x in port_list}
+
+    def parse_ports_from_line (self, line):
+        port_list = set()
+        if line:
+            for port_id in line.split(' '):
+                if (not port_id.isdigit()) or (int(port_id) < 0) or (int(port_id) >= self.stateless_client.get_port_count()):
+                    print "Please provide a list of ports separated by spaces between 0 and {0}".format(self.stateless_client.get_port_count() - 1)
+                    return None
+
+                port_list.add(int(port_id))
+
+            port_list = list(port_list)
+
+        else:
+            port_list = [i for i in xrange(0, self.stateless_client.get_port_count())]
+
+        return port_list
+
+
+    def do_acquire(self, line, force=False):
+        '''Acquire ports\n'''
+
+        # make sure that the user wants to acquire all
+        args = line.split()
+        if len(args) < 1:
+            print magenta("Please provide a list of ports separated by spaces, or specify 'all' to acquire all available ports")
+            return
+
+        if args[0] == "all":
+            ask = ConfirmMenu('Are you sure you want to acquire all ports ? ')
+            rc = ask.show()
+            if rc == False:
+                print yellow("[ABORTED]\n")
+                return
+            else:
+                port_list = self.stateless_client.get_port_ids()
+        else:
+            port_list = self.extract_port_ids_from_line(line)
+
+        # rc, resp_list = self.stateless_client.take_ownership(port_list, force)
+        try:
+            res_ok, log = self.stateless_client.acquire(port_list, force)
+            self.prompt_response(log)
+            if not res_ok:
+                print format_text("[FAILED]\n", 'red', 'bold')
+                return
+            print format_text("[SUCCESS]\n", 'green', 'bold')
+        except ValueError as e:
+            print magenta(str(e))
+            print format_text("[FAILED]\n", 'red', 'bold')
+
+
+    def port_auto_complete(self, text, line, begidx, endidx, acquired=True, active=False):
+        if acquired:
+            if not active:
+                ret_list = [x
+                            for x in map(str, self.stateless_client.get_acquired_ports())
+                            if x.startswith(text)]
+            else:
+                ret_list = [x
+                            for x in map(str, self.stateless_client.get_active_ports())
+                            if x.startswith(text)]
+        else:
+            ret_list = [x
+                        for x in map(str, self.stateless_client.get_port_ids())
+                        if x.startswith(text)]
+        ret_list.append("all")
+        return ret_list
+
+
+    def complete_acquire(self, text, line, begidx, endidx):
+        return self.port_auto_complete(text, line, begidx, endidx, acquired=False)
+
+    def do_release (self, line):
+        '''Release ports\n'''
+
+        # if line:
+        #     port_list = self.parse_ports_from_line(line)
+        # else:
+        #     port_list = self.stateless_client.get_owned_ports()
+        args = line.split()
+        if len(args) < 1:
+            print "Please provide a list of ports separated by spaces, or specify 'all' to acquire all available ports"
+        if args[0] == "all":
+            ask = ConfirmMenu('Are you sure you want to release all acquired ports? ')
+            rc = ask.show()
+            if rc == False:
+                print yellow("[ABORTED]\n")
+                return
+            else:
+                port_list = self.stateless_client.get_acquired_ports()
+        else:
+            port_list = self.extract_port_ids_from_line(line)
+
+        try:
+            res_ok, log = self.stateless_client.release(port_list)
+            self.prompt_response(log)
+            if not res_ok:
+                print format_text("[FAILED]\n", 'red', 'bold')
+                return
+            print format_text("[SUCCESS]\n", 'green', 'bold')
+        except ValueError as e:
+            print magenta(str(e))
+            print format_text("[FAILED]\n", 'red', 'bold')
+            return
+
+    def complete_release(self, text, line, begidx, endidx):
+        return self.port_auto_complete(text, line, begidx, endidx)
+
+    def do_connect (self, line):
+        '''Connects to the server\n'''
+
+        if line == "":
+            res_ok, msg = self.stateless_client.connect()
+        else:
+            sp = line.split()
+            if (len(sp) != 2):
+                print "\n[usage] connect [server] [port] or without parameters\n"
+                return
+
+            res_ok, msg = self.stateless_client.connect(sp[0], sp[1])
+
+        if res_ok:
+            print format_text("[SUCCESS]\n", 'green', 'bold')
+        else:
+            print "\n*** " + msg + "\n"
+            print format_text("[FAILED]\n", 'red', 'bold')
+            return
+
+        self.supported_rpc = self.stateless_client.get_supported_cmds().data
+
+    # def do_rpc (self, line):
+    #     '''Launches a RPC on the server\n'''
+    #
+    #     if line == "":
+    #         print "\nUsage: [method name] [param dict as string]\n"
+    #         print "Example: rpc test_add {'x': 12, 'y': 17}\n"
+    #         return
+    #
+    #     sp = line.split(' ', 1)
+    #     method = sp[0]
+    #
+    #     params = None
+    #     bad_parse = False
+    #     if len(sp) > 1:
+    #
+    #         try:
+    #             params = ast.literal_eval(sp[1])
+    #             if not isinstance(params, dict):
+    #                 bad_parse = True
+    #
+    #         except ValueError as e1:
+    #             bad_parse = True
+    #         except SyntaxError as e2:
+    #             bad_parse = True
+    #
+    #     if bad_parse:
+    #         print "\nValue should be a valid dict: '{0}'".format(sp[1])
+    #         print "\nUsage: [method name] [param dict as string]\n"
+    #         print "Example: rpc test_add {'x': 12, 'y': 17}\n"
+    #         return
+    #
+    #     res_ok, msg = self.stateless_client.transmit(method, params)
+    #     if res_ok:
+    #         print "\nServer Response:\n\n" + pretty_json(json.dumps(msg)) + "\n"
+    #     else:
+    #         print "\n*** " + msg + "\n"
+    #         #print "Please try 'reconnect' to reconnect to server"
+    #
+    #
+    # def complete_rpc (self, text, line, begidx, endidx):
+    #     return [x
+    #             for x in self.supported_rpc
+    #             if x.startswith(text)]
+
+    def do_status (self, line):
+        '''Shows a graphical console\n'''
+
+        if not self.stateless_client.is_connected():
+            print "Not connected to server\n"
+            return
+
+        self.do_verbose('off')
+        trex_status.show_trex_status(self.stateless_client)
+
+    def do_quit(self, line):
+        '''Exit the client\n'''
+        return True
+
+    def do_disconnect (self, line):
+        '''Disconnect from the server\n'''
+        if not self.stateless_client.is_connected():
+            print "Not connected to server\n"
+            return
+
+        res_ok, msg = self.stateless_client.disconnect()
+        if res_ok:
+            print format_text("[SUCCESS]\n", 'green', 'bold')
+        else:
+            print msg + "\n"
+
+    def do_whoami (self, line):
+        '''Prints console user name\n'''
+        print "\n" + self.stateless_client.user + "\n"
+
+    def postcmd(self, stop, line):
+        if self.stateless_client.is_connected():
+            self.prompt = "TRex > "
+        else:
+            self.supported_rpc = None
+            self.prompt = "TRex (offline) > "
+
+        return stop
+
+    def default(self, line):
+        print "'{0}' is an unrecognized command. type 'help' or '?' for a list\n".format(line)
+
+    # def do_help (self, line):
+    #     '''Shows This Help Screen\n'''
+    #     if line:
+    #         try:
+    #             func = getattr(self, 'help_' + line)
+    #         except AttributeError:
+    #             try:
+    #                 doc = getattr(self, 'do_' + line).__doc__
+    #                 if doc:
+    #                     self.stdout.write("%s\n"%str(doc))
+    #                     return
+    #             except AttributeError:
+    #                 pass
+    #             self.stdout.write("%s\n"%str(self.nohelp % (line,)))
+    #             return
+    #         func()
+    #         return
+    #
+    #     print "\nSupported Console Commands:"
+    #     print "----------------------------\n"
+    #
+    #     cmds =  [x[3:] for x in self.get_names() if x.startswith("do_")]
+    #     for cmd in cmds:
+    #         if cmd == "EOF":
+    #             continue
+    #
+    #         try:
+    #             doc = getattr(self, 'do_' + cmd).__doc__
+    #             if doc:
+    #                 help = str(doc)
+    #             else:
+    #                 help = "*** Undocumented Function ***\n"
+    #         except AttributeError:
+    #             help = "*** Undocumented Function ***\n"
+    #
+    #         print "{:<30} {:<30}".format(cmd + " - ", help)
+
+    def do_stream_db_add(self, line):
+        '''Loads a YAML stream list serialization into user console \n'''
+        args = line.split()
+        if len(args) >= 2:
+            name = args[0]
+            yaml_path = args[1]
+            try:
+                multiplier = args[2]
+            except IndexError:
+                multiplier = 1
+            stream_list = CStreamList()
+            loaded_obj = stream_list.load_yaml(yaml_path, multiplier)
+            # print self.stateless_client.pretty_json(json.dumps(loaded_obj))
+            try:
+                compiled_streams = stream_list.compile_streams()
+                res_ok = self.streams_db.load_streams(name, LoadedStreamList(loaded_obj,
+                                                                             [StreamPack(v.stream_id, v.stream.dump())
+                                                                              for k, v in compiled_streams.items()]))
+                if res_ok:
+                    print green("Stream pack '{0}' loaded and added successfully\n".format(name))
+                else:
+                    print magenta("Picked name already exist. Please pick another name.\n")
+            except Exception as e:
+                print "adding new stream failed due to the following error:\n", str(e)
+                print format_text("[FAILED]\n", 'red', 'bold')
+
+            return
+        else:
+            print magenta("please provide load name and YAML path, separated by space.\n"
+                          "Optionally, you may provide a third argument to specify multiplier.\n")
+
+    @staticmethod
+    def tree_autocomplete(text):
+        dir = os.path.dirname(text)
+        if dir:
+            path = dir
+        else:
+            path = "."
+        start_string = os.path.basename(text)
+        return [x
+                for x in os.listdir(path)
+                if x.startswith(start_string)]
+
+
+    def complete_stream_db_add(self, text, line, begidx, endidx):
+        arg_num = len(line.split()) - 1
+        if arg_num == 2:
+            return TRexConsole.tree_autocomplete(line.split()[-1])
+        else:
+            return [text]
+
+    def do_stream_db_show(self, line):
+        '''Shows the loaded stream list named [name] \n'''
+        args = line.split()
+        if args:
+            list_name = args[0]
+            try:
+                stream = self.streams_db.get_stream_pack(list_name)#user_streams[list_name]
+                if len(args) >= 2 and args[1] == "full":
+                    print pretty_json(json.dumps(stream.compiled))
+                else:
+                    print pretty_json(json.dumps(stream.loaded))
+            except KeyError as e:
+                print "Unknown stream list name provided"
+        else:
+            print "Available stream packs:\n{0}".format(', '.join(sorted(self.streams_db.get_loaded_streams_names())))
+
+    def complete_stream_db_show(self, text, line, begidx, endidx):
+        return [x
+                for x in self.streams_db.get_loaded_streams_names()
+                if x.startswith(text)]
+
+    def do_stream_db_remove(self, line):
+        '''Removes a single loaded stream packs from loaded stream pack repository\n'''
+        args = line.split()
+        if args:
+            removed_streams = self.streams_db.remove_stream_packs(*args)
+            if removed_streams:
+                print green("The following stream packs were removed:")
+                print bold(", ".join(sorted(removed_streams)))
+                print format_text("[SUCCESS]\n", 'green', 'bold')
+            else:
+                print red("No streams were removed. Make sure to provide valid stream pack names.")
+        else:
+            print magenta("Please provide stream pack name(s), separated with spaces.")
+
+    def do_stream_db_clear(self, line):
+        '''Clears all loaded stream packs from loaded stream pack repository\n'''
+        self.streams_db.clear()
+        print format_text("[SUCCESS]\n", 'green', 'bold')
+
+
+    def complete_stream_db_remove(self, text, line, begidx, endidx):
+        return [x
+                for x in self.streams_db.get_loaded_streams_names()
+                if x.startswith(text)]
+
+
+    def do_attach(self, line):
+        '''Assign loaded stream pack into specified ports on TRex\n'''
+        args = line.split()
+        if len(args) >= 2:
+            stream_pack_name = args[0]
+            stream_list = self.streams_db.get_stream_pack(stream_pack_name) #user_streams[args[0]]
+            if not stream_list:
+                print "Provided stream list name '{0}' doesn't exists.".format(stream_pack_name)
+                print format_text("[FAILED]\n", 'red', 'bold')
+                return
+            if args[1] == "all":
+                ask = ConfirmMenu('Are you sure you want to release all acquired ports? ')
+                rc = ask.show()
+                if rc == False:
+                    print yellow("[ABORTED]\n")
+                    return
+                else:
+                    port_list = self.stateless_client.get_acquired_ports()
+            else:
+                port_list = self.extract_port_ids_from_line(' '.join(args[1:]))
+            owned = set(self.stateless_client.get_acquired_ports())
+            try:
+                if set(port_list).issubset(owned):
+                    res_ok, log = self.stateless_client.add_stream_pack(stream_list.compiled, port_id=port_list)
+                    # res_ok, msg = self.stateless_client.add_stream(port_list, stream_list.compiled)
+                    self.prompt_response(log)
+                    if not res_ok:
+                        print format_text("[FAILED]\n", 'red', 'bold')
+                        return
+                    print format_text("[SUCCESS]\n", 'green', 'bold')
+                    return
+                else:
+                    print "Not all desired ports are acquired.\n" \
+                          "Acquired ports are: {acq}\n" \
+                          "Requested ports:    {req}\n" \
+                          "Missing ports:      {miss}".format(acq=list(owned),
+                                                              req=port_list,
+                                                              miss=list(set(port_list).difference(owned)))
+                    print format_text("[FAILED]\n", 'red', 'bold')
+            except ValueError as e:
+                print magenta(str(e))
+                print format_text("[FAILED]\n", 'red', 'bold')
+        else:
+            print magenta("Please provide list name and ports to attach to, "
+                          "or specify 'all' to attach all owned ports.\n")
+
+    def complete_attach(self, text, line, begidx, endidx):
+        arg_num = len(line.split()) - 1
+        if arg_num == 1:
+            # return optional streams packs
+            if line.endswith(" "):
+                return self.port_auto_complete(text, line, begidx, endidx)
+            return [x
+                    for x in self.streams_db.get_loaded_streams_names()
+                    if x.startswith(text)]
+        elif arg_num >= 2:
+            # return optional ports to attach to
+            return self.port_auto_complete(text, line, begidx, endidx)
+        else:
+            return [text]
+
+    def prompt_response(self, response_obj):
+        resp_list = response_obj if isinstance(response_obj, list) else [response_obj]
+        def format_return_status(return_status):
+            if return_status:
+                return green("OK")
+            else:
+                return red("FAIL")
+
+        for response in resp_list:
+            response_str = "{id:^3} - {msg} ({stat})".format(id=response.id,
+                                                             msg=response.msg,
+                                                             stat=format_return_status(response.success))
+            print response_str
+        return
+
+    def do_remove_all_streams(self, line):
+        '''Acquire ports\n'''
+
+        # make sure that the user wants to acquire all
+        args = line.split()
+        if len(args) < 1:
+            print magenta("Please provide a list of ports separated by spaces, "
+                          "or specify 'all' to remove from all acquired ports")
+            return
+        if args[0] == "all":
+            ask = ConfirmMenu('Are you sure you want to remove all stream packs from all acquired ports? ')
+            rc = ask.show()
+            if rc == False:
+                print yellow("[ABORTED]\n")
+                return
+            else:
+                port_list = self.stateless_client.get_acquired_ports()
+        else:
+            port_list = self.extract_port_ids_from_line(line)
+
+        # rc, resp_list = self.stateless_client.take_ownership(port_list, force)
+        try:
+            res_ok, log = self.stateless_client.remove_all_streams(port_list)
+            self.prompt_response(log)
+            if not res_ok:
+                print format_text("[FAILED]\n", 'red', 'bold')
+                return
+            print format_text("[SUCCESS]\n", 'green', 'bold')
+        except ValueError as e:
+            print magenta(str(e))
+            print format_text("[FAILED]\n", 'red', 'bold')
+
+    def complete_remove_all_streams(self, text, line, begidx, endidx):
+        return self.port_auto_complete(text, line, begidx, endidx)
+
+    def do_start(self, line):
+        '''Start selected traffic in specified ports on TRex\n'''
+        # make sure that the user wants to acquire all
+        parser = parsing_opts.gen_parser("start", self.do_start.__doc__,
+                                         parsing_opts.PORT_LIST_WITH_ALL,
+                                         parsing_opts.FORCE,
+                                         parsing_opts.STREAM_FROM_PATH_OR_FILE,
+                                         parsing_opts.DURATION,
+                                         parsing_opts.MULTIPLIER)
+        opts = parser.parse_args(line.split())
+        if opts is None:
+            # avoid further processing in this command
+            return
+        # print opts
+        port_list = self.extract_port_list(opts)
+        # print port_list
+        if opts.force:
+            # stop all active ports, if any
+            res_ok = self.stop_traffic(set(self.stateless_client.get_active_ports()).intersection(port_list))
+            if not res_ok:
+                print yellow("[ABORTED]\n")
+                return
+        # remove all traffic from ports
+        res_ok = self.remove_all_streams(port_list)
+        if not res_ok:
+            print yellow("[ABORTED]\n")
+            return
+        # decide which traffic to use
+        stream_pack_name = None
+        if opts.db:
+            # use pre-loaded traffic
+            print format_text('{:<30}'.format("Load stream pack (from DB):"), 'bold'),
+            if opts.db not in self.streams_db.get_loaded_streams_names():
+                print format_text("[FAILED]\n", 'red', 'bold')
+                print yellow("[ABORTED]\n")
+                return
+            else:
+                stream_pack_name = opts.db
+        else:
+            # try loading a YAML file
+            print format_text('{:<30}'.format("Load stream pack (from file):"), 'bold'),
+            stream_list = CStreamList()
+            loaded_obj = stream_list.load_yaml(opts.file[0])
+            # print self.stateless_client.pretty_json(json.dumps(loaded_obj))
+            try:
+                compiled_streams = stream_list.compile_streams()
+                res_ok = self.streams_db.load_streams(opts.file[1],
+                                                      LoadedStreamList(loaded_obj,
+                                                                       [StreamPack(v.stream_id, v.stream.dump())
+                                                                        for k, v in compiled_streams.items()]))
+                if not res_ok:
+                    print format_text("[FAILED]\n", 'red', 'bold')
+                    print yellow("[ABORTED]\n")
+                    return
+                print format_text("[SUCCESS]\n", 'green', 'bold')
+                stream_pack_name = opts.file[1]
+            except Exception as e:
+                print format_text("[FAILED]\n", 'red', 'bold')
+                print yellow("[ABORTED]\n")
+        res_ok = self.attach_to_port(stream_pack_name, port_list)
+        if not res_ok:
+            print yellow("[ABORTED]\n")
+            return
+        # finally, start the traffic
+        res_ok = self.start_traffic(opts.mult, port_list)
+        if not res_ok:
+            print yellow("[ABORTED]\n")
+            return
+        return
+
+    def help_start(self):
+        self.do_start("-h")
+
+    def do_stop(self, line):
+        '''Stop active traffic in specified ports on TRex\n'''
+        parser = parsing_opts.gen_parser("stop", self.do_stop.__doc__,
+                                         parsing_opts.PORT_LIST_WITH_ALL)
+        opts = parser.parse_args(line.split())
+        if opts is None:
+            # avoid further processing in this command
+            return
+        port_list = self.extract_port_list(opts)
+        res_ok = self.stop_traffic(port_list)
+        return
+
+
+    def help_stop(self):
+        self.do_stop("-h")
+
+
+    def do_debug(self, line):
+        '''Enter DEBUG mode of the console to invoke smaller building blocks with server'''
+        i = DebugTRexConsole(self)
+        i.prompt = self.prompt[:-3] + ':' + blue('debug') + ' > '
+        i.cmdloop()
+
+    # aliasing
+    do_exit = do_EOF = do_q = do_quit
+
+    # ----- utility methods ----- #
+
+    def start_traffic(self, multiplier, port_list):#, silent=True):
+        print format_text('{:<30}'.format("Start traffic:"), 'bold'),
+        try:
+            res_ok, log = self.stateless_client.start_traffic(multiplier, port_id=port_list)
+            if not self._silent:
+                print ''
+                self.prompt_response(log)
+            if not res_ok:
+                print format_text("[FAILED]\n", 'red', 'bold')
+                return False
+            print format_text("[SUCCESS]\n", 'green', 'bold')
+            return True
+        except ValueError as e:
+            print ''
+            print magenta(str(e))
+            print format_text("[FAILED]\n", 'red', 'bold')
+            return False
+
+    def attach_to_port(self, stream_pack_name, port_list):
+        print format_text('{:<30}'.format("Attaching traffic to ports:"), 'bold'),
+        stream_list = self.streams_db.get_stream_pack(stream_pack_name) #user_streams[args[0]]
+        if not stream_list:
+            print "Provided stream list name '{0}' doesn't exists.".format(stream_pack_name)
+            print format_text("[FAILED]\n", 'red', 'bold')
+            return
+        try:
+            res_ok, log = self.stateless_client.add_stream_pack(stream_list.compiled, port_id=port_list)
+            if not self._silent:
+                print ''
+                self.prompt_response(log)
+            if not res_ok:
+                print format_text("[FAILED]\n", 'red', 'bold')
+                return False
+            print format_text("[SUCCESS]\n", 'green', 'bold')
+            return True
+        except ValueError as e:
+            print ''
+            print magenta(str(e))
+            print format_text("[FAILED]\n", 'red', 'bold')
+            return False
+
+    def stop_traffic(self, port_list):
+        print format_text('{:<30}'.format("Stop traffic:"), 'bold'),
+        try:
+            res_ok, log = self.stateless_client.stop_traffic(port_id=port_list)
+            if not self._silent:
+                print ''
+                self.prompt_response(log)
+            if not res_ok:
+                print format_text("[FAILED]\n", 'red', 'bold')
+                return
+            print format_text("[SUCCESS]\n", 'green', 'bold')
+            return True
+        except ValueError as e:
+            print ''
+            print magenta(str(e))
+            print format_text("[FAILED]\n", 'red', 'bold')
+
+    def remove_all_streams(self, port_list):
+        '''Remove all streams from given port_list'''
+        print format_text('{:<30}'.format("Remove all streams:"), 'bold'),
+        try:
+            res_ok, log = self.stateless_client.remove_all_streams(port_id=port_list)
+            if not self._silent:
+                print ''
+                self.prompt_response(log)
+            if not res_ok:
+                print format_text("[FAILED]\n", 'red', 'bold')
+                return
+            print format_text("[SUCCESS]\n", 'green', 'bold')
+            return True
+        except ValueError as e:
+            print ''
+            print magenta(str(e))
+            print format_text("[FAILED]\n", 'red', 'bold')
+
+
+
+
+
+    def extract_port_list(self, opts):
+        if opts.all_ports or "all" in opts.ports:
+            # handling all ports
+            port_list = self.stateless_client.get_acquired_ports()
+        else:
+            port_list = self.extract_port_ids_from_list(opts.ports)
+        return port_list
+
+    def decode_multiplier(self, opts_mult):
+        pass
+
+
+class DebugTRexConsole(cmd.Cmd):
+
+    def __init__(self, trex_main_console):
+        cmd.Cmd.__init__(self)
+        self.trex_console = trex_main_console
+        self.stateless_client = self.trex_console.stateless_client
+        self.streams_db = self.trex_console.streams_db
+        self.register_main_console_methods()
+        self.do_silent("on")
+        pass
+
+    # ----- super methods overriding ----- #
+    def completenames(self, text, *ignored):
+        dotext = 'do_'+text
+        return [a[3:]+' ' for a in self.get_names() if a.startswith(dotext)]
+
+    def get_names(self):
+        result = cmd.Cmd.get_names(self)
+        result += self.trex_console.get_names()
+        return list(set(result))
+
+    def register_main_console_methods(self):
+        main_names = set(self.trex_console.get_names()).difference(set(dir(self.__class__)))
+        for name in main_names:
+            for prefix in 'do_', 'help_', 'complete_':
+                if name.startswith(prefix):
+                    self.__dict__[name] = getattr(self.trex_console, name)
+
+            # if (name[:3] == 'do_') or (name[:5] == 'help_') or (name[:9] == 'complete_'):
+            #     chosen.append(name)
+            #     self.__dict__[name] = getattr(self.trex_console, name)
+            #     # setattr(self, name, classmethod(getattr(self.trex_console, name)))
+
+        # print chosen
+        # self.get_names()
+
+        # return result
+
+
+    # ----- DEBUGGING methods ----- #
+    # set silent on / off
+    def do_silent(self, line):
+        '''Shows or set silent mode\n'''
+        if line == "":
+            print "\nsilent mode is " + ("on\n" if self.trex_console._silent else "off\n")
+
+        elif line == "on":
+            self.verbose = True
+            self.stateless_client.set_verbose(True)
+            print green("\nsilent set to on\n")
+
+        elif line == "off":
+            self.verbose = False
+            self.stateless_client.set_verbose(False)
+            print green("\nsilent set to off\n")
+
+        else:
+            print magenta("\nplease specify 'on' or 'off'\n")
+
+    def do_quit(self, line):
+        '''Exit the debug client back to main console\n'''
+        self.do_silent("off")
+        return True
+
+    def do_start_traffic(self, line):
+        '''Start pre-submitted traffic in specified ports on TRex\n'''
+        # make sure that the user wants to acquire all
+        parser = parsing_opts.gen_parser("start_traffic", self.do_start_traffic.__doc__,
+                                         parsing_opts.PORT_LIST_WITH_ALL, parsing_opts.MULTIPLIER)
+        opts = parser.parse_args(line.split())
+        # print opts
+        # return
+        if opts is None:
+            # avoid further processing in this command
+            return
+        try:
+            port_list = self.trex_console.extract_port_list(opts)
+            return self.trex_console.start_traffic(opts.mult, port_list)
+        except Exception as e:
+            print e
+            return
+
+    def do_stop_traffic(self, line):
+        '''Stop active traffic in specified ports on TRex\n'''
+        parser = parsing_opts.gen_parser("stop_traffic", self.do_stop_traffic.__doc__,
+                                         parsing_opts.PORT_LIST_WITH_ALL)
+        opts = parser.parse_args(line.split())
+        # print opts
+        # return
+        if opts is None:
+            # avoid further processing in this command
+            return
+        try:
+            port_list = self.trex_console.extract_port_list(opts)
+            return self.trex_console.stop_traffic(port_list)
+        except Exception as e:
+            print e
+            return
+
+
+    def complete_stop_traffic(self, text, line, begidx, endidx):
+        return self.port_auto_complete(text, line, begidx, endidx, active=True)
+
+        # return
+        # # return
+        # # if not opts.port_list:
+        # #     print magenta("Please provide a list of ports separated by spaces, "
+        # #                   "or specify 'all' to start traffic on all acquired ports")
+        # #     return
+        #
+
+
+        return
+        args = line.split()
+        if len(args) < 1:
+            print magenta("Please provide a list of ports separated by spaces, "
+                          "or specify 'all' to start traffic on all acquired ports")
+            return
+        if args[0] == "all":
+            ask = ConfirmMenu('Are you sure you want to start traffic at all acquired ports? ')
+            rc = ask.show()
+            if rc == False:
+                print yellow("[ABORTED]\n")
+                return
+            else:
+                port_list = self.stateless_client.get_acquired_ports()
+        else:
+            port_list = self.extract_port_ids_from_line(line)
+
+        try:
+            res_ok, log = self.stateless_client.start_traffic(1.0, port_id=port_list)
+            self.prompt_response(log)
+            if not res_ok:
+                print format_text("[FAILED]\n", 'red', 'bold')
+                return
+            print format_text("[SUCCESS]\n", 'green', 'bold')
+        except ValueError as e:
+            print magenta(str(e))
+            print format_text("[FAILED]\n", 'red', 'bold')
+
+    def complete_start_traffic(self, text, line, begidx, endidx):
+        # return self.port_auto_complete(text, line, begidx, endidx)
+        return [text]
+
+    def help_start_traffic(self):
+        self.do_start_traffic("-h")
+
+    def help_stop_traffic(self):
+        self.do_stop_traffic("-h")
+
+    # def do_help(self):
+
+    def do_rpc (self, line):
+        '''Launches a RPC on the server\n'''
+
+        if line == "":
+            print "\nUsage: [method name] [param dict as string]\n"
+            print "Example: rpc test_add {'x': 12, 'y': 17}\n"
+            return
+
+        sp = line.split(' ', 1)
+        method = sp[0]
+
+        params = None
+        bad_parse = False
+        if len(sp) > 1:
+
+            try:
+                params = ast.literal_eval(sp[1])
+                if not isinstance(params, dict):
+                    bad_parse = True
+
+            except ValueError as e1:
+                bad_parse = True
+            except SyntaxError as e2:
+                bad_parse = True
+
+        if bad_parse:
+            print "\nValue should be a valid dict: '{0}'".format(sp[1])
+            print "\nUsage: [method name] [param dict as string]\n"
+            print "Example: rpc test_add {'x': 12, 'y': 17}\n"
+            return
+
+        res_ok, msg = self.stateless_client.transmit(method, params)
+        if res_ok:
+            print "\nServer Response:\n\n" + pretty_json(json.dumps(msg)) + "\n"
+        else:
+            print "\n*** " + msg + "\n"
+            #print "Please try 'reconnect' to reconnect to server"
+
+
+    def complete_rpc (self, text, line, begidx, endidx):
+        return [x
+                for x in self.trex_console.supported_rpc
+                if x.startswith(text)]
+
+    # aliasing
+    do_exit = do_EOF = do_q = do_quit
+
+#