Removing qos test scenarios due to pyshark removal from

test-requirements.txt. Will add these tests back with new
tempest design and workaround for pyshark

Change-Id: I1d7bd3c906de072263ee76aaf46754e9782aa92b
This commit is contained in:
Deepthi Kandavara Jayarama 2017-07-18 10:47:04 -07:00
parent 908908e93b
commit 3694165a3b

View File

@ -1,580 +0,0 @@
# Copyright 2017 VMware, Inc.
# All Rights Reserved
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
# Below are the requirements to run this test
# 1) Ensure openstack image supports iperf and tcpdump
# 2) Install pyshark on machine running the tests
# 3) Install sshpass on machine running the tests
import subprocess
import time
from oslo_log import log as logging
import pyshark
from tempest import config
from tempest import test
from tempest.common.utils.linux import remote_client
from tempest.lib import decorators
from tempest.lib.common.utils import data_utils
from tempest.lib.common.utils import test_utils
from vmware_nsx_tempest.services.qos import base_qos
from vmware_nsx_tempest.tests.scenario import manager
CONF = config.CONF
LOG = logging.getLogger(__name__)
class TestQoSOps(manager.NetworkScenarioTest):
@classmethod
def skip_checks(cls):
super(TestQoSOps, cls).skip_checks()
if not (CONF.network.project_networks_reachable
or CONF.network.public_network_id):
msg = ('Either project_networks_reachable must be "true", or '
'public_network_id must be defined.')
raise cls.skipException(msg)
if not test.is_extension_enabled('qos', 'network'):
msg = "q-qos extension not enabled."
raise cls.skipException(msg)
@classmethod
def setup_credentials(cls):
cls.set_network_resources()
super(TestQoSOps, cls).setup_credentials()
@classmethod
def resource_setup(cls):
"""setup resources."""
super(TestQoSOps, cls).resource_setup()
cls.admin_mgr = cls.get_client_manager('admin')
cls.primary_mgr = cls.get_client_manager('primary')
cls.adm_qos_client = base_qos.BaseQosClient(cls.admin_mgr)
cls.pri_qos_client = base_qos.BaseQosClient(cls.primary_mgr)
cls.qos_available_rule_types = (
cls.adm_qos_client.available_rule_types())
cls.policies_created = []
@classmethod
def show_network(cls, network_id, client_mgr=None):
"""show network."""
client_mgr = client_mgr if client_mgr else cls.admin_mgr
network = client_mgr.networks_client.show_network(network_id)
return network.get('network', network)
@classmethod
def update_network(cls, network_id, client_mgr=None, **kwargs):
"""update network."""
client_mgr = client_mgr if client_mgr else cls.admin_mgr
network = client_mgr.networks_client.update_network(
network_id, **kwargs)
return network.get('network', network)
@classmethod
def delete_network(cls, network_id, client_mgr=None):
"""delete network."""
client_mgr = client_mgr if client_mgr else cls.admin_mgr
network = client_mgr.networks_client.delete_network(network_id)
return network.get('network', network)
def _create_subnet(self, network, cidr, subnets_client=None, **kwargs):
client = subnets_client or self.subnets_client
body = client.create_subnet(
name=data_utils.rand_name('subnet-qos'),
network_id=network['id'], tenant_id=network['tenant_id'],
cidr=cidr, ip_version=4, **kwargs)
subnet = body.get('subnet', body)
self.addCleanup(test_utils.call_and_ignore_notfound_exc,
client.delete_subnet, subnet['id'])
return subnet
def _create_router(self, router_name=None, admin_state_up=True,
external_network_id=None, enable_snat=None,
**kwargs):
ext_gw_info = {}
if external_network_id:
ext_gw_info['network_id'] = external_network_id
if enable_snat is not None:
ext_gw_info['enable_snat'] = enable_snat
body = self.routers_client.create_router(
name=router_name, external_gateway_info=ext_gw_info,
admin_state_up=admin_state_up, **kwargs)
router = body.get('router', body)
self.addCleanup(self._delete_router, router)
return router
def _delete_router(self, router):
body = self.ports_client.list_ports(device_id=router['id'])
interfaces = body['ports']
for i in interfaces:
test_utils.call_and_ignore_notfound_exc(
self.routers_client.remove_router_interface, router['id'],
subnet_id=i['fixed_ips'][0]['subnet_id'])
self.routers_client.delete_router(router['id'])
def _create_security_group(self):
# Create security group
sg_name = data_utils.rand_name(self.__class__.__name__)
sg_desc = sg_name + " description"
secgroup = self.compute_security_groups_client.create_security_group(
name=sg_name, description=sg_desc)['security_group']
self.assertEqual(secgroup['name'], sg_name)
self.assertEqual(secgroup['description'], sg_desc)
self.addCleanup(
test_utils.call_and_ignore_notfound_exc,
self.compute_security_groups_client.delete_security_group,
secgroup['id'])
rulesets = [
dict(protocol='tcp', port_range_min=22, port_range_max=22),
dict(protocol='icmp'),
dict(protocol='icmp', ethertype='IPv6'),
dict(protocol='udp', ethertype='IPv4')
]
for ruleset in rulesets:
for r_direction in ['ingress', 'egress']:
ruleset['direction'] = r_direction
self._create_security_group_rule(
secgroup=secgroup,
**ruleset)
return secgroup
def create_security_group_rule(self, security_group_id,
cmgr=None, project_id=None,
protocol=None):
cmgr = cmgr or self.cmgr_adm
sgr_client = cmgr.security_group_rules_client
sgr_dict = dict(security_group_id=security_group_id,
direction='ingress', protocol=protocol)
if project_id:
sgr_dict['tenant_id'] = project_id
sgr = sgr_client.create_security_group_rule(**sgr_dict)
return sgr.get('security_group_rule', sgr)
def _create_server(self, name, network, image_id=None):
security_groups = [{'name': self.security_group['name']}]
network = {'uuid': network['id']}
server = self.create_server(name=name, networks=[network],
security_groups=security_groups,
image_id=CONF.compute.image_ref_alt,
wait_until='ACTIVE')
return server
def _get_server_ip(self, server):
addresses = server['addresses'][self.network['name']]
for address in addresses:
if address['version'] == CONF.validation.ip_version_for_ssh:
return address['addr']
def _create_vms(self, network_topo):
"""create a source and dest vm for traffic"""
source_vm = data_utils.rand_name('source_vm')
network = network_topo['network']
src_vm = self._create_server(source_vm, network)
dest_vm = data_utils.rand_name('dest_vm')
dst_vm = self._create_server(dest_vm, network)
servers = dict(dst_vm=dst_vm, src_vm=src_vm)
return servers
@classmethod
def create_qos_policy(cls, name='test-policy',
description='test policy desc',
shared=False,
qos_client=None, **kwargs):
"""create qos policy."""
qos_client = qos_client if qos_client else cls.adm_qos_client
policy = qos_client.create_policy(
name=name, description=description,
shared=shared, **kwargs)
cls.policies_created.append(policy)
return policy
@classmethod
def create_qos_bandwidth_limit_rule(cls, policy_id,
qos_client=None, **kwargs):
"""create qos-bandwidth-limit-rule."""
qos_client = qos_client if qos_client else cls.adm_qos_client
rule = qos_client.create_bandwidth_limit_rule(policy_id, **kwargs)
return rule
@classmethod
def create_qos_dscp_marking_rule(cls, policy_id, dscp_mark,
qos_client=None, **kwargs):
"""create qos-dscp-marking-rule."""
qos_client = qos_client if qos_client else cls.adm_qos_client
rule = qos_client.create_dscp_marking_rule(
policy_id, dscp_mark, **kwargs)
return rule
def check_show_policy(self, policy_id, rule_type=None,
rule_bw=None, rule_dscp=None):
retrieved_policy = self.adm_qos_client.show_policy(policy_id)
policy_rules = retrieved_policy['rules']
if rule_type == 'bw':
self.assertEqual(1, len(policy_rules))
self.assertEqual(rule_bw['id'], policy_rules[0]['id'])
self.assertEqual(base_qos.RULE_TYPE_BANDWIDTH_LIMIT,
policy_rules[0]['type'])
elif rule_type == 'dscp':
self.assertEqual(1, len(policy_rules))
self.assertEqual(rule_dscp['id'], policy_rules[0]['id'])
self.assertEqual(base_qos.RULE_TYPE_DSCP_MARK,
policy_rules[0]['type'])
elif rule_type == 'bw+dscp':
self.assertEqual(2, len(policy_rules))
self.assertEqual(rule_bw['id'], policy_rules[0]['id'])
self.assertEqual(rule_dscp['id'], policy_rules[1]['id'])
self.assertEqual(base_qos.RULE_TYPE_BANDWIDTH_LIMIT,
policy_rules[0]['type'])
self.assertEqual(base_qos.RULE_TYPE_DSCP_MARK,
policy_rules[1]['type'])
def create_qos_network_topo(self):
"""Create basic network topology with 2 instances"""
self.security_group = self._create_security_group()
self.network = self._create_network(namestart="net-qos")
self.addCleanup(test_utils.call_and_ignore_notfound_exc,
self.delete_network, network_id=self.network['id'])
self.subnet = self._create_subnet(self.network,
cidr='192.153.1.0/24')
self.router = self._create_router(
router_name=data_utils.rand_name('router-qos'),
external_network_id=CONF.network.public_network_id)
self.routers_client.add_router_interface(
self.router['id'], subnet_id=self.subnet['id'])
self.addCleanup(self.routers_client.remove_router_interface,
self.router['id'], subnet_id=self.subnet['id'])
qos_topo = dict(network=self.network,
subnet=self.subnet, router=self.router)
return qos_topo
def _test_connectivity_between_vms(self, network_topo, servers):
"""To check if private ip is reachable from both vms"""
floating_ip_src = self.create_floating_ip(
servers['src_vm'])
floating_ip_dst = self.create_floating_ip(servers['dst_vm'])
private_ip_address_dst_vm = floating_ip_dst['fixed_ip_address']
public_ip_address_dst_vm = \
floating_ip_dst['floating_ip_address']
private_ip_address_src_vm = floating_ip_src['fixed_ip_address']
public_ip_address_src_vm = \
floating_ip_src['floating_ip_address']
src_client = remote_client.RemoteClient(
public_ip_address_src_vm,
username=CONF.validation.image_ssh_user,
password=CONF.validation.image_ssh_password)
cmd = ('ifconfig eth0 | grep %s' % private_ip_address_src_vm)
timeout = time.time() + 60 * 5
while True:
if not src_client.exec_command(cmd) or time.time() < timeout:
continue
else:
break
dst_client = remote_client.RemoteClient(
public_ip_address_dst_vm,
username=CONF.validation.image_ssh_user,
password=CONF.validation.image_ssh_password)
# To ensure IP address is assigned to the VM before checking ping
cmd = ('ifconfig eth0 | grep %s' % private_ip_address_dst_vm)
timeout = time.time() + 60 * 5
while True:
if not dst_client.exec_command(cmd) or time.time() < timeout:
continue
else:
break
cmd = ('ping %s -c 3' % private_ip_address_dst_vm)
output_data = src_client.exec_command(cmd)
expected_output = "64 bytes from %s" % private_ip_address_dst_vm
self.assertIn(expected_output, output_data)
cmd = ('ping %s -c 3' % private_ip_address_src_vm)
output_data = dst_client.exec_command(cmd)
expected_output = "64 bytes from %s" % private_ip_address_src_vm
self.assertIn(expected_output, output_data)
vm_environment = dict(src_public_ip=public_ip_address_src_vm,
dst_public_ip=public_ip_address_dst_vm,
src_private_ip=private_ip_address_src_vm,
dst_private_ip=private_ip_address_dst_vm)
return vm_environment
def _test_bandwidth_rule(self, vm_env, max_mbps):
"""To verify traffic being capped according to bandwidth_rule"""
src_client = remote_client.RemoteClient(
vm_env['src_public_ip'], username='root', password='nicira')
dst_client = remote_client.RemoteClient(
vm_env['dst_public_ip'], username='root', password='nicira')
# set up iperf server on destination VM
cmd = ('iperf -p 49162 -s -u > /dev/null 2>&1 &')
dst_client.exec_command(cmd)
# sending traffic greater than configured value
sending_rate = max_mbps + 1
# set up iperf client on source VM
LOG.info("Traffic sending rate: {sr}".format(sr=sending_rate))
cmd = ('iperf -p 49162 -c %s -b %sM -t 1 -u | grep %%'
% (unicode(vm_env['dst_private_ip']), unicode(sending_rate)))
output = src_client.exec_command(cmd)
bandwidth_value = output.split()[7]
# kill the iperf process on destination VM
cmd = ('ps -ef | grep iperf ')
output = dst_client.exec_command(cmd)
for line in output.splitlines():
if 'iperf -p 49162 -s -u' not in line:
continue
else:
iperf_process_id = line.split()[1]
cmd = ('kill %s' % (unicode(iperf_process_id)))
dst_client.exec_command(cmd)
"""Check if traffic received is greater than configured value
For example if configured value is 5Mbps and sending rate is 6Mbps
Traffic should be capped below 5.5 which includes default burst"""
if (float(bandwidth_value) - float(max_mbps)) > 0.5:
LOG.info("Traffic received: {bw}".format(bw=bandwidth_value))
raise Exception('Traffic is not limited by bw-limit rule')
elif(float(max_mbps) - float(bandwidth_value)) > 0.5:
LOG.info("Traffic received: {bw}".format(bw=bandwidth_value))
raise Exception('Traffic is limited below configured value')
def _test_dscp_rule(self, vm_env, dscp_value):
"""To verify if traffic is being marked according to dscp_value"""
src_client = remote_client.RemoteClient(
vm_env['src_public_ip'], username='root', password='nicira')
dst_client = remote_client.RemoteClient(
vm_env['dst_public_ip'], username='root', password='nicira')
dscp_filename = 'dscp_' + str(dscp_value) + '.pcap'
# To capture packets from eth0
cmd = ('nohup tcpdump -ni eth0 -w %s > /dev/null 2>&1 &'
% dscp_filename)
dst_client.exec_command(cmd)
# Iperf server on destination VM
cmd = ('iperf -p 49162 -s -u > /dev/null 2>&1 &')
dst_client.exec_command(cmd)
# Iperf client on source VM
cmd = ('iperf -p 49162 -c %s -b 1M -t 1 -u | grep %%'
% (unicode(vm_env['dst_private_ip'])))
output = src_client.exec_command(cmd)
loss_prcnt = output.split()[13].strip('()%')
loss_val = float(loss_prcnt) if '.' in loss_prcnt else int(loss_prcnt)
if (loss_val > 50.0):
raise Exception('Huge packet loss at the destination VM')
# Kill iperf process on destination VM
cmd = ('ps -ef | grep iperf ')
output = dst_client.exec_command(cmd)
for line in output.splitlines():
if 'iperf -p 49162 -s -u' not in line:
continue
else:
iperf_process_id = line.split()[1]
cmd = ('kill %s' % (unicode(iperf_process_id)))
dst_client.exec_command(cmd)
# kill tcpdump process on destination VM
cmd = ('ps -ef | grep tcpdump')
output = dst_client.exec_command(cmd)
for line in output.splitlines():
if 'tcpdump -ni eth0 -w' not in line:
continue
else:
tcpdump_process_id = line.split()[1]
cmd = ('kill %s' % (unicode(tcpdump_process_id)))
dst_client.exec_command(cmd)
# To copy pcap (packet capture) file from destination VM to external VM
cmd = ('sshpass -p \"nicira\" scp -o StrictHostKeyChecking=no'
' root@%s:/root/%s .'
% (unicode(vm_env['dst_public_ip']), unicode(dscp_filename)))
try:
subprocess.check_call(cmd, shell=True, executable='/bin/bash',
stderr=subprocess.STDOUT)
except Exception as e:
message = ('Failed to copy file from VM.'
'Error: %(error)s' % {'error': e})
LOG.exception(message)
raise
"""Check the entire file to see if any UDP packets are sent without configured
dscp value.Example capture all UDP packets with DSCP value !=12"""
filter_string = (
'ip.dsfield.dscp != %s && udp.dstport == 49162 '
'&& ip.src == %s && ip.dst == %s' %
(str(dscp_value), (unicode(
vm_env['src_private_ip'])), (unicode(
vm_env['dst_private_ip']))))
capture = pyshark.FileCapture(dscp_filename,
display_filter=filter_string)
# capture file includes all packets that match the filter criteria
if len(capture) > 0:
raise Exception('Traffic is being marked with incorrect DSCP')
class QosBandwidthLimitRuleTest(TestQoSOps):
BW_VALUE_KBPS = 5000
BW_VALUE_MBPS = 5
@decorators.idempotent_id('68fa3170-b61c-4e69-b0b7-6cbe34b57724')
def test_qos_bw_rule(self):
"""Test bandwidth_limit rule by sending traffic between two instances
and verifying if egress traffic is being bandwidth-limited
"""
qos_client = self.adm_qos_client
policy = self.create_qos_policy(name='test-qos-policy',
description='bandwidth_rule',
shared=False)
self.addCleanup(test_utils.call_and_ignore_notfound_exc,
self.adm_qos_client.delete_policy, policy['id'])
rule = self.create_qos_bandwidth_limit_rule(
policy_id=policy['id'], max_kbps=self.BW_VALUE_KBPS,
max_burst_kbps=0)
# Test 'show rule'
retrieved_rule = qos_client.show_bandwidth_limit_rule(
rule['id'], policy['id'])
self.assertEqual(rule['id'], retrieved_rule['id'])
self.assertEqual(self.BW_VALUE_KBPS, retrieved_rule['max_kbps'])
# Test 'list rules'
rules = qos_client.list_bandwidth_limit_rules(policy['id'])
rules_ids = [r['id'] for r in rules]
self.assertIn(rule['id'], rules_ids)
# Test 'show policy'
self.check_show_policy(policy_id=policy['id'], rule_type='bw',
rule_bw=rule)
self.network_topo = self.create_qos_network_topo()
self.update_network(
self.network_topo['network']['id'], qos_policy_id=policy['id'])
updated_network = self.show_network(self.network_topo['network']['id'])
self.assertEqual(
policy['id'], updated_network['qos_policy_id'])
self.servers = self._create_vms(self.network_topo)
vm_env = self._test_connectivity_between_vms(self.network_topo,
self.servers)
self._test_bandwidth_rule(vm_env, max_mbps=self.BW_VALUE_MBPS)
class QosDSCPRuleTest(TestQoSOps):
DSCP_MARK = 12
@decorators.idempotent_id('f00f77c4-2963-4e28-8cb9-d6a51d92262d')
def test_qos_dscp_rule(self):
"""Test DSCP rule by sending traffic between two instances
and verifying if egress traffic is being marked
"""
qos_client = self.adm_qos_client
policy = self.create_qos_policy(name='test-qos-policy',
description='dscp_rule',
shared=False)
self.addCleanup(test_utils.call_and_ignore_notfound_exc,
self.adm_qos_client.delete_policy, policy['id'])
# add dscp rule
rule = self.create_qos_dscp_marking_rule(
policy_id=policy['id'], dscp_mark=12)
# Test 'show rule'
retrieved_rule = qos_client.show_dscp_marking_rule(
rule['id'], policy['id'])
self.assertEqual(rule['id'], retrieved_rule['id'])
self.assertEqual(self.DSCP_MARK, retrieved_rule['dscp_mark'])
# Test 'list rules'
rules = qos_client.list_dscp_marking_rules(policy['id'])
rules_ids = [r['id'] for r in rules]
self.assertIn(rule['id'], rules_ids)
# Test 'show policy'
self.check_show_policy(policy_id=policy['id'],
rule_type='dscp', rule_dscp=rule)
self.network_topo = self.create_qos_network_topo()
self.update_network(
self.network_topo['network']['id'], qos_policy_id=policy['id'])
updated_network = self.show_network(self.network_topo['network']['id'])
self.assertEqual(
policy['id'], updated_network['qos_policy_id'])
self.servers = self._create_vms(self.network_topo)
vm_env = self._test_connectivity_between_vms(self.network_topo,
self.servers)
self._test_dscp_rule(vm_env, dscp_value=self.DSCP_MARK)
class QosBWDSCPRuleTest(TestQoSOps):
BW_VALUE_KBPS = 5000
BW_VALUE_MBPS = 5
DSCP_MARK = 16
@decorators.idempotent_id('77ae2231-029f-4f7f-9858-3d610fb62386')
def test_qos_bw_dscp_rule(self):
"""Test BW and DSCP rule by sending traffic between two instances
and verifying if egress traffic is being marked and bandwidth-limited
"""
qos_client = self.adm_qos_client
policy = self.create_qos_policy(name='test-qos-policy',
description='dscp_rule and bw_rule',
shared=False)
self.addCleanup(test_utils.call_and_ignore_notfound_exc,
self.adm_qos_client.delete_policy, policy['id'])
# add bw rule
rule_bw = self.create_qos_bandwidth_limit_rule(
policy_id=policy['id'], max_kbps=self.BW_VALUE_KBPS,
max_burst_kbps=0)
# add dscp rule
rule_dscp = self.create_qos_dscp_marking_rule(
policy_id=policy['id'], dscp_mark=self.DSCP_MARK)
# Test 'show rule'
retrieved_rule = qos_client.show_bandwidth_limit_rule(
rule_bw['id'], policy['id'])
self.assertEqual(rule_bw['id'], retrieved_rule['id'])
self.assertEqual(self.BW_VALUE_KBPS, retrieved_rule['max_kbps'])
# Test 'show rule'
retrieved_rule = qos_client.show_dscp_marking_rule(
rule_dscp['id'], policy['id'])
self.assertEqual(rule_dscp['id'], retrieved_rule['id'])
self.assertEqual(self.DSCP_MARK, retrieved_rule['dscp_mark'])
# Test 'list rules'
rules = qos_client.list_bandwidth_limit_rules(policy['id'])
rules_ids = [r['id'] for r in rules]
self.assertIn(rule_bw['id'], rules_ids)
# Test 'list rules'
rules = qos_client.list_dscp_marking_rules(policy['id'])
rules_ids = [r['id'] for r in rules]
self.assertIn(rule_dscp['id'], rules_ids)
# Test 'show policy'
self.check_show_policy(policy_id=policy['id'], rule_type='bw+dscp',
rule_bw=rule_bw, rule_dscp=rule_dscp)
self.network_topo = self.create_qos_network_topo()
self.update_network(
self.network_topo['network']['id'], qos_policy_id=policy['id'])
updated_network = self.show_network(self.network_topo['network']['id'])
self.assertEqual(
policy['id'], updated_network['qos_policy_id'])
self.servers = self._create_vms(self.network_topo)
vm_env = self._test_connectivity_between_vms(self.network_topo,
self.servers)
self._test_bandwidth_rule(vm_env, max_mbps=self.BW_VALUE_MBPS)
self._test_dscp_rule(vm_env, dscp_value=self.DSCP_MARK)