Merge trex-204

12 files changed, 848 insertions, 253 deletions

diff --git a/scripts/automation/trex_control_plane/doc_stl/api/client_code.rst b/scripts/automation/trex_control_plane/doc_stl/api/client_code.rst
index 4ae2b9fd..d3e48dab 100755
--- a/scripts/automation/trex_control_plane/doc_stl/api/client_code.rst
+++ b/scripts/automation/trex_control_plane/doc_stl/api/client_code.rst
@@ -82,6 +82,11 @@ STLClient snippet
         # block until done
         c.wait_on_traffic(ports = [0, 1])
 
+        # check for any warnings
+	if c.get_warnings():
+	    # handle warnings here
+	    pass
+
     finally:
         c.disconnect()
 
diff --git a/scripts/automation/trex_control_plane/server/trex_server.py b/scripts/automation/trex_control_plane/server/trex_server.py
index 3f8bc374..e32fc9d1 100755
--- a/scripts/automation/trex_control_plane/server/trex_server.py
+++ b/scripts/automation/trex_control_plane/server/trex_server.py
@@ -84,10 +84,10 @@ class CTRexServer(object):
     def push_file (self, filename, bin_data):
         logger.info("Processing push_file() command.")
         try:
-            filepath = os.path.abspath(os.path.join(self.trex_files_path, filename))
+            filepath = os.path.join(self.trex_files_path, os.path.basename(filename))
             with open(filepath, 'wb') as f:
                 f.write(binascii.a2b_base64(bin_data))
-            logger.info("push_file() command finished. `{name}` was saved at {fpath}".format( name = filename, fpath = self.trex_files_path))
+            logger.info("push_file() command finished. File is saved as %s" % filepath)
             return True
         except IOError as inst:
             logger.error("push_file method failed. " + str(inst))
@@ -125,28 +125,32 @@ class CTRexServer(object):
         # set further functionality and peripherals to server instance 
         try:
             self.server.register_function(self.add)
-            self.server.register_function(self.get_trex_log)
-            self.server.register_function(self.get_trex_daemon_log)
-            self.server.register_function(self.get_trex_version)
+            self.server.register_function(self.cancel_reservation)
             self.server.register_function(self.connectivity_check)
-            self.server.register_function(self.start_trex)
-            self.server.register_function(self.stop_trex)
-            self.server.register_function(self.wait_until_kickoff_finish)
-            self.server.register_function(self.get_running_status)
-            self.server.register_function(self.is_running)
+            self.server.register_function(self.force_trex_kill)
+            self.server.register_function(self.get_file)
+            self.server.register_function(self.get_files_list)
+            self.server.register_function(self.get_files_path)
             self.server.register_function(self.get_running_info)
+            self.server.register_function(self.get_running_status)
+            self.server.register_function(self.get_trex_daemon_log)
+            self.server.register_function(self.get_trex_log)
+            self.server.register_function(self.get_trex_version)
             self.server.register_function(self.is_reserved)
-            self.server.register_function(self.get_files_path)
+            self.server.register_function(self.is_running)
             self.server.register_function(self.push_file)
             self.server.register_function(self.reserve_trex)
-            self.server.register_function(self.cancel_reservation)
-            self.server.register_function(self.force_trex_kill)
+            self.server.register_function(self.start_trex)
+            self.server.register_function(self.stop_trex)
+            self.server.register_function(self.wait_until_kickoff_finish)
             signal.signal(signal.SIGTSTP, self.stop_handler)
             signal.signal(signal.SIGTERM, self.stop_handler)
             self.zmq_monitor.start()
             self.server.serve_forever()
         except KeyboardInterrupt:
             logger.info("Daemon shutdown request detected." )
+        except Exception as e:
+            logger.error(e)
         finally:
             self.zmq_monitor.join()            # close ZMQ monitor thread resources
             self.server.shutdown()
@@ -160,8 +164,40 @@ class CTRexServer(object):
                 file_content = f.read()
                 return binascii.b2a_base64(file_content)
         except Exception as e:
-            err_str = "Can't get requested file: {0}, possibly due to TRex that did not run".format(filepath)
-            logger.error('{0}, error: {1}'.format(err_str, e))
+            err_str = "Can't get requested file %s: %s" % (filepath, e)
+            logger.error(err_str)
+            return Fault(-33, err_str)
+
+    # returns True if given path is under TRex package or under /tmp/trex_files
+    def _check_path_under_TRex_or_temp(self, path):
+        if not os.path.relpath(path, self.trex_files_path).startswith(os.pardir):
+            return True
+        if not os.path.relpath(path, self.TREX_PATH).startswith(os.pardir):
+            return True
+        return False
+
+    # gets the file content encoded base64 either from /tmp/trex_files or TRex server dir
+    def get_file(self, filepath):
+        try:
+            logger.info("Processing get_file() command.")
+            if not self._check_path_under_TRex_or_temp(filepath):
+                raise Exception('Given path should be under current TRex package or /tmp/trex_files')
+            return self._pull_file(filepath)
+        except Exception as e:
+            err_str = "Can't get requested file %s: %s" % (filepath, e)
+            logger.error(err_str)
+            return Fault(-33, err_str)
+
+    # get tuple (dirs, files) with directories and files lists from given path (limited under TRex package or /tmp/trex_files)
+    def get_files_list(self, path):
+        try:
+            logger.info("Processing get_files_list() command, given path: %s" % path)
+            if not self._check_path_under_TRex_or_temp(path):
+                raise Exception('Given path should be under current TRex package or /tmp/trex_files')
+            return os.walk(path).next()[1:3]
+        except Exception as e:
+            err_str = "Error processing get_files_list(): %s" % e
+            logger.error(err_str)
             return Fault(-33, err_str)
 
     # get Trex log /tmp/trex.txt
diff --git a/scripts/automation/trex_control_plane/stf/trex_stf_lib/trex_client.py b/scripts/automation/trex_control_plane/stf/trex_stf_lib/trex_client.py
index 4fd1e4c7..fd409b16 100755
--- a/scripts/automation/trex_control_plane/stf/trex_stf_lib/trex_client.py
+++ b/scripts/automation/trex_control_plane/stf/trex_stf_lib/trex_client.py
@@ -725,7 +725,59 @@ class CTRexClient(object):
             raise
         finally:
             self.prompt_verbose_data()
