Merge from origin

3 files changed, 701 insertions, 668 deletions

diff --git a/scripts/automation/trex_control_plane/console/trex_console.py b/scripts/automation/trex_control_plane/console/trex_console.py
index 2672665c..88ff45dc 100755
--- a/scripts/automation/trex_control_plane/console/trex_console.py
+++ b/scripts/automation/trex_control_plane/console/trex_console.py
@@ -29,7 +29,7 @@ import sys
 import tty, termios
 import trex_root_path
 from common.trex_streams import *
-from client.trex_stateless_client import CTRexStatelessClient
+from client.trex_stateless_client import STLClient, LoggerApi, STLError
 from common.text_opts import *
 from client_utils.general_utils import user_input, get_current_user
 from client_utils import parsing_opts
@@ -39,6 +39,28 @@ from functools import wraps
 
 __version__ = "1.1"
 
+# console custom logger
+class ConsoleLogger(LoggerApi):
+    def __init__ (self):
+        self.prompt_redraw = None
+
+    def write (self, msg, newline = True):
+        if newline:
+            print msg
+        else:
+            print msg,
+
+    def flush (self):
+        sys.stdout.flush()
+
+    # override this for the prompt fix
+    def async_log (self, msg, level = LoggerApi.VERBOSE_REGULAR, newline = True):
+        self.log(msg, level, newline)
+        if self.prompt_redraw:
+            self.prompt_redraw()
+            self.flush()
+
+
 def set_window_always_on_top (title):
     # we need the GDK module, if not available - ignroe this command
     try:
@@ -133,9 +155,9 @@ class TRexGeneralCmd(cmd.Cmd):
 class TRexConsole(TRexGeneralCmd):
     """Trex Console"""
 
-    def __init__(self, stateless_client, verbose=False):
+    def __init__(self, stateless_client, verbose = False):
+
         self.stateless_client = stateless_client
-        self.stateless_client.set_prompt_redraw_cb(self.prompt_redraw)
 
         TRexGeneralCmd.__init__(self)
 
@@ -153,7 +175,10 @@ class TRexConsole(TRexGeneralCmd):
     ################### internal section ########################
 
     def prompt_redraw (self):
-        sys.stdout.write(self.prompt + readline.get_line_buffer())
+        self.postcmd(False, "")
+        sys.stdout.write("\n" + self.prompt + readline.get_line_buffer())
+        sys.stdout.flush()
+
 
     def verify_connected(f):
         @wraps(f)
@@ -185,7 +210,7 @@ class TRexConsole(TRexGeneralCmd):
                 print format_text("\n'{0}' cannot be executed on offline mode\n".format(func_name), 'bold')
                 return
 
-            if inst.stateless_client.is_read_only():
+            if inst.stateless_client.is_all_ports_acquired():
                 print format_text("\n'{0}' cannot be executed on read only mode\n".format(func_name), 'bold')
                 return
 
@@ -197,7 +222,7 @@ class TRexConsole(TRexGeneralCmd):
 
     def get_console_identifier(self):
         return "{context}_{server}".format(context=self.__class__.__name__,
-                                           server=self.stateless_client.get_server_ip())
+                                           server=self.stateless_client.get_connection_info()['server'])
     
     def register_main_console_methods(self):
         main_names = set(self.trex_console.get_names()).difference(set(dir(self.__class__)))
@@ -229,7 +254,7 @@ class TRexConsole(TRexGeneralCmd):
             self.supported_rpc = None
             return stop
 
-        if self.stateless_client.is_read_only():
+        if self.stateless_client.is_all_ports_acquired():
             self.prompt = "TRex (read only) > "
             return stop
 
@@ -264,44 +289,12 @@ class TRexConsole(TRexGeneralCmd):
 
         return targets
 
-    # 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
-
-        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 ""
-
-            elif isinstance(err_log, str):
-                print "\n" + err_log + "\n"
-
-            print format_text("[FAILED]\n", 'red', 'bold')
-            if ext_err_msg:
-                print format_text(ext_err_msg + "\n", 'blue', 'bold')
-
-            return False
-
-        else:
-            print format_text("[SUCCESS]\n", 'green', 'bold')
-            return True
-
 
     ####################### shell commands #######################
     @verify_connected
     def do_ping (self, line):
         '''Ping the server\n'''
-        rc = self.stateless_client.cmd_ping()
-        if rc.bad():
-            return
+        self.stateless_client.ping()
 
 
     # set verbose on / off
