X-Git-Url: https://gerrit.opnfv.org/gerrit/gitweb?a=blobdiff_plain;f=nfvbench%2Fnfvbench.py;h=eb86deab7574efe8492477d5a8805cb4c6be5ceb;hb=95f2491ed89ac99b0d8bd006b4a13cbeb1eb96ce;hp=1cb5a9c9ca394c51e4c0e6843578036aaae2edf2;hpb=e456fff7801702f1cf672d9ebda54eabd5100ece;p=nfvbench.git

diff --git a/nfvbench/nfvbench.py b/nfvbench/nfvbench.py
index 1cb5a9c..eb86dea 100644
--- a/nfvbench/nfvbench.py
+++ b/nfvbench/nfvbench.py
@@ -15,7 +15,6 @@
 #
 
 import argparse
-from collections import defaultdict
 import copy
 import datetime
 import importlib
@@ -28,22 +27,20 @@ from attrdict import AttrDict
 import pbr.version
 from pkg_resources import resource_string
 
-from __init__ import __version__
-from chain_runner import ChainRunner
-from cleanup import Cleaner
-from config import config_load
-from config import config_loads
-import credentials as credentials
-from factory import BasicFactory
-from fluentd import FluentLogHandler
-import log
-from log import LOG
-from nfvbenchd import WebSocketIoServer
-from specs import ChainType
-from specs import Specs
-from summarizer import NFVBenchSummarizer
-from traffic_client import TrafficGeneratorFactory
-import utils
+from .__init__ import __version__
+from .chain_runner import ChainRunner
+from .cleanup import Cleaner
+from .config import config_load
+from .config import config_loads
+from . import credentials
+from .fluentd import FluentLogHandler
+from . import log
+from .log import LOG
+from .nfvbenchd import WebServer
+from .specs import ChainType
+from .specs import Specs
+from .summarizer import NFVBenchSummarizer
+from . import utils
 
 fluent_logger = None
 
@@ -55,7 +52,9 @@ class NFVBench(object):
     STATUS_ERROR = 'ERROR'
 
     def __init__(self, config, openstack_spec, config_plugin, factory, notifier=None):
+        # the base config never changes for a given NFVbench instance
         self.base_config = config
+        # this is the running config, updated at every run()
         self.config = None
         self.config_plugin = config_plugin
         self.factory = factory
@@ -65,23 +64,18 @@ class NFVBench(object):
         self.chain_runner = None
         self.specs = Specs()
         self.specs.set_openstack_spec(openstack_spec)
-        self.clients = defaultdict(lambda: None)
         self.vni_ports = []
         sys.stdout.flush()
 
-    def setup(self):
-        self.specs.set_run_spec(self.config_plugin.get_run_spec(self.config, self.specs.openstack))
-        self.chain_runner = ChainRunner(self.config,
-                                        self.clients,
-                                        self.cred,
-                                        self.specs,
-                                        self.factory,
-                                        self.notifier)
-
     def set_notifier(self, notifier):
         self.notifier = notifier
 
     def run(self, opts, args):
+        """This run() method is called for every NFVbench benchmark request.
+
+        In CLI mode, this method is called only once per invocation.
+        In REST server mode, this is called once per REST POST request
+        """
         status = NFVBench.STATUS_OK
         result = None
         message = ''
@@ -91,21 +85,36 @@ class NFVBench(object):
             fluent_logger.start_new_run()
         LOG.info(args)
         try:
-            self.update_config(opts)
-            self.setup()
+            # recalc the running config based on the base config and options for this run
+            self._update_config(opts)
+            if int(self.config.cache_size) < 0:
+                self.config.cache_size = self.config.flow_count
+            # check that an empty openrc file (no OpenStack) is only allowed
+            # with EXT chain
+            if not self.config.openrc_file and self.config.service_chain != ChainType.EXT:
+                raise Exception("openrc_file in the configuration is required for PVP/PVVP chains")
+
+            self.specs.set_run_spec(self.config_plugin.get_run_spec(self.config,
+                                                                    self.specs.openstack))
+            self.chain_runner = ChainRunner(self.config,
+                                            self.cred,
+                                            self.specs,
+                                            self.factory,
+                                            self.notifier)
             new_frame_sizes = []
-            min_packet_size = "68" if self.config.vlan_tagging else "64"
+            # make sure that the min frame size is 64
+            min_packet_size = 64
             for frame_size in self.config.frame_sizes:
                 try:
