X-Git-Url: https://gerrit.opnfv.org/gerrit/gitweb?a=blobdiff_plain;f=nfvbench%2Fnfvbench.py;h=581206eadd04bc30381b42803811f0fbf2a84bcf;hb=391dcf76fefb747888a3411ae3b8df7b1ad26685;hp=5b7eb91407c8405914afe30e07e5f75d5a0d2d79;hpb=f9be20deb65085a0bb2a32980bb182c10a56324a;p=nfvbench.git

diff --git a/nfvbench/nfvbench.py b/nfvbench/nfvbench.py
index 5b7eb91..581206e 100644
--- a/nfvbench/nfvbench.py
+++ b/nfvbench/nfvbench.py
@@ -14,80 +14,97 @@
 #    under the License.
 #
 
-from __init__ import __version__
 import argparse
-from attrdict import AttrDict
-from chain_runner import ChainRunner
-from collections import defaultdict
-from config import config_load
-from config import config_loads
 import copy
-import credentials
 import datetime
-from factory import BasicFactory
 import importlib
 import json
-import log
-from log import LOG
-from nfvbenchd import WebSocketIoServer
 import os
+import sys
+import traceback
+
+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 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
-import sys
-import traceback
-from traffic_client import TrafficGeneratorFactory
 import utils
 
+fluent_logger = None
+
 
 class NFVBench(object):
     """Main class of NFV benchmarking tool."""
+
     STATUS_OK = 'OK'
     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
         self.notifier = notifier
-        self.cred = credentials.Credentials(config.openrc_file, None, False)
+        self.cred = credentials.Credentials(config.openrc_file, None, False) \
+            if config.openrc_file else None
         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.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):
+    def run(self, opts, args):
         status = NFVBench.STATUS_OK
         result = None
         message = ''
+        if fluent_logger:
+            # take a snapshot of the current time for this new run
+            # so that all subsequent logs can relate to this run
+            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)
+            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"
+            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:
+                        new_frame_sizes.append(frame_size)
+                except ValueError:
+                    new_frame_sizes.append(frame_size)
+            self.config.actual_frame_sizes = tuple(new_frame_sizes)
             result = {
                 "date": datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
                 "nfvbench_version": __version__,
-                "openstack_spec": {
-                    "vswitch": self.specs.openstack.vswitch,
-                    "encaps": self.specs.openstack.encaps
-                },
                 "config": self.config_plugin.prepare_results_config(copy.deepcopy(self.config)),
                 "benchmarks": {
                     "network": {
@@ -96,6 +113,9 @@ class NFVBench(object):
                     }
                 }
             }
+            if self.specs.openstack:
+                result['openstack_spec'] = {"vswitch": self.specs.openstack.vswitch,
+                                            "encaps": self.specs.openstack.encaps}
             result['benchmarks']['network']['versions'].update(self.config_plugin.get_version())
         except Exception:
             status = NFVBench.STATUS_ERROR
@@ -107,22 +127,22 @@ class NFVBench(object):
             if self.chain_runner:
                 self.chain_runner.close()
 
-            if status == NFVBench.STATUS_OK:
-                result = utils.dict_to_json_dict(result)
-                return {
-                    'status': status,
-                    'result': result
-                }
-            else:
-                return {
-                    'status': status,
-                    'error_message': message
-                }
+        if status == NFVBench.STATUS_OK:
+            # result2 = utils.dict_to_json_dict(result)
+            return {
+                'status': status,
+                'result': result
+            }
+        return {
+            'status': status,
+            'error_message': message
+        }
 
-    def print_summary(self, result):
-        """Print summary of the result"""
-        print NFVBenchSummarizer(result)
-        sys.stdout.flush()
+    def prepare_summary(self, result):
+        """Prepare summary of the result to print and send it to logger (eg: fluentd)."""
+        global fluent_logger
+        summary = NFVBenchSummarizer(result, fluent_logger)
+        LOG.info(str(summary))
 
     def save(self, result):
         """Save results in json format file."""