@@ -312,12 +305,12 @@ class TRexConsole(TRexGeneralCmd):
 
         elif line == "on":
             self.verbose = True
-            self.stateless_client.set_verbose(self.stateless_client.VERBOSE_HIGH)
+            self.stateless_client.set_verbose(self.stateless_client.logger.VERBOSE_HIGH)
             print format_text("\nverbose set to on\n", 'green', 'bold')
 
         elif line == "off":
             self.verbose = False
-            self.stateless_client.set_verbose(self.stateless_client.VERBOSE_REGULAR)
+            self.stateless_client.set_verbose(self.stateless_client.logger.VERBOSE_REGULAR)
             print format_text("\nverbose set to off\n", 'green', 'bold')
 
         else:
@@ -361,13 +354,13 @@ class TRexConsole(TRexGeneralCmd):
     def do_connect (self, line):
         '''Connects to the server\n'''
 
-        self.stateless_client.cmd_connect_line(line)
+        self.stateless_client.connect_line(line)
 
 
     def do_disconnect (self, line):
         '''Disconnect from the server\n'''
 
-        self.stateless_client.cmd_disconnect()
+        self.stateless_client.disconnect_line(line)
 
  
     ############### start
@@ -388,7 +381,7 @@ class TRexConsole(TRexGeneralCmd):
     def do_start(self, line):
         '''Start selected traffic in specified port(s) on TRex\n'''
 
-        self.stateless_client.cmd_start_line(line)
+        self.stateless_client.start_line(line)
 
         
 
@@ -401,7 +394,7 @@ class TRexConsole(TRexGeneralCmd):
     def do_stop(self, line):
         '''stops port(s) transmitting traffic\n'''
 
-        self.stateless_client.cmd_stop_line(line)
+        self.stateless_client.stop_line(line)
 
     def help_stop(self):
         self.do_stop("-h")
@@ -411,7 +404,7 @@ class TRexConsole(TRexGeneralCmd):
     def do_update(self, line):
         '''update speed of port(s)currently transmitting traffic\n'''
 
-        self.stateless_client.cmd_update_line(line)
+        self.stateless_client.update_line(line)
 
     def help_update (self):
         self.do_update("-h")
@@ -421,14 +414,14 @@ class TRexConsole(TRexGeneralCmd):
     def do_pause(self, line):
         '''pause port(s) transmitting traffic\n'''
 
-        self.stateless_client.cmd_pause_line(line)
+        self.stateless_client.pause_line(line)
 
     ############# resume
     @verify_connected_and_rw
     def do_resume(self, line):
         '''resume port(s) transmitting traffic\n'''
 
-        self.stateless_client.cmd_resume_line(line)
+        self.stateless_client.resume_line(line)
 
    
 
@@ -436,7 +429,7 @@ class TRexConsole(TRexGeneralCmd):
     @verify_connected_and_rw
     def do_reset (self, line):
         '''force stop all ports\n'''
-        self.stateless_client.cmd_reset_line(line)
+        self.stateless_client.reset_line(line)
 
 
     ######### validate
@@ -444,13 +437,13 @@ class TRexConsole(TRexGeneralCmd):
     def do_validate (self, line):
         '''validates port(s) stream configuration\n'''
 
-        self.stateless_client.cmd_validate_line(line)
+        self.stateless_client.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)
+        self.stateless_client.show_stats_line(line)
 
 
     def help_stats(self):
@@ -459,7 +452,7 @@ class TRexConsole(TRexGeneralCmd):
     @verify_connected
     def do_streams(self, line):
         '''Fetch statistics from TRex server by port\n'''
-        self.stateless_client.cmd_streams_line(line)
+        self.stateless_client.show_streams_line(line)
 
 
     def help_streams(self):
@@ -468,7 +461,7 @@ class TRexConsole(TRexGeneralCmd):
     @verify_connected
     def do_clear(self, line):
         '''Clear cached local statistics\n'''
-        self.stateless_client.cmd_clear_line(line)
+        self.stateless_client.clear_stats_line(line)
 
 
     def help_clear(self):
@@ -520,20 +513,17 @@ class TRexConsole(TRexGeneralCmd):
 
         if opts.xterm:
 