-    
+
+    def get_files_list (self, path):
+        """
+        Gets a list of dirs and files either from /tmp/trex_files or path relative to TRex server.
+
+        :parameters:
+            path : str
+                a path to directory to read.
+
+        :return: 
+            Tuple: list of dirs and list of files in given path
+
+        :raises:
+            + :exc:`trex_exceptions.TRexRequestDenied`, in case TRex is reserved for another user than the one trying to cancel the reservation.
+            + ProtocolError, in case of error in JSON-RPC protocol.
+
+        """
+        
+        try:
+            return self.server.get_files_list(path)
+        except AppError as err:
+            self._handle_AppError_exception(err.args[0])
+        except ProtocolError:
+            raise
+        finally:
+            self.prompt_verbose_data()
+
+    def get_file(self, filepath):
+        """
+        Gets content of file as bytes string from /tmp/trex_files or TRex server directory.
+
+        :parameters:
+            filepath : str
+                a path to a file at server.
+                it can be either relative to TRex server or absolute path starting with /tmp/trex_files
+
+        :return: 
+            Content of the file
+
+        :raises:
+            + :exc:`trex_exceptions.TRexRequestDenied`, in case TRex is reserved for another user than the one trying to cancel the reservation.
+            + ProtocolError, in case of error in JSON-RPC protocol.
+        """
+
+        try:
+            return binascii.a2b_base64(self.server.get_file(filepath))
+        except AppError as err:
+            self._handle_AppError_exception(err.args[0])
+        except ProtocolError:
+            raise
+        finally:
+            self.prompt_verbose_data()
+
     def push_files (self, filepaths):
         """
         Pushes a file (or a list of files) to store locally on server. 
@@ -761,7 +813,7 @@ class CTRexClient(object):
                     filename = os.path.basename(filepath)
                     with open(filepath, 'rb') as f:
                         file_content = f.read()
-                        self.server.push_file(filename, binascii.b2a_base64(file_content))
+                        self.server.push_file(filename, binascii.b2a_base64(file_content).decode())
             finally:
                 self.prompt_verbose_data()
         return True
@@ -1042,7 +1094,7 @@ class CTRexResult(object):
         if not self.is_valid_hist():
             return None
         else:
-            return CTRexResult.__get_value_by_path(self._history[len(self._history)-1], tree_path_to_key, regex)
+            return CTRexResult.__get_value_by_path(self._history[-1], tree_path_to_key, regex)
 
     def get_value_list (self, tree_path_to_key, regex = None, filter_none = True):
         """
@@ -1093,11 +1145,23 @@ class CTRexResult(object):
             + an empty dictionary if history is empty.
 
         """
-        history_size = len(self._history)
-        if history_size != 0:
-            return self._history[len(self._history) - 1]
-        else:
-            return {}
+        if len(self._history):
+            return self._history[-1]
+        return {}
+
+    def get_ports_count(self):
+        """
+        Returns number of ports based on TRex result
+
+        :return: 
+            + number of ports in TRex result
+            + -1 if history is empty.
+        """
+
+        if not len(self._history):
+            return -1
+        return len(self.__get_value_by_path(self._history[-1], 'trex-global.data', 'opackets-\d+'))
+
 
     def update_result_data (self, latest_dump):
         """
@@ -1225,26 +1289,25 @@ class CTRexResult(object):
     def __get_filtered_max_latency (src_dict, filtered_latency_amount = 0.001):
         result = {}
         for port, data in src_dict.items():
-            if port.startswith('port-'):
-                max_port = 'max-%s' % port[5:]
-                res = data['hist']
-                if not len(res['histogram']):
-                    result[max_port] = 0
-                    continue
-                hist_last_keys = deque([res['histogram'][-1]['key']], maxlen = 2)
-                sum_high = 0.0
-                for elem in reversed(res['histogram']):
-                    sum_high += elem['val']
-                    hist_last_keys.append(elem['key'])
-                    if sum_high / res['cnt'] >= filtered_latency_amount:
-                        break
-                result[max_port] = (hist_last_keys[0] + hist_last_keys[-1]) / 2
-            else:
-                return {}
+            if not port.startswith('port-'):
+                continue
+            max_port = 'max-%s' % port[5:]
+            res = data['hist']
+            if not len(res['histogram']):
+                result[max_port] = 0
+                continue
+            result[max_port] = 5 # if sum below will not get to filtered amount, use this value
+            sum_high = 0.0
+            for elem in reversed(res['histogram']):
+                sum_high += elem['val']
+                if sum_high >= filtered_latency_amount * res['cnt']:
+                    result[max_port] = elem['key'] + int('5' + repr(elem['key'])[2:])
+                    break
         return result
 
 
 
+
 if __name__ == "__main__":
     pass
 
diff --git a/scripts/automation/trex_control_plane/stl/console/trex_console.py b/scripts/automation/trex_control_plane/stl/console/trex_console.py
index 2b53b7ec..f8161dcb 100755
--- a/scripts/automation/trex_control_plane/stl/console/trex_console.py
+++ b/scripts/automation/trex_control_plane/stl/console/trex_console.py
@@ -289,7 +289,7 @@ class TRexConsole(TRexGeneralCmd):
     @verify_connected
     def do_ping (self, line):
         '''Ping the server\n'''
-        self.stateless_client.ping()
+        self.stateless_client.ping_line(line)
 
 
     # set verbose on / off
@@ -421,6 +421,9 @@ class TRexConsole(TRexGeneralCmd):
         '''Release ports\n'''
         self.stateless_client.release_line(line)
 
+    def do_reacquire (self, line):
+        '''reacquire all the ports under your logged user name'''
+        self.stateless_client.reacquire_line(line)
 
     def help_acquire (self):
         self.do_acquire("-h")
@@ -428,6 +431,9 @@ class TRexConsole(TRexGeneralCmd):
     def help_release (self):
         self.do_release("-h")
 
+    def help_reacquire (self):
+        self.do_reacquire("-h")
+
     ############### start
 
     def complete_start(self, text, line, begidx, endidx):
@@ -571,7 +577,7 @@ class TRexConsole(TRexGeneralCmd):
             info = self.stateless_client.get_connection_info()
 
             exe = './trex-console --top -t -q -s {0} -p {1} --async_port {2}'.format(info['server'], info['sync_port'], info['async_port'])
-            cmd = ['/usr/bin/xterm', '-geometry', '111x48', '-sl', '0', '-title', 'trex_tui', '-e', exe]
+            cmd = ['/usr/bin/xterm', '-geometry', '111x49', '-sl', '0', '-title', 'trex_tui', '-e', exe]
 
             # detach child
             self.terminal = subprocess.Popen(cmd, preexec_fn = os.setpgrp)
@@ -774,7 +780,29 @@ def setParserOptions():
 
     return parser
 
-    
+# a simple info printed on log on
+def show_intro (logger, c):
+    x   = c.get_server_system_info()
+    ver = c.get_server_version().get('version', 'N/A')
+
+    # find out which NICs the server has
+    port_types = {}
+    for port in x['ports']:
+        key = (port['speed'], port['driver'])
+        if not key in port_types:
+            port_types[key] = 0
+        port_types[key] += 1
+
+    port_line = ''
+    for k, v in port_types.items():
+        port_line += "{0} x {1}Gbps @ {2}".format(v, k[0], k[1])
+
+    logger.log(format_text("\nServer Info:\n", 'underline'))
+    logger.log("Server version:   {:>}".format(format_text(ver, 'bold')))
+    logger.log("Server CPU:       {:>}".format(format_text("{:>} x {:>}".format(x.get('dp_core_count'), x.get('core_type')), 'bold')))
+    logger.log("Ports count:      {:>}".format(format_text(port_line, 'bold')))
+
+
 def main():
     parser = setParserOptions()
     options = parser.parse_args()
@@ -824,6 +852,9 @@ def main():
     if options.readonly:
         logger.log(format_text("\nRead only mode - only few commands will be available", 'bold'))
 