-                    if int(frame_size) < int(min_packet_size):
-                        new_frame_sizes.append(min_packet_size)
-                        LOG.info("Adjusting frame size %s Bytes to minimum size %s Bytes due to " +
-                                 "traffic generator restriction", frame_size, min_packet_size)
-                    else:
+                    if int(frame_size) < min_packet_size:
+                        frame_size = str(min_packet_size)
+                        LOG.info("Adjusting frame size %s bytes to minimum size %s bytes",
+                                 frame_size, min_packet_size)
+                    if frame_size not in new_frame_sizes:
                         new_frame_sizes.append(frame_size)
                 except ValueError:
-                    new_frame_sizes.append(frame_size)
-            self.config.actual_frame_sizes = tuple(new_frame_sizes)
+                    new_frame_sizes.append(frame_size.upper())
+            self.config.frame_sizes = new_frame_sizes
             result = {
                 "date": datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
                 "nfvbench_version": __version__,
@@ -132,7 +141,7 @@ class NFVBench(object):
                 self.chain_runner.close()
 
         if status == NFVBench.STATUS_OK:
-            result = utils.dict_to_json_dict(result)
+            # result2 = utils.dict_to_json_dict(result)
             return {
                 'status': status,
                 'result': result
@@ -158,100 +167,83 @@ class NFVBench(object):
                                self.config.flow_count,
                                self.config.frame_sizes)
 
-    def update_config(self, opts):
+    def _update_config(self, opts):
+        """Recalculate the running config based on the base config and opts.
+
+        Sanity check on the config is done here as well.
+        """
         self.config = AttrDict(dict(self.base_config))
         self.config.update(opts)
-
-        self.config.service_chain = self.config.service_chain.upper()
-        self.config.service_chain_count = int(self.config.service_chain_count)
-        self.config.flow_count = utils.parse_flow_count(self.config.flow_count)
-        required_flow_count = self.config.service_chain_count * 2
-        if self.config.flow_count < required_flow_count:
+        config = self.config
+
+        config.service_chain = config.service_chain.upper()
+        config.service_chain_count = int(config.service_chain_count)
+        if config.l2_loopback:
+            # force the number of chains to be 1 in case of l2 loopback
+            config.service_chain_count = 1
+            config.service_chain = ChainType.EXT
+            config.no_arp = True
+            LOG.info('Running L2 loopback: using EXT chain/no ARP')
+        config.flow_count = utils.parse_flow_count(config.flow_count)
+        required_flow_count = config.service_chain_count * 2
+        if config.flow_count < required_flow_count:
             LOG.info("Flow count %d has been set to minimum value of '%d' "
-                     "for current configuration", self.config.flow_count,
+                     "for current configuration", config.flow_count,
                      required_flow_count)
-            self.config.flow_count = required_flow_count
-
-        if self.config.flow_count % 2 != 0:
-            self.config.flow_count += 1
-
-        self.config.duration_sec = float(self.config.duration_sec)
-        self.config.interval_sec = float(self.config.interval_sec)
-
-        # Get traffic generator profile config
-        if not self.config.generator_profile:
-            self.config.generator_profile = self.config.traffic_generator.default_profile
-
-        generator_factory = TrafficGeneratorFactory(self.config)
-        self.config.generator_config = \
-            generator_factory.get_generator_config(self.config.generator_profile)
-
-        # Check length of mac_addrs_left/right for serivce_chain EXT with no_arp
-        if self.config.service_chain == ChainType.EXT and self.config.no_arp:
-            if not (self.config.generator_config.mac_addrs_left is None and
-                    self.config.generator_config.mac_addrs_right is None):
-                if (self.config.generator_config.mac_addrs_left is None or
-                        self.config.generator_config.mac_addrs_right is None):
-                    raise Exception("mac_addrs_left and mac_addrs_right must either "
-                                    "both be None or have a number of entries matching "
-                                    "service_chain_count")
-                if not (len(self.config.generator_config.mac_addrs_left) ==
-                        self.config.service_chain_count and
-                        len(self.config.generator_config.mac_addrs_right) ==
-                        self.config.service_chain_count):
-                    raise Exception("length of mac_addrs_left ({a}) and/or mac_addrs_right ({b}) "
-                                    "does not match service_chain_count ({c})"
-                                    .format(a=len(self.config.generator_config.mac_addrs_left),
-                                            b=len(self.config.generator_config.mac_addrs_right),
-                                            c=self.config.service_chain_count))
-
-        if not any(self.config.generator_config.pcis):
-            raise Exception("PCI addresses configuration for selected traffic generator profile "
-                            "({tg_profile}) are missing. Please specify them in configuration file."
-                            .format(tg_profile=self.config.generator_profile))
-
-        if self.config.traffic is None or not self.config.traffic:
-            raise Exception("No traffic profile found in traffic configuration, "
-                            "please fill 'traffic' section in configuration file.")
-
-        if isinstance(self.config.traffic, tuple):
-            self.config.traffic = self.config.traffic[0]
-
-        self.config.frame_sizes = generator_factory.get_frame_sizes(self.config.traffic.profile)
-
-        self.config.ipv6_mode = False
-        self.config.no_dhcp = True
-        self.config.same_network_only = True
-        if self.config.openrc_file:
-            self.config.openrc_file = os.path.expanduser(self.config.openrc_file)
-
-        self.config.ndr_run = (not self.config.no_traffic and
-                               'ndr' in self.config.rate.strip().lower().split('_'))
-        self.config.pdr_run = (not self.config.no_traffic and
-                               'pdr' in self.config.rate.strip().lower().split('_'))
-        self.config.single_run = (not self.config.no_traffic and
-                                  not (self.config.ndr_run or self.config.pdr_run))
-
-        if self.config.vlans and len(self.config.vlans) != 2:
-            raise Exception('Number of configured VLAN IDs for VLAN tagging must be exactly 2.')
-
-        self.config.json_file = self.config.json if self.config.json else None
-        if self.config.json_file:
-            (path, _filename) = os.path.split(self.config.json)
+            config.flow_count = required_flow_count
+
+        if config.flow_count % 2:
+            config.flow_count += 1
+
+        config.duration_sec = float(config.duration_sec)
+        config.interval_sec = float(config.interval_sec)
+        config.pause_sec = float(config.pause_sec)
+
+        if config.traffic is None or not config.traffic:
+            raise Exception("Missing traffic property in configuration")
+
+        if config.openrc_file:
+            config.openrc_file = os.path.expanduser(config.openrc_file)
+            if config.flavor.vcpus < 2:
+                raise Exception("Flavor vcpus must be >= 2")
+
+
+        config.ndr_run = (not config.no_traffic and
+                          'ndr' in config.rate.strip().lower().split('_'))
+        config.pdr_run = (not config.no_traffic and
+                          'pdr' in config.rate.strip().lower().split('_'))
+        config.single_run = (not config.no_traffic and
+                             not (config.ndr_run or config.pdr_run))
+
+        config.json_file = config.json if config.json else None
+        if config.json_file:
+            (path, _filename) = os.path.split(config.json)
             if not os.path.exists(path):
                 raise Exception('Please provide existing path for storing results in JSON file. '
                                 'Path used: {path}'.format(path=path))
 
-        self.config.std_json_path = self.config.std_json if self.config.std_json else None
-        if self.config.std_json_path:
-            if not os.path.exists(self.config.std_json):
+        config.std_json_path = config.std_json if config.std_json else None
+        if config.std_json_path:
+            if not os.path.exists(config.std_json):
                 raise Exception('Please provide existing path for storing results in JSON file. '
-                                'Path used: {path}'.format(path=self.config.std_json_path))
+                                'Path used: {path}'.format(path=config.std_json_path))
+
+        # Check that multiqueue is between 1 and 8 (8 is the max allowed by libvirt/qemu)
+        if config.vif_multiqueue_size < 1 or config.vif_multiqueue_size > 8:
+            raise Exception('vif_multiqueue_size (%d) must be in [1..8]' %
+                            config.vif_multiqueue_size)
 