-            exe = './trex-console -t -q -s {0} -p {1}'.format(self.stateless_client.get_server_ip(), self.stateless_client.get_server_port())
+            info = self.stateless_client.get_connection_info()
+
+            exe = './trex-console -t -q -s {0} -p {1} --async_port {2}'.format(info['server'], info['sync_port'], info['async_port'])
             cmd = ['xterm', '-geometry', '111x42', '-sl', '0', '-title', 'trex_tui', '-e', exe]
             self.terminal = subprocess.Popen(cmd)
 
             return
 
 
-        set_window_always_on_top('trex_tui')
-
-        save_verbose = self.stateless_client.get_verbose()
-
-        self.stateless_client.set_verbose(self.stateless_client.VERBOSE_QUIET)
-        self.tui.show()
-        self.stateless_client.set_verbose(save_verbose)
+        with self.stateless_client.logger.supress():
+            self.tui.show()
 
 
     def help_tui (self):
@@ -605,6 +595,49 @@ class TRexConsole(TRexGeneralCmd):
     do_h = do_history
 
 
+# run a script of commands
+def run_script_file (self, filename, stateless_client):
+
+    self.logger.log(format_text("\nRunning script file '{0}'...".format(filename), 'bold'))
+
+    with open(filename) as f:
+        script_lines = f.readlines()
+
+    cmd_table = {}
+
+    # register all the commands
+    cmd_table['start'] = stateless_client.start_line
+    cmd_table['stop']  = stateless_client.stop_line
+    cmd_table['reset'] = stateless_client.reset_line
+
+    for index, line in enumerate(script_lines, start = 1):
+        line = line.strip()
+        if line == "":
+            continue
+        if line.startswith("#"):
+            continue
+
+        sp = line.split(' ', 1)
+        cmd = sp[0]
+        if len(sp) == 2:
+            args = sp[1]
+        else:
+            args = ""
+
+        stateless_client.logger.log(format_text("Executing line {0} : '{1}'\n".format(index, line)))
+
+        if not cmd in cmd_table:
+            print "\n*** Error at line {0} : '{1}'\n".format(index, line)
+            stateless_client.logger.log(format_text("unknown command '{0}'\n".format(cmd), 'bold'))
+            return False
+
+        cmd_table[cmd](args)
+
+    stateless_client.logger.log(format_text("\n[Done]", 'bold'))
+
+    return True
+
+
 #
 def is_valid_file(filename):
     if not os.path.isfile(filename):
@@ -613,6 +646,7 @@ def is_valid_file(filename):
     return filename
 
 
+
 def setParserOptions():
     parser = argparse.ArgumentParser(prog="trex_console.py")
 
@@ -633,7 +667,7 @@ def setParserOptions():
                         default = get_current_user(),
                         type = str)
 