+    show_intro(logger, stateless_client)
+    
+
     # a script mode
     if options.batch:
         cont = run_script_file(options.batch[0], stateless_client)
diff --git a/scripts/automation/trex_control_plane/stl/console/trex_tui.py b/scripts/automation/trex_control_plane/stl/console/trex_tui.py
index effcf55e..0c3ea8d6 100644
--- a/scripts/automation/trex_control_plane/stl/console/trex_tui.py
+++ b/scripts/automation/trex_control_plane/stl/console/trex_tui.py
@@ -13,6 +13,7 @@ else:
 from trex_stl_lib.utils.text_opts import *
 from trex_stl_lib.utils import text_tables
 from trex_stl_lib import trex_stl_stats
+from trex_stl_lib.utils.filters import ToggleFilter
 
 # for STL exceptions
 from trex_stl_lib.api import *
@@ -62,31 +63,37 @@ class TrexTUIDashBoard(TrexTUIPanel):
     def __init__ (self, mng):
         super(TrexTUIDashBoard, self).__init__(mng, "dashboard")
 
+        self.ports = self.stateless_client.get_all_ports()
+
         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.key_actions['p'] = {'action': self.action_pause,  'legend': 'pause', 'show': True, 'color': 'red'}
+        self.key_actions['r'] = {'action': self.action_resume, 'legend': 'resume', 'show': True, 'color': 'blue'}
 
         self.key_actions['o'] = {'action': self.action_show_owned,  'legend': 'owned ports', 'show': True}
+        self.key_actions['n'] = {'action': self.action_reset_view,  'legend': 'reset view', 'show': True}
         self.key_actions['a'] = {'action': self.action_show_all,  'legend': 'all ports', 'show': True}
 
-        self.ports_filter = self.FILTER_ALL
+        # register all the ports to the toggle action
+        for port_id in self.ports:
+            self.key_actions[str(port_id)] = {'action': self.action_toggle_port(port_id), 'legend': 'port {0}'.format(port_id), 'show': False}
+
+
+        self.toggle_filter = ToggleFilter(self.ports)
 
+        if self.stateless_client.get_acquired_ports():
+            self.action_show_owned()
+        else:
+            self.action_show_all()
 
-    def get_ports (self):
-        if self.ports_filter == self.FILTER_ACQUIRED:
-            return self.stateless_client.get_acquired_ports()
 
-        elif self.ports_filter == self.FILTER_ALL:
-            return self.stateless_client.get_all_ports()
+    def get_showed_ports (self):
+        return self.toggle_filter.filter_items()
 
-        assert(0)
 
     def show (self):
-        stats = self.stateless_client._get_formatted_stats(self.get_ports())
+        stats = self.stateless_client._get_formatted_stats(self.get_showed_ports())
         # print stats to screen
         for stat_type, stat_data in stats.items():
             text_tables.print_table_with_header(stat_data.text_table, stat_type)
@@ -95,29 +102,37 @@ class TrexTUIDashBoard(TrexTUIPanel):
     def get_key_actions (self):
         allowed = OrderedDict()
 
-        allowed['c'] = self.key_actions['c']
+
+        allowed['n'] = self.key_actions['n']
         allowed['o'] = self.key_actions['o']
         allowed['a'] = self.key_actions['a']
+        for i in self.ports:
+            allowed[str(i)] = self.key_actions[str(i)]
 
-        if self.ports_filter == self.FILTER_ALL:
-            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 self.get_showed_ports():
+            allowed['c'] = self.key_actions['c']
 
+        # if not all ports are acquired - no operations
+        if not (set(self.get_showed_ports()) <= set(self.stateless_client.get_acquired_ports())):
+            return allowed
 
-        if len(self.stateless_client.get_paused_ports()) > 0:
+        # if any/some ports can be resumed
+        if set(self.get_showed_ports()) & set(self.stateless_client.get_paused_ports()):
             allowed['r'] = self.key_actions['r']
 
+        # if any/some ports are transmitting - support those actions
+        if set(self.get_showed_ports()) & set(self.stateless_client.get_transmitting_ports()):
+            allowed['p'] = self.key_actions['p']
+
+
         return allowed
 
 
     ######### actions
     def action_pause (self):
         try:
-            rc = self.stateless_client.pause(ports = self.mng.ports)
+            rc = self.stateless_client.pause(ports = self.get_showed_ports())
         except STLError:
             pass
 
@@ -127,142 +142,38 @@ class TrexTUIDashBoard(TrexTUIPanel):
 
     def action_resume (self):
         try:
-            self.stateless_client.resume(ports = self.mng.ports)
-        except STLError:
-            pass
-
-        return ""
-
-
-    def action_raise (self):
-        try:
-            self.stateless_client.update(mult = "5%+", ports = self.mng.ports)
+            self.stateless_client.resume(ports = self.get_showed_ports())
         except STLError:
             pass
 
         return ""
 
 
-    def action_lower (self):
-        try:
-            self.stateless_client.update(mult = "5%-", ports = self.mng.ports)
-        except STLError:
-            pass
-
+    def action_reset_view (self):
+        self.toggle_filter.reset()
         return ""
 
-
     def action_show_owned (self):
-        self.ports_filter = self.FILTER_ACQUIRED
+        self.toggle_filter.reset()
+        self.toggle_filter.toggle_items(*self.stateless_client.get_acquired_ports())
         return ""
 
     def action_show_all (self):
-        self.ports_filter = self.FILTER_ALL
+        self.toggle_filter.reset()
+        self.toggle_filter.toggle_items(*self.stateless_client.get_all_ports())
         return ""
 
     def action_clear (self):
-        self.stateless_client.clear_stats(self.mng.ports)
+        self.stateless_client.clear_stats(self.toggle_filter.filter_items())
         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}
-        self.key_actions['t'] = {'action': self.action_toggle_graph, 'legend': 'toggle graph', 'show': True}
-
-
-    def show (self):
-        if self.mng.tui.is_graph is False:
-            stats = self.stateless_client._get_formatted_stats([self.port_id])
-            # print stats to screen
-            for stat_type, stat_data in stats.items():
-                text_tables.print_table_with_header(stat_data.text_table, stat_type)
-        else:
-            stats = self.stateless_client._get_formatted_stats([self.port_id], stats_mask = trex_stl_stats.GRAPH_PORT_COMPACT)
-            for stat_type, stat_data in stats.items():
-                text_tables.print_table_with_header(stat_data.text_table, stat_type)
-
-    def get_key_actions (self):
-
-        allowed = OrderedDict()
-
-        allowed['c'] = self.key_actions['c']
-        allowed['t'] = self.key_actions['t']
-
-        if self.stateless_client.is_all_ports_acquired():
-            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
-
-    def action_toggle_graph(self):
-        try:
-            self.mng.tui.is_graph = not self.mng.tui.is_graph
-        except Exception:
-            pass
-
-        return ""
-
-    def action_pause (self):
-        try:
-            self.stateless_client.pause(ports = [self.port_id])
-        except STLError:
-            pass
-
-        return ""
-
-    def action_resume (self):
-        try:
-            self.stateless_client.resume(ports = [self.port_id])
-        except STLError:
-            pass
-
-        return ""
-
-
-    def action_raise (self):
-        mult = {'type': 'percentage', 'value': 5, 'op': 'add'}
-
-        try:
-            self.stateless_client.update(mult = mult, ports = [self.port_id])
-        except STLError:
-            pass
-
-        return ""
-
-    def action_lower (self):
-        mult = {'type': 'percentage', 'value': 5, 'op': 'sub'}
-
-        try:
-            self.stateless_client.update(mult = mult, ports = [self.port_id])
-        except STLError:
-            pass
+    def action_toggle_port(self, port_id):
+        def action_toggle_port_x():
+            self.toggle_filter.toggle_item(port_id)
+            return ""
 
