Merge branch 'dan_stateless' into a test branch

Conflicts:
	scripts/automation/trex_control_plane/client/trex_async_client.py
	scripts/automation/trex_control_plane/client/trex_stateless_client.py
	scripts/automation/trex_control_plane/client_utils/parsing_opts.py
	scripts/automation/trex_control_plane/console/trex_console.py

4 files changed, 342 insertions, 3 deletions

diff --git a/scripts/automation/trex_control_plane/client_utils/external_packages.py b/scripts/automation/trex_control_plane/client_utils/external_packages.py
index e2bb37a5..3c6eb449 100755
--- a/scripts/automation/trex_control_plane/client_utils/external_packages.py
+++ b/scripts/automation/trex_control_plane/client_utils/external_packages.py
@@ -9,7 +9,8 @@ PATH_TO_PYTHON_LIB  = os.path.abspath(os.path.join(ROOT_PATH, os.pardir, os.pard
 
 CLIENT_UTILS_MODULES = ['zmq',
                         'dpkt-1.8.6',
-                        'PyYAML-3.01/lib'
+                        'PyYAML-3.01/lib',
+                        'texttable-0.8.4'
                         ]
 
 def import_client_utils_modules():
diff --git a/scripts/automation/trex_control_plane/client_utils/jsonrpc_client.py b/scripts/automation/trex_control_plane/client_utils/jsonrpc_client.py
index 90d7f8e8..f55d7798 100755
--- a/scripts/automation/trex_control_plane/client_utils/jsonrpc_client.py
+++ b/scripts/automation/trex_control_plane/client_utils/jsonrpc_client.py
@@ -172,7 +172,7 @@ class JsonRpcClient(object):
     def process_single_response (self, response_json):
 
         if (response_json.get("jsonrpc") != "2.0"):
-            return False, "Malfromed Response ({0})".format(str(response))
+            return False, "Malformed Response ({0})".format(str(response_json))
 
         # error reported by server
         if ("error" in response_json):
@@ -183,7 +183,7 @@ class JsonRpcClient(object):
 
         # if no error there should be a result
         if ("result" not in response_json):
-            return False, "Malformed Response ({0})".format(str(response))
+            return False, "Malformed Response ({0})".format(str(response_json))
 
         return True, response_json["result"]
 
diff --git a/scripts/automation/trex_control_plane/client_utils/parsing_opts.py b/scripts/automation/trex_control_plane/client_utils/parsing_opts.py
new file mode 100755
index 00000000..7ac9e312
--- /dev/null
+++ b/scripts/automation/trex_control_plane/client_utils/parsing_opts.py
@@ -0,0 +1,304 @@
+import argparse
+from collections import namedtuple
+import sys
+import re
+import os
+
+ArgumentPack = namedtuple('ArgumentPack', ['name_or_flags', 'options'])
+ArgumentGroup = namedtuple('ArgumentGroup', ['type', 'args', 'options'])
+
+
+# list of available parsing options
+MULTIPLIER = 1
+MULTIPLIER_STRICT = 2
+PORT_LIST = 3
+ALL_PORTS = 4
+PORT_LIST_WITH_ALL = 5
+FILE_PATH = 6
+FILE_FROM_DB = 7
+SERVER_IP = 8
+STREAM_FROM_PATH_OR_FILE = 9
+DURATION = 10
+FORCE = 11
+DRY_RUN = 12
+TOTAL = 13
+
+GLOBAL_STATS = 14
+PORT_STATS = 15
+PORT_STATUS = 16
+STATS_MASK = 17
+
+# list of ArgumentGroup types
+MUTEX = 1
+
+def check_negative(value):
+    ivalue = int(value)
+    if ivalue < 0:
+        raise argparse.ArgumentTypeError("non positive value provided: '{0}'".format(value))
+    return ivalue
+
+def match_time_unit(val):
+    '''match some val against time shortcut inputs '''
+    match = re.match("^(\d+)([m|h]?)$", val)
+    if match:
+        digit = int(match.group(1))
+        unit = match.group(2)
+        if not unit:
+            return digit
+        elif unit == 'm':
+            return digit*60
+        else:
+            return digit*60*60
+    else:
+        raise argparse.ArgumentTypeError("Duration should be passed in the following format: \n"
+                                         "-d 100 : in sec \n"
+                                         "-d 10m : in min \n"
+                                         "-d 1h  : in hours")
+
+match_multiplier_help = """Multiplier should be passed in the following format:
+                          [number][<empty> | bps | kbps | mbps | gbps | pps | kpps | mpps | %% ].
+                          no suffix will provide an absoulute factor and percentage 
+                          will provide a percentage of the line rate. examples
+                          : '-m 10', '-m 10kbps', '-m 10mpps', '-m 23%%' """
+
+def match_multiplier_common(val, strict_abs = True):
+
+    # on strict absolute we do not allow +/-
+    if strict_abs:
+        match = re.match("^(\d+(\.\d+)?)(bps|kbps|mbps|gbps|pps|kpps|mpps|%?)$", val)
+        op = None
+    else:
+        match = re.match("^(\d+(\.\d+)?)(bps|kbps|mbps|gbps|pps|kpps|mpps|%?)([\+\-])?$", val)
+        op  = match.group(4)
+
+    result = {}
+
+    if match:
+
+        value = float(match.group(1))
+        unit = match.group(3)
+        
+
+        
+        # raw type (factor)
+        if not unit:
+            result['type'] = 'raw'
+            result['value'] = value
+
+        elif unit == 'bps':
+            result['type'] = 'bps'
+            result['value'] = value
+
+        elif unit == 'kbps':
+            result['type'] = 'bps'
+            result['value'] = value * 1000
+
+        elif unit == 'mbps':
+            result['type'] = 'bps'
+            result['value'] = value * 1000 * 1000
+
+        elif unit == 'gbps':
+            result['type'] = 'bps'
+            result['value'] = value * 1000 * 1000 * 1000
+
+        elif unit == 'pps':
+            result['type'] = 'pps'
+            result['value'] = value
+
+        elif unit == "kpps":
+            result['type'] = 'pps'
+            result['value'] = value * 1000
+
+        elif unit == "mpps":
+            result['type'] = 'pps'
+            result['value'] = value * 1000 * 1000
+
+        elif unit == "%":
+            result['type'] = 'percentage'
+            result['value']  = value
+
+
+        if op == "+":
+            result['op'] = "add"
+        elif op == "-":
+            result['op'] = "sub"
+        else:
+            result['op'] = "abs"
+
+        return result
+
+    else:
+        raise argparse.ArgumentTypeError(match_multiplier_help)
+
+
+def match_multiplier(val):
+    '''match some val against multiplier  shortcut inputs '''
+    return match_multiplier_common(val, strict_abs = False)
+
+def match_multiplier_strict(val):
+    '''match some val against multiplier  shortcut inputs '''
+    return match_multiplier_common(val, strict_abs = True)
+
+def is_valid_file(filename):
+    if not os.path.isfile(filename):
+        raise argparse.ArgumentTypeError("The file '%s' does not exist" % filename)
+
+    return filename
+
+
+OPTIONS_DB = {MULTIPLIER: ArgumentPack(['-m', '--multiplier'],
+                                 {'help': match_multiplier_help,
+                                  'dest': "mult",
+                                  'default': {'type':'raw', 'value':1, 'op': 'abs'},
+                                  'type': match_multiplier}),
+
+              MULTIPLIER_STRICT: ArgumentPack(['-m', '--multiplier'],
+                               {'help': match_multiplier_help,
+                                  'dest': "mult",
+                                  'default': {'type':'raw', 'value':1, 'op': 'abs'},
+                                  'type': match_multiplier_strict}),
+
+              TOTAL: ArgumentPack(['-t', '--total'],
+                                 {'help': "traffic will be divided between all ports specified",
+                                  'dest': "total",
+                                  'default': False,
+                                  'action': "store_true"}),
+
+              PORT_LIST: ArgumentPack(['--port'],
+                                        {"nargs": '+',
+                                         'dest':'ports',
+                                         'metavar': 'PORTS',
+                                          'type': int,
+                                         'help': "A list of ports on which to apply the command",
+                                         'default': []}),
+
+              ALL_PORTS: ArgumentPack(['-a'],
+                                        {"action": "store_true",
+                                         "dest": "all_ports",
+                                         'help': "Set this flag to apply the command on all available ports"}),
+              DURATION: ArgumentPack(['-d'],
+                                        {'action': "store",
+                                         'metavar': 'TIME',
+                                         'dest': 'duration',
+                                         'type': match_time_unit,
+                                         'default': -1.0,
+                                         'help': "Set duration time for TRex."}),
+
+              FORCE: ArgumentPack(['--force'],
+                                        {"action": "store_true",
+                                         'default': False,
+                                         'help': "Set if you want to stop active ports before applying new TRex run on them."}),
+
+              FILE_PATH: ArgumentPack(['-f'],
+                                      {'metavar': 'FILE',
+                                       'dest': 'file',
+                                       'nargs': 1,
+                                       'type': is_valid_file,
+                                       'help': "File path to YAML file that describes a stream pack. "}),
+
+              FILE_FROM_DB: ArgumentPack(['--db'],
+                                         {'metavar': 'LOADED_STREAM_PACK',
+                                          'help': "A stream pack which already loaded into console cache."}),
+
+              SERVER_IP: ArgumentPack(['--server'],
+                                      {'metavar': 'SERVER',
+                                       'help': "server IP"}),
+
+              DRY_RUN: ArgumentPack(['-n', '--dry'],
+                                    {'action': 'store_true',
+                                     'dest': 'dry',
+                                     'default': False,
+                                     'help': "Dry run - no traffic will be injected"}),
+
+              GLOBAL_STATS: ArgumentPack(['-g'],
+                                         {'action': 'store_true',
+                                          'help': "Fetch only global statistics"}),
+
+              PORT_STATS: ArgumentPack(['-p'],
+                                       {'action': 'store_true',
+                                        'help': "Fetch only port statistics"}),
+
+              PORT_STATUS: ArgumentPack(['--ps'],
+                                        {'action': 'store_true',
+                                         'help': "Fetch only port status data"}),
+
+
+              # advanced options
+              PORT_LIST_WITH_ALL: ArgumentGroup(MUTEX, [PORT_LIST,
+                                                        ALL_PORTS],
+                                                {'required': True}),
+              STREAM_FROM_PATH_OR_FILE: ArgumentGroup(MUTEX, [FILE_PATH,
+                                                              FILE_FROM_DB],
+                                                      {'required': True}),
+              STATS_MASK: ArgumentGroup(MUTEX, [GLOBAL_STATS,
+                                                PORT_STATS,
+                                                PORT_STATUS],
+                                        {})
+              }
+
+
+class CCmdArgParser(argparse.ArgumentParser):
+
+    def __init__(self, stateless_client, *args, **kwargs):
+        super(CCmdArgParser, self).__init__(*args, **kwargs)
+        self.stateless_client = stateless_client
+
+    def parse_args(self, args=None, namespace=None):
+        try:
+            opts = super(CCmdArgParser, self).parse_args(args, namespace)
+            if opts is None:
+                return None
+
+            if getattr(opts, "all_ports", None):
+                opts.ports = self.stateless_client.get_port_ids()
+
+            if getattr(opts, "ports", None):
+                for port in opts.ports:
+                    if not self.stateless_client.validate_port_list([port]):
+                        self.error("port id '{0}' is not a valid port id\n".format(port))
+
+            return opts
+
+        except SystemExit:
+            # recover from system exit scenarios, such as "help", or bad arguments.
+            return None
+
+
+def get_flags (opt):
+    return OPTIONS_DB[opt].name_or_flags
+
+def gen_parser(stateless_client, op_name, description, *args):
+    parser = CCmdArgParser(stateless_client, prog=op_name, conflict_handler='resolve',
+                           description=description)
+    for param in args:
+        try:
+
+            if isinstance(param, int):
+                argument = OPTIONS_DB[param]
+            else:
+                argument = param
+
+            if isinstance(argument, ArgumentGroup):
+                if argument.type == MUTEX:
+                    # handle as mutually exclusive group
+                    group = parser.add_mutually_exclusive_group(**argument.options)
+                    for sub_argument in argument.args:
+                        group.add_argument(*OPTIONS_DB[sub_argument].name_or_flags,
+                                           **OPTIONS_DB[sub_argument].options)
+                else:
+                    # ignore invalid objects
+                    continue
+            elif isinstance(argument, ArgumentPack):
+                parser.add_argument(*argument.name_or_flags,
+                                    **argument.options)
+            else:
+                # ignore invalid objects
+                continue
+        except KeyError as e:
+            cause = e.args[0]
+            raise KeyError("The attribute '{0}' is missing as a field of the {1} option.\n".format(cause, param))
+    return parser
+
+
+if __name__ == "__main__":
+    pass
\ No newline at end of file
diff --git a/scripts/automation/trex_control_plane/client_utils/text_tables.py b/scripts/automation/trex_control_plane/client_utils/text_tables.py
new file mode 100644
index 00000000..2debca38
--- /dev/null
+++ b/scripts/automation/trex_control_plane/client_utils/text_tables.py
@@ -0,0 +1,34 @@
+
+import external_packages
+from texttable import Texttable
+from common.text_opts import format_text
+
+class TRexTextTable(Texttable):
+
+    def __init__(self):
+        Texttable.__init__(self)
+        # set class attributes so that it'll be more like TRex standard output
+        self.set_chars(['-', '|', '-', '-'])
+        self.set_deco(Texttable.HEADER | Texttable.VLINES)
+
+class TRexTextInfo(Texttable):
+
+    def __init__(self):
+        Texttable.__init__(self)
+        # set class attributes so that it'll be more like TRex standard output
+        self.set_chars(['-', ':', '-', '-'])
+        self.set_deco(Texttable.VLINES)
+
+def generate_trex_stats_table():
+    pass
+
+def print_table_with_header(texttable_obj, header=""):
+    header = header.replace("_", " ").title()
+    print format_text(header, 'cyan', 'underline') + "\n"
+    print texttable_obj.draw() + "\n"
+
+    pass
+
+if __name__ == "__main__":
+    pass
+