@@ -134,83 +154,75 @@ 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:
-            LOG.info("Flow count '{}' has been set to minimum value of '{}' "
-                     "for current configuration".format(self.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)
-
-        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 len(self.config.traffic) == 0:
-            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 = 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", config.flow_count,
+                     required_flow_count)
+            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)
+
+        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))
 
-        self.config_plugin.validate_config(self.config)
+        self.config_plugin.validate_config(config, self.specs.openstack)
 
 
 def parse_opts_from_cli():
     parser = argparse.ArgumentParser()
 
+    parser.add_argument('--status', dest='status',
+                        action='store_true',
+                        default=None,
+                        help='Provide NFVbench status')
+
     parser.add_argument('-c', '--config', dest='config',
                         action='store',
                         help='Override default values with a config file or '
@@ -235,7 +247,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')
 
@@ -274,6 +286,12 @@ def parse_opts_from_cli():
                         action='store_true',
                         help='Use SRIOV (no vswitch - requires SRIOV support in compute nodes)')
 
+    parser.add_argument('--use-sriov-middle-net', dest='use_sriov_middle_net',
+                        default=None,
+                        action='store_true',
+                        help='Use SRIOV to handle the middle network traffic '
+                             '(PVVP with SRIOV only)')
+
     parser.add_argument('-d', '--debug', dest='debug',
                         action='store_true',
                         default=None,
@@ -283,10 +301,6 @@ def parse_opts_from_cli():
                         action='store',
                         help='Traffic generator profile to use')
 
-    parser.add_argument('-i', '--image', dest='image_name',
-                        action='store',
-                        help='VM image name to use')
-
     parser.add_argument('-0', '--no-traffic', dest='no_traffic',
                         default=None,
                         action='store_true',
@@ -298,30 +312,25 @@ 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',
+    parser.add_argument('--no-vswitch-access', dest='no_vswitch_access',
                         default=None,
                         action='store_true',
-                        help='Skip interfaces config on EXT service chain')
+                        help='Skip vswitch configuration and retrieving of stats')
 
-    parser.add_argument('--no-tor-access', dest='no_tor_access',
+    parser.add_argument('--no-cleanup', dest='no_cleanup',
                         default=None,
                         action='store_true',
-                        help='Skip TOR switch configuration and retrieving of stats')
+                        help='no cleanup after run')
 
-    parser.add_argument('--no-vswitch-access', dest='no_vswitch_access',
+    parser.add_argument('--cleanup', dest='cleanup',
                         default=None,
                         action='store_true',
-                        help='Skip vswitch configuration and retrieving of stats')
+                        help='Cleanup NFVbench resources (prompt to confirm)')
 
-    parser.add_argument('--no-cleanup', dest='no_cleanup',
+    parser.add_argument('--force-cleanup', dest='force_cleanup',
                         default=None,
                         action='store_true',
-                        help='no cleanup after run')
+                        help='Cleanup NFVbench resources (do not prompt)')
 
     parser.add_argument('--json', dest='json',
                         action='store',
@@ -365,6 +374,20 @@ def parse_opts_from_cli():
                         default=None,
                         help='Override traffic profile direction (requires -fs)')
 
+    parser.add_argument('--log-file', '--logfile', dest='log_file',
+                        action='store',
+                        help='Filename for saving logs',
+                        metavar='<log_file>')
+
+    parser.add_argument('--user-label', '--userlabel', dest='user_label',
+                        action='store',
+                        help='Custom label for performance records')
+
+    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')
+
     opts, unknown_opts = parser.parse_known_args()
     return opts, unknown_opts
 
@@ -377,8 +400,7 @@ def load_default_config():
 
 
 def override_custom_traffic(config, frame_sizes, unidir):