-        return ""
-
-    def action_clear (self):
-        self.stateless_client.clear_stats([self.port_id])
-        return "port {0}: cleared stats".format(self.port_id)
+        return action_toggle_port_x
 
 
 
@@ -330,10 +241,6 @@ class TrexTUIPanelManager():
         self.key_actions['g'] = {'action': self.action_show_dash, 'legend': 'dashboard', 'show': True}
         self.key_actions['s'] = {'action': self.action_show_sstats, 'legend': 'streams stats', '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']
 
@@ -346,23 +253,31 @@ class TrexTUIPanelManager():
         self.dis_bar =  SimpleBar('status: ', ['X', ' '])
         self.show_log = False
 
+        
 
     def generate_legend (self):
+
         self.legend = "\n{:<12}".format("browse:")
 
         for k, v in self.key_actions.items():
             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)
+                if v.get('color'):
+                    self.legend += "{:}".format(format_text(x, v.get('color')))
+                else:
+                    self.legend += "{:}".format(x)
 
 
         self.legend += "\n{:<12}".format(self.main_panel.get_name() + ":")
+
         for k, v in self.main_panel.get_key_actions().items():
             if v['show']:
                 x = "'{0}' - {1}, ".format(k, v['legend'])
-                self.legend += "{:}".format(x)
+
+                if v.get('color'):
+                    self.legend += "{:}".format(format_text(x, v.get('color')))
+                else:
+                    self.legend += "{:}".format(x)
 
 
     def print_connection_status (self):
@@ -430,6 +345,7 @@ class TrexTUIPanelManager():
         return action_show_port_x
 
 
+
     def action_show_sstats (self):
         self.main_panel = self.panels['sstats']
         self.init(self.show_log)
@@ -535,7 +451,9 @@ class TrexTUI():
             sys.stdout = old_stdout
 
             self.clear_screen()
+
             print(mystdout.getvalue())
+
             sys.stdout.flush()
 
             self.draw_policer = 0
diff --git a/scripts/automation/trex_control_plane/stl/trex_stl_lib/trex_stl_client.py b/scripts/automation/trex_control_plane/stl/trex_stl_lib/trex_stl_client.py
index aa95f037..862a9979 100755
--- a/scripts/automation/trex_control_plane/stl/trex_stl_lib/trex_stl_client.py
+++ b/scripts/automation/trex_control_plane/stl/trex_stl_lib/trex_stl_client.py
@@ -264,22 +264,55 @@ class EventsHandler(object):
             self.__async_event_port_job_done(port_id)
             show_event = True
 
-        # port was stolen...
+        # port was acquired - maybe stolen...
         elif (type == 5):
             session_id = data['session_id']
 
-            # false alarm, its us
+            port_id = int(data['port_id'])
+            who     = data['who']
+            force   = data['force']
+
+            # if we hold the port and it was not taken by this session - show it
+            if port_id in self.client.get_acquired_ports() and session_id != self.client.session_id:
+                show_event = True
+
+            # format the thief/us...
             if session_id == self.client.session_id:
-                return
+                user = 'you'
+            elif who == self.client.username:
+                user = 'another session of you'
+            else:
+                user = "'{0}'".format(who)
 
-            port_id = int(data['port_id'])
-            who = data['who']
+            if force:
+                ev = "Port {0} was forcely taken by {1}".format(port_id, user)
+            else:
+                ev = "Port {0} was taken by {1}".format(port_id, user)
 
-            ev = "Port {0} was forcely taken by '{1}'".format(port_id, who)
+            # call the handler in case its not this session
+            if session_id != self.client.session_id:
+                self.__async_event_port_acquired(port_id, who)
+
+
+        # port was released
+        elif (type == 6):
+            port_id     = int(data['port_id'])
+            who         = data['who']
+            session_id  = data['session_id']
+
+            if session_id == self.client.session_id:
+                user = 'you'
+            elif who == self.client.username:
+                user = 'another session of you'
+            else:
+                user = "'{0}'".format(who)
+
+            ev = "Port {0} was released by {1}".format(port_id, user)
+
+            # call the handler in case its not this session
+            if session_id != self.client.session_id:
+                self.__async_event_port_released(port_id)
 
-            # call the handler
-            self.__async_event_port_forced_acquired(port_id, who)
-            show_event = True
 
         # server stopped
         elif (type == 100):
@@ -317,9 +350,11 @@ class EventsHandler(object):
         self.client.ports[port_id].async_event_port_resumed()
 
 
-    def __async_event_port_forced_acquired (self, port_id, who):
-        self.client.ports[port_id].async_event_forced_acquired(who)
+    def __async_event_port_acquired (self, port_id, who):
+        self.client.ports[port_id].async_event_acquired(who)
 
+    def __async_event_port_released (self, port_id):
+        self.client.ports[port_id].async_event_released()
 
     def __async_event_server_stopped (self):
         self.client.connected = False
@@ -462,6 +497,11 @@ class STLClient(object):
         self.session_id = random.getrandbits(32)
         self.connected = False
 
+        # API classes
+        self.api_vers = [ {'type': 'core', 'major': 1, 'minor':2 }
+                        ]
+        self.api_h = {'core': None}
+
         # logger
         self.logger = DefaultLogger() if not logger else logger
 
@@ -505,10 +545,7 @@ class STLClient(object):
                                                                  self.flow_stats)
 
 
-        # API classes
-        self.api_vers = [ {'type': 'core', 'major': 1, 'minor':1 }
-                        ]
-        self.api_h = {'core': None}
+       
 
     ############# private functions - used by the class itself ###########
 
@@ -545,13 +582,13 @@ class STLClient(object):
         return rc
 
     # acquire ports, if port_list is none - get all
-    def __acquire (self, port_id_list = None, force = False):
+    def __acquire (self, port_id_list = None, force = False, sync_streams = True):
         port_id_list = self.__ports(port_id_list)
 
         rc = RC()
 
         for port_id in port_id_list:
-            rc.add(self.ports[port_id].acquire(force))
+            rc.add(self.ports[port_id].acquire(force, sync_streams))
 
         return rc
 
@@ -1335,16 +1372,20 @@ class STLClient(object):
 
 
     @__api_check(True)