-    parser.add_argument("--verbose", dest="verbose",
+    parser.add_argument("-v", "--verbose", dest="verbose",
                         action="store_true", help="Switch ON verbose option. Default is: OFF.",
                         default = False)
 
@@ -665,34 +699,50 @@ def main():
     options = parser.parse_args()
 
     # Stateless client connection
-    stateless_client = CTRexStatelessClient(options.user, options.server, options.port, options.pub, options.quiet)
+    if options.quiet:
+        verbose_level = LoggerApi.VERBOSE_QUIET
+    elif options.verbose:
+        verbose_level = LoggerApi.VERBOSE_HIGH
+    else:
+        verbose_level = LoggerApi.VERBOSE_REGULAR
 
-    if not options.quiet:
-        print "\nlogged as {0}".format(format_text(options.user, 'bold'))
+    # Stateless client connection
+    logger = ConsoleLogger()
+    stateless_client = STLClient(username = options.user,
+                                 server = options.server,
+                                 sync_port = options.port,
+                                 async_port = options.pub,
+                                 verbose_level = verbose_level,
+                                 logger = logger)
 
     # 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()
+    try:
+        stateless_client.connect("RO")
+    except STLError as e:
+        logger.log("Log:\n" + format_text(e.brief() + "\n", 'bold'))
         return
 
+    if not options.tui and options.acquire:
+        try:
+            stateless_client.acquire()
+        except STLError as e:
+            logger.log("Log:\n" + format_text(e.brief() + "\n", 'bold'))
+            logger.log(format_text("\nSwitching to read only mode - only few commands will be available", 'bold'))
 
+  
     # a script mode
     if options.batch:
-        cont = stateless_client.run_script_file(options.batch[0])
+        cont = run_script_file(options.batch[0], stateless_client)
         if not cont:
             return
         
     # console
-
     try:
         console = TRexConsole(stateless_client, options.verbose)
+        logger.prompt_redraw = console.prompt_redraw
+
         if options.tui:
+            set_window_always_on_top('trex_tui')
             console.do_tui("")
         else:
             console.start()
@@ -701,7 +751,7 @@ def main():
         print "\n\n*** Caught Ctrl + C... Exiting...\n\n"
 
     finally:
-        stateless_client.disconnect()
+        stateless_client.teardown(stop_traffic = False)
 
 if __name__ == '__main__':
     
diff --git a/scripts/automation/trex_control_plane/console/trex_status.py b/scripts/automation/trex_control_plane/console/trex_status.py
index cdf3fb69..45769693 100644
--- a/scripts/automation/trex_control_plane/console/trex_status.py
+++ b/scripts/automation/trex_control_plane/console/trex_status.py
@@ -1,525 +1,525 @@
-from time import sleep
-
-import os
-
-import curses 
-from curses import panel
-import random
-import collections
-import operator
-import datetime
-
-g_curses_active = False
-
-################### utils #################
-
-# simple percetange show
-def percentage (a, total):
-    x = int ((float(a) / total) * 100)
-    return str(x) + "%"
-
-################### panels #################
-
-# panel object
-class TrexStatusPanel(object):
-    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
-        self.x = x
-        self.headline = headline
-
-        self.win = curses.newwin(h, l, y, x)
-        self.win.erase()
-        self.win.box()
-
-        self.win.addstr(1, 2, headline, curses.A_UNDERLINE)
-        self.win.refresh()
-
-        panel.new_panel(self.win)
-        self.panel = panel.new_panel(self.win)
-        self.panel.top()
-
-    def clear (self):
-        self.win.erase()
-        self.win.box()
-        self.win.addstr(1, 2, self.headline, curses.A_UNDERLINE)
-
-    def getwin (self):
-        return self.win
-
-
-# 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:", status_obj)
-
-    def draw (self):
-
-        if not self.status_obj.server_version :
-            return
-
-        if not self.status_obj.server_sys_info:
-            return
-
-
-        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"] + " @ " + 
-                                                                    self.status_obj.server_version["build_time"] + " by " + 
-                                                                    self.status_obj.server_version["built_by"]))
-
-        self.getwin().addstr(6, 2, "{:<30} {:30}".format("Server Uptime:", self.status_obj.server_sys_info["uptime"]))
-        self.getwin().addstr(7, 2, "{:<30} {:<3} / {:<30}".format("DP Cores:", str(self.status_obj.server_sys_info["dp_core_count"]) + 
-                                                                  " cores", self.status_obj.server_sys_info["core_type"]))
-
-        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.owned_ports_list)
-
-        if not ports_owned:
-            ports_owned = "None"
-
-        self.getwin().addstr(10, 2, "{:<30} {:<30}".format("Ports Owned:", ports_owned))
-
-# general info panel
-class GeneralInfoPanel(TrexStatusPanel):
-    def __init__ (self, h, l, y, x, status_obj):
-
-        super(GeneralInfoPanel, self).__init__(h, l, y ,x ,"General Info:", status_obj)
-
-    def draw (self):
-        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:", status_obj)
-
-
-    def draw (self):
-
-        self.clear()
-
-        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} {:^30} {:^30} {:^30}".format(
-            "Port ID", "Tx Rate [bps/pps]", "Rx Rate [bps/pps]", "Total Bytes [tx/rx]"))
-
-
-
-        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} {:^30} {:^30} {:^30}".format(
-                    "{0} ({1})".format(str(port_index), self.status_obj.server_sys_info["ports"][port_index]["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(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"))
-
-
-                # old format
+#from time import sleep
+#
+#import os
+#
+#import curses 
+#from curses import panel
+#import random
+#import collections
+#import operator
+#import datetime
+#
+#g_curses_active = False
+#
+#################### utils #################
+#
+## simple percetange show
+#def percentage (a, total):
+#    x = int ((float(a) / total) * 100)
+#    return str(x) + "%"
+#
+#################### panels #################
+#
+## panel object
+#class TrexStatusPanel(object):
+#    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
+#        self.x = x
+#        self.headline = headline
+#
+#        self.win = curses.newwin(h, l, y, x)
+#        self.win.erase()
+#        self.win.box()
+#
+#        self.win.addstr(1, 2, headline, curses.A_UNDERLINE)
+#        self.win.refresh()
+#
+#        panel.new_panel(self.win)
+#        self.panel = panel.new_panel(self.win)
+#        self.panel.top()
+#
+#    def clear (self):
+#        self.win.erase()
+#        self.win.box()
+#        self.win.addstr(1, 2, self.headline, curses.A_UNDERLINE)
+#
+#    def getwin (self):
+#        return self.win
+#
+#
+## 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:", status_obj)
+#
+#    def draw (self):
+#
+#        if not self.status_obj.server_version :
+#            return
+#
+#        if not self.status_obj.server_sys_info:
+#            return
+#
+#
+#        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"] + " @ " + 
+#                                                                    self.status_obj.server_version["build_time"] + " by " + 
+#                                                                    self.status_obj.server_version["built_by"]))
+#
+#        self.getwin().addstr(6, 2, "{:<30} {:30}".format("Server Uptime:", self.status_obj.server_sys_info["uptime"]))
+#        self.getwin().addstr(7, 2, "{:<30} {:<3} / {:<30}".format("DP Cores:", str(self.status_obj.server_sys_info["dp_core_count"]) + 
+#                                                                  " cores", self.status_obj.server_sys_info["core_type"]))
+#
+#        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.owned_ports_list)
+#
+#        if not ports_owned:
+#            ports_owned = "None"
+#
+#        self.getwin().addstr(10, 2, "{:<30} {:<30}".format("Ports Owned:", ports_owned))
+#
+## general info panel
+#class GeneralInfoPanel(TrexStatusPanel):
+#    def __init__ (self, h, l, y, x, status_obj):
+#
+#        super(GeneralInfoPanel, self).__init__(h, l, y ,x ,"General Info:", status_obj)
+#
+#    def draw (self):
+#        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:", status_obj)
+#
+#
+#    def draw (self):
+#
+#        self.clear()
+#
+#        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} {:^30} {:^30} {:^30}".format(
+#            "Port ID", "Tx Rate [bps/pps]", "Rx Rate [bps/pps]", "Total Bytes [tx/rx]"))
+#
+#
+#
+#        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} {:^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"]),
-#                    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")))
+#                    "{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"))
-
-# control panel
-class ControlPanel(TrexStatusPanel):
-    def __init__ (self, h, l, y, x, status_obj):
-
-        super(ControlPanel, self).__init__(h, l, y, x, "", 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.stateless_client.get_port_count() - 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), status_obj)
-
-        self.port_id = port_id
-
-    def draw (self):
-        y = 3
-
-        self.clear()
-
-        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
-
-        # streams
-        self.getwin().addstr(y, 2, "Streams:", curses.A_UNDERLINE)
-        y += 2
-
-        # stream table header 
-        self.getwin().addstr(y, 2, "{:^15} {:^15} {:^15} {:^15} {:^15} {:^15} {:^15}".format(
-            "Stream ID", "Enabled", "Type", "Self Start", "ISG", "Next Stream", "VM"))
-        y += 2
-
-        # streams
-        
-        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['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
-
-        # new section - traffic
-        y += 2
-
-        self.getwin().addstr(y, 2, "Traffic:", curses.A_UNDERLINE)
-        y += 2
-
-
-
-         # 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
-
-        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} {:^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"))
-
-
-################### main objects #################
-
-# status log
-class TrexStatusLog():
-    def __init__ (self):
-        self.log = []
-
-    def add_event (self, msg):
-        self.log.append("[{0}] {1}".format(str(datetime.datetime.now().time()), msg))
-
-    def draw (self, window, x, y, max_lines = 4):
-        index = y
-
-        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
-
-        self.actions = {}
-        self.actions[ord('q')] = self._quit
-        self.actions[ord('p')] = self._ping
-        self.actions[ord('f')] = self._freeze 
-
-        self.actions[ord('g')] = self._show_ports_stats
-
-        # 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
-
-        return True
-
-
-     # 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 _show_port
-
-    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 _quit(self):
-        return False
-
-    def _ping (self):
-        self.log.add_event("Pinging RPC server")
-
-        rc, msg = self.stateless_client.ping()
-        if rc:
-            self.log.add_event("Server replied: '{0}'".format(msg))
-        else:
-            self.log.add_event("Failed to get reply")
-
-        return True
-
-# status object
-# 
-#
-#
-class CTRexStatus():
-    def __init__ (self, stdscr, stateless_client):
-        self.stdscr = stdscr
-
-        self.stateless_client = stateless_client
-
-        self.log  = TrexStatusLog()
-        self.cmds = TrexStatusCommands(self)
-
-        self.stats         = stateless_client.get_stats_async()
-        self.general_stats = stateless_client.get_stats_async().get_general_stats()
-
-        # fetch server info
-        self.server_sys_info = self.stateless_client.get_system_info()
-
-        self.server_version = self.stateless_client.get_version()
-
-        # list of owned ports
-        self.owned_ports_list = self.stateless_client.get_acquired_ports()
-     
-        # 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
-        
-        
-        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]
-
-        self.server_info_panel    = ServerInfoPanel(int(self.max_y * 0.3), self.max_x / 2, int(self.max_y * 0.5), self.max_x /2, self)
-        self.general_info_panel   = GeneralInfoPanel(int(self.max_y * 0.5), self.max_x / 2, 0, self.max_x /2, self)
-        self.control_panel        = ControlPanel(int(self.max_y * 0.2), self.max_x , int(self.max_y * 0.8), 0, self)
-
-        # those can be switched on the same place 
-        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.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 
-        self.stats_panel = self.ports_stats_panel
-        self.stats_panel.panel.top()
-
-        panel.update_panels(); self.stdscr.refresh()
-        return 
-
-
-    def wait_for_key_input (self):
-        ch = self.stdscr.getch()
-
-        # no key , continue
-        if ch == curses.ERR:
-            return True
-    
-        return self.cmds.handle(ch)
-
-    # main run entry point
-    def run (self):
-
-        # list of owned ports
-        self.owned_ports_list = self.stateless_client.get_acquired_ports()
-     
-        # 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):
-
-            rc = self.wait_for_key_input()
-            if not rc:
-                break
-
-            self.server_info_panel.draw()
-            self.general_info_panel.draw()
-            self.control_panel.draw()
-
-            # can be different kinds of panels
-            self.stats_panel.panel.top()
-            self.stats_panel.draw()
-
-            panel.update_panels()
-            self.stdscr.refresh()
-            sleep(0.01)
-
-
-# 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 (stateless_client):
-
-    try:
-        curses.wrapper(show_trex_status_internal, stateless_client)
-    except KeyboardInterrupt:
-        curses.endwin()
-
-def cleanup ():
-    try:
-        curses.endwin()
-    except:
-        pass
-
+#
+#
+#                # 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, "", 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.stateless_client.get_port_count() - 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), status_obj)
+#
+#        self.port_id = port_id
+#
+#    def draw (self):
+#        y = 3
+#
+#        self.clear()
+#
+#        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
+#
+#        # streams
+#        self.getwin().addstr(y, 2, "Streams:", curses.A_UNDERLINE)
+#        y += 2
+#
+#        # stream table header 
+#        self.getwin().addstr(y, 2, "{:^15} {:^15} {:^15} {:^15} {:^15} {:^15} {:^15}".format(
+#            "Stream ID", "Enabled", "Type", "Self Start", "ISG", "Next Stream", "VM"))
+#        y += 2
+#
+#        # streams
+#        
+#        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['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
+#
+#        # new section - traffic
+#        y += 2
+#
+#        self.getwin().addstr(y, 2, "Traffic:", curses.A_UNDERLINE)
+#        y += 2
+#
+#
+#
+#         # 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
+#
+#        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} {:^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"))
+#
+#
+#################### main objects #################
+#
+## status log
+#class TrexStatusLog():
+#    def __init__ (self):
+#        self.log = []
+#
+#    def add_event (self, msg):
+#        self.log.append("[{0}] {1}".format(str(datetime.datetime.now().time()), msg))
+#
+#    def draw (self, window, x, y, max_lines = 4):
+#        index = y
+#
+#        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
+#
+#        self.actions = {}
+#        self.actions[ord('q')] = self._quit
+#        self.actions[ord('p')] = self._ping
+#        self.actions[ord('f')] = self._freeze 
+#
+#        self.actions[ord('g')] = self._show_ports_stats
+#
+#        # 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
+#
+#        return True
+#
+#
+#     # 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 _show_port
+#
+#    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 _quit(self):
+#        return False
+#
+#    def _ping (self):
+#        self.log.add_event("Pinging RPC server")
+#
+#        rc, msg = self.stateless_client.ping()
+#        if rc:
+#            self.log.add_event("Server replied: '{0}'".format(msg))
+#        else:
+#            self.log.add_event("Failed to get reply")
+#
+#        return True
+#
+## status object
+## 
+##
+##
+#class CTRexStatus():
+#    def __init__ (self, stdscr, stateless_client):
+#        self.stdscr = stdscr
+#
+#        self.stateless_client = stateless_client
+#
+#        self.log  = TrexStatusLog()
+#        self.cmds = TrexStatusCommands(self)
+#
+#        self.stats         = stateless_client.get_stats_async()
+#        self.general_stats = stateless_client.get_stats_async().get_general_stats()
+#
+#        # fetch server info
+#        self.server_sys_info = self.stateless_client.get_system_info()
+#
+#        self.server_version = self.stateless_client.get_server_version()
+#
+#        # list of owned ports
+#        self.owned_ports_list = self.stateless_client.get_acquired_ports()
+#     
+#        # 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
+#        
+#        
+#        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]
+#
+#        self.server_info_panel    = ServerInfoPanel(int(self.max_y * 0.3), self.max_x / 2, int(self.max_y * 0.5), self.max_x /2, self)
+#        self.general_info_panel   = GeneralInfoPanel(int(self.max_y * 0.5), self.max_x / 2, 0, self.max_x /2, self)
+#        self.control_panel        = ControlPanel(int(self.max_y * 0.2), self.max_x , int(self.max_y * 0.8), 0, self)
+#
+#        # those can be switched on the same place 
+#        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.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 
+#        self.stats_panel = self.ports_stats_panel
+#        self.stats_panel.panel.top()
+#
+#        panel.update_panels(); self.stdscr.refresh()
+#        return 
+#
+#
+#    def wait_for_key_input (self):
+#        ch = self.stdscr.getch()
+#
+#        # no key , continue
+#        if ch == curses.ERR:
+#            return True
+#    
+#        return self.cmds.handle(ch)
+#
+#    # main run entry point
+#    def run (self):
+#
+#        # list of owned ports
+#        self.owned_ports_list = self.stateless_client.get_acquired_ports()
+#     
+#        # 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):
+#
+#            rc = self.wait_for_key_input()
+#            if not rc:
+#                break
+#
+#            self.server_info_panel.draw()
+#            self.general_info_panel.draw()
+#            self.control_panel.draw()
+#
+#            # can be different kinds of panels
+#            self.stats_panel.panel.top()
+#            self.stats_panel.draw()
+#
+#            panel.update_panels()
+#            self.stdscr.refresh()
+#            sleep(0.01)
+#
+#
+## 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 (stateless_client):
+#
+#    try:
+#        curses.wrapper(show_trex_status_internal, stateless_client)
+#    except KeyboardInterrupt:
+#        curses.endwin()
+#
+#def cleanup ():
+#    try:
+#        curses.endwin()
+#    except:
+#        pass
+#
diff --git a/scripts/automation/trex_control_plane/console/trex_tui.py b/scripts/automation/trex_control_plane/console/trex_tui.py
index dbbac02b..1e22b005 100644
--- a/scripts/automation/trex_control_plane/console/trex_tui.py
+++ b/scripts/automation/trex_control_plane/console/trex_tui.py
@@ -8,6 +8,7 @@ from client_utils import text_tables
 from collections import OrderedDict
 import datetime
 from cStringIO import StringIO