-        self.config_plugin.validate_config(self.config, self.specs.openstack)
+        # VxLAN sanity checks
+        if config.vxlan:
+            if config.vlan_tagging:
+                config.vlan_tagging = False
+                LOG.info('VxLAN: vlan_tagging forced to False '
+                         '(inner VLAN tagging must be disabled)')
 
+        self.config_plugin.validate_config(config, self.specs.openstack)
 
-def parse_opts_from_cli():
+
+def _parse_opts_from_cli():
     parser = argparse.ArgumentParser()
 
     parser.add_argument('--status', dest='status',
@@ -267,10 +259,8 @@ def parse_opts_from_cli():
 
     parser.add_argument('--server', dest='server',
                         default=None,
-                        action='store',
-                        metavar='<http_root_pathname>',
-                        help='Run nfvbench in server mode and pass'
-                             ' the HTTP root folder full pathname')
+                        action='store_true',
+                        help='Run nfvbench in server mode')
 
     parser.add_argument('--host', dest='host',
                         action='store',
@@ -283,7 +273,7 @@ def parse_opts_from_cli():
                         help='Port on which server will be listening (default 7555)')
 
     parser.add_argument('-sc', '--service-chain', dest='service_chain',
-                        choices=BasicFactory.chain_classes,
+                        choices=ChainType.names,
                         action='store',
                         help='Service chain to run')
 