-    """Override the traffic profiles with a custom one
-    """
+    """Override the traffic profiles with a custom one."""
     if frame_sizes is not None:
         traffic_profile_name = "custom_traffic_profile"
         config.traffic_profile = [
@@ -396,17 +418,38 @@ def override_custom_traffic(config, frame_sizes, unidir):
         "profile": traffic_profile_name
     }
 
+
 def check_physnet(name, netattrs):
     if not netattrs.physical_network:
         raise Exception("SRIOV requires physical_network to be specified for the {n} network"
-                            .format(n=name))
+                        .format(n=name))
     if not netattrs.segmentation_id:
         raise Exception("SRIOV requires segmentation_id to be specified for the {n} network"
-                            .format(n=name))
+                        .format(n=name))
+
+def status_cleanup(config, cleanup, force_cleanup):
+    LOG.info('Version: %s', pbr.version.VersionInfo('nfvbench').version_string_with_vcs())
+    # check if another run is pending
+    ret_code = 0
+    try:
+        with utils.RunLock():
+            LOG.info('Status: idle')
+    except Exception:
+        LOG.info('Status: busy (run pending)')
+        ret_code = 1
+    # check nfvbench resources
+    if config.openrc_file and config.service_chain != ChainType.EXT:
+        cleaner = Cleaner(config)
+        count = cleaner.show_resources()
+        if count and (cleanup or force_cleanup):
+            cleaner.clean(not force_cleanup)
+    sys.exit(ret_code)
 
 def main():
+    global fluent_logger
+    run_summary_required = False
     try:
-        log.setup('nfvbench')
+        log.setup()
         # load default config file
         config, default_cfg = load_default_config()
         # create factory for platform specific classes
@@ -419,10 +462,9 @@ def main():
         # create config plugin for this platform
         config_plugin = factory.get_config_plugin_class()(config)
         config = config_plugin.get_config()
-        openstack_spec = config_plugin.get_openstack_spec()
 
         opts, unknown_opts = parse_opts_from_cli()
-        log.set_level('nfvbench', debug=opts.debug)
+        log.set_level(debug=opts.debug)
 
         if opts.version:
             print pbr.version.VersionInfo('nfvbench').version_string_with_vcs()
@@ -430,7 +472,10 @@ def main():
 
         if opts.summary:
             with open(opts.summary) as json_data:
-                print NFVBenchSummarizer(json.load(json_data))
+                result = json.load(json_data)
+                if opts.user_label:
+                    result['config']['user_label'] = opts.user_label
+                print NFVBenchSummarizer(result, fluent_logger)
             sys.exit(0)
 
         # show default config in text/yaml format
@@ -440,15 +485,25 @@ def main():
 
         config.name = ''
         if opts.config:
+            # do not check extra_specs in flavor as it can contain any key/value pairs
+            whitelist_keys = ['extra_specs']
             # override default config options with start config at path parsed from CLI
             # check if it is an inline yaml/json config or a file name
             if os.path.isfile(opts.config):
-                LOG.info('Loading configuration file: ' + opts.config)
-                config = config_load(opts.config, config)
+                LOG.info('Loading configuration file: %s', opts.config)
+                config = config_load(opts.config, config, whitelist_keys)
                 config.name = os.path.basename(opts.config)
             else:
-                LOG.info('Loading configuration string: ' + opts.config)
-                config = config_loads(opts.config, config)
+                LOG.info('Loading configuration string: %s', opts.config)
+                config = config_loads(opts.config, config, whitelist_keys)
+
+        # setup the fluent logger as soon as possible right after the config plugin is called,
+        # if there is any logging or result tag is set then initialize the fluent logger
+        for fluentd in config.fluentd:
+            if fluentd.logging_tag or fluentd.result_tag:
+                fluent_logger = FluentLogHandler(config.fluentd)
+                LOG.addHandler(fluent_logger)
+                break
 
         # traffic profile override options
         override_custom_traffic(config, opts.frame_sizes, opts.unidir)
