Merge branch 'master' into get_logs_and_version

3 files changed, 1071 insertions, 612 deletions

diff --git a/scripts/automation/trex_control_plane/console/trex_console.py b/scripts/automation/trex_control_plane/console/trex_console.py
index a9ac040b..0ecfce9c 100755
--- a/scripts/automation/trex_control_plane/console/trex_console.py
+++ b/scripts/automation/trex_control_plane/console/trex_console.py
@@ -17,575 +17,587 @@ See the License for the specific language governing permissions and
 limitations under the License.
 """
 
+
 import cmd
 import json
 import ast
 import argparse
 import random
+import readline
 import string
 import os
 import sys
 import tty, termios
 import trex_root_path
 from common.trex_streams import *
+from client.trex_stateless_client import CTRexStatelessClient
+from common.text_opts import *
+from client_utils.general_utils import user_input, get_current_user
+from client_utils import parsing_opts
+import trex_tui
+from functools import wraps
 
 
-from client_utils.jsonrpc_client import TrexStatelessClient
-import trex_status
-from collections import namedtuple
-
-LoadedStreamList = namedtuple('LoadedStreamList', ['loaded', 'compiled'])
+__version__ = "1.1"
 
-#
 
-def readch (choices = []):
-        
-    fd = sys.stdin.fileno()
-    old_settings = termios.tcgetattr(fd)
-    try:
-        tty.setraw(sys.stdin.fileno())
-        while True:
-            ch = sys.stdin.read(1)
-            if (ord(ch) == 3) or (ord(ch) == 4):
-                return None
-            if ch in choices:
-                return ch
-    finally:
-        termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
-
-    return None
+class TRexGeneralCmd(cmd.Cmd):
+    def __init__(self):
+        cmd.Cmd.__init__(self)
+        # configure history behaviour
+        self._history_file_dir = "/tmp/trex/console/"
+        self._history_file = self.get_history_file_full_path()
+        readline.set_history_length(100)
+        # load history, if any
+        self.load_console_history()
 
-class YesNoMenu(object):
-    def __init__ (self, caption):
-        self.caption = caption
 
-    def show (self):
-        print "{0}".format(self.caption)
-        sys.stdout.write("[Y/y/N/n] : ")
-        ch = readch(choices = ['y', 'Y', 'n', 'N'])
-        if ch == None:
-            return None
-    
-        print "\n"    
-        if ch == 'y' or ch == 'Y':
-            return True
-        else:
-            return False
+    def get_console_identifier(self):
+        return self.__class__.__name__
 
-# multi level cmd menu
-class CmdMenu(object):
-    def __init__ (self):
-        self.menus = []
+    def get_history_file_full_path(self):
+        return "{dir}{filename}.hist".format(dir=self._history_file_dir,
+                                             filename=self.get_console_identifier())
 
+    def load_console_history(self):
+        if os.path.exists(self._history_file):
+            readline.read_history_file(self._history_file)
+        return
 
-    def add_menu (self, caption, options):
-        menu = {}
-        menu['caption'] = caption
-        menu['options'] = options
-        self.menus.append(menu)
+    def save_console_history(self):
+        if not os.path.exists(self._history_file_dir):
+            os.makedirs(self._history_file_dir)
+        # os.mknod(self._history_file)
+        readline.write_history_file(self._history_file)
+        return
 
-    def show (self):
-        cur_level = 0
-        print "\n"
+    def print_history (self):
+        
+        length = readline.get_current_history_length()
 
-        selected_path = []
-        for menu in self.menus:
-            # show all the options
-            print "{0}\n".format(menu['caption'])
-            for i, option in enumerate(menu['options']):
-                print "{0}. {1}".format(i + 1, option)
+        for i in xrange(1, length + 1):
+            cmd = readline.get_history_item(i)
+            print "{:<5}   {:}".format(i, cmd)
 
-            #print "\nPlease select an option: "
+    def get_history_item (self, index):
+        length = readline.get_current_history_length()
+        if index > length:
+            print format_text("please select an index between {0} and {1}".format(0, length))
+            return None
 
-            choices = range(0, len(menu['options']))
-            choices = [ chr(x + 48) for x in choices]
+        return readline.get_history_item(index)
 
-            print ""
-            ch = readch(choices)
-            print ""
 
-            if ch == None:
-                return None
+    def emptyline(self):
+        """Called when an empty line is entered in response to the prompt.
 