-    def acquire (self, ports = None, force = False):
+    def acquire (self, ports = None, force = False, sync_streams = True):
         """
             Acquires ports for executing commands
 
             :parameters:
                 ports : list
                     Ports on which to execute the command
+
                 force : bool
                     Force acquire the ports.
 
+                sync_streams: bool
+                    sync with the server about the configured streams
+
             :raises:
                 + :exc:`STLError`
 
@@ -1359,7 +1400,7 @@ class STLClient(object):
         else:
             self.logger.pre_cmd("Acquiring ports {0}:".format(ports))
 
-        rc = self.__acquire(ports, force)
+        rc = self.__acquire(ports, force, sync_streams)
 
         self.logger.post_cmd(rc)
 
@@ -1459,7 +1500,8 @@ class STLClient(object):
         ports = ports if ports is not None else self.get_all_ports()
         ports = self._validate_port_list(ports)
 
-        self.acquire(ports, force = True)
+        # force take the port and ignore any streams on it
+        self.acquire(ports, force = True, sync_streams = False)
         self.stop(ports, rx_delay_ms = 0)
         self.remove_all_streams(ports)
         self.clear_stats(ports)
@@ -2038,6 +2080,11 @@ class STLClient(object):
 
         return wrap
 
+    @__console
+    def ping_line (self, line):
+        '''pings the server'''
+        self.ping()
+        return True
 
     @__console
     def connect_line (self, line):
@@ -2117,6 +2164,28 @@ class STLClient(object):
 
 
     @__console
+    def reacquire_line (self, line):
+        '''reacquire all the ports under your username which are not acquired by your session'''
+
+        parser = parsing_opts.gen_parser(self,
+                                         "reacquire",
+                                         self.reacquire_line.__doc__)
+
+        opts = parser.parse_args(line.split())
+        if opts is None:
+            return
+
+        # find all the on-owned ports under your name
+        my_unowned_ports = list_difference([k for k, v in self.ports.items() if v.get_owner() == self.username], self.get_acquired_ports())
+        if not my_unowned_ports:
+            self.logger.log("reacquire - no unowned ports under '{0}'".format(self.username))
+            return
+
+        self.acquire(ports = my_unowned_ports, force = True)
+        return True
+
+
+    @__console
     def disconnect_line (self, line):
         self.disconnect()
         
@@ -2491,15 +2560,20 @@ class STLClient(object):
         '''Sets port attributes '''
 
         parser = parsing_opts.gen_parser(self,
-                                         "port",
+                                         "port_attr",
                                          self.set_port_attr_line.__doc__,
                                          parsing_opts.PORT_LIST_WITH_ALL,
                                          parsing_opts.PROMISCUOUS_SWITCH)
 
-        opts = parser.parse_args(line.split())
+        opts = parser.parse_args(line.split(), default_ports = self.get_acquired_ports(), verify_acquired = True)
         if opts is None:
             return
 
+        # if no attributes - fall back to printing the status
+        if opts.prom is None:
+            self.show_stats_line("--ps --port {0}".format(' '.join(str(port) for port in opts.ports)))
+            return
+
         self.set_port_attr(opts.ports, opts.prom)
 
     
@@ -2592,5 +2666,4 @@ class STLClient(object):
 
         if opts.clear:
             self.clear_events()
-            self.logger.log(format_text("\nEvent log was cleared\n"))
-
+         
\ No newline at end of file
diff --git a/scripts/automation/trex_control_plane/stl/trex_stl_lib/trex_stl_jsonrpc_client.py b/scripts/automation/trex_control_plane/stl/trex_stl_lib/trex_stl_jsonrpc_client.py
index bd5ba8e7..fa04b9f6 100644
--- a/scripts/automation/trex_control_plane/stl/trex_stl_lib/trex_stl_jsonrpc_client.py
+++ b/scripts/automation/trex_control_plane/stl/trex_stl_lib/trex_stl_jsonrpc_client.py
@@ -47,7 +47,7 @@ class JsonRpcClient(object):
     MSG_COMPRESS_HEADER_MAGIC = 0xABE85CEA
 
     def __init__ (self, default_server, default_port, client):
-        self.client = client
+        self.client_api = client.api_h
         self.logger = client.logger
         self.connected = False
 
@@ -104,7 +104,7 @@ class JsonRpcClient(object):
 
         # if this RPC has an API class - add it's handler
         if api_class:
-            msg["params"]["api_h"] = self.client.api_h[api_class]
+            msg["params"]["api_h"] = self.client_api[api_class]
         
 
         if encode:
diff --git a/scripts/automation/trex_control_plane/stl/trex_stl_lib/trex_stl_port.py b/scripts/automation/trex_control_plane/stl/trex_stl_lib/trex_stl_port.py
index 6f6f50b1..e8f89b27 100644
--- a/scripts/automation/trex_control_plane/stl/trex_stl_lib/trex_stl_port.py
+++ b/scripts/automation/trex_control_plane/stl/trex_stl_lib/trex_stl_port.py
@@ -76,29 +76,55 @@ class Port(object):
     def get_speed_bps (self):
         return (self.info['speed'] * 1000 * 1000 * 1000)
 
+    def get_formatted_speed (self):
+        return "{0} Gbps".format(self.info['speed'])
+
     # take the port
-    def acquire(self, force = False):
+    def acquire(self, force = False, sync_streams = True):
         params = {"port_id":     self.port_id,
                   "user":        self.user,
                   "session_id":  self.session_id,
                   "force":       force}
 
         rc = self.transmit("acquire", params)
-        if rc.good():
-            self.handler = rc.data()
-            return self.ok()
+        if not rc:
+            return self.err(rc.err())
+
+        self.handler = rc.data()
+
+        if sync_streams:
+            return self.sync_streams()
         else:
+            return self.ok()
+
+      
+    # sync all the streams with the server
+    def sync_streams (self):
+        params = {"port_id": self.port_id}
+
+        rc = self.transmit("get_all_streams", params)
+        if rc.bad():
             return self.err(rc.err())
 
+        for k, v in rc.data()['streams'].items():
+            self.streams[k] = {'next_id': v['next_stream_id'],
+                               'pkt'    : base64.b64decode(v['packet']['binary']),
+                               'mode'   : v['mode']['type'],
+                               'rate'   : STLStream.get_rate_from_field(v['mode']['rate'])}
+        return self.ok()
+
     # release the port
     def release(self):
         params = {"port_id": self.port_id,
                   "handler": self.handler}
 
         rc = self.transmit("release", params)
-        self.handler = None
-
+        
         if rc.good():
+
+            self.handler = None
+            self.owner = ''
+
             return self.ok()
         else:
             return self.err(rc.err())
@@ -151,19 +177,7 @@ class Port(object):
         # attributes
         self.attr = rc.data()['attr']
 
-        # sync the streams
-        params = {"port_id": self.port_id}
-
-        rc = self.transmit("get_all_streams", params)
-        if rc.bad():
-            return self.err(rc.err())
-
-        for k, v in rc.data()['streams'].items():
-            self.streams[k] = {'next_id': v['next_stream_id'],
-                               'pkt'    : base64.b64decode(v['packet']['binary']),
-                               'mode'   : v['mode']['type'],
-                               'rate'   : STLStream.get_rate_from_field(v['mode']['rate'])}
-
+     
         return self.ok()
 
 
@@ -679,7 +693,10 @@ class Port(object):
         if not self.is_acquired():
             self.state = self.STATE_TX
 
-    def async_event_forced_acquired (self, who):
+    def async_event_acquired (self, who):
         self.handler = None
         self.owner = who
 
+    def async_event_released (self):
+        self.owner = ''
+
diff --git a/scripts/automation/trex_control_plane/stl/trex_stl_lib/trex_stl_stats.py b/scripts/automation/trex_control_plane/stl/trex_stl_lib/trex_stl_stats.py
index 6b1185ef..c7513144 100644
--- a/scripts/automation/trex_control_plane/stl/trex_stl_lib/trex_stl_stats.py
+++ b/scripts/automation/trex_control_plane/stl/trex_stl_lib/trex_stl_stats.py
@@ -201,6 +201,10 @@ class CTRexInfoGenerator(object):
     def _get_rational_block_char(value, range_start, interval):
         # in Konsole, utf-8 is sometimes printed with artifacts, return ascii for now
         #return 'X' if value >= range_start + float(interval) / 2 else ' '
+
+        if sys.__stdout__.encoding != 'UTF-8':
+            return 'X' if value >= range_start + float(interval) / 2 else ' '
+
         value -= range_start
         ratio = float(value) / interval
         if ratio <= 0.0625:
@@ -208,7 +212,7 @@ class CTRexInfoGenerator(object):
         if ratio <= 0.1875:
             return u'\u2581'    # 1/8
         if ratio <= 0.3125:
-            return u'\u2582'    # 2/4
+            return u'\u2582'    # 2/8
         if ratio <= 0.4375:
             return u'\u2583'    # 3/8
         if ratio <= 0.5625:
@@ -247,6 +251,7 @@ class CTRexInfoGenerator(object):
         return_stats_data = {}
         per_field_stats = OrderedDict([("owner", []),
                                        ("state", []),
+                                       ("speed", []),
                                        ("--", []),
                                        ("Tx bps L2", []),
                                        ("Tx bps L1", []),
@@ -532,7 +537,12 @@ class CTRexStats(object):
         v = self.get_trend(field, use_raw)
 
         value = abs(v)
-        arrow = u'\u25b2' if v > 0 else u'\u25bc'
+
+        # use arrows if utf-8 is supported
+        if sys.__stdout__.encoding == 'UTF-8':
+            arrow = u'\u25b2' if v > 0 else u'\u25bc'
+        else:
+            arrow = ''
 
         if sys.version_info < (3,0):
             arrow = arrow.encode('utf-8')
@@ -584,6 +594,7 @@ class CGlobalStats(CTRexStats):
         # absolute
         stats['cpu_util']    = self.get("m_cpu_util")
         stats['rx_cpu_util'] = self.get("m_rx_cpu_util")
+        stats['bw_per_core']    = self.get("m_bw_per_core")
 
         stats['tx_bps'] = self.get("m_tx_bps")
         stats['tx_pps'] = self.get("m_tx_pps")
@@ -688,12 +699,13 @@ class CPortStats(CTRexStats):
             else:
                 self.__merge_dicts(self.reference_stats, x.reference_stats)
 
-        # history
-        if not self.history:
-            self.history = copy.deepcopy(x.history)
-        else:
-            for h1, h2 in zip(self.history, x.history):
-                self.__merge_dicts(h1, h2)
+        # history - should be traverse with a lock
+        with self.lock, x.lock:
+            if not self.history:
+                self.history = copy.deepcopy(x.history)
+            else:
+                for h1, h2 in zip(self.history, x.history):
+                    self.__merge_dicts(h1, h2)
 
         return self
 
@@ -758,9 +770,17 @@ class CPortStats(CTRexStats):
         else:
             state = format_text(state, 'bold')
 
+        # mark owned ports by color
+        if self._port_obj:
+            owner = self._port_obj.get_owner()
+            if self._port_obj.is_acquired():
+                owner = format_text(owner, 'green')
+        else:
+            owner = ''
 
-        return {"owner": self._port_obj.get_owner() if self._port_obj else "",
+        return {"owner": owner,
                 "state": "{0}".format(state),
+                "speed": self._port_obj.get_formatted_speed() if self._port_obj else '',
 
                 "--": " ",
                 "---": " ",
diff --git a/scripts/automation/trex_control_plane/stl/trex_stl_lib/utils/GAObjClass.py b/scripts/automation/trex_control_plane/stl/trex_stl_lib/utils/GAObjClass.py
new file mode 100755
index 00000000..164aae7a
--- /dev/null
+++ b/scripts/automation/trex_control_plane/stl/trex_stl_lib/utils/GAObjClass.py
@@ -0,0 +1,295 @@
+#import requests # need external lib for that

+try: # Python2

+    import Queue

+    from urllib2 import *

+except: # Python3

+    import queue as Queue

+    from urllib.request import *

+    from urllib.error import *

+import threading

+import sys

+from time import sleep

+

+"""

