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

diff --git a/nfvbench/nfvbench.py b/nfvbench/nfvbench.py
index f17b51c..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,32 +27,34 @@ from attrdict import AttrDict
 import pbr.version
 from pkg_resources import resource_string
 
-from __init__ import __version__
-from chain_runner import ChainRunner
-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
 
 
 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
@@ -63,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.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 = ''
@@ -89,9 +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 = []
+            # 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) < 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.upper())
+            self.config.frame_sizes = new_frame_sizes
             result = {
                 "date": datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
                 "nfvbench_version": __version__,
@@ -118,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
@@ -129,7 +152,7 @@ class NFVBench(object):
         }
 
     def prepare_summary(self, result):
-        """Prepares summary of the result to print and send it to logger (eg: fluentd)"""
+        """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))
@@ -144,102 +167,90 @@ 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',
+                        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 '
@@ -248,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',
@@ -264,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')
 
@@ -296,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,
@@ -318,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',
@@ -329,30 +343,35 @@ 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',
+    parser.add_argument('--no-vswitch-access', dest='no_vswitch_access',
+                        default=None,
+                        action='store_true',
+                        help='Skip vswitch configuration and retrieving of stats')
+
+    parser.add_argument('--vxlan', dest='vxlan',
                         default=None,
                         action='store_true',
-                        help='Do not reset counters prior to running')
+                        help='Enable VxLan encapsulation')
 
-    parser.add_argument('--no-int-config', dest='no_int_config',
+    parser.add_argument('--no-cleanup', dest='no_cleanup',
                         default=None,
                         action='store_true',
-                        help='Skip interfaces config on EXT service chain')
+                        help='no cleanup after run')
 
-    parser.add_argument('--no-tor-access', dest='no_tor_access',
+    parser.add_argument('--cleanup', dest='cleanup',
                         default=None,
                         action='store_true',
-                        help='Skip TOR switch configuration and retrieving of stats')
+                        help='Cleanup NFVbench resources (prompt to confirm)')
 
-    parser.add_argument('--no-vswitch-access', dest='no_vswitch_access',
+    parser.add_argument('--force-cleanup', dest='force_cleanup',
                         default=None,
                         action='store_true',
-                        help='Skip vswitch configuration and retrieving of stats')
+                        help='Cleanup NFVbench resources (do not prompt)')
 
-    parser.add_argument('--no-cleanup', dest='no_cleanup',
+    parser.add_argument('--restart', dest='restart',
                         default=None,
                         action='store_true',
-                        help='no cleanup after run')
+                        help='Restart TRex server')
 
     parser.add_argument('--json', dest='json',
                         action='store',
@@ -405,6 +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
 
@@ -417,8 +471,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 = [
@@ -445,6 +498,23 @@ def check_physnet(name, netattrs):
         raise Exception("SRIOV requires segmentation_id to be specified for the {n} network"
                         .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
@@ -464,19 +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)
 
-        # 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
-
         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:
@@ -484,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 = ''
@@ -506,6 +568,14 @@ def main():
                 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)
 
@@ -521,11 +591,35 @@ 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
+            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 (not config.service_chain == ChainType.PVVP):
+            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
 
@@ -539,21 +633,16 @@ 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)
 
+        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)
@@ -564,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
@@ -585,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)
@@ -601,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