-            selected_path.append(int(ch) - 1)
+        This overriding is such that when empty line is passed, **nothing happens**.
+        """
+        return
 
-        return selected_path
+    def completenames(self, text, *ignored):
+        """
+        This overriding is such that a space is added to name completion.
+        """
+        dotext = 'do_'+text
+        return [a[3:]+' ' for a in self.get_names() if a.startswith(dotext)]
 
+    def precmd(self, line):
+        # before doing anything, save history snapshot of the console
+        # this is done before executing the command in case of ungraceful application exit
+        self.save_console_history()
+        return line
 
-class AddStreamMenu(CmdMenu):
-    def __init__ (self):
-        super(AddStreamMenu, self).__init__()
-        self.add_menu('Please select type of stream', ['a', 'b', 'c'])
-        self.add_menu('Please select ISG', ['d', 'e', 'f'])
 
+#
 # main console object
-class TrexConsole(cmd.Cmd):
+class TRexConsole(TRexGeneralCmd):
     """Trex Console"""
-   
-    def __init__(self, rpc_client):
-        cmd.Cmd.__init__(self)
 
-        self.rpc_client = rpc_client
+    def __init__(self, stateless_client, verbose=False):
+        self.stateless_client = stateless_client
+        TRexGeneralCmd.__init__(self)
 
-        self.do_connect("")
+        self.tui = trex_tui.TrexTUI(stateless_client)
 
-        self.intro  = "\n-=TRex Console V1.0=-\n"
-        self.intro += "\nType 'help' or '?' for supported actions\n" 
+        self.verbose = verbose
 
-        self.verbose = False
+        self.intro  = "\n-=TRex Console v{ver}=-\n".format(ver=__version__)
+        self.intro += "\nType 'help' or '?' for supported actions\n"
 
         self.postcmd(False, "")
 
-        self.user_streams = {}
-      
 
-    # 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)]
+    ################### internal section ########################
 
-    # 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")
+    def verify_connected(f):
+        @wraps(f)
+        def wrap(*args):
+            inst = args[0]
+            func_name = f.__name__
+            if func_name.startswith("do_"):
+                func_name = func_name[3:]
 
-        elif line == "on":
-            self.verbose = True
-            self.rpc_client.set_verbose(True)
-            print "\nverbose set to on\n"
+            if not inst.stateless_client.is_connected():
+                print format_text("\n'{0}' cannot be executed on offline mode\n".format(func_name), 'bold')
+                return
 
-        elif line == "off":
-            self.verbose = False
-            self.rpc_client.set_verbose(False)
-            print "\nverbose set to off\n"
+            ret = f(*args)
+            return ret
 
-        else:
-            print "\nplease specify 'on' or 'off'\n"
+        return wrap
 
-    # query the server for registered commands
-    def do_query_server(self, line):
-        '''query the RPC server for supported remote commands\n'''
+    # TODO: remove this ugly duplication
+    def verify_connected_and_rw (f):
+        @wraps(f)
+        def wrap(*args):
+            inst = args[0]
+            func_name = f.__name__
+            if func_name.startswith("do_"):
+                func_name = func_name[3:]
 
-        rc, msg = self.rpc_client.query_rpc_server()
-        if not rc:
-            print "\n*** " + msg + "\n"
-            return
+            if not inst.stateless_client.is_connected():
+                print format_text("\n'{0}' cannot be executed on offline mode\n".format(func_name), 'bold')
+                return
 
-        print "\nRPC server supports the following commands: \n\n"
-        for func in msg:
-            if func:
-                print func
-        print "\n"
+            if inst.stateless_client.is_read_only():
+                print format_text("\n'{0}' cannot be executed on read only mode\n".format(func_name), 'bold')
+                return
 
-    def do_ping (self, line):
-        '''Pings the RPC server\n'''
+            ret = f(*args)
+            return ret
 
-        print "\n-> Pinging RPC server"
+        return wrap
 
-        rc, msg = self.rpc_client.ping_rpc_server()
-        if rc:
-            print "[SUCCESS]\n"
-        else:
-            print "\n*** " + msg + "\n"
-            return
 
-    def do_force_acquire (self, line):
-        '''Acquires ports by force\n'''
+    def get_console_identifier(self):
+        return "{context}_{server}".format(context=self.__class__.__name__,
+                                           server=self.stateless_client.get_server())
+    
+    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)
 
-        self.do_acquire(line, True)
+    def postcmd(self, stop, line):
 
-    def parse_ports_from_line (self, line):
-        port_list = set()
+        if not self.stateless_client.is_connected():
+            self.prompt = "TRex (offline) > "
+            self.supported_rpc = None
+            return stop
 
-        if line:
-            for port_id in line.split(' '):
-                if (not port_id.isdigit()) or (int(port_id) < 0) or (int(port_id) >= self.rpc_client.get_port_count()):
-                    print "Please provide a list of ports seperated by spaces between 0 and {0}".format(self.rpc_client.get_port_count() - 1)
-                    return None
+        if self.stateless_client.is_read_only():
+            self.prompt = "TRex (read only) > "
+            return stop
 
-                port_list.add(int(port_id))
 
-            port_list = list(port_list)
+        self.prompt = "TRex > "
 
-        else:
-            port_list = [i for i in xrange(0, self.rpc_client.get_port_count())]
+        return stop
 
-        return port_list
+    def default(self, line):
+        print "'{0}' is an unrecognized command. type 'help' or '?' for a list\n".format(line)
 
-    def do_acquire (self, line, force = False):
-        '''Acquire ports\n'''
+    @staticmethod
+    def tree_autocomplete(text):
+        dir = os.path.dirname(text)
+        if dir:
+            path = dir
+        else:
+            path = "."
 
-        # make sure that the user wants to acquire all
-        if line == "":
-            ask = YesNoMenu('Do you want to acquire all ports ? ')
-            rc = ask.show()
-            if rc == False:
-                return
 
-        port_list = self.parse_ports_from_line(line)
-        if not port_list:
-            return
+        start_string = os.path.basename(text)
+        
+        targets = []
 
-        print "\nTrying to acquire ports: " + (" ".join(str(x) for x in port_list)) + "\n"
+        for x in os.listdir(path):
+            if x.startswith(start_string):
+                y = os.path.join(path, x)
+                if os.path.isfile(y):
+                    targets.append(x + ' ')
+                elif os.path.isdir(y):
+                    targets.append(x + '/')
 
-        rc, resp_list = self.rpc_client.take_ownership(port_list, force)
+        return targets
 
-        if not rc:
-            print "\n*** " + resp_list + "\n"
+    # annotation method
+    @staticmethod
+    def annotate (desc, rc = None, err_log = None, ext_err_msg = None):
+        print format_text('\n{:<40}'.format(desc), 'bold'),
+        if rc == None:
+            print "\n"
             return
 
-        for i, rc in enumerate(resp_list):
-            if rc[0]:
-                print "Port {0} - Acquired".format(port_list[i])
-            else:
-                print "Port {0} - ".format(port_list[i]) + rc[1]
+        if rc == False:
+            # do we have a complex log object ?
+            if isinstance(err_log, list):
+                print ""
+                for func in err_log:
+                    if func:
+                        print func
+                print ""
 
-        print "\n"
+            elif isinstance(err_log, str):
+                print "\n" + err_log + "\n"
 
-    def do_release (self, line):
-        '''Release ports\n'''
+            print format_text("[FAILED]\n", 'red', 'bold')
+            if ext_err_msg:
+                print format_text(ext_err_msg + "\n", 'blue', 'bold')
+
+            return False
 
-        if line:
-            port_list = self.parse_ports_from_line(line)
         else:
-            port_list = self.rpc_client.get_owned_ports()
+            print format_text("[SUCCESS]\n", 'green', 'bold')
+            return True
 
-        if not port_list:
+
+    ####################### shell commands #######################
+    @verify_connected
+    def do_ping (self, line):
+        '''Ping the server\n'''
+        rc = self.stateless_client.cmd_ping()
+        if rc.bad():
             return
 
-        rc, resp_list = self.rpc_client.release_ports(port_list)
 
+    # 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")
 
-        print "\n"
+        elif line == "on":
+            self.verbose = True
+            self.stateless_client.set_verbose(self.stateless_client.VERBOSE_HIGH)
+            print format_text("\nverbose set to on\n", 'green', 'bold')
 
-        for i, rc in enumerate(resp_list):
-            if rc[0]:
-                print "Port {0} - Released".format(port_list[i])
-            else:
-                print "Port {0} - Failed to release port, probably not owned by you or port is under traffic"
+        elif line == "off":
+            self.verbose = False
+            self.stateless_client.set_verbose(self.stateless_client.VERBOSE_REGULAR)
+            print format_text("\nverbose set to off\n", 'green', 'bold')
 
-        print "\n"
+        else:
+            print format_text("\nplease specify 'on' or 'off'\n", 'bold')
 
-    def do_get_port_stats (self, line):
-        '''Get ports stats\n'''
+    # show history
+    def help_history (self):
+        self.do_history("-h")
 
-        port_list = self.parse_ports_from_line(line)
-        if not port_list:
-            return
+    def do_history (self, line):
+        '''Manage the command history\n'''
+
+        item = parsing_opts.ArgumentPack(['item'],
+                                         {"nargs": '?',
+                                          'metavar': 'item',
+                                          'type': parsing_opts.check_negative,
+                                          'help': "an history item index",
+                                          'default': 0})
 
-        rc, resp_list = self.rpc_client.get_port_stats(port_list)
+        parser = parsing_opts.gen_parser(self,
+                                         "history",
+                                         self.do_history.__doc__,
+                                         item)
 
-        if not rc:
-            print "\n*** " + resp_list + "\n"
+        opts = parser.parse_args(line.split())
+        if opts is None:
             return
 
-        for i, rc in enumerate(resp_list):
-            if rc[0]:
-                print "\nPort {0} stats:\n{1}\n".format(port_list[i], self.rpc_client.pretty_json(json.dumps(rc[1])))
-            else:
-                print "\nPort {0} - ".format(i) + rc[1] + "\n"
+        if opts.item == 0:
+            self.print_history()
+        else:
+            cmd = self.get_history_item(opts.item)
+            if cmd == None:
+                return
+
+            self.onecmd(cmd)
 
-        print "\n"
 
 
+    ############### connect
     def do_connect (self, line):
         '''Connects to the server\n'''
 
-        if line == "":
-            rc, msg = self.rpc_client.connect()
-        else:
-            sp = line.split()
-            if (len(sp) != 2):
-                print "\n[usage] connect [server] [port] or without parameters\n"
-                return
+        self.stateless_client.cmd_connect_line(line)
 
-            rc, msg = self.rpc_client.connect(sp[0], sp[1])
 
-        if rc:
-            print "[SUCCESS]\n"
-        else:
-            print "\n*** " + msg + "\n"
-            return
+    def do_disconnect (self, line):
+        '''Disconnect from the server\n'''
 
-        self.supported_rpc = self.rpc_client.get_supported_cmds()
+        self.stateless_client.cmd_disconnect()
 
-    def do_rpc (self, line):
-        '''Launches a RPC on the server\n'''
+ 
+    ############### start
 
-        if line == "":
-            print "\nUsage: [method name] [param dict as string]\n"
-            print "Example: rpc test_add {'x': 12, 'y': 17}\n"
-            return
+    def complete_start(self, text, line, begidx, endidx):
+        s = line.split()
+        l = len(s)
 
-        sp = line.split(' ', 1)
-        method = sp[0]
+        file_flags = parsing_opts.get_flags(parsing_opts.FILE_PATH)
 
-        params = None
-        bad_parse = False
-        if len(sp) > 1:
+        if (l > 1) and (s[l - 1] in file_flags):
+            return TRexConsole.tree_autocomplete("")
 
-            try:
-                params = ast.literal_eval(sp[1])
-                if not isinstance(params, dict):
-                    bad_parse = True
+        if (l > 2) and (s[l - 2] in file_flags):
+            return TRexConsole.tree_autocomplete(s[l - 1])
 
-            except ValueError as e1:
-                bad_parse = True
-            except SyntaxError as e2:
-                bad_parse = True
+    @verify_connected_and_rw
+    def do_start(self, line):
+        '''Start selected traffic in specified port(s) on TRex\n'''
 
-        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
+        self.stateless_client.cmd_start_line(line)
 
-        rc, msg = self.rpc_client.invoke_rpc_method(method, params)
-        if rc:
-            print "\nServer Response:\n\n" + self.rpc_client.pretty_json(json.dumps(msg)) + "\n"
-        else:
-            print "\n*** " + msg + "\n"
-            #print "Please try 'reconnect' to reconnect to server"
 
+    def help_start(self):
+        self.do_start("-h")
 
-    def complete_rpc (self, text, line, begidx, endidx):
-        return [x for x in self.supported_rpc if x.startswith(text)]
+    ############# stop
+    @verify_connected_and_rw
+    def do_stop(self, line):
+        '''stops port(s) transmitting traffic\n'''
 
-    def do_status (self, line):
-        '''Shows a graphical console\n'''
+        self.stateless_client.cmd_stop_line(line)
 
-        self.do_verbose('off')
-        trex_status.show_trex_status(self.rpc_client)
+    def help_stop(self):
+        self.do_stop("-h")
 
-    def do_quit(self, line):
-        '''Exit the client\n'''
-        return True
+    ############# update
+    @verify_connected_and_rw
+    def do_update(self, line):
+        '''update speed of port(s)currently transmitting traffic\n'''
 
-    def do_disconnect (self, line):
-        '''Disconnect from the server\n'''
-        if not self.rpc_client.is_connected():
-            print "Not connected to server\n"
-            return
+        self.stateless_client.cmd_update_line(line)
 
-        rc, msg = self.rpc_client.disconnect()
-        if rc:
-            print "[SUCCESS]\n"
-        else:
-            print msg + "\n"
+    def help_update (self):
+        self.do_update("-h")
 
-    def do_whoami (self, line):
-        '''Prints console user name\n'''
-        print "\n" + self.rpc_client.whoami() + "\n"
-        
-    def postcmd(self, stop, line):
-        if self.rpc_client.is_connected():
-            self.prompt = "TRex > "
-        else:
-            self.supported_rpc = None
-            self.prompt = "TRex (offline) > "
+    ############# pause
+    @verify_connected_and_rw
+    def do_pause(self, line):
+        '''pause port(s) transmitting traffic\n'''
 
-        return stop
+        self.stateless_client.cmd_pause_line(line)
 
-    def default(self, line):
-        print "'{0}' is an unrecognized command. type 'help' or '?' for a list\n".format(line)
+    ############# resume
+    @verify_connected_and_rw
+    def do_resume(self, line):
+        '''resume port(s) transmitting traffic\n'''
 
-    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
+        self.stateless_client.cmd_resume_line(line)
 
-        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_load_stream_list(self, line):
-        '''Loads a YAML stream list serialization into user console \n'''
-        args = line.split()
-        if 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.rpc_client.pretty_json(json.dumps(loaded_obj))
-            if name in self.user_streams:
-                print "Picked name already exist. Please pick another name."
-            else:
-                try:
-                    compiled_streams = stream_list.compile_streams()
-                    self.user_streams[name] = LoadedStreamList(loaded_obj,
-                                                               [StreamPack(v.stream_id, v.stream.dump_compiled())
-                                                                for k, v in compiled_streams.items()])
-
-                    print "Stream '{0}' loaded successfully".format(name)
-                except Exception as e:
-                    raise
-            return
-        else:
-            print "please provide load name and YAML path, separated by space.\n" \
-                  "Optionally, you may provide a third argument to specify multiplier."
+   
 
-    @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)]
+    ########## reset
+    @verify_connected_and_rw
+    def do_reset (self, line):
+        '''force stop all ports\n'''
+        self.stateless_client.cmd_reset_line(line)
 
 
-    def complete_load_stream_list(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_show_stream_list(self, line):
-        '''Shows the loaded stream list named [name] \n'''
-        args = line.split()
-        if args:
-            list_name = args[0]
-            try:
-                stream = self.user_streams[list_name]
-                if len(args) >= 2 and args[1] == "full":
-                    print self.rpc_client.pretty_json(json.dumps(stream.compiled))
-                else:
-                    print self.rpc_client.pretty_json(json.dumps(stream.loaded))
-            except KeyError as e:
-                print "Unknown stream list name provided"
-        else:
-            print "\nAvailable stream lists:\n{0}".format(', '.join([x
-                                                                  for x in self.user_streams.keys()]))
-
-    def complete_show_stream_list(self, text, line, begidx, endidx):
-        return [x
-                for x in self.user_streams.keys()
-                if x.startswith(text)]
-
-    def do_attach(self, line):
-        args = line.split()
-        if len(args) >= 1:
-            try:
-                stream_list = self.user_streams[args[0]]
-                port_list = self.parse_ports_from_line(' '.join(args[1:]))
-                owned = set(self.rpc_client.get_owned_ports())
-                if set(port_list).issubset(owned):
-                    rc, resp_list = self.rpc_client.add_stream(port_list, stream_list.compiled)
-                    if not rc:
-                        print "\n*** " + resp_list + "\n"
-                        return
-                else:
-                    print "Not all desired ports are aquired.\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)))
-            except KeyError as e:
-                cause = e.args[0]
-                print "Provided stream list name '{0}' doesn't exists.".format(cause)
-        else:
-            print "Please provide list name and ports to attach to, or leave empty to attach to all ports."
+    ######### validate
+    @verify_connected
+    def do_validate (self, line):
+        '''validates port(s) stream configuration\n'''
 
+        self.stateless_client.cmd_validate_line(line)
 
 
+    @verify_connected
+    def do_stats(self, line):
+        '''Fetch statistics from TRex server by port\n'''
+        self.stateless_client.cmd_stats_line(line)
 
 
+    def help_stats(self):
+        self.do_stats("-h")
 
+    @verify_connected
+    def do_clear(self, line):
+        '''Clear cached local statistics\n'''
+        self.stateless_client.cmd_clear_line(line)
 
+    def help_clear(self):
+        self.do_clear("-h")
 
+  
+    def help_events (self):
+        self.do_events("-h")
 
+    def do_events (self, line):
+        '''shows events recieved from server\n'''
 
+        x = parsing_opts.ArgumentPack(['-c','--clear'],
+                                      {'action' : "store_true",
+                                       'default': False,
+                                       'help': "clear the events log"})
 
-    # adds a very simple stream
-    def do_add_simple_stream (self, line):
-        if line == "":
-            add_stream = AddStreamMenu()
-            add_stream.show()
+        parser = parsing_opts.gen_parser(self,
+                                         "events",
+                                         self.do_events.__doc__,
+                                         x)
+
+        opts = parser.parse_args(line.split())
+        if opts is None:
             return
 
-        params = line.split()
-        port_id = int(params[0])
-        stream_id = int(params[1])
+        events = self.stateless_client.get_events()
+        for ev in events:
+            print ev
 
-        packet = [0xFF,0xFF,0xFF]
-        rc, msg = self.rpc_client.add_stream(port_id = port_id, stream_id = stream_id, isg = 1.1, next_stream_id = -1, packet = packet)
-        if rc:
-            print "\nServer Response:\n\n" + self.rpc_client.pretty_json(json.dumps(msg)) + "\n"
-        else:
-            print "\n*** " + msg + "\n"
+        if opts.clear:
+            self.stateless_client.clear_events()
+            print format_text("\n\nEvent log was cleared\n\n")
+
+    # tui
+    @verify_connected
+    def do_tui (self, line):
+        '''Shows a graphical console\n'''
+
+        save_verbose = self.stateless_client.get_verbose()
+
+        self.stateless_client.set_verbose(self.stateless_client.VERBOSE_SILENCE)
+        self.tui.show()
+        self.stateless_client.set_verbose(save_verbose)
+
+    # quit function
+    def do_quit(self, line):
+        '''Exit the client\n'''
+        return True
 
-    # aliasing
+    
+    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") or (cmd == "q") or (cmd == "exit") or (cmd == "h")):
+                 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)
+
+    # aliases
     do_exit = do_EOF = do_q = do_quit
+    do_h = do_history
+
+#
+def is_valid_file(filename):
+    if not os.path.isfile(filename):
+        raise argparse.ArgumentTypeError("The file '%s' does not exist" % filename)
+
+    return filename
 
-def setParserOptions ():
+
+def setParserOptions():
     parser = argparse.ArgumentParser(prog="trex_console.py")
 
     parser.add_argument("-s", "--server", help = "TRex Server [default is localhost]",
                         default = "localhost",
                         type = str)
 
-    parser.add_argument("-p", "--port", help = "TRex Server Port  [default is 5050]\n",
-                        default = 5050,
+    parser.add_argument("-p", "--port", help = "TRex Server Port  [default is 4501]\n",
+                        default = 4501,
+                        type = int)
+
+    parser.add_argument("--async_port", help = "TRex ASync Publisher Port [default is 4500]\n",
+                        default = 4500,
+                        dest='pub',
                         type = int)
 
-    parser.add_argument("-u", "--user", help = "User Name  [default is random generated]\n",
-                        default = 'user_' + ''.join(random.choice(string.digits) for _ in range(5)),
+    parser.add_argument("-u", "--user", help = "User Name  [default is currently logged in user]\n",
+                        default = get_current_user(),
                         type = str)
 
+    parser.add_argument("--verbose", dest="verbose",
+                        action="store_true", help="Switch ON verbose option. Default is: OFF.",
+                        default = False)
+
+
+    parser.add_argument("--no_acquire", dest="acquire",
+                        action="store_false", help="Acquire all ports on connect. Default is: ON.",
+                        default = True)
+
+    parser.add_argument("--batch", dest="batch",
+                        nargs = 1,
+                        type = is_valid_file,
+                        help = "Run the console in a batch mode with file",
+                        default = None)
+
+    parser.add_argument("-t", "--tui", dest="tui",
+                        action="store_true", help="Starts with TUI mode",
+                        default = False)
+
     return parser
 
-def main ():
+
+def main():
     parser = setParserOptions()
-    options = parser.parse_args(sys.argv[1:])
+    options = parser.parse_args()
+
+    # Stateless client connection
+    stateless_client = CTRexStatelessClient(options.user, options.server, options.port, options.pub)
+
+    print "\nlogged as {0}".format(format_text(options.user, 'bold'))
 
-    # RPC client
-    rpc_client = TrexStatelessClient(options.server, options.port, options.user)
+    # TUI or no acquire will give us READ ONLY mode
+    if options.tui or not options.acquire:
+        rc = stateless_client.connect("RO")
+    else:
+        rc = stateless_client.connect("RW")
 
+    # unable to connect - bye
+    if rc.bad():
+        rc.annotate()
+        return
+
+
+    # a script mode
+    if options.batch:
+        cont = stateless_client.run_script_file(options.batch[0])
+        if not cont:
+            return
+        
     # console
     try:
-        console = TrexConsole(rpc_client)
-        console.cmdloop()
+        console = TRexConsole(stateless_client, options.verbose)
+        if options.tui:
+            console.do_tui("")
+        else:
+            console.cmdloop()
+
     except KeyboardInterrupt as e:
         print "\n\n*** Caught Ctrl + C... Exiting...\n\n"
-        return
+        
+    finally:
+        stateless_client.disconnect()
 
 if __name__ == '__main__':
     main()
diff --git a/scripts/automation/trex_control_plane/console/trex_status.py b/scripts/automation/trex_control_plane/console/trex_status.py
index 2c5a648f..cdf3fb69 100644
--- a/scripts/automation/trex_control_plane/console/trex_status.py
+++ b/scripts/automation/trex_control_plane/console/trex_status.py
@@ -11,22 +11,27 @@ import datetime
 
 g_curses_active = False
 
+################### utils #################
+
 # simple percetange show
 def percentage (a, total):
     x = int ((float(a) / total) * 100)
     return str(x) + "%"
 
-# simple float to human readable
-def float_to_human_readable (size, suffix = "bps"):
-    for unit in ['','K','M','G']:
-        if abs(size) < 1024.0:
-            return "%3.1f %s%s" % (size, unit, suffix)
-        size /= 1024.0
-    return "NaN"
+################### panels #################
 
 # panel object
 class TrexStatusPanel(object):
-    def __init__ (self, h, l, y, x, headline):
+    def __init__ (self, h, l, y, x, headline, status_obj):
+
+        self.status_obj = status_obj
+
+        self.log = status_obj.log
+        self.stateless_client = status_obj.stateless_client
+
+        self.stats         = status_obj.stats
+        self.general_stats = status_obj.general_stats
+
         self.h = h
         self.l = l
         self.y = y
@@ -53,64 +58,26 @@ class TrexStatusPanel(object):
         return self.win
 
 
-# total stats (ports + global)
-class Stats():
-    def __init__ (self, rpc_client, port_list, interval = 100):
-
-        self.rpc_client = rpc_client
-
-        self.port_list = port_list
-        self.port_stats = {}
-
-        self.interval = interval
-        self.delay_count = 0
-
-    def get_port_stats (self, port_id):
-        if self.port_stats.get(port_id):
-            return self.port_stats[port_id]
-        else:
-            return None
-
-    def query_sync (self):
-        self.delay_count += 1
-        if self.delay_count < self.interval:
-            return
-
-        self.delay_count = 0
-
-        # query global stats
-
-        # query port stats
-
-        rc, resp_list = self.rpc_client.get_port_stats(self.port_list)
-        if not rc:
-            return
-
-        for i, rc in enumerate(resp_list):
-            if rc[0]:
-                self.port_stats[self.port_list[i]] = rc[1]
-
-
 # various kinds of panels
 
 # Server Info Panel
 class ServerInfoPanel(TrexStatusPanel):
     def __init__ (self, h, l, y, x, status_obj):
 
-        super(ServerInfoPanel, self).__init__(h, l, y ,x ,"Server Info:")
-
-        self.status_obj = status_obj
+        super(ServerInfoPanel, self).__init__(h, l, y ,x ,"Server Info:", status_obj)
 
     def draw (self):
 
-        if self.status_obj.server_version == None:
+        if not self.status_obj.server_version :
             return
 
-        self.clear()
+        if not self.status_obj.server_sys_info:
+            return
 
-        connection_details = self.status_obj.rpc_client.get_connection_details()
 
-        self.getwin().addstr(3, 2, "{:<30} {:30}".format("Server:",self.status_obj.server_sys_info["hostname"] + ":" + str(connection_details['port'])))
+        self.clear()
+
+        self.getwin().addstr(3, 2, "{:<30} {:30}".format("Server:",self.status_obj.server_sys_info["hostname"] + ":" + str(self.stateless_client.get_connection_port())))
         self.getwin().addstr(4, 2, "{:<30} {:30}".format("Version:", self.status_obj.server_version["version"]))
         self.getwin().addstr(5, 2, "{:<30} {:30}".format("Build:", 
                                                                     self.status_obj.server_version["build_date"] + " @ " + 
@@ -123,7 +90,7 @@ class ServerInfoPanel(TrexStatusPanel):
 
         self.getwin().addstr(9, 2, "{:<30} {:<30}".format("Ports Count:", self.status_obj.server_sys_info["port_count"]))
 
-        ports_owned = " ".join(str(x) for x in self.status_obj.rpc_client.get_owned_ports())
+        ports_owned = " ".join(str(x) for x in self.status_obj.owned_ports_list)
 
         if not ports_owned:
             ports_owned = "None"
@@ -134,92 +101,124 @@ class ServerInfoPanel(TrexStatusPanel):
 class GeneralInfoPanel(TrexStatusPanel):
     def __init__ (self, h, l, y, x, status_obj):
 
-        super(GeneralInfoPanel, self).__init__(h, l, y ,x ,"General Info:")
-
-        self.status_obj = status_obj
+        super(GeneralInfoPanel, self).__init__(h, l, y ,x ,"General Info:", status_obj)
 
     def draw (self):
-        pass
+        self.clear()
+
+        if not self.general_stats.is_online():
+            self.getwin().addstr(3, 2, "No Published Data From TRex Server")
+            return
+
+        self.getwin().addstr(3, 2, "{:<30} {:0.2f} %".format("CPU util.:", self.general_stats.get("m_cpu_util")))
+
+        self.getwin().addstr(6, 2, "{:<30} {:} / {:}".format("Total Tx. rate:",
+                                                               self.general_stats.get("m_tx_bps", format = True, suffix = "bps"),
+                                                               self.general_stats.get("m_tx_pps", format = True, suffix = "pps")))
+
+      
+        self.getwin().addstr(8, 2, "{:<30} {:} / {:}".format("Total Tx:",
+                                                             self.general_stats.get_rel("m_total_tx_bytes", format = True, suffix = "B"),
+                                                             self.general_stats.get_rel("m_total_tx_pkts", format = True, suffix = "pkts")))
+
+        self.getwin().addstr(11, 2, "{:<30} {:} / {:}".format("Total Rx. rate:",
+                                                               self.general_stats.get("m_rx_bps", format = True, suffix = "bps"),
+                                                               self.general_stats.get("m_rx_pps", format = True, suffix = "pps")))
+
+      
+        self.getwin().addstr(13, 2, "{:<30} {:} / {:}".format("Total Rx:",
+                                                             self.general_stats.get_rel("m_total_rx_bytes", format = True, suffix = "B"),
+                                                             self.general_stats.get_rel("m_total_rx_pkts", format = True, suffix = "pkts")))
 
 # all ports stats
 class PortsStatsPanel(TrexStatusPanel):
     def __init__ (self, h, l, y, x, status_obj):
 
-        super(PortsStatsPanel, self).__init__(h, l, y ,x ,"Trex Ports:")
+        super(PortsStatsPanel, self).__init__(h, l, y ,x ,"Trex Ports:", status_obj)
 
-        self.status_obj = status_obj
 
     def draw (self):
 
         self.clear()
 
-        owned_ports = self.status_obj.rpc_client.get_owned_ports()
+        owned_ports = self.status_obj.owned_ports_list
         if not owned_ports:
             self.getwin().addstr(3, 2, "No Owned Ports - Please Acquire One Or More Ports")
             return
 
         # table header 
-        self.getwin().addstr(3, 2, "{:^15} {:^15} {:^15} {:^15} {:^15} {:^15} {:^15}".format(
-            "Port ID", "Tx [pps]", "Tx [bps]", "Tx [bytes]", "Rx [pps]", "Rx [bps]", "Rx [bytes]"))
+        self.getwin().addstr(3, 2, "{:^15} {:^30} {:^30} {:^30}".format(
+            "Port ID", "Tx Rate [bps/pps]", "Rx Rate [bps/pps]", "Total Bytes [tx/rx]"))
+
 
-        # port loop
-        self.status_obj.stats.query_sync()
 
         for i, port_index in enumerate(owned_ports):
 
             port_stats = self.status_obj.stats.get_port_stats(port_index)
 
             if port_stats:
-                self.getwin().addstr(5 + (i * 4), 2, "{:^15} {:^15,.2f} {:^15,.2f} {:^15,} {:^15,.2f} {:^15,.2f} {:^15,}".format(
+                self.getwin().addstr(5 + (i * 4), 2, "{:^15} {:^30} {:^30} {:^30}".format(
                     "{0} ({1})".format(str(port_index), self.status_obj.server_sys_info["ports"][port_index]["speed"]),
-                    port_stats["tx_pps"],
-                    port_stats["tx_bps"],
-                    port_stats["total_tx_bytes"],
-                    port_stats["rx_pps"],
-                    port_stats["rx_bps"],
-                    port_stats["total_rx_bytes"]))
-
+                    "{0} / {1}".format(port_stats.get("m_total_tx_bps", format = True, suffix = "bps"),
+                                       port_stats.get("m_total_tx_pps", format = True, suffix = "pps")),
+                                       
+                    "{0} / {1}".format(port_stats.get("m_total_rx_bps", format = True, suffix = "bps"),
+                                       port_stats.get("m_total_rx_pps", format = True, suffix = "pps")),
+                    "{0} / {1}".format(port_stats.get_rel("obytes", format = True, suffix = "B"),
+                                       port_stats.get_rel("ibytes", format = True, suffix = "B"))))
+        
             else:
-                self.getwin().addstr(5 + (i * 4), 2, "{:^15} {:^15} {:^15} {:^15} {:^15} {:^15} {:^15}".format(
+
+                self.getwin().addstr(5 + (i * 4), 2, "{:^15} {:^30} {:^30} {:^30}".format(
                     "{0} ({1})".format(str(port_index), self.status_obj.server_sys_info["ports"][port_index]["speed"]),
                     "N/A",
                     "N/A",
                     "N/A",
-                    "N/A",
-                    "N/A",
                     "N/A"))
 
+
+                # old format
+#            if port_stats:
+#                self.getwin().addstr(5 + (i * 4), 2, "{:^15} {:^15} {:^15} {:^15} {:^15} {:^15} {:^15}".format(
+#                    "{0} ({1})".format(str(port_index), self.status_obj.server_sys_info["ports"][port_index]["speed"]),
+#                    port_stats.get("m_total_tx_pps", format = True, suffix = "pps"),
+#                    port_stats.get("m_total_tx_bps", format = True, suffix = "bps"),
+#                    port_stats.get_rel("obytes", format = True, suffix = "B"),
+#                    port_stats.get("m_total_rx_pps", format = True, suffix = "pps"),
+#                    port_stats.get("m_total_rx_bps", format = True, suffix = "bps"),
+#                    port_stats.get_rel("ibytes", format = True, suffix = "B")))
+#        
+#            else:
+#                self.getwin().addstr(5 + (i * 4), 2, "{:^15} {:^15} {:^15} {:^15} {:^15} {:^15} {:^15}".format(
+#                    "{0} ({1})".format(str(port_index), self.status_obj.server_sys_info["ports"][port_index]["speed"]),
+#                    "N/A",
+#                    "N/A",
+#                    "N/A",
+#                    "N/A",
+#                    "N/A",
+#                    "N/A"))
+
 # control panel
 class ControlPanel(TrexStatusPanel):
     def __init__ (self, h, l, y, x, status_obj):
 
-        super(ControlPanel, self).__init__(h, l, y, x, "")
+        super(ControlPanel, self).__init__(h, l, y, x, "", status_obj)
 
-        self.status_obj = status_obj
 
     def draw (self):
         self.clear()
 
         self.getwin().addstr(1, 2, "'g' - general, '0-{0}' - specific port, 'f' - freeze, 'c' - clear stats, 'p' - ping server, 'q' - quit"
-                             .format(self.status_obj.rpc_client.get_port_count() - 1))
-
-        index = 3
+                             .format(self.status_obj.stateless_client.get_port_count() - 1))
 
-        cut = len(self.status_obj.log) - 4
-        if cut < 0:
-            cut = 0
-
-        for l in self.status_obj.log[cut:]:
-            self.getwin().addstr(index, 2, l)
-            index += 1
+        self.log.draw(self.getwin(), 2, 3)
 
 # specific ports panels
 class SinglePortPanel(TrexStatusPanel):
     def __init__ (self, h, l, y, x, status_obj, port_id):
 
-        super(SinglePortPanel, self).__init__(h, l, y, x, "Port {0}".format(port_id))
+        super(SinglePortPanel, self).__init__(h, l, y, x, "Port {0}".format(port_id), status_obj)
 
-        self.status_obj = status_obj
         self.port_id = port_id
 
     def draw (self):
@@ -227,7 +226,7 @@ class SinglePortPanel(TrexStatusPanel):
 
         self.clear()
 
-        if not self.port_id in self.status_obj.rpc_client.get_owned_ports():
+        if not self.port_id in self.status_obj.owned_ports_list:
              self.getwin().addstr(y, 2, "Port {0} is not owned by you, please acquire the port for more info".format(self.port_id))
              return
 
@@ -241,16 +240,19 @@ class SinglePortPanel(TrexStatusPanel):
         y += 2
 
         # streams
-        if 'streams' in self.status_obj.snapshot[self.port_id]:
-            for stream_id, stream in self.status_obj.snapshot[self.port_id]['streams'].iteritems():
+        
+        if 'streams' in self.status_obj.owned_ports[str(self.port_id)]:
+            stream_info = self.status_obj.owned_ports[str(self.port_id)]['streams']
+
+            for stream_id, stream in sorted(stream_info.iteritems(), key=operator.itemgetter(0)):
                 self.getwin().addstr(y, 2, "{:^15} {:^15} {:^15} {:^15} {:^15} {:^15} {:^15}".format(
                     stream_id,
-                    ("True" if stream['stream']['enabled'] else "False"),
-                    stream['stream']['mode']['type'],
-                    ("True" if stream['stream']['self_start'] else "False"),
-                    stream['stream']['isg'],
-                    (stream['stream']['next_stream_id'] if stream['stream']['next_stream_id'] != -1 else "None"),
-                    ("{0} instr.".format(len(stream['stream']['vm'])) if stream['stream']['vm'] else "None")))
+                    ("True" if stream['enabled'] else "False"),
+                    stream['mode']['type'],
+                    ("True" if stream['self_start'] else "False"),
+                    stream['isg'],
+                    (stream['next_stream_id'] if stream['next_stream_id'] != -1 else "None"),
+                    ("{0} instr.".format(len(stream['vm'])) if stream['vm'] else "None")))
 
                 y += 1
 
@@ -260,128 +262,174 @@ class SinglePortPanel(TrexStatusPanel):
         self.getwin().addstr(y, 2, "Traffic:", curses.A_UNDERLINE)
         y += 2
 
-        self.status_obj.stats.query_sync()
-        port_stats = self.status_obj.stats.get_port_stats(self.port_id)
 
 
-        # table header 
-        self.getwin().addstr(y, 2, "{:^15} {:^15} {:^15} {:^15} {:^15} {:^15} {:^15}".format(
-            "Port ID", "Tx [pps]", "Tx [bps]", "Tx [bytes]", "Rx [pps]", "Rx [bps]", "Rx [bytes]"))
+         # table header 
+        self.getwin().addstr(y, 2, "{:^15} {:^30} {:^30} {:^30}".format(
+            "Port ID", "Tx Rate [bps/pps]", "Rx Rate [bps/pps]", "Total Bytes [tx/rx]"))
+
 
         y += 2
 
-        if port_stats:
-                self.getwin().addstr(y, 2, "{:^15} {:^15,} {:^15,} {:^15,} {:^15,} {:^15,} {:^15,}".format(
-                    "{0} ({1})".format(str(self.port_id), self.status_obj.server_sys_info["ports"][self.port_id]["speed"]),
-                    port_stats["tx_pps"],
-                    port_stats["tx_bps"],
-                    port_stats["total_tx_bytes"],
-                    port_stats["rx_pps"],
-                    port_stats["rx_bps"],
-                    port_stats["total_rx_bytes"]))
+        port_stats = self.status_obj.stats.get_port_stats(self.port_id)
 
+        if port_stats:
+            self.getwin().addstr(y, 2, "{:^15} {:^30} {:^30} {:^30}".format(
+                "{0} ({1})".format(str(self.port_id), self.status_obj.server_sys_info["ports"][self.port_id]["speed"]),
+                "{0} / {1}".format(port_stats.get("m_total_tx_bps", format = True, suffix = "bps"),
+                                   port_stats.get("m_total_tx_pps", format = True, suffix = "pps")),
+                                        
+                "{0} / {1}".format(port_stats.get("m_total_rx_bps", format = True, suffix = "bps"),
+                                   port_stats.get("m_total_rx_pps", format = True, suffix = "pps")),
+                "{0} / {1}".format(port_stats.get_rel("obytes", format = True, suffix = "B"),
+                                   port_stats.get_rel("ibytes", format = True, suffix = "B"))))
+        
         else:
-            self.getwin().addstr(y, 2, "{:^15} {:^15} {:^15} {:^15} {:^15} {:^15} {:^15}".format(
+            self.getwin().addstr(y, 2, "{:^15} {:^30} {:^30} {:^30}".format(
                 "{0} ({1})".format(str(self.port_id), self.status_obj.server_sys_info["ports"][self.port_id]["speed"]),
                 "N/A",
                 "N/A",
                 "N/A",
-                "N/A",
-                "N/A",
                 "N/A"))
 
-        y += 2
 
-# status object
-class TrexStatus():
-    def __init__ (self, stdscr, rpc_client):
-        self.stdscr = stdscr
+################### main objects #################
+
+# status log
+class TrexStatusLog():
+    def __init__ (self):
         self.log = []
-        self.rpc_client = rpc_client
 
-        self.snapshot = self.rpc_client.snapshot()
+    def add_event (self, msg):
+        self.log.append("[{0}] {1}".format(str(datetime.datetime.now().time()), msg))
 
-        # fetch server info
-        self.get_server_info()
+    def draw (self, window, x, y, max_lines = 4):
+        index = y
 
-        # create stats objects
-        self.stats = Stats(rpc_client, self.rpc_client.get_owned_ports())
+        cut = len(self.log) - max_lines
+        if cut < 0:
+            cut = 0
+
+        for msg in self.log[cut:]:
+            window.addstr(index, x, msg)
+            index += 1
+
+# status commands
+class TrexStatusCommands():
+    def __init__ (self, status_object):
+
+        self.status_object = status_object
+
+        self.stateless_client = status_object.stateless_client
+        self.log = self.status_object.log
 
-        # register actions
         self.actions = {}
-        self.actions[ord('q')] = self.action_quit
-        self.actions[ord('p')] = self.action_ping
-        self.actions[ord('f')] = self.action_freeze 
+        self.actions[ord('q')] = self._quit
+        self.actions[ord('p')] = self._ping
+        self.actions[ord('f')] = self._freeze 
 
-        self.actions[ord('g')] = self.action_show_ports_stats
+        self.actions[ord('g')] = self._show_ports_stats
 
-        for port_id in xrange(0, self.rpc_client.get_port_count()):
-            self.actions[ord('0') + port_id] = self.action_show_port_generator(port_id)
+        # register all the available ports shortcuts
+        for port_id in xrange(0, self.stateless_client.get_port_count()):
+            self.actions[ord('0') + port_id] = self._show_port_generator(port_id)
+
+
+    # handle a key pressed
+    def handle (self, ch):
+        if ch in self.actions:
+            return self.actions[ch]()
+        else:
+            self.log.add_event("Unknown key pressed, please see legend")
+            return True
+
+    # show all ports
+    def _show_ports_stats (self):
+        self.log.add_event("Switching to all ports view")
+        self.status_object.stats_panel = self.status_object.ports_stats_panel
 
-        
-    # all ports stats
-    def action_show_ports_stats (self):
-        self.add_log_event("Switching to all ports view")
-        self.stats_panel = self.ports_stats_panel
-        
         return True
 
-    # function generator for different ports requests
-    def action_show_port_generator (self, port_id):
-        def action_show_port():
-            self.add_log_event("Switching panel to port {0}".format(port_id))
-            self.stats_panel = self.ports_panels[port_id]
+
+     # function generator for different ports requests
+    def _show_port_generator (self, port_id):
+        def _show_port():
+            self.log.add_event("Switching panel to port {0}".format(port_id))
+            self.status_object.stats_panel = self.status_object.ports_panels[port_id]
 
             return True
 
-        return action_show_port
+        return _show_port
 
-    def action_freeze (self):
-        self.update_active = not self.update_active
-        self.add_log_event("Update continued" if self.update_active else "Update stopped")
+    def _freeze (self):
+        self.status_object.update_active = not self.status_object.update_active
+        self.log.add_event("Update continued" if self.status_object.update_active else "Update stopped")
 
         return True
 
-    def action_quit(self):
+    def _quit(self):
         return False
 
-    def action_ping (self):
-        self.add_log_event("Pinging RPC server")
+    def _ping (self):
+        self.log.add_event("Pinging RPC server")
 
-        rc, msg = self.rpc_client.ping_rpc_server()
+        rc, msg = self.stateless_client.ping()
         if rc:
-            self.add_log_event("Server replied: '{0}'".format(msg))
+            self.log.add_event("Server replied: '{0}'".format(msg))
         else:
-            self.add_log_event("Failed to get reply")
+            self.log.add_event("Failed to get reply")
 
         return True
 
-    def get_server_info (self):
+# status object
+# 
+#
+#
+class CTRexStatus():
+    def __init__ (self, stdscr, stateless_client):
+        self.stdscr = stdscr
 
-        self.server_version = self.rpc_client.get_rpc_server_version()
-        self.server_sys_info = self.rpc_client.get_system_info()
+        self.stateless_client = stateless_client
 
+        self.log  = TrexStatusLog()
+        self.cmds = TrexStatusCommands(self)
 
-    def add_log_event (self, msg):
-        self.log.append("[{0}] {1}".format(str(datetime.datetime.now().time()), msg))
+        self.stats         = stateless_client.get_stats_async()
+        self.general_stats = stateless_client.get_stats_async().get_general_stats()
 
-    # control panel
-    def update_control (self):
-        self.control_panel.clear()
+        # fetch server info
+        self.server_sys_info = self.stateless_client.get_system_info()
 
-        self.control_panel.getwin().addstr(1, 2, "'g' - general, '0-{0}' - specific port, 'f' - freeze, 'c' - clear stats, 'p' - ping server, 'q' - quit"
-                                           .format(self.rpc_client.get_port_count() - 1))
+        self.server_version = self.stateless_client.get_version()
 
-        index = 3
+        # list of owned ports
+        self.owned_ports_list = self.stateless_client.get_acquired_ports()
+     
+        # data per port
+        self.owned_ports = {}
 
-        cut = len(self.log) - 4
-        if cut < 0:
-            cut = 0
+        for port_id in self.owned_ports_list:
+            self.owned_ports[str(port_id)] = {}
+            self.owned_ports[str(port_id)]['streams'] = {}
 
-        for l in self.log[cut:]:
-            self.control_panel.getwin().addstr(index, 2, l)
-            index += 1
+            stream_list = self.stateless_client.get_all_streams(port_id)
 
+            self.owned_ports[str(port_id)] = stream_list
+        
+        
+        try:
+            curses.curs_set(0)
+        except:
+            pass
+
+        curses.use_default_colors()        
+        self.stdscr.nodelay(1)
+        curses.nonl()
+        curses.noecho()
+     
+        self.generate_layout()
+
+  
     def generate_layout (self):
         self.max_y = self.stdscr.getmaxyx()[0]
         self.max_x = self.stdscr.getmaxyx()[1]
@@ -394,7 +442,7 @@ class TrexStatus():
         self.ports_stats_panel    = PortsStatsPanel(int(self.max_y * 0.8), self.max_x / 2, 0, 0, self)
 
         self.ports_panels = {}
-        for i in xrange(0, self.rpc_client.get_port_count()):
+        for i in xrange(0, self.stateless_client.get_port_count()):
             self.ports_panels[i] = SinglePortPanel(int(self.max_y * 0.8), self.max_x / 2, 0, 0, self, i)
 
         # at start time we point to the main one 
@@ -411,28 +459,25 @@ class TrexStatus():
         # no key , continue
         if ch == curses.ERR:
             return True
-        
-        # check for registered function        
-        if ch in self.actions:
-            return self.actions[ch]()
-        else:
-            self.add_log_event("Unknown key pressed, please see legend")
-
-        return True
+    
+        return self.cmds.handle(ch)
 
     # main run entry point
     def run (self):
-        try:
-            curses.curs_set(0)
-        except:
-            pass
 
-        curses.use_default_colors()        
-        self.stdscr.nodelay(1)
-        curses.nonl()
-        curses.noecho()
+        # list of owned ports
+        self.owned_ports_list = self.stateless_client.get_acquired_ports()
      
-        self.generate_layout()
+        # data per port
+        self.owned_ports = {}
+
+        for port_id in self.owned_ports_list:
+            self.owned_ports[str(port_id)] = {}
+            self.owned_ports[str(port_id)]['streams'] = {}
+
+            stream_list = self.stateless_client.get_all_streams(port_id)
+
+            self.owned_ports[str(port_id)] = stream_list
 
         self.update_active = True
         while (True):
@@ -449,19 +494,26 @@ class TrexStatus():
             self.stats_panel.panel.top()
             self.stats_panel.draw()
 
-            panel.update_panels(); 
+            panel.update_panels()
             self.stdscr.refresh()
             sleep(0.01)
 
 
-def show_trex_status_internal (stdscr, rpc_client):
-    trex_status = TrexStatus(stdscr, rpc_client)
+# global container
+trex_status = None
+
+def show_trex_status_internal (stdscr, stateless_client):
+    global trex_status
+
+    if trex_status == None:
+        trex_status = CTRexStatus(stdscr, stateless_client)
+
     trex_status.run()
 
-def show_trex_status (rpc_client):
+def show_trex_status (stateless_client):
 
     try:
-        curses.wrapper(show_trex_status_internal, rpc_client)
+        curses.wrapper(show_trex_status_internal, stateless_client)
     except KeyboardInterrupt:
         curses.endwin()
 
diff --git a/scripts/automation/trex_control_plane/console/trex_tui.py b/scripts/automation/trex_control_plane/console/trex_tui.py
new file mode 100644
index 00000000..2e6be4a6
--- /dev/null
+++ b/scripts/automation/trex_control_plane/console/trex_tui.py
@@ -0,0 +1,395 @@
+import termios
+import sys
+import os
+import time
+from common.text_opts import *
+from common import trex_stats
+from client_utils import text_tables
+from collections import OrderedDict
+import datetime
+
+# base type of a panel
+class TrexTUIPanel(object):
+    def __init__ (self, mng, name):
+
+        self.mng = mng
+        self.name = name
+        self.stateless_client = mng.stateless_client
+
+
+    def show (self):
+        raise Exception("must implement this")
+
+    def get_key_actions (self):
+        raise Exception("must implement this")
+
+    def get_name (self):
+        return self.name
+
+
+# dashboard panel
+class TrexTUIDashBoard(TrexTUIPanel):
+    def __init__ (self, mng):
+        super(TrexTUIDashBoard, self).__init__(mng, "dashboard")
+
+        self.key_actions = OrderedDict()
+
+        self.key_actions['c'] = {'action': self.action_clear,  'legend': 'clear', 'show': True}
+        self.key_actions['p'] = {'action': self.action_pause,  'legend': 'pause', 'show': True}
+        self.key_actions['r'] = {'action': self.action_resume, 'legend': 'resume', 'show': True}
+        self.key_actions['+'] = {'action': self.action_raise,  'legend': 'up 5%', 'show': True}
+        self.key_actions['-'] = {'action': self.action_lower,  'legend': 'low 5%', 'show': True}
+
+        self.ports = self.stateless_client.get_all_ports()
+
+
+    def show (self):
+        stats = self.stateless_client.cmd_stats(self.ports, trex_stats.COMPACT)
+        # print stats to screen
+        for stat_type, stat_data in stats.iteritems():
+            text_tables.print_table_with_header(stat_data.text_table, stat_type)
+
+
+    def get_key_actions (self):
+        allowed = {}
+
+        allowed['c'] = self.key_actions['c']
+
+        # thats it for read only
+        if self.stateless_client.is_read_only():
+            return allowed
+
+        if len(self.stateless_client.get_transmitting_ports()) > 0:
+            allowed['p'] = self.key_actions['p']
+            allowed['+'] = self.key_actions['+']
+            allowed['-'] = self.key_actions['-']
+
+
+        if len(self.stateless_client.get_paused_ports()) > 0:
+            allowed['r'] = self.key_actions['r']
+
+        return allowed
+
+
+    ######### actions
+    def action_pause (self):
+        rc = self.stateless_client.pause_traffic(self.mng.ports)
+
+        ports_succeeded = []
+        for rc_single, port_id in zip(rc.rc_list, self.mng.ports):
+            if rc_single.rc:
+                ports_succeeded.append(port_id)
+
+        if len(ports_succeeded) > 0:
+            return "paused traffic on port(s): {0}".format(ports_succeeded)
+        else:
+            return ""
+
+
+    def action_resume (self):
+        rc = self.stateless_client.resume_traffic(self.mng.ports)
+
+        ports_succeeded = []
+        for rc_single, port_id in zip(rc.rc_list, self.mng.ports):
+            if rc_single.rc:
+                ports_succeeded.append(port_id)
+
+        if len(ports_succeeded) > 0:
+            return "resumed traffic on port(s): {0}".format(ports_succeeded)
+        else:
+            return ""
+
+
+    def action_raise (self):
+        mul = {'type': 'percentage', 'value': 5, 'op': 'add'}
+        rc = self.stateless_client.update_traffic(mul, self.mng.ports)
+
+        ports_succeeded = []
+        for rc_single, port_id in zip(rc.rc_list, self.mng.ports):
+            if rc_single.rc:
+                ports_succeeded.append(port_id)
+
+        if len(ports_succeeded) > 0:
+            return "raised B/W by %5 on port(s): {0}".format(ports_succeeded)
+        else:
+            return ""
+
+    def action_lower (self):
+        mul = {'type': 'percentage', 'value': 5, 'op': 'sub'}
+        rc = self.stateless_client.update_traffic(mul, self.mng.ports)
+
+        ports_succeeded = []
+        for rc_single, port_id in zip(rc.rc_list, self.mng.ports):
+            if rc_single.rc:
+                ports_succeeded.append(port_id)
+
+        if len(ports_succeeded) > 0:
+            return "lowered B/W by %5 on port(s): {0}".format(ports_succeeded)
+        else:
+            return ""
+
+
+    def action_clear (self):
+        self.stateless_client.cmd_clear(self.mng.ports)
+        return "cleared all stats"
+
+
+# port panel
+class TrexTUIPort(TrexTUIPanel):
+    def __init__ (self, mng, port_id):
+        super(TrexTUIPort, self).__init__(mng, "port {0}".format(port_id))
+
+        self.port_id = port_id
+        self.port = self.mng.stateless_client.get_port(port_id)
+
+        self.key_actions = OrderedDict()
+
+        self.key_actions['c'] = {'action': self.action_clear,  'legend': 'clear', 'show': True}
+        self.key_actions['p'] = {'action': self.action_pause, 'legend': 'pause', 'show': True}
+        self.key_actions['r'] = {'action': self.action_resume, 'legend': 'resume', 'show': True}
+        self.key_actions['+'] = {'action': self.action_raise, 'legend': 'up 5%', 'show': True}
+        self.key_actions['-'] = {'action': self.action_lower, 'legend': 'low 5%', 'show': True}
+
+
+    def show (self):
+        stats = self.stateless_client.cmd_stats([self.port_id], trex_stats.COMPACT)
+        # print stats to screen
+        for stat_type, stat_data in stats.iteritems():
+            text_tables.print_table_with_header(stat_data.text_table, stat_type)
+
+    def get_key_actions (self):
+
+        allowed = {}
+
+        allowed['c'] = self.key_actions['c']
+
+        # thats it for read only
+        if self.stateless_client.is_read_only():
+            return allowed
+
+        if self.port.state == self.port.STATE_TX:
+            allowed['p'] = self.key_actions['p']
+            allowed['+'] = self.key_actions['+']
+            allowed['-'] = self.key_actions['-']
+
+        elif self.port.state == self.port.STATE_PAUSE:
+            allowed['r'] = self.key_actions['r']
+
+
+        return allowed
+
+    # actions
+    def action_pause (self):
+        rc = self.stateless_client.pause_traffic([self.port_id])
+        if rc.good():
+            return "port {0}: paused traffic".format(self.port_id)
+        else:
+            return ""
+
+    def action_resume (self):
+        rc = self.stateless_client.resume_traffic([self.port_id])
+        if rc.good():
+            return "port {0}: resumed traffic".format(self.port_id)
+        else:
+            return ""
+
+    def action_raise (self):
+        mul = {'type': 'percentage', 'value': 5, 'op': 'add'}
+        rc = self.stateless_client.update_traffic(mul, [self.port_id])
+
+        if rc.good():
+            return "port {0}: raised B/W by 5%".format(self.port_id)
+        else:
+            return ""
+
+    def action_lower (self):
+        mul = {'type': 'percentage', 'value': 5, 'op': 'sub'}
+        rc = self.stateless_client.update_traffic(mul, [self.port_id])
+
+        if rc.good():
+            return "port {0}: lowered B/W by 5%".format(self.port_id)
+        else:
+            return ""
+
+    def action_clear (self):
+        self.stateless_client.cmd_clear([self.port_id])
+        return "port {0}: cleared stats".format(self.port_id)
+
+# log
+class TrexTUILog():
+    def __init__ (self):
+        self.log = []
+
+    def add_event (self, msg):
+        self.log.append("[{0}] {1}".format(str(datetime.datetime.now().time()), msg))
+
+    def show (self, max_lines = 4):
+        cut = len(self.log) - max_lines
+        if cut < 0:
+            cut = 0
+
+        print format_text("\nLog:", 'bold', 'underline')
+
+        for msg in self.log[cut:]:
+            print msg
+
+
+# Panels manager (contains server panels)
+class TrexTUIPanelManager():
+    def __init__ (self, tui):
+        self.tui = tui
+        self.stateless_client = tui.stateless_client
+        self.ports = self.stateless_client.get_all_ports()
+        
+
+        self.panels = {}
+        self.panels['dashboard'] = TrexTUIDashBoard(self)
+
+        self.key_actions = OrderedDict()
+        self.key_actions['q'] = {'action': self.action_quit, 'legend': 'quit', 'show': True}
+        self.key_actions['g'] = {'action': self.action_show_dash, 'legend': 'dashboard', 'show': True}
+
+        for port_id in self.ports:
+            self.key_actions[str(port_id)] = {'action': self.action_show_port(port_id), 'legend': 'port {0}'.format(port_id), 'show': False}
+            self.panels['port {0}'.format(port_id)] = TrexTUIPort(self, port_id)
+
+        # start with dashboard
+        self.main_panel = self.panels['dashboard']
+
+        # log object
+        self.log = TrexTUILog()
+
+        self.generate_legend()
+
+
+    def generate_legend (self):
+        self.legend = "\n{:<12}".format("browse:")
+
+        for k, v in self.key_actions.iteritems():
+            if v['show']:
+                x = "'{0}' - {1}, ".format(k, v['legend'])
+                self.legend += "{:}".format(x)
+
+        self.legend += "'0-{0}' - port display".format(len(self.ports) - 1)
+
+
+        self.legend += "\n{:<12}".format(self.main_panel.get_name() + ":")
+        for k, v in self.main_panel.get_key_actions().iteritems():
+            if v['show']:
+                x = "'{0}' - {1}, ".format(k, v['legend'])
+                self.legend += "{:}".format(x)
+
+
+    def print_legend (self):
+        print format_text(self.legend, 'bold')
+
+
+    # on window switch or turn on / off of the TUI we call this
+    def init (self):
+        self.generate_legend()
+
+    def show (self):
+        self.main_panel.show()
+        self.print_legend()
+        self.log.show()
+
+
+    def handle_key (self, ch):
+        # check for the manager registered actions
+        if ch in self.key_actions:
+            msg = self.key_actions[ch]['action']()
+
+        # check for main panel actions
+        elif ch in self.main_panel.get_key_actions():
+            msg = self.main_panel.get_key_actions()[ch]['action']()
+
+        else:
+            msg = ""
+
+        self.generate_legend()
+
+        if msg == None:
+            return False
+        else:
+            if msg:
+                self.log.add_event(msg)
+            return True
+            
+
+    # actions
+
+    def action_quit (self):
+        return None
+
+    def action_show_dash (self):
+        self.main_panel = self.panels['dashboard']
+        self.init()
+        return ""
+
+    def action_show_port (self, port_id):
+        def action_show_port_x ():
+            self.main_panel = self.panels['port {0}'.format(port_id)]
+            self.init()
+            return ""
+
+        return action_show_port_x
+
+
+
+# shows a textual top style window
+class TrexTUI():
+    def __init__ (self, stateless_client):
+        self.stateless_client = stateless_client
+
+        self.pm = TrexTUIPanelManager(self)
+
+
+
+    def handle_key_input (self):
+        # try to read a single key
+        ch = os.read(sys.stdin.fileno(), 1)
+        if ch != None and len(ch) > 0:
+            return self.pm.handle_key(ch)
+
+        else:
+            return True
+            
+
+    def clear_screen (self):
+        os.system('clear')
+
+
+
+    def show (self):
+        # init termios
+        old_settings = termios.tcgetattr(sys.stdin)
+        new_settings = termios.tcgetattr(sys.stdin)
+        new_settings[3] = new_settings[3] & ~(termios.ECHO | termios.ICANON) # lflags
+        new_settings[6][termios.VMIN] = 0  # cc
+        new_settings[6][termios.VTIME] = 0 # cc
+        termios.tcsetattr(sys.stdin, termios.TCSADRAIN, new_settings)
+
+        self.pm.init()
+
+        try:
+            while True:
+                self.clear_screen()
+
+                cont = self.handle_key_input()
+                self.pm.show()
+
+                if not cont:
+                    break
+
+                time.sleep(0.1)
+
+        finally:
+            # restore
+            termios.tcsetattr(sys.stdin, termios.TCSADRAIN, old_settings)
+
+        print ""
+
+    # key actions
+    def action_quit (self):
+        return False
+