+GAObjClass is a class destined to send Google Analytics Information.

+

+cid - unique number per user.

+command - the Event Category rubric appears on site. type: TEXT

+action - the Event Action rubric appears on site - type: TEXT

+label - the Event Label rubric - type: TEXT

+value - the event value metric - type: INTEGER

+

+QUOTAS:

+1 single payload - up to 8192Bytes

+batched:

+A maximum of 20 hits can be specified per request.

+The total size of all hit payloads cannot be greater than 16K bytes.

+No single hit payload can be greater than 8K bytes.

+"""

+

+url_single = 'http://www.google-analytics.com/collect' #sending single event

+url_batched = 'http://www.google-analytics.com/batch' #sending batched events

+url_debug = 'http://www.google-analytics.com/debug/collect' #verifying hit is valid

+url_conn = 'http://172.217.2.196' # testing internet connection to this address (google-analytics server)

+

+

+#..................................................................class GA_EVENT_ObjClass................................................................

+class GA_EVENT_ObjClass:

+    def __init__(self,cid,trackerID,command,action,label,value,appName,appVer):

+        self.cid = cid

+        self.trackerID = trackerID

+        self.command = command

+        self.action = action

+        self.label = label

+        self.value = value

+        self.appName = appName

+        self.appVer = appVer

+        self.generate_payload()

+        self.size = sys.getsizeof(self.payload)

+

+    def generate_payload(self):

+        self.payload ='v=1&t=event&tid='+str(self.trackerID)

+        self.payload+='&cid='+str(self.cid)

+        self.payload+='&ec='+str(self.command)

+        self.payload+='&ea='+str(self.action)

+        self.payload+='&el='+str(self.label)

+        self.payload+='&ev='+str(self.value)

+        self.payload+='&an='+str(self.appName)

+        self.payload+='&av='+str(self.appVer)

+

+#..................................................................class GA_EXCEPTION_ObjClass................................................................

+#ExceptionFatal - BOOLEAN

+class GA_EXCEPTION_ObjClass:

+    def __init__(self,cid,trackerID,ExceptionName,ExceptionFatal,appName,appVer):

+        self.cid = cid

+        self.trackerID = trackerID

+        self.ExceptionName = ExceptionName

+        self.ExceptionFatal = ExceptionFatal

+        self.appName = appName

+        self.appVer = appVer

+        self.generate_payload()

+

+    def generate_payload(self):

+        self.payload ='v=1&t=exception&tid='+str(self.trackerID)

+        self.payload+='&cid='+str(self.cid)

+        self.payload+='&exd='+str(self.ExceptionName)

+        self.payload+='&exf='+str(self.ExceptionFatal)

+        self.payload+='&an='+str(self.appName)

+        self.payload+='&av='+str(self.appVer)

+

+#.....................................................................class ga_Thread.................................................................

+"""