@@ -315,7 +305,7 @@ def parse_opts_from_cli():
     parser.add_argument('--inter-node', dest='inter_node',
                         default=None,
                         action='store_true',
-                        help='run VMs in different compute nodes (PVVP only)')
+                        help='(deprecated)')
 
     parser.add_argument('--sriov', dest='sriov',
                         default=None,
@@ -337,6 +327,11 @@ def parse_opts_from_cli():
                         action='store',
                         help='Traffic generator profile to use')
 
+    parser.add_argument('-l3', '--l3-router', dest='l3_router',
+                        default=None,
+                        action='store_true',
+                        help='Use L3 neutron routers to handle traffic')
+
     parser.add_argument('-0', '--no-traffic', dest='no_traffic',
                         default=None,
                         action='store_true',
@@ -348,25 +343,15 @@ def parse_opts_from_cli():
                         help='Do not use ARP to find MAC addresses, '
                              'instead use values in config file')
 
-    parser.add_argument('--no-reset', dest='no_reset',
-                        default=None,
-                        action='store_true',
-                        help='Do not reset counters prior to running')
-
-    parser.add_argument('--no-int-config', dest='no_int_config',
-                        default=None,
-                        action='store_true',
-                        help='Skip interfaces config on EXT service chain')
-
-    parser.add_argument('--no-tor-access', dest='no_tor_access',
+    parser.add_argument('--no-vswitch-access', dest='no_vswitch_access',
                         default=None,
                         action='store_true',
-                        help='Skip TOR switch configuration and retrieving of stats')
+                        help='Skip vswitch configuration and retrieving of stats')
 
-    parser.add_argument('--no-vswitch-access', dest='no_vswitch_access',
+    parser.add_argument('--vxlan', dest='vxlan',
                         default=None,
                         action='store_true',
-                        help='Skip vswitch configuration and retrieving of stats')
+                        help='Enable VxLan encapsulation')
 
     parser.add_argument('--no-cleanup', dest='no_cleanup',
                         default=None,
@@ -383,6 +368,11 @@ def parse_opts_from_cli():
                         action='store_true',
                         help='Cleanup NFVbench resources (do not prompt)')
 
+    parser.add_argument('--restart', dest='restart',
+                        default=None,
+                        action='store_true',
+                        help='Restart TRex server')
+
     parser.add_argument('--json', dest='json',
                         action='store',
                         help='store results in json format file',
@@ -434,11 +424,41 @@ def parse_opts_from_cli():
                         action='store',
                         help='Custom label for performance records')
 
+    parser.add_argument('--hypervisor', dest='hypervisor',
+                        action='store',
+                        metavar='<hypervisor name>',
+                        help='Where chains must run ("compute", "az:", "az:compute")')
+
     parser.add_argument('--l2-loopback', '--l2loopback', dest='l2_loopback',
                         action='store',
                         metavar='<vlan>',
                         help='Port to port or port to switch to port L2 loopback with VLAN id')
 
+    parser.add_argument('--cache-size', dest='cache_size',
+                        action='store',
+                        default='0',
+                        help='Specify the FE cache size (default: 0, flow-count if < 0)')
+
+    parser.add_argument('--service-mode', dest='service_mode',
+                        action='store_true',
+                        default=False,
+                        help='Enable T-Rex service mode for debugging only')
+
+    parser.add_argument('--no-flow-stats', dest='no_flow_stats',
+                        action='store_true',
+                        default=False,
+                        help='Disable extra flow stats (on high load traffic)')
+
+    parser.add_argument('--no-latency-stats', dest='no_latency_stats',
+                        action='store_true',
+                        default=False,
+                        help='Disable flow stats for latency traffic')
+
+    parser.add_argument('--no-latency-streams', dest='no_latency_streams',
+                        action='store_true',
+                        default=False,
+                        help='Disable latency measurements (no streams)')
+
     opts, unknown_opts = parser.parse_known_args()
     return opts, unknown_opts
 
@@ -514,11 +534,11 @@ def main():
         config_plugin = factory.get_config_plugin_class()(config)
         config = config_plugin.get_config()
 
-        opts, unknown_opts = parse_opts_from_cli()
+        opts, unknown_opts = _parse_opts_from_cli()
         log.set_level(debug=opts.debug)
 
         if opts.version:
-            print pbr.version.VersionInfo('nfvbench').version_string_with_vcs()
+            print((pbr.version.VersionInfo('nfvbench').version_string_with_vcs()))
             sys.exit(0)
 
         if opts.summary:
@@ -526,12 +546,12 @@ def main():
                 result = json.load(json_data)
                 if opts.user_label:
                     result['config']['user_label'] = opts.user_label
-                print NFVBenchSummarizer(result, fluent_logger)
+                print((NFVBenchSummarizer(result, fluent_logger)))
             sys.exit(0)
 
         # show default config in text/yaml format
         if opts.show_default_config:
-            print default_cfg
+            print((default_cfg.decode("utf-8")))
             sys.exit(0)
 
         config.name = ''
@@ -571,10 +591,24 @@ def main():
             config.service_chain_count = opts.service_chain_count
         if opts.no_vswitch_access:
             config.no_vswitch_access = opts.no_vswitch_access
-        if opts.no_int_config:
-            config.no_int_config = opts.no_int_config
-
+        if opts.hypervisor:
+            # can be any of 'comp1', 'nova:', 'nova:comp1'
+            config.compute_nodes = opts.hypervisor
+        if opts.vxlan:
+            config.vxlan = True
+        if opts.restart:
+            config.restart = True
+        if opts.service_mode:
+            config.service_mode = True
+        if opts.no_flow_stats:
+            config.no_flow_stats = True
+        if opts.no_latency_stats:
+            config.no_latency_stats = True
+        if opts.no_latency_streams:
+            config.no_latency_streams = True
+        # port to port loopback (direct or through switch)
         if opts.l2_loopback:
+            config.l2_loopback = True
             if config.service_chain != ChainType.EXT:
                 LOG.info('Changing service chain type to EXT')
                 config.service_chain = ChainType.EXT
@@ -582,7 +616,7 @@ def main():
                 LOG.info('Disabling ARP')
                 config.no_arp = True
             config.vlans = [int(opts.l2_loopback), int(opts.l2_loopback)]
-            LOG.info('Running L2 loopback: using EXT chain and no ARP')
+            LOG.info('Running L2 loopback: using EXT chain/no ARP')
 
         if opts.use_sriov_middle_net:
             if (not config.sriov) or (config.service_chain != ChainType.PVVP):
@@ -599,17 +633,9 @@ def main():
 
         # show running config in json format
         if opts.show_config:
-            print json.dumps(config, sort_keys=True, indent=4)
+            print((json.dumps(config, sort_keys=True, indent=4)))
             sys.exit(0)
 
-        # check that an empty openrc file (no OpenStack) is only allowed
-        # with EXT chain
-        if not config.openrc_file:
-            if config.service_chain == ChainType.EXT:
-                LOG.info('EXT chain with OpenStack mode disabled')
-            else:
-                raise Exception("openrc_file is empty in the configuration and is required")
-
         # update the config in the config plugin as it might have changed
         # in a copy of the dict (config plugin still holds the original dict)
         config_plugin.set_config(config)
@@ -627,18 +653,14 @@ def main():
         nfvbench_instance = NFVBench(config, openstack_spec, config_plugin, factory)
 
         if opts.server:
-            if os.path.isdir(opts.server):
-                server = WebSocketIoServer(opts.server, nfvbench_instance, fluent_logger)
-                nfvbench_instance.set_notifier(server)
-                try:
-                    port = int(opts.port)
-                except ValueError:
-                    server.run(host=opts.host)
-                else:
-                    server.run(host=opts.host, port=port)
+            server = WebServer(nfvbench_instance, fluent_logger)
+            try:
+                port = int(opts.port)
+            except ValueError:
+                server.run(host=opts.host)
             else:
-                print 'Invalid HTTP root directory: ' + opts.server
-                sys.exit(1)
+                server.run(host=opts.host, port=port)
+            # server.run() should never return
         else:
             with utils.RunLock():
                 run_summary_required = True
@@ -648,7 +670,7 @@ def main():
                     raise Exception(err_msg)
 
                 # remove unfilled values
-                opts = {k: v for k, v in vars(opts).iteritems() if v is not None}
+                opts = {k: v for k, v in list(vars(opts).items()) if v is not None}
                 # get CLI args
                 params = ' '.join(str(e) for e in sys.argv[1:])
                 result = nfvbench_instance.run(opts, params)
@@ -664,7 +686,7 @@ def main():
             'status': NFVBench.STATUS_ERROR,
             'error_message': traceback.format_exc()
         })
-        print str(exc)
+        print((str(exc)))
     finally:
         if fluent_logger:
             # only send a summary record if there was an actual nfvbench run or