# 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
-from fluentd import FluentLogHandler
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 WebServer
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, 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 = ''
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 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__,
- "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": {
}
}
}
+ 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
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
- }
-
- def print_summary(self, result):
- """Print summary of the result"""
- summary = NFVBenchSummarizer(result)
+ if status == NFVBench.STATUS_OK:
+ # result2 = utils.dict_to_json_dict(result)
+ return {
+ 'status': status,
+ 'result': result
+ }
+ return {
+ 'status': status,
+ 'error_message': message
+ }
+
+ 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):
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)
+ 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))
- self.config_plugin.validate_config(self.config, self.specs.openstack)
+ # 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)
+ # 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)')
-def parse_opts_from_cli():
+ 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 '
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',
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')
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,
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,
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('-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,
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='Do not reset counters prior to running')
+ help='Skip vswitch configuration and retrieving of stats')
- parser.add_argument('--no-int-config', dest='no_int_config',
+ parser.add_argument('--vxlan', dest='vxlan',
default=None,
action='store_true',
- help='Skip interfaces config on EXT service chain')
+ help='Enable VxLan encapsulation')
- 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('--restart', dest='restart',
+ default=None,
+ action='store_true',
+ help='Restart TRex server')
parser.add_argument('--json', dest='json',
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('--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
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 = [
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
# 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()
-
- # setup the fluent logger as soon as possible right after the config plugin is called
- if config.fluentd.logging_tag:
- fluent_logger = FluentLogHandler(config.fluentd.logging_tag,
- fluentd_ip=config.fluentd.ip,
- fluentd_port=config.fluentd.port)
- LOG.addHandler(fluent_logger)
- else:
- fluent_logger = None
- opts, unknown_opts = parse_opts_from_cli()
+ opts, unknown_opts = _parse_opts_from_cli()
log.set_level(debug=opts.debug)
if opts.version:
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
# 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)
+ 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)
+ 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)
config.sriov = True
if opts.log_file:
config.log_file = opts.log_file
-
- # show running config in json format
- if opts.show_config:
- print json.dumps(config, sort_keys=True, indent=4)
- sys.exit(0)
+ 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
+ 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 (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)
+
# 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)
- nfvbench = NFVBench(config, openstack_spec, config_plugin, factory)
+ 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, fluent_logger)
- nfvbench.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
opts = {k: v for k, v in vars(opts).iteritems() if v is not None}
# get CLI args
params = ' '.join(str(e) for e in sys.argv[1:])
- result = nfvbench.run(opts, params)
+ 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({
Code Review / nfvbench.git / blobdiff