+

+Google analytics thread manager:

+

+will report and empty queue of google analytics items to GA server, every Timeout (parameter given on initialization)

+will perform connectivity check every timeout*10 seconds

+

+

+"""

+

+class ga_Thread (threading.Thread):

+    def __init__(self,threadID,gManager):

+        threading.Thread.__init__(self)

+        self.threadID = threadID

+        self.gManager = gManager

+

+    def run(self):

+        keepAliveCounter=0

+        #sys.stdout.write('thread started \n')

+        #sys.stdout.flush()

+        while True:

+            if (keepAliveCounter==10):

+                keepAliveCounter=0

+                if (self.gManager.internet_on()==True):

+                    self.gManager.connectedToInternet=1

+                else:

+                     self.gManager.connectedToInternet=0

+            sleep(self.gManager.Timeout)

+            keepAliveCounter+=1

+            if not self.gManager.GA_q.empty():

+                self.gManager.threadLock.acquire(1)

+#               sys.stdout.write('lock acquired: reporting to GA \n')

+#               sys.stdout.flush()

+                if (self.gManager.connectedToInternet==1):

+                    self.gManager.emptyAndReportQ()

+                self.gManager.threadLock.release()

+#               sys.stdout.write('finished \n')

+#               sys.stdout.flush()

+

+

+

+#.....................................................................class GAmanager.................................................................

+"""

+

+Google ID - specify tracker property, example: UA-75220362-2 (when the suffix '2' specifies the analytics property profile)

+

+UserID - unique userID, this will differ between users on GA

+

+appName - s string to determine app name

+

+appVer - a string to determine app version

+

+QueueSize - the size of the queue that holds reported items. once the Queue is full:

+            on blocking mode:

+                will block program until next submission to GA server, which will make new space

+            on non-blocking mode:

+                will drop new requests

+

+Timout - the timeout the queue uses between data transmissions. Timeout should be shorter than the time it takes to generate 20 events. MIN VALUE = 11 seconds

+

+User Permission - the user must accept data transmission, use this flag as 1/0 flag, when UserPermission=1 allows data collection

+ 

+BlockingMode - set to 1 if you wish every Google Analytic Object will be submitted and processed, with no drops allowed. 

+               this will block the running of the program until every item is processed

+

+*** Restriction - Google's restriction for amount of packages being sent per session per second is: 1 event per second, per session. session length is 30min ***