+from client.trex_stateless_client import STLError
 
 class SimpleBar(object):
     def __init__ (self, desc, pattern):
@@ -60,7 +61,7 @@ class TrexTUIDashBoard(TrexTUIPanel):
 
 
     def show (self):
-        stats = self.stateless_client.cmd_stats(self.ports, trex_stats.COMPACT)
+        stats = self.stateless_client._get_formatted_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)
@@ -71,8 +72,7 @@ class TrexTUIDashBoard(TrexTUIPanel):
 
         allowed['c'] = self.key_actions['c']
 
-        # thats it for read only
-        if self.stateless_client.is_read_only():
+        if self.stateless_client.is_all_ports_acquired():
             return allowed
 
         if len(self.stateless_client.get_transmitting_ports()) > 0:
@@ -89,64 +89,44 @@ class TrexTUIDashBoard(TrexTUIPanel):
 
     ######### actions
     def action_pause (self):
-        rc = self.stateless_client.pause_traffic(self.mng.ports)
+        try:
+            rc = self.stateless_client.pause(ports = self.mng.ports)
+        except STLError:
+            pass
 
-        ports_succeeded = []
-        for rc_single, port_id in zip(rc.rc_list, self.mng.ports):
-            if rc_single.rc:
-                ports_succeeded.append(port_id)
+        return ""
 
