vmware-nsx-tempest-plugin/vmware_nsx_tempest_plugin/tests/scenario/test_qos.py

# 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.

import subprocess
import time

from oslo_log import log as logging
from tempest import config
from tempest.lib.common.utils import data_utils
from tempest.lib import decorators
from tempest import test

from vmware_nsx_tempest_plugin.lib import feature_manager
from vmware_nsx_tempest_plugin.services import nsx_client

CONF = config.CONF
CONF.validation.auth_method = 'None'

LOG = logging.getLogger(__name__)

DSCP_MARK = 12
DSCP_MARK_UPDATED = 16
BW_VALUE_KBPS = 1024
BW_VALUE_MBPS = 1
UPDATED_BW_VALUE_KBPS = 2048
UPDATED_BW_VALUE_MBPS = 2
MAX_BURST_KBPS = 1024000
MAX_BURST_MBPS = 1


class TestQosOps(feature_manager.FeatureManager):

    @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 CONF.network.public_network_cidr:
            msg = "public_network_cidr must be defined in network section."
            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()
        cls.admin_mgr = cls.get_client_manager('admin')
        super(TestQosOps, cls).setup_credentials()

    @classmethod
    def setup_clients(cls):
        """
        Create various client connections. Such as NSX.
        """
        super(TestQosOps, cls).setup_clients()
        cls.nsx_client = nsx_client.NSXClient(
            CONF.network.backend,
            CONF.nsxv3.nsx_manager,
            CONF.nsxv3.nsx_user,
            CONF.nsxv3.nsx_password)

    def define_security_groups(self):
        self.qos_sg = self.create_topology_empty_security_group(
            namestart="qos_sg_")
        # Common rules to allow the following traffic
        # 1. Egress ICMP IPv4 any any
        # 2. Egress ICMP IPv6 any any
        # 3. Ingress ICMP IPv4 from public network
        # 4. Ingress TCP 22 (SSH) from public network
        common_ruleset = [dict(direction='egress', protocol='icmp'),
                          dict(direction='egress', protocol='icmp',
                               ethertype='IPv6'),
                          dict(direction='egress', protocol='tcp',
                               port_range_min=22, port_range_max=22),
                          dict(direction='egress', protocol='udp'),
                          dict(direction='ingress', protocol='tcp',
                               port_range_min=22, port_range_max=22),
                          dict(direction='ingress', protocol='udp'),
                          dict(direction='ingress', protocol='icmp')]
        for rule in common_ruleset:
            self.add_security_group_rule(self.qos_sg, rule)

    def check_show_policy(self, policy_id, rule_type=None,
                          rule_bw=None, rule_dscp=None):
        retrieved_policy = self.show_qos_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(feature_manager.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(feature_manager.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(feature_manager.RULE_TYPE_BANDWIDTH_LIMIT,
                             policy_rules[0]['type'])
            self.assertEqual(feature_manager.RULE_TYPE_DSCP_MARK,
                             policy_rules[1]['type'])

    def deploy_qos_ops_topology(self):
        router_qos = self.create_topology_router("router_qos")
        # Qos network
        network_qos = self.create_topology_network("network_qos")
        self.create_topology_subnet("subnet_qos", network_qos,
                           router_id=router_qos["id"])
        return network_qos

    def create_qos_bw_setup(self, bw_value_kbps, burst_kbps=0):
        name = data_utils.rand_name('test-qos-policy-')
        policy = self.create_qos_policy(name,
                                        description='bandwidth_rule',
                                        shared=False)
        rule = self.create_bandwidth_limit_rule(
            policy_id=policy['id'], max_kbps=bw_value_kbps,
            max_burst_kbps=burst_kbps)
        # Test 'show rule'
        retrieved_rule = self.show_bandwidth_limit_rule(
            rule['id'], policy['id'])
        self.assertEqual(rule['id'], retrieved_rule['id'])
        self.assertEqual(bw_value_kbps, retrieved_rule['max_kbps'])
        self.assertEqual(burst_kbps, retrieved_rule['max_burst_kbps'])

        network = self.deploy_qos_ops_topology()
        # Test 'list rules'
        rules = self.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)

        #Verify backend
        nsx_policy = self.nsx_client.get_qos_switching_profile(policy['name'])
        #verify bandwidth-limit rule at the backend
        avg_bw, peak_bw, max_burst = self.nsx_client.get_qos_bandwidth_rule(
            nsx_policy['id'])
        #check the values at the backend
        msg = 'Backend bw-limit rule values are incorrect'
        self.assertEqual(avg_bw, BW_VALUE_MBPS, msg)
        self.assertEqual(peak_bw, BW_VALUE_MBPS * 2, msg)
        self.assertEqual(max_burst, 0, msg)
        return dict(network_qos=network,
            policy_id=policy['id'])

    def create_qos_dscp_setup(self, dscp_mark):
        name = data_utils.rand_name('test-qos-policy-')
        policy = self.create_qos_policy(name,
                                        description='dscp_rule',
                                        shared=False)
        # add dscp rule
        rule = self.create_dscp_marking_rule(
            policy_id=policy['id'], dscp_mark=dscp_mark)

        # Test 'show rule'
        retrieved_rule = self.show_dscp_marking_rule(
            rule['id'], policy['id'])
        self.assertEqual(rule['id'], retrieved_rule['id'])
        self.assertEqual(DSCP_MARK, retrieved_rule['dscp_mark'])

        network = self.deploy_qos_ops_topology()
        # Test 'list rules'
        rules = self.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)
        #Verify backend
        nsx_policy = self.nsx_client.get_qos_switching_profile(policy['name'])
        #verify dscp rule at the backend
        dscp_value = self.nsx_client.get_qos_dscp_rule(
            nsx_policy['id'])
        #check the values at the backend
        msg = 'Backend DSCP value is incorrect'
        self.assertEqual(dscp_value, DSCP_MARK, msg)
        return dict(network_qos=network,
            policy_id=policy['id'])

    def create_qos_bw_dscp_setup(self, bw_value_kbps, dscp_mark, burst_kbps=0):
        name = data_utils.rand_name('test-qos-policy-')
        policy = self.create_qos_policy(name,
                                        description='bw_dscp_rule',
                                        shared=False)
        # add bw rule
        self.create_bandwidth_limit_rule(
            policy_id=policy['id'], max_kbps=bw_value_kbps,
            max_burst_kbps=burst_kbps)
        # add dscp rule
        self.create_dscp_marking_rule(
            policy_id=policy['id'], dscp_mark=dscp_mark)
        network = self.deploy_qos_ops_topology()
        #Verify backend
        nsx_policy = self.nsx_client.get_qos_switching_profile(policy['name'])
        #verify bandwidth-limit rule at the backend
        avg_bw, peak_bw, max_burst = self.nsx_client.get_qos_bandwidth_rule(
            nsx_policy['id'])
        #check the values at the backend
        msg = 'Backend bw-limit rule values are incorrect'
        self.assertEqual(avg_bw, BW_VALUE_MBPS, msg)
        self.assertEqual(peak_bw, BW_VALUE_MBPS * 2, msg)
        self.assertEqual(max_burst, 0, msg)
        #verify dscp rule at the backend
        dscp_value = self.nsx_client.get_qos_dscp_rule(
            nsx_policy['id'])
        #check the values at the backend
        msg = 'Backend DSCP value is incorrect'
        self.assertEqual(dscp_value, DSCP_MARK, msg)
        return dict(network_qos=network,
            policy_id=policy['id'])

    def create_vms(self, network):
        #Obtain image id of debian_vmdk used for qos testing
        image_id = self.get_glance_image_id('debian')
        qos_src_vm = self.create_topology_instance(
            "qos_src_vm", [network],
            security_groups=[{'name': self.qos_sg['name']}],
            create_floating_ip=True, image_id=image_id)
        qos_dst_vm = self.create_topology_instance(
            "qos_dst_vm", [network],
            security_groups=[{'name': self.qos_sg['name']}],
            create_floating_ip=True, image_id=image_id)
        return (qos_src_vm, qos_dst_vm)

    def check_internal_connectivity(self, network):
        src_server_floatingip = self.topology_servers["qos_src_vm"][
            "floating_ip"]
        src_server = self.topology_servers["qos_src_vm"]
        self.check_vm_internal_connectivity(network,
            src_server_floatingip, src_server)
        dst_server_floatingip = self.topology_servers["qos_dst_vm"][
            "floating_ip"]
        dst_server = self.topology_servers["qos_dst_vm"]
        self.check_vm_internal_connectivity(network,
           dst_server_floatingip, dst_server)

    def verify_bandwidth_rule(self, max_mbps, max_burst=0):
        """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
        """
        send_rate = max_mbps + max_burst + 1
        bw_value = self.use_iperf_send_traffic(
            src_server=self.topology_servers["qos_src_vm"],
            dst_server=self.topology_servers["qos_dst_vm"],
            send_rate=send_rate, traffic_type='udp')
        if bw_value == -1:
            raise Exception('Incorrect IPERF output received')
        elif float(bw_value) - (float(max_mbps) + float(max_burst)) > 0.5:
            LOG.info("Traffic received: {bw}".format(bw=bw_value))
            raise Exception('Traffic is not limited by bw-limit rule')
        elif((float(max_mbps) + float(max_burst)) - float(bw_value)) > 0.5:
            LOG.info("Traffic received: {bw}".format(bw=bw_value))
            raise Exception('Traffic is limited below configured value')

    def verify_dscp_rule(self, dscp_value):
        """Check if traffic received is marked with configured dscp value
        """
        dscp_filename = self.capture_iperf_traffic_dscp(
            src_server=self.topology_servers["qos_src_vm"],
            dst_server=self.topology_servers["qos_dst_vm"],
            traffic_type='udp', send_dscp='0', interface='eth0')
        # 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
        src_vm_ip_dict = self.topology_servers['qos_src_vm']['floating_ips'][0]
        filter_string = ('tshark -r %s -Y '
            '\"ip.dsfield.dscp != %s && udp.dstport == 49162 '
            '&& ip.src == %s && ip.dst == %s\"' %
            (dscp_filename, str(dscp_value),
            src_vm_ip_dict['fixed_ip_address'],
            self.topology_servers['qos_dst_vm']))
        p = subprocess.Popen(filter_string, shell=True,
                             stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
        stdout, stderr = p.communicate()
        LOG.info(stdout)
        LOG.info(stderr)
        #output should not contain packet trace
        if "Source port:" in stdout:
            raise Exception('Traffic is not being marked with correct DSCP')


class QosBandwidthLimitRuleTest(TestQosOps):

    @decorators.idempotent_id('68fa3170-b61c-4e69-b0b7-6cbe34b57724')
    def test_qos_bw_rule_network(self):
        """
        Test bandwidth_limit rule by sending traffic between two instances
        and verifying if egress traffic is being bandwidth-limited
        """
        self.define_security_groups()
        qos_bw_dict = self.create_qos_bw_setup(bw_value_kbps=BW_VALUE_KBPS)
        self.admin_mgr.networks_client.update_network(
            qos_bw_dict['network_qos']['id'],
            qos_policy_id=qos_bw_dict['policy_id'])
        updated_network = self.admin_mgr.networks_client.show_network(
            qos_bw_dict['network_qos']['id'])
        qos_network = updated_network.get('network', updated_network)
        self.assertEqual(
            qos_bw_dict['policy_id'], qos_network['qos_policy_id'])
        self.create_vms(qos_bw_dict['network_qos'])
        #sleep to ensure VMs have finished complete bootup
        time.sleep(120)
        #check bandwidth rule
        self.verify_bandwidth_rule(max_mbps=BW_VALUE_MBPS)

    @decorators.idempotent_id('bf687826-ec76-4655-90a0-cc8f5316eaaf')
    def test_qos_bw_rule_network_with_burst(self):
        """
        Test bandwidth_limit rule by sending traffic between two instances
        and verifying if egress traffic is being bandwidth-limited
        """
        self.define_security_groups()
        qos_bw_dict = self.create_qos_bw_setup(bw_value_kbps=BW_VALUE_KBPS,
            burst_kbps=MAX_BURST_KBPS)
        self.admin_mgr.networks_client.update_network(
            qos_bw_dict['network_qos']['id'],
            qos_policy_id=qos_bw_dict['policy_id'])
        updated_network = self.admin_mgr.networks_client.show_network(
            qos_bw_dict['network_qos']['id'])
        qos_network = updated_network.get('network', updated_network)
        self.assertEqual(
            qos_bw_dict['policy_id'], qos_network['qos_policy_id'])
        self.create_vms(qos_bw_dict['network_qos'])
        #sleep to ensure VMs have finished complete bootup
        time.sleep(120)
        #check bandwidth rule
        self.verify_bandwidth_rule(max_mbps=BW_VALUE_MBPS,
            max_burst=MAX_BURST_MBPS)

    @decorators.idempotent_id('531c7476-6cee-4224-9b23-8e67e4c30703')
    def test_qos_bw_rule_port(self):
        """
        Test bandwidth_limit rule by sending traffic between two instances
        and verifying if egress traffic is being bandwidth-limited
        """
        self.define_security_groups()
        qos_bw_dict = self.create_qos_bw_setup(bw_value_kbps=BW_VALUE_KBPS)
        qos_src_vm, qos_dst_vm = self.create_vms(qos_bw_dict['network_qos'])
        self.os_admin.ports_client.update_port(
            qos_src_vm['floating_ips'][0]['port_id'],
            qos_policy_id=qos_bw_dict['policy_id'])
        self.os_admin.ports_client.update_port(
            qos_dst_vm['floating_ips'][0]['port_id'],
            qos_policy_id=qos_bw_dict['policy_id'])
        #sleep to ensure VMs have finished complete bootup
        time.sleep(120)
        #check bandwidth rule
        self.verify_bandwidth_rule(max_mbps=BW_VALUE_MBPS)

    @decorators.idempotent_id('ae40717f-6a08-4e9c-86d0-87e45375c844')
    def test_qos_bw_rule_port_with_burst(self):
        """
        Test bandwidth_limit rule by sending traffic between two instances
        and verifying if egress traffic is being bandwidth-limited
        """
        self.define_security_groups()
        qos_bw_dict = self.create_qos_bw_setup(bw_value_kbps=BW_VALUE_KBPS,
            burst_kbps=MAX_BURST_KBPS)
        qos_src_vm, qos_dst_vm = self.create_vms(qos_bw_dict['network_qos'])
        self.os_admin.ports_client.update_port(
            qos_src_vm['floating_ips'][0]['port_id'],
            qos_policy_id=qos_bw_dict['policy_id'])
        self.os_admin.ports_client.update_port(
            qos_dst_vm['floating_ips'][0]['port_id'],
            qos_policy_id=qos_bw_dict['policy_id'])
        #sleep to ensure VMs have finished complete bootup
        time.sleep(120)
        #check bandwidth rule
        self.verify_bandwidth_rule(max_mbps=BW_VALUE_MBPS,
            max_burst=MAX_BURST_MBPS)


class QosDSCPRuleTest(TestQosOps):

    @decorators.idempotent_id('40995e11-9231-406e-b3d7-b36dd362a94b')
    def test_qos_dscp_mark_network(self):
        """
        Test qos dscp rule by sending traffic between two instance
        and verifying if egress traffic is marked with dscp value
        """
        self.define_security_groups()
        qos_dscp_dict = self.create_qos_dscp_setup(dscp_mark=DSCP_MARK)
        self.admin_mgr.networks_client.update_network(
            qos_dscp_dict['network_qos']['id'],
            qos_policy_id=qos_dscp_dict['policy_id'])
        updated_network = self.admin_mgr.networks_client.show_network(
            qos_dscp_dict['network_qos']['id'])
        qos_network = updated_network.get('network', updated_network)
        self.assertEqual(
            qos_dscp_dict['policy_id'], qos_network['qos_policy_id'])
        self.create_vms(qos_dscp_dict['network_qos'])
        #sleep to ensure VMs have finished complete bootup
        time.sleep(240)
        #check dscp rule
        self.verify_dscp_rule(dscp_value=DSCP_MARK)

    @decorators.idempotent_id('4c5dc539-2878-4235-8880-35927b7a0c33')
    def test_qos_dscp_mark_port(self):
        """
        Test qos dscp rule by sending traffic between two instance
        and verifying if egress traffic is marked with dscp value
        """
        self.define_security_groups()
        qos_dscp_dict = self.create_qos_dscp_setup(dscp_mark=DSCP_MARK)
        qos_src_vm, qos_dst_vm = self.create_vms(qos_dscp_dict['network_qos'])
        self.os_admin.ports_client.update_port(
            qos_src_vm['floating_ips'][0]['port_id'],
            qos_policy_id=qos_dscp_dict['policy_id'])
        self.os_admin.ports_client.update_port(
            qos_dst_vm['floating_ips'][0]['port_id'],
            qos_policy_id=qos_dscp_dict['policy_id'])
        #sleep to ensure VMs have finished complete bootup
        time.sleep(240)
        #check dscp rule
        self.verify_dscp_rule(dscp_value=DSCP_MARK)


class QosPolicyRuleTest(TestQosOps):

    @decorators.idempotent_id('3566016a-31cc-4905-b217-98844caad4a9')
    def test_qos_bw_dscp_rule_network(self):
        """
        Test qos and bw dscp rule by sending traffic between two instance
        and verifying if traffic is rate-limited and marked with dscp value
        """
        self.define_security_groups()
        qos_bw_dscp_dict = self.create_qos_bw_dscp_setup(
            bw_value_kbps=BW_VALUE_KBPS,
            dscp_mark=DSCP_MARK)
        self.admin_mgr.networks_client.update_network(
            qos_bw_dscp_dict['network_qos']['id'],
            qos_policy_id=qos_bw_dscp_dict['policy_id'])
        updated_network = self.admin_mgr.networks_client.show_network(
            qos_bw_dscp_dict['network_qos']['id'])
        qos_network = updated_network.get('network', updated_network)
        self.assertEqual(
            qos_bw_dscp_dict['policy_id'], qos_network['qos_policy_id'])
        self.create_vms(qos_bw_dscp_dict['network_qos'])
        #sleep to ensure VMs have finished complete bootup
        time.sleep(240)
        #check bandwidth rule
        self.verify_bandwidth_rule(max_mbps=BW_VALUE_MBPS)
        #check dscp rule
        self.verify_dscp_rule(dscp_value=DSCP_MARK)

    @decorators.idempotent_id('c545c322-b37e-45e2-af22-b160a5320594')
    def test_qos_bw_dscp_rule_port(self):
        """
        Test qos and bw dscp rule by sending traffic between two instance
        and verifying if traffic is rate-limited and marked with dscp value
        """
        self.define_security_groups()
        qos_bw_dscp_dict = self.create_qos_bw_dscp_setup(
            bw_value_kbps=BW_VALUE_KBPS,
            dscp_mark=DSCP_MARK)
        qos_src_vm, qos_dst_vm = self.create_vms(
            qos_bw_dscp_dict['network_qos'])
        self.os_admin.ports_client.update_port(
            qos_src_vm['floating_ips'][0]['port_id'],
            qos_policy_id=qos_bw_dscp_dict['policy_id'])
        self.os_admin.ports_client.update_port(
            qos_dst_vm['floating_ips'][0]['port_id'],
            qos_policy_id=qos_bw_dscp_dict['policy_id'])
        #sleep to ensure VMs have finished complete bootup
        time.sleep(240)
        #check bandwidth rule
        self.verify_bandwidth_rule(max_mbps=BW_VALUE_MBPS)
        #check dscp rule
        self.verify_dscp_rule(dscp_value=DSCP_MARK)