+"""

+class GAmanager:

+    def __init__(self,GoogleID,UserID,appName,appVer,QueueSize,Timeout,UserPermission,BlockingMode):

+        self.UserID = UserID

+        self.GoogleID = GoogleID

+        self.QueueSize = QueueSize

+        self.Timeout = Timeout

+        self.appName = appName

+        self.appVer = appVer

+        self.UserPermission = UserPermission

+        self.GA_q = Queue.Queue(QueueSize)

+        self.thread = ga_Thread(UserID,self)

+        self.threadLock = threading.Lock()

+        self.BlockingMode = BlockingMode

+        self.connectedToInternet =0

+        if (self.internet_on()==True):

+#           sys.stdout.write('internet connection active \n')

+#           sys.stdout.flush()

+            self.connectedToInternet=1

+        else:

+            self.connectedToInternet=0

+

+    def gaAddAction(self,Event,action,label,value):

+        self.gaAddObject(GA_EVENT_ObjClass(self.UserID,self.GoogleID,Event,action,label,value,self.appName,self.appVer))

+

+    def gaAddException(self,ExceptionName,ExceptionFatal):

+        self.gaAddObject(GA_EXCEPTION_ObjClass(self.UserID,self.GoogleID,ExceptionName,ExceptionFatal,self.appName,self.appVer))

+

+    def gaAddObject(self,Object):

+        if self.BlockingMode==1:

+            while self.GA_q.full():

+                sleep(self.Timeout)

+#               sys.stdout.write('blocking mode=1 \n queue full - sleeping for timeout \n') # within Timout, the thread will empty part of the queue

+#               sys.stdout.flush()

+        lockState = self.threadLock.acquire(self.BlockingMode)

+        if lockState==1:

+#           sys.stdout.write('got lock, adding item \n')

+#           sys.stdout.flush()

+            try:

+                self.GA_q.put_nowait(Object)

+#               sys.stdout.write('got lock, item added \n')

+#               sys.stdout.flush()

+            except Queue.Full:

+#               sys.stdout.write('Queue full \n')

+#               sys.stdout.flush()

+                pass

+            self.threadLock.release()

+

+    def emptyQueueToList(self,obj_list):

+        items=0

+        while ((not self.GA_q.empty()) and (items<20)):

+            obj_list.append(self.GA_q.get_nowait().payload)

+            items+=1

+#           print items

+

+    def reportBatched(self,batched):

+        req = Request(url_batched, data=batched.encode('ascii'))

+        urlopen(req)

+        #requests.post(url_batched,data=batched)

+        

+    def emptyAndReportQ(self):

+        obj_list = []

+        self.emptyQueueToList(obj_list)

+        if not len(obj_list):

+            return

+        batched = '\n'.join(obj_list)

+#       print batched # - for debug

+        self.reportBatched(batched)

+     

+    def printSelf(self):

+        print('remaining in queue:')

+        while not self.GA_q.empty():

+            obj = self.GA_q.get_nowait()

+            print(obj.payload)

+

+    def internet_on(self):

+        try:

+            urlopen(url_conn,timeout=10)

+            return True

+        except URLError as err: pass

+        return False

+

+    def activate(self):

+        if (self.UserPermission==1):

+            self.thread.start()

+

+

+

+#***************************************------TEST--------------**************************************

+

+if __name__ == '__main__':

+    g = GAmanager(GoogleID='UA-75220362-4',UserID="Foo",QueueSize=100,Timeout=5,UserPermission=1,BlockingMode=1,appName='TRex',appVer='1.11.232') #timeout in seconds

+#for i in range(0,35,1):

+#i = 42

+    g.gaAddAction(Event='stl',action='stl/udp_1pkt_simple.py {packet_count:1000,packet_len:9000}',label='Boo',value=20)

+    #g.gaAddAction(Event='test',action='start',label='Boo1',value=20)

+

+#g.gaAddException('MEMFAULT',1)

+#g.gaAddException('MEMFAULT',1)

+#g.gaAddException('MEMFAULT',1)

+#g.gaAddException('MEMFAULT',1)

+#g.gaAddException('MEMFAULT',1)

+#g.gaAddException('MEMFAULT',1)

+    g.emptyAndReportQ()

+#    g.printSelf()

+#print g.payload

+#print g.size

+

+

+

+

+#g.activate()

+#g.gaAddAction(Event='test',action='start',label='1',value='1')

+#sys.stdout.write('element added \n')

+#sys.stdout.flush()

+#g.gaAddAction(Event='test',action='start',label='2',value='1')

+#sys.stdout.write('element added \n')

+#sys.stdout.flush()

+#g.gaAddAction(Event='test',action='start',label='3',value='1')

+#sys.stdout.write('element added \n')

+#sys.stdout.flush()

+

+#testdata = "v=1&t=event&tid=UA-75220362-4&cid=2&ec=test&ea=testing&el=testpacket&ev=2"

+#r = requests.post(url_debug,data=testdata)

+#print r

+

+#thread1 = ga_Thread(1,g)

+#thread1.start()

+#thread1.join()

+#for i in range(1,10,1):

+#    sys.stdout.write('yesh %d'% (i))

+#    sys.stdout.flush()

+

+

+# add timing mechanism - DONE

+# add exception mechanism - DONE

+# add version mechanism - DONE

+# ask Itay for unique ID generation per user

+

+

+

+

+   

+        

+

+

+

+

+

diff --git a/scripts/automation/trex_control_plane/stl/trex_stl_lib/utils/filters.py b/scripts/automation/trex_control_plane/stl/trex_stl_lib/utils/filters.py
new file mode 100644
index 00000000..714f7807
--- /dev/null
+++ b/scripts/automation/trex_control_plane/stl/trex_stl_lib/utils/filters.py
@@ -0,0 +1,144 @@
+
+def shallow_copy(x):
+    return type(x)(x)
+
+
+class ToggleFilter(object):
+    """
+    This class provides a "sticky" filter, that works by "toggling" items of the original database on and off.
+    """
+    def __init__(self, db_ref, show_by_default=True):
+        """
+        Instantiate a ToggleFilter object
+
+        :parameters:
+             db_ref : iterable
+                an iterable object (i.e. list, set etc) that would serve as the reference db of the instance.
+                Changes in that object will affect the output of ToggleFilter instance.
+
+             show_by_default: bool
+                decide if by default all the items are "on", i.e. these items will be presented if no other
+                toggling occurred.
+
+                default value : **True**
+
+        """
+        self._data = db_ref
+        self._toggle_db = set()
+        self._filter_method = filter
+        self.__set_initial_state(show_by_default)
+
+    def reset (self):
+        """
+        Toggles off all the items
+        """
+        self._toggle_db = set()
+
+
+    def toggle_item(self, item_key):
+        """
+        Toggle a single item in/out.
+
+        :parameters:
+             item_key :
+                an item the by its value the filter can decide to toggle or not.
+                Example: int, str and so on.
+
+        :return:
+            + **True** if item toggled **into** the filtered items
+            + **False** if item toggled **out from** the filtered items
+
+        :raises:
+            + KeyError, in case if item key is not part of the toggled list and not part of the referenced db.
+
+        """
+        if item_key in self._toggle_db:
+            self._toggle_db.remove(item_key)
+            return False
+        elif item_key in self._data:
+            self._toggle_db.add(item_key)
+            return True
+        else:
+            raise KeyError("Provided item key isn't a key of the referenced data structure.")
+
+    def toggle_items(self, *args):
+        """
+        Toggle multiple items in/out with a single call. Each item will be ha.
+
+        :parameters:
+             args : iterable
+                an iterable object containing all item keys to be toggled in/out
+
+        :return:
+            + **True** if all toggled items were toggled **into** the filtered items
+            + **False** if at least one of the items was toggled **out from** the filtered items
+
+        :raises:
+            + KeyError, in case if ont of the item keys was not part of the toggled list and not part of the referenced db.
+
+        """
+        # in python 3, 'map' returns an iterator, so wrapping with 'list' call creates same effect for both python 2 and 3
+        return all(list(map(self.toggle_item, args)))
+
+    def filter_items(self):
+        """
+        Filters the pointed database by showing only the items mapped at toggle_db set.
+
+        :returns:
+            Filtered data of the original object.
+
+        """
+        return self._filter_method(self.__toggle_filter, self._data)
+
+    # private methods
+
+    def __set_initial_state(self, show_by_default):
+        try:
+            _ = (x for x in self._data)
+            if isinstance(self._data, dict):
+                self._filter_method = ToggleFilter.dict_filter
+                if show_by_default:
+                    self._toggle_db = set(self._data.keys())
+                return
+            elif isinstance(self._data, list):
+                self._filter_method = ToggleFilter.list_filter
+            elif isinstance(self._data, set):
+                self._filter_method = ToggleFilter.set_filter
+            elif isinstance(self._data, tuple):
+                self._filter_method = ToggleFilter.tuple_filter
+            if show_by_default:
+                self._toggle_db = set(shallow_copy(self._data))  # assuming all relevant data with unique identifier
+            return
+        except TypeError:
+            raise TypeError("provided data object is not iterable")
+
+    def __toggle_filter(self, x):
+        return (x in self._toggle_db)
+
+    # static utility methods
+
+    @staticmethod
+    def dict_filter(function, iterable):
+        assert isinstance(iterable, dict)
+        return {k: v
+                for k,v in iterable.items()
+                if function(k)}
+
+    @staticmethod
+    def list_filter(function, iterable):
+        # in python 3, filter returns an iterator, so wrapping with list creates same effect for both python 2 and 3
+        return list(filter(function, iterable))
+
+    @staticmethod
+    def set_filter(function, iterable):
+        return {x
+                for x in iterable
+                if function(x)}
+
+    @staticmethod
+    def tuple_filter(function, iterable):
+        return tuple(filter(function, iterable))
+
+
+if __name__ == "__main__":
+    pass
diff --git a/scripts/automation/trex_control_plane/stl/trex_stl_lib/utils/text_opts.py b/scripts/automation/trex_control_plane/stl/trex_stl_lib/utils/text_opts.py
index bc2d44f4..5c0dfb14 100644
--- a/scripts/automation/trex_control_plane/stl/trex_stl_lib/utils/text_opts.py
+++ b/scripts/automation/trex_control_plane/stl/trex_stl_lib/utils/text_opts.py
@@ -124,16 +124,9 @@ def underline(text):
 
 
 def text_attribute(text, attribute):
-    if isinstance(text, str):
-        return "{start}{txt}{stop}".format(start=TEXT_CODES[attribute]['start'],
-                                           txt=text,
-                                           stop=TEXT_CODES[attribute]['end'])
-    elif isinstance(text, unicode):
-        return u"{start}{txt}{stop}".format(start=TEXT_CODES[attribute]['start'],
-                                            txt=text,
-                                            stop=TEXT_CODES[attribute]['end'])
-    else:
-        raise Exception("not a string")
+    return "{start}{txt}{stop}".format(start=TEXT_CODES[attribute]['start'],
+                                       txt=text,
+                                       stop=TEXT_CODES[attribute]['end'])
 
 
 FUNC_DICT = {'blue': blue,