-        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)
+        try:
+            self.stateless_client.resume(ports = self.mng.ports)
+        except STLError:
+            pass
 
-        if len(ports_succeeded) > 0:
-            return "resumed traffic on port(s): {0}".format(ports_succeeded)
-        else:
-            return ""
+        return ""
 
 
     def action_raise (self):
-        mul = {'type': 'percentage', 'value': 5, 'op': 'add'}
-        rc = self.stateless_client.update_traffic(mul, self.mng.ports)
+        try:
+            self.stateless_client.update(mult = "5%+", ports = self.mng.ports)
+        except STLError:
+            pass
 
-        ports_succeeded = []
-        for rc_single, port_id in zip(rc.rc_list, self.mng.ports):
-            if rc_single.rc:
-                ports_succeeded.append(port_id)
+        return ""
 
-        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)
+        try:
+            self.stateless_client.update(mult = "5%-", ports = self.mng.ports)
+        except STLError:
+            pass
 
-        if len(ports_succeeded) > 0:
-            return "lowered B/W by %5 on port(s): {0}".format(ports_succeeded)
-        else:
-            return ""
+        return ""
 
 
     def action_clear (self):
-        self.stateless_client.cmd_clear(self.mng.ports)
+        self.stateless_client.clear_stats(self.mng.ports)
         return "cleared all stats"
 
 