@@ -457,30 +512,73 @@ def main():
         config.generator_profile = opts.generator_profile
         if opts.sriov:
             config.sriov = True
-
-        # show running config in json format
-        if opts.show_config:
-            print json.dumps(config, sort_keys=True, indent=4)
-            sys.exit(0)
+        if opts.log_file:
+            config.log_file = opts.log_file
+        if opts.service_chain:
+            config.service_chain = opts.service_chain
+        if opts.service_chain_count:
+            config.service_chain_count = opts.service_chain_count
+        if opts.no_vswitch_access:
+            config.no_vswitch_access = opts.no_vswitch_access
+
+        # 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
+            if not config.no_arp:
+                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/no ARP')
+
+        if opts.use_sriov_middle_net:
+            if (not config.sriov) or (config.service_chain != ChainType.PVVP):
+                raise Exception("--use-sriov-middle-net is only valid for PVVP with SRIOV")
+            config.use_sriov_middle_net = True
 
         if config.sriov and config.service_chain != ChainType.EXT:
             # if sriov is requested (does not apply to ext chains)
             # make sure the physnet names are specified
             check_physnet("left", config.internal_networks.left)
             check_physnet("right", config.internal_networks.right)
-            if config.service_chain == ChainType.PVVP:
+            if config.service_chain == ChainType.PVVP and config.use_sriov_middle_net:
                 check_physnet("middle", config.internal_networks.middle)
 
+        # show running config in json format
+        if opts.show_config:
+            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)
 
-        nfvbench = NFVBench(config, openstack_spec, config_plugin, factory)
+        if opts.status or opts.cleanup or opts.force_cleanup:
+            status_cleanup(config, opts.cleanup, opts.force_cleanup)
+
+        # add file log if requested
+        if config.log_file:
+            log.add_file_logger(config.log_file)
+
+        openstack_spec = config_plugin.get_openstack_spec() if config.openrc_file \
+            else None
+
+        nfvbench_instance = NFVBench(config, openstack_spec, config_plugin, factory)
 
         if opts.server:
             if os.path.isdir(opts.server):
-                server = WebSocketIoServer(opts.server, nfvbench)
-                nfvbench.set_notifier(server)
+                server = WebSocketIoServer(opts.server, nfvbench_instance, fluent_logger)
+                nfvbench_instance.set_notifier(server)
                 try:
                     port = int(opts.port)
                 except ValueError:
@@ -492,25 +590,36 @@ def main():
                 sys.exit(1)
         else:
             with utils.RunLock():
+                run_summary_required = True
                 if unknown_opts:
-                    LOG.warning('Unknown options: ' + ' '.join(unknown_opts))
+                    err_msg = 'Unknown options: ' + ' '.join(unknown_opts)
+                    LOG.error(err_msg)
+                    raise Exception(err_msg)
 
                 # remove unfilled values
                 opts = {k: v for k, v in vars(opts).iteritems() if v is not None}
-                result = nfvbench.run(opts)
+                # get CLI args
+                params = ' '.join(str(e) for e in sys.argv[1:])
+                result = nfvbench_instance.run(opts, params)
                 if 'error_message' in result:
                     raise Exception(result['error_message'])
 
                 if 'result' in result and result['status']:
-                    nfvbench.save(result['result'])
-                    nfvbench.print_summary(result['result'])
+                    nfvbench_instance.save(result['result'])
+                    nfvbench_instance.prepare_summary(result['result'])
     except Exception as exc:
+        run_summary_required = True
         LOG.error({
             'status': NFVBench.STATUS_ERROR,
             'error_message': traceback.format_exc()
         })
         print str(exc)
-        sys.exit(1)
+    finally:
+        if fluent_logger:
+            # only send a summary record if there was an actual nfvbench run or
+            # if an error/exception was logged.
+            fluent_logger.send_run_summary(run_summary_required)
+
 
 if __name__ == '__main__':
     main()