@@ -168,7 +148,7 @@ class TrexTUIPort(TrexTUIPanel):
 
 
     def show (self):
-        stats = self.stateless_client.cmd_stats([self.port_id], trex_stats.COMPACT)
+        stats = self.stateless_client._get_formatted_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)
@@ -179,8 +159,7 @@ class TrexTUIPort(TrexTUIPanel):
 
         allowed['c'] = self.key_actions['c']
 
-        # thats it for read only
-        if self.stateless_client.is_read_only():
+        if self.stateless_client.is_all_ports_acquired():
             return allowed
 
         if self.port.state == self.port.STATE_TX:
@@ -196,39 +175,44 @@ class TrexTUIPort(TrexTUIPanel):
 
     # 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 ""
+        try:
+            self.stateless_client.pause(ports = [self.port_id])
+        except STLError:
+            pass
+
+        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 ""
+        try:
+            self.stateless_client.resume(ports = [self.port_id])
+        except STLError:
+            pass
+
+        return ""
+
 
     def action_raise (self):
-        mul = {'type': 'percentage', 'value': 5, 'op': 'add'}
-        rc = self.stateless_client.update_traffic(mul, [self.port_id])
+        mult = {'type': 'percentage', 'value': 5, 'op': 'add'}
 
-        if rc.good():
-            return "port {0}: raised B/W by 5%".format(self.port_id)
-        else:
-            return ""
+        try:
+            self.stateless_client.update(mult = mult, ports = [self.port_id])
+        except STLError:
+            pass
+
+        return ""
 
     def action_lower (self):
-        mul = {'type': 'percentage', 'value': 5, 'op': 'sub'}
-        rc = self.stateless_client.update_traffic(mul, [self.port_id])
+        mult = {'type': 'percentage', 'value': 5, 'op': 'sub'}
 
-        if rc.good():
-            return "port {0}: lowered B/W by 5%".format(self.port_id)
-        else:
-            return ""
+        try:
+            self.stateless_client.update(mult = mult, ports = [self.port_id])
+        except STLError:
+            pass
+
+        return ""
 
     def action_clear (self):
-        self.stateless_client.cmd_clear([self.port_id])
+        self.stateless_client.clear_stats([self.port_id])
         return "port {0}: cleared stats".format(self.port_id)
 
 # log
@@ -425,7 +409,7 @@ class TrexTUI():
                 if self.state == self.STATE_ACTIVE:
                     # if no connectivity - move to lost connecitivty
                     if not self.stateless_client.async_client.is_alive():
-                        self.stateless_client.cmd_invalidate(self.pm.ports)
+                        self.stateless_client._invalidate_stats(self.pm.ports)
                         self.state = self.STATE_LOST_CONT
 
 
@@ -440,11 +424,10 @@ class TrexTUI():
                 # restored connectivity - try to reconnect
                 elif self.state == self.STATE_RECONNECT:
 
-                    rc = self.stateless_client.connect("RO")
-                    if rc.good():
+                    try:
+                        self.stateless_client.connect("RO")
                         self.state = self.STATE_ACTIVE
-                    else:
-                        # maybe we lost it again
+                    except STLError:
                         self.state = self.STATE_LOST_CONT