A Tempest plugin to test Neutron VMware NSX plugin.
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 

1360 lines
66 KiB

# Copyright 2019 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 time
from oslo_utils import uuidutils
from tempest import config
from tempest.lib.common.utils import data_utils
from tempest.lib.common.utils import test_utils
from tempest.lib import decorators
from tempest.lib import exceptions
from tempest.lib import exceptions as lib_exc
from tempest import test
from vmware_nsx_tempest_plugin.common import constants
from vmware_nsx_tempest_plugin.lib import feature_manager
from vmware_nsx_tempest_plugin.services import nsxp_client
from vmware_nsx_tempest_plugin.services import nsxv3_client
LOG = constants.log.getLogger(__name__)
CONF = config.CONF
class OctaviaRoundRobin(feature_manager.FeatureManager):
"""Base class to support LBaaS ROUND-ROBIN test.
It provides the methods to create loadbalancer network, and
start web servers.
Default lb_algorithm is ROUND_ROBIND.
"""
@classmethod
def setup_clients(cls):
super(OctaviaRoundRobin, cls).setup_clients()
cls.cmgr_adm = cls.get_client_manager('admin')
cls.cmgr_alt = cls.get_client_manager('alt')
cls.cmgr_adm = cls.get_client_manager('admin')
@classmethod
def skip_checks(cls):
super(OctaviaRoundRobin, cls).skip_checks()
cfg = CONF.network
if not test.is_extension_enabled('lbaasv2', 'network'):
msg = 'lbaasv2 extension is not enabled.'
raise cls.skipException(msg)
if not (cfg.project_networks_reachable or cfg.public_network_id):
msg = ('Either project_networks_reachable must be "true", or '
'public_network_id must be defined.')
raise cls.skipException(msg)
@classmethod
def resource_setup(cls):
super(OctaviaRoundRobin, cls).resource_setup()
cls.nsx = nsxv3_client.NSXV3Client(CONF.nsxv3.nsx_manager,
CONF.nsxv3.nsx_user,
CONF.nsxv3.nsx_password)
cls.nsxp = nsxp_client.NSXPClient(CONF.nsxv3.nsx_manager,
CONF.nsxv3.nsx_user,
CONF.nsxv3.nsx_password)
@classmethod
def setup_credentials(cls):
# Ask framework to not create network resources for these tests.
cls.set_network_resources()
super(OctaviaRoundRobin, cls).setup_credentials()
def setUp(self):
super(OctaviaRoundRobin, self).setUp()
CONF.validation.ssh_shell_prologue = ''
self.vip_ip_address = ''
self.namestart = 'lbaas-ops'
self.poke_counters = 12
self.hm_delay = 4
self.hm_max_retries = 3
self.hm_timeout = 10
self.server_names = []
self.loadbalancer = None
self.vip_fip = None
self.web_service_start_delay = 2.5
def tearDown(self, clean=None):
if self.vip_fip:
LOG.debug("tearDown lbass vip fip")
self.disassociate_floatingip(self.vip_fip, and_delete=True)
if self.loadbalancer:
LOG.debug("tearDown lbass")
lb_id = self.loadbalancer['id']
self.delete_octavia_lb_resources(lb_id)
cert_file = open(constants.CERT_FILE, "r")
cert_content = cert_file.read()
self.check_certificate_at_backend(should_present=False,
cert_conent=cert_content)
LOG.debug("tearDown lbaas exiting...")
super(OctaviaRoundRobin, self).tearDown()
@decorators.attr(type='nsxv3')
@decorators.idempotent_id('c5ac8546-6867-4b7a-8704-3844b11b1a34')
def test_create_verify_octavia_lb_with_vip_subnet_id_rr(self):
"""
This testcase creates an octavia Loadbalancer with vip-subnet-ip
option, and verifies the traffic on the loadbalancer vip
"""
diction = self.deploy_octavia_topology()
self.start_web_servers(constants.HTTP_PORT)
subnet_id = diction['subnet']['subnet']['id']
self.create_project_octavia(protocol_type="HTTP", protocol_port="80",
lb_algorithm="ROUND_ROBIN",
vip_subnet_id=subnet_id)
self.check_project_lbaas()
@decorators.attr(type='nsxv3')
@decorators.idempotent_id('c5ac8546-6867-4b7a-8704-3844b11b1a34')
def test_create_verify_octavia_lb_with_vip_net_id_rr(self):
"""
This testcase creates an octavia Loadbalancer with vip-net-ip
option, and verifies the traffic on the loadbalancer vip
"""
diction = self.deploy_octavia_topology()
self.start_web_servers(constants.HTTP_PORT)
net_id = diction['network']['id']
self.create_project_octavia(protocol_type="HTTP", protocol_port="80",
lb_algorithm="ROUND_ROBIN",
vip_net_id=net_id)
self.check_project_lbaas()
@decorators.attr(type='nsxv3')
@decorators.idempotent_id('c5ac8546-6867-4b7a-8704-3844b11b1a34')
def test_create_verify_octavia_lb_with_vip_net_id_LC(self):
"""
This testcase creates an octavia Loadbalancer with vip-net-ip
option, and verifies the traffic on the loadbalancer vip
"""
diction = self.deploy_octavia_topology()
self.start_web_servers(constants.HTTP_PORT)
net_id = diction['network']['id']
self.create_project_octavia(protocol_type="HTTP", protocol_port="80",
lb_algorithm="LEAST_CONNECTIONS",
vip_net_id=net_id)
self.check_project_lbaas()
@decorators.attr(type='nsxv3')
@decorators.idempotent_id('d6bd0657-6867-4b7a-8704-3844b11b1a34')
def test_octavia_lb_vip_route_with_tenant_net(self):
"""
This testcase creates an octavia Loadbalancer with tenant net
and create floating ip for lb vip, and check advertised
route at tier1 backend
"""
diction = self.deploy_octavia_topology()
self.start_web_servers(constants.HTTP_PORT)
net_id = diction['network']['id']
lb_dict = self.create_project_octavia(protocol_type="HTTP",
protocol_port="80",
lb_algorithm="LEAST_CONNECTIONS",
vip_net_id=net_id)
self.check_project_lbaas()
vip_address = lb_dict['vip_address']
vip_fip = lb_dict['vip_fip']
router_state_1 = diction['router']['router']
nsx_router_nat_rules = self.nsx.get_logical_router_nat_rule_ips(
router_state_1['name'], router_state_1['id'])
route_present = False
for advertised_net in nsx_router_nat_rules['advertisedNetworks']:
if len(advertised_net['networks']) > 0:
if vip_address in advertised_net[
'networks'][0]['network'] and\
advertised_net['networks'][
0]['advertiseRouteType'] == 'T1_LB_VIP' and\
advertised_net['networks'][0]['advertiseAllow']:
route_present = True
self.assertEqual(True, route_present, 'Lb vip route is not advertised')
kwargs = dict(port_id=None)
self.cmgr_adm.floating_ips_client.\
update_floatingip(vip_fip['id'],
**kwargs)['floatingip']
time.sleep(30)
nsx_router_nat_rules = self.nsx.get_logical_router_nat_rule_ips(
router_state_1['name'], router_state_1['id'])
vip_address = vip_fip['fixed_ip_address']
route_present = False
for advertised_net in nsx_router_nat_rules['advertisedNetworks']:
if len(advertised_net['networks']) > 0:
if vip_address in advertised_net[
'networks'][0]['network'] and\
advertised_net['networks'][
0]['advertiseRouteType'] == 'T1_LB_VIP' and\
advertised_net['networks'][0]['advertiseAllow']:
route_present = True
self.assertEqual(False, route_present, 'Lb vip route is advertised')
@decorators.attr(type='nsxv3')
@decorators.idempotent_id('d6bd0657-7078-4b7a-8704-3844b11b1a34')
def test_octavia_lb_vip_route_with_external_net(self):
"""
This testcase creates an octavia Loadbalancer with external net
and check lb vip route should get advertised at tier1 backend
"""
diction = self.deploy_octavia_topology()
self.start_web_servers(constants.HTTP_PORT)
network = self.cmgr_adm.networks_client.show_network(
CONF.network.public_network_id)['network']
lb_dict = self.create_project_octavia(
protocol_type="HTTP",
protocol_port="80",
lb_algorithm="LEAST_CONNECTIONS",
external_subnet=network['subnets'][0],
external=True)
self.check_project_lbaas()
vip_address = lb_dict['vip_address']
router_state_1 = diction['router']['router']
nsx_router_nat_rules = self.nsx.get_logical_router_nat_rule_ips(
router_state_1['name'], router_state_1['id'])
route_present = False
for advertised_net in nsx_router_nat_rules['advertisedNetworks']:
if len(advertised_net['networks']) > 0:
if vip_address in advertised_net[
'networks'][0]['network'] and\
advertised_net['networks'][
0]['advertiseRouteType'] == 'T1_LB_VIP' and\
advertised_net['networks'][0]['advertiseAllow']:
route_present = True
self.assertEqual(True, route_present, 'Lb vip route is not advertised')
@decorators.attr(type='nsxv3')
@decorators.idempotent_id('c5ac8546-6867-4b7a-8704-3844b11b1a34')
def test_create_verify_octavia_lb_with_vip_subnet_id_LC(self):
"""
This testcase creates an octavia Loadbalancer with vip-subnet-ip
option, and verifies the traffic on the loadbalancer vip
"""
diction = self.deploy_octavia_topology()
self.start_web_servers(constants.HTTP_PORT)
subnet_id = diction['subnet']['subnet']['id']
self.create_project_octavia(protocol_type="HTTP", protocol_port="80",
lb_algorithm="LEAST_CONNECTIONS",
vip_subnet_id=subnet_id)
self.check_project_lbaas()
@decorators.attr(type='nsxv3')
@decorators.idempotent_id('c5ac8546-6867-4b7a-8704-3844b11b1a34')
def test_create_verify_octavia_lb_with_vip_subnet_id(self):
"""
This testcase creates an octavia Loadbalancer with vip-subnet-ip
option, and verifies the traffic on the loadbalancer vip
"""
diction = self.deploy_octavia_topology()
self.start_web_servers(constants.HTTP_PORT)
subnet_id = diction['subnet']['subnet']['id']
self.create_project_octavia(protocol_type="HTTP", protocol_port="80",
lb_algorithm="LEAST_CONNECTIONS",
vip_subnet_id=subnet_id)
self.check_project_lbaas()
get_lb = self.octavia_admin_client.list_octavia_load_balancers()
lb_id = get_lb['loadbalancers'][0]['id']
stat = self.octavia_admin_client.\
show_octavia_load_balancer_stats(lb_id)
assert (stat['stats']['bytes_in'] == 0 and
stat['stats']['bytes_out'] == 0)
self.check_lbaas_project_weight_values(constants.NO_OF_VMS_2)
stat = self.octavia_admin_client.\
show_octavia_load_balancer_stats(lb_id)
assert (stat['stats']['bytes_in'] >= 0 and
stat['stats']['bytes_out'] >= 0)
@decorators.attr(type='nsxv3')
@decorators.idempotent_id('60e9ecaf-b8d6-48a9-b0d2-942e5bb38f38')
def test_octavia_http_round_robin_with_session_persistence(self):
"""
To verify the server count for LB pool with SOURCE_IP
session persistence and ROUND_ROBIN lb-algorithm
expected outcome is only one server responds to the
client requests
"""
diction = self.deploy_octavia_topology()
self.start_web_servers(constants.HTTP_PORT)
subnet_id = diction['subnet']['subnet']['id']
self.create_project_octavia(protocol_type="HTTP", protocol_port="80",
lb_algorithm="ROUND_ROBIN",
vip_subnet_id=subnet_id, persistence=True,
persistence_type="SOURCE_IP")
self.check_lbaas_project_weight_values(constants.NO_OF_VMS_2,
hash_persistence=True)
@decorators.attr(type='nsxv3')
@decorators.idempotent_id('60e9ecaf-b8d6-48a9-b0d2-942e5bb38f38')
def test_octavia_http_round_robin_with_net_id_session_persistence(self):
"""
To verify the server count for LB pool with SOURCE_IP
session persistence and ROUND_ROBIN lb-algorithm,
expected outcome is only one server responds to the
client requests.
"""
diction = self.deploy_octavia_topology()
self.start_web_servers(constants.HTTP_PORT)
net_id = diction['network']['id']
self.create_project_octavia(protocol_type="HTTP", protocol_port="80",
lb_algorithm="ROUND_ROBIN",
vip_net_id=net_id, persistence=True,
persistence_type="SOURCE_IP")
self.check_lbaas_project_weight_values(constants.NO_OF_VMS_2,
hash_persistence=True)
@decorators.attr(type='nsxv3')
@decorators.idempotent_id('c5ac8546-6768-4b7a-8704-3844b11b1a34')
def test_create_verify_lb_rr_with_allowed_cidr_on_listener(self):
"""
The Loadbalancer listener is created with allowed_cidrs specified
"""
diction = self.deploy_octavia_topology()
cidr_list = ['192.92.0.0/24', '192.94.0.0/16']
if not CONF.nsxv3.ens:
self.start_web_servers(constants.HTTP_PORT)
subnet_id = diction['subnet']['subnet']['id']
self.create_project_octavia(protocol_type="HTTP", protocol_port="80",
lb_algorithm="ROUND_ROBIN",
vip_subnet_id=subnet_id,
allowed_cidrs=cidr_list)
self.check_project_lbaas()
@decorators.attr(type='nsxv3')
@decorators.idempotent_id('ca5c8546-6768-4b7a-8704-3844b11b1a34')
def test_create_verify_lb_rr_with_allowed_cidr_0_0_0_0_on_listener(self):
"""
The Loadbalancer listener is created with allowed_cidrs specified
"""
diction = self.deploy_octavia_topology()
cidr_list = ['0.0.0.0/0']
if not CONF.nsxv3.ens:
self.start_web_servers(constants.HTTP_PORT)
subnet_id = diction['subnet']['subnet']['id']
self.create_project_octavia(protocol_type="HTTP", protocol_port="80",
lb_algorithm="ROUND_ROBIN",
vip_subnet_id=subnet_id,
allowed_cidrs=cidr_list)
self.check_project_lbaas()
@decorators.attr(type='nsxv3')
@decorators.idempotent_id('ca5c5468-6768-4b7a-8704-3844b11b1a34')
def test_create_REJECT_l7policies_listeneres(self):
"""
The Loadbalancer listener is created with allowed_cidrs specified
"""
diction = self.deploy_octavia_topology()
if not CONF.nsxv3.ens:
self.start_web_servers(constants.HTTP_PORT)
subnet_id = diction['subnet']['subnet']['id']
self.create_project_octavia(protocol_type="HTTP",
protocol_port="80",
lb_algorithm="ROUND_ROBIN",
vip_subnet_id=subnet_id,
l7policy=True, action='REJECT')
@decorators.attr(type='nsxv3')
@decorators.idempotent_id('ca5c4368-6768-4b7a-8704-3844b11b1a34')
def test_create_REDIRECT_TO_URL_l7policies_listeneres(self):
"""
The Loadbalancer listener is created with redirect_url l7policy
with no url specified.
"""
diction = self.deploy_octavia_topology()
if not CONF.nsxv3.ens:
self.start_web_servers(constants.HTTP_PORT)
subnet_id = diction['subnet']['subnet']['id']
self.assertRaises(exceptions.BadRequest,
self.create_project_octavia,
protocol_type="HTTP",
protocol_port="80",
lb_algorithm="ROUND_ROBIN",
vip_subnet_id=subnet_id,
l7policy=True,
action='REDIRECT_TO_URL')
@decorators.attr(type='nsxv3')
@decorators.idempotent_id('ca5c4368-6768-4b7a-8704-3844b11b1b34')
def test_create_REDIRECT_TO_URL_url_l7policies_listeneres(self):
"""
The Loadbalancer listener is created with redirect_url l7policy
with url specified.
"""
diction = self.deploy_octavia_topology()
if not CONF.nsxv3.ens:
self.start_web_servers(constants.HTTP_PORT)
subnet_id = diction['subnet']['subnet']['id']
self.create_project_octavia(protocol_type="HTTP",
protocol_port="80",
lb_algorithm="ROUND_ROBIN",
vip_subnet_id=subnet_id,
l7policy=True,
action='REDIRECT_TO_URL',
redirect_url='http://www.vmware.com')
@decorators.attr(type='nsxv3')
@decorators.idempotent_id('ca5c4368-6768-4a7b-8704-3844b11b1b34')
def test_create_REDIRECT_TO_POOL_l7policies_listeneres(self):
"""
The Loadbalancer listener is created with redirect_pool l7policy
with url specified.
"""
diction = self.deploy_octavia_topology()
if not CONF.nsxv3.ens:
self.start_web_servers(constants.HTTP_PORT)
subnet_id = diction['subnet']['subnet']['id']
lb = self.create_project_octavia(protocol_type="HTTP",
protocol_port="80",
lb_algorithm="ROUND_ROBIN",
vip_subnet_id=subnet_id)
listener = lb['listener_id']
self.octavia_admin_l7policies_client.create_octavia_l7policies(
listener_id=listener, action='REDIRECT_TO_POOL',
redirect_pool_id=lb['pool_id'])
self.octavia_admin_client.wait_for_load_balancer_status(lb['lb_id'])
l7p = self.octavia_admin_l7policies_client.list_octavia_l7policies(
lb['listener_id'])
for i in l7p['l7policies']:
if lb['listener_id'] == i['listener_id']:
l7p_id = i['id']
self.octavia_admin_l7policies_client.delete_octavia_l7policy(
l7p_id)
@decorators.attr(type='nsxv3')
@decorators.idempotent_id('ca5c5468-6768-4a7a-8704-3844b11b1a34')
def test_create_REJECT_l7policies_with_rules_REGEX_compare_type(self):
"""
This testcase creates a l7policy to reject particular regex i.e
regex rule is added to the l7policy.
"""
diction = self.deploy_octavia_topology()
if not CONF.nsxv3.ens:
self.start_web_servers(constants.HTTP_PORT)
subnet_id = diction['subnet']['subnet']['id']
self.create_project_octavia(protocol_type="HTTP",
protocol_port="80",
lb_algorithm="ROUND_ROBIN",
vip_subnet_id=subnet_id,
l7policy=True, action='REJECT',
compare_type='REGEX', type='PATH',
value='.*', l7rule=True)
@decorators.attr(type='nsxv3')
@decorators.idempotent_id('ca5c5468-6768-4a7a-8704-3844b11b1a34')
def test_create_REJECT_l7policies_with_rules_CONTAINS_compare_type(self):
"""
This testcase creates a l7policy to reject particular regex i.e
regex rule is added to the l7policy.
"""
diction = self.deploy_octavia_topology()
if not CONF.nsxv3.ens:
self.start_web_servers(constants.HTTP_PORT)
subnet_id = diction['subnet']['subnet']['id']
self.create_project_octavia(protocol_type="HTTP",
protocol_port="80",
lb_algorithm="ROUND_ROBIN",
vip_subnet_id=subnet_id,
l7policy=True, action='REJECT',
compare_type='CONTAINS', type='PATH',
value='.*', l7rule=True)
@decorators.attr(type='nsxv3')
@decorators.idempotent_id('ca5c5468-6768-4a7a-8704-3844b11b1a34')
def test_create_REJECT_l7policies_with_rules_ENDS_WITH_compare_type(self):
"""
This testcase creates a l7policy to reject particular regex i.e
regex rule is added to the l7policy.
"""
diction = self.deploy_octavia_topology()
if not CONF.nsxv3.ens:
self.start_web_servers(constants.HTTP_PORT)
subnet_id = diction['subnet']['subnet']['id']
self.create_project_octavia(protocol_type="HTTP",
protocol_port="80",
lb_algorithm="ROUND_ROBIN",
vip_subnet_id=subnet_id,
l7policy=True, action='REJECT',
compare_type='ENDS_WITH', type='PATH',
value='*', l7rule=True)
@decorators.attr(type='nsxv3')
@decorators.idempotent_id('ca5c5468-6768-4a7a-8704-3844b11b1a34')
def test_create_REJECT_l7policies_with_rules_STARTS_WITH_cmpr_type(self):
"""
This testcase creates a l7policy to reject particular regex i.e
regex rule is added to the l7policy.
"""
diction = self.deploy_octavia_topology()
if not CONF.nsxv3.ens:
self.start_web_servers(constants.HTTP_PORT)
subnet_id = diction['subnet']['subnet']['id']
self.assertRaises(exceptions.BadRequest,
self.create_project_octavia,
protocol_type="HTTP",
protocol_port="80",
lb_algorithm="ROUND_ROBIN",
vip_subnet_id=subnet_id,
l7policy=True, action='REJECT',
compare_type='STARTS_WITH', type='PATH',
value='', l7rule=True)
@decorators.attr(type='nsxv3')
@decorators.idempotent_id('ca5c5468-6768-4a7a-8704-3844b11b1a34')
def test_create_REJECT_l7policies_with_invert_enabled(self):
"""
This testcase creates a l7policy to reject particular regex i.e
regex rule is added to the l7policy.
"""
diction = self.deploy_octavia_topology()
if not CONF.nsxv3.ens:
self.start_web_servers(constants.HTTP_PORT)
subnet_id = diction['subnet']['subnet']['id']
self.create_project_octavia(protocol_type="HTTP",
protocol_port="80",
lb_algorithm="ROUND_ROBIN",
vip_subnet_id=subnet_id,
l7policy=True, action='REJECT',
invert=True)
self.check_project_lbaas(no_resp=True)
@decorators.attr(type='nsxv3')
@decorators.idempotent_id('74f022d6-a6ef-4458-96a7-541deadacf99')
def test_octavia_http_traffic_with_barbican_secrets(self):
"""
Create octavia loadbalancer with http traffic with barbican enabled.
"""
diction = self.deploy_octavia_topology()
subnet_id = diction['subnet']['subnet']['id']
if not CONF.nsxv3.ens:
self.start_web_servers(constants.HTTP_PORT)
barbican_secrets = self.create_barbican_secret_conatainer(
constants.CERT_FILE, constants.KEY_FILE)
barbican_container = barbican_secrets['secret_container']
self.create_project_octavia(protocol_type="HTTP",
protocol_port="80",
lb_algorithm="ROUND_ROBIN",
vip_subnet_id=subnet_id,
hm_type='HTTP',
member_count=2,
weight=5,
pool_protocol='HTTP',
pool_port='80',
barbican_container=barbican_container,
count=0, barbican=True,
delay=self.hm_delay,
max_retries=self.hm_max_retries,
timeout=self.hm_timeout)
self.check_lbaas_project_weight_values(barbican_http=True)
@decorators.attr(type='nsxv3')
@decorators.idempotent_id('74f022d6-a6ef-4458-96a7-541deadacf99')
def test_octavia_https_traffic_with_barbican_secrets(self):
"""
Create octavia loadbalancer with http traffic with barbican enabled.
"""
diction = self.deploy_octavia_topology()
subnet_id = diction['subnet']['subnet']['id']
if not CONF.nsxv3.ens:
self.start_web_servers(constants.HTTP_PORT)
barbican_secrets = self.create_barbican_secret_conatainer(
constants.CERT_FILE, constants.KEY_FILE)
barbican_container = barbican_secrets['secret_container']
self.create_project_octavia(protocol_type="TERMINATED_HTTPS",
protocol_port="443",
lb_algorithm="ROUND_ROBIN",
vip_subnet_id=subnet_id,
hm_type='HTTP',
member_count=2,
weight=5,
pool_protocol='HTTP',
pool_port='80',
barbican_container=barbican_container,
count=0, barbican=True,
delay=self.hm_delay,
max_retries=self.hm_max_retries,
timeout=self.hm_timeout)
self.check_lbaas_project_weight_values(HTTPS=True)
@decorators.attr(type='nsxv3')
@decorators.idempotent_id('d6bd0657-7078-5c8b-8704-3844b11b1a34')
def test_octavia_multiple_listeners_with_secrets(self):
"""
Create multiple terminated https protocol
based listener with same loadbalancer
"""
diction = self.deploy_octavia_topology()
subnet_id = diction['subnet']['subnet']['id']
if not CONF.nsxv3.ens:
self.start_web_servers(constants.HTTP_PORT)
barbican_secrets = self.create_barbican_secret_conatainer(
constants.CERT_FILE, constants.KEY_FILE)
barbican_container = barbican_secrets['secret_container']
protocol_type = "TERMINATED_HTTPS"
protocol_port = 443
lb_name = data_utils.rand_name("tempest_lb")
self.loadbalancer = self.\
octavia_admin_client.\
create_octavia_load_balancer(name=lb_name,
vip_subnet_id=subnet_id
)['loadbalancer']
lb_id = self.loadbalancer['id']
self.octavia_admin_client.wait_for_load_balancer_status(lb_id)
for i in range(1, 20):
tls_id = barbican_container["container_ref"]
self.listener = self.octavia_admin_listener_client.\
create_octavia_listener(loadbalancer_id=lb_id,
protocol=protocol_type,
protocol_port=protocol_port,
name=lb_name,
allowed_cidrs=None,
default_tls_container_ref=tls_id
)['listener']
self.octavia_admin_client.wait_for_load_balancer_status(lb_id)
protocol_port = protocol_port + 1
@decorators.idempotent_id('d6bd0657-7078-5c8b-0815-3844b11b1a34')
def test_octavia_create_listener_with_empty_secrets(self):
"""
Try to create listener with terminated https
protocol and empty secret , it should fail.
"""
secret_name1 = data_utils.rand_name(name='tempest-cert-secret')
kwargs = {"secret_type": constants.SECRET_TYPE,
"algorithm": constants.ALGORITHM,
"name": secret_name1}
barbican_secret1 = self.create_barbican_secret(**kwargs)
secret_name2 = data_utils.rand_name(name='tempest-key-secret')
kwargs = {"secret_type": constants.SECRET_TYPE,
"algorithm": constants.ALGORITHM,
"name": secret_name2}
barbican_secret2 = self.create_barbican_secret(**kwargs)
container_name = data_utils.rand_name(name='tempest-container')
kwargs = {"type": constants.CONTAINER_TYPE,
"name": container_name,
"secret_refs": [{"secret_ref":
barbican_secret1['secret_ref'],
"name": 'certificate'},
{"secret_ref":
barbican_secret2['secret_ref'],
"name": 'private_key'}]}
barbican_container = self.create_barbican_container(**kwargs)
diction = self.deploy_octavia_topology()
subnet_id = diction['subnet']['subnet']['id']
protocol_type = "TERMINATED_HTTPS"
protocol_port = 443
lb_name = data_utils.rand_name("tempest_lb")
self.loadbalancer = self.\
octavia_admin_client.\
create_octavia_load_balancer(name=lb_name,
vip_subnet_id=subnet_id
)['loadbalancer']
lb_id = self.loadbalancer['id']
self.octavia_admin_client.wait_for_load_balancer_status(lb_id)
self.assertRaises(exceptions.BadRequest,
self.octavia_admin_listener_client.
create_octavia_listener,
loadbalancer_id=lb_id,
protocol=protocol_type,
protocol_port=protocol_port,
name=lb_name,
allowed_cidrs=None,
default_tls_container_ref=barbican_container[
'container_ref'])
@decorators.attr(type='nsxv3')
@decorators.idempotent_id('d6bd0657-7078-5c8b-0815-4055c21b1a34')
def test_octavia_check_certificate_at_backend(self):
"""
Create octavia loadbalancer with http traffic with barbican enabled.
"""
diction = self.deploy_octavia_topology()
subnet_id = diction['subnet']['subnet']['id']
if not CONF.nsxv3.ens:
self.start_web_servers(constants.HTTP_PORT)
barbican_secrets = self.create_barbican_secret_conatainer(
constants.CERT_FILE, constants.KEY_FILE)
barbican_container = barbican_secrets['secret_container']
self.create_project_octavia(
protocol_type="TERMINATED_HTTPS",
protocol_port="443",
lb_algorithm="ROUND_ROBIN",
vip_subnet_id=subnet_id,
hm_type='HTTP',
member_count=2,
weight=5,
pool_protocol='HTTP',
pool_port='80',
barbican_container=barbican_container,
count=0, barbican=True, delay=self.hm_delay,
max_retries=self.hm_max_retries, timeout=self.hm_timeout)
self.check_lbaas_project_weight_values(HTTPS=True)
cert_file = open(constants.CERT_FILE, "r")
cert_content = cert_file.read()
self.check_certificate_at_backend(cert_conent=cert_content.rstrip())
@decorators.attr(type='nsxv3')
@decorators.idempotent_id('d6bd0657-7078-5c8b-0815-4055c21c2b45')
def test_octavia_create_lbaas_listener_with_invalid_container_uuid(self):
"""
Create octavia loadbalancer with http traffic with barbican enabled.
"""
diction = self.deploy_octavia_topology()
subnet_id = diction['subnet']['subnet']['id']
if not CONF.nsxv3.ens:
self.start_web_servers(constants.HTTP_PORT)
barbican_secrets = self.create_barbican_secret_conatainer(
constants.CERT_FILE, constants.KEY_FILE)
container_ref = barbican_secrets["secret_container"]['container_ref']\
.split('/')
container_ref.remove(container_ref[len(container_ref) - 1])
container_ref.append(uuidutils.generate_uuid())
container_ref = '/'.join(str(e) for e in container_ref)
protocol_type = "TERMINATED_HTTPS"
protocol_port = 443
lb_name = data_utils.rand_name("tempest_lb")
self.loadbalancer = self.\
octavia_admin_client.\
create_octavia_load_balancer(name=lb_name,
vip_subnet_id=subnet_id
)['loadbalancer']
lb_id = self.loadbalancer['id']
self.octavia_admin_client.wait_for_load_balancer_status(lb_id)
self.assertRaises(exceptions.BadRequest,
self.octavia_admin_listener_client.
create_octavia_listener,
loadbalancer_id=lb_id,
protocol=protocol_type,
protocol_port=protocol_port,
name=lb_name,
allowed_cidrs=None,
default_tls_container_ref=container_ref)
@decorators.attr(type='nsxv3')
@decorators.idempotent_id('c5ac8546-6867-4b7a-8704-3844b11b1a34')
def test_create_verify_octavia_lb_with_vip_net_id_LC_hm_ping(self):
"""
This testcase creates an octavia Loadbalancer with vip-net-ip
option, and verifies the traffic on the loadbalancer vip
"""
diction = self.deploy_octavia_topology()
self.start_web_servers(constants.HTTP_PORT)
net_id = diction['network']['id']
self.create_project_octavia(protocol_type="HTTP", protocol_port="80",
lb_algorithm="LEAST_CONNECTIONS",
vip_net_id=net_id, hm_type='PING',
timeout=self.hm_timeout,
max_retries=self.hm_max_retries,
delay=self.hm_delay)
self.check_project_lbaas()
@decorators.attr(type='nsxv3')
@decorators.idempotent_id('c5ac8546-6867-4b7a-8704-3844b11b1a34')
def test_create_verify_octavia_lb_with_vip_net_id_LC_hm_ping_https(self):
"""
This testcase creates an octavia Loadbalancer with vip-net-ip
option, and verifies the traffic on the loadbalancer vip
"""
diction = self.deploy_octavia_topology()
self.start_web_servers(constants.HTTP_PORT)
net_id = diction['network']['id']
self.create_project_octavia(protocol_type="HTTPS", protocol_port="80",
lb_algorithm="LEAST_CONNECTIONS",
vip_net_id=net_id, hm_type='PING',
timeout=self.hm_timeout,
max_retries=self.hm_max_retries,
delay=self.hm_delay)
self.check_project_lbaas()
@decorators.attr(type='nsxv3')
@decorators.idempotent_id('c5ac8546-6867-4b7a-8704-3844b11b1a34')
def test_create_verify_octavia_lb_with_vip_net_id_RR_hm_ping(self):
"""
This testcase creates an octavia Loadbalancer with vip-net-ip
option, and verifies the traffic on the loadbalancer vip
"""
diction = self.deploy_octavia_topology()
self.start_web_servers(constants.HTTP_PORT)
net_id = diction['network']['id']
self.create_project_octavia(protocol_type="HTTP", protocol_port="80",
lb_algorithm="ROUND_ROBIN",
vip_net_id=net_id, hm_type='PING',
timeout=self.hm_timeout,
max_retries=self.hm_max_retries,
delay=self.hm_delay)
self.check_project_lbaas()
@decorators.attr(type='nsxv3')
@decorators.idempotent_id('c5ac8546-6867-4b7a-8704-3844b11b1a34')
def test_create_verify_octavia_lb_with_vip_net_id_SOURCE_IP_hm_ping(self):
"""
This testcase creates an octavia Loadbalancer with vip-net-ip
option, and verifies the traffic on the loadbalancer vip
"""
diction = self.deploy_octavia_topology()
self.start_web_servers(constants.HTTP_PORT)
net_id = diction['network']['id']
self.create_project_octavia(protocol_type="HTTP", protocol_port="80",
lb_algorithm="ROUND_ROBIN",
vip_net_id=net_id, hm_type='PING',
timeout=self.hm_timeout,
max_retries=self.hm_max_retries,
delay=self.hm_delay)
self.check_project_lbaas()
@decorators.attr(type='nsxv3')
@decorators.idempotent_id('c5ac8546-6867-4b7a-8704-3844b11b1b43')
def test_verify_octavia_lb_vip_net_id_ROUND_ROBIN_default_pool(self):
"""
This testcase is for verifying the loadbalancer with net-id and
the pool is created using lb option and attached to a listener
with default-pool option
"""
diction = self.deploy_octavia_topology()
self.start_web_servers(constants.HTTP_PORT)
net_id = diction['network']['id']
self.create_project_octavia(protocol_type="HTTP", protocol_port="80",
lb_algorithm="ROUND_ROBIN",
vip_net_id=net_id, hm_type='PING',
timeout=self.hm_timeout,
max_retries=self.hm_max_retries,
delay=self.hm_delay, default_pool=True)
self.check_project_lbaas()
@decorators.attr(type='nsxv3')
@decorators.idempotent_id('c5ac8546-6867-4b7a-8704-3844b11a1b34')
def test_verify_octavia_lb_vip_subnet_id_rr_default_pool(self):
"""
This testcase is for verifying the loadbalancer with subnet-id and
the pool is created using lb option and attached to a listener
with default-pool option
"""
diction = self.deploy_octavia_topology()
self.start_web_servers(constants.HTTP_PORT)
subnet_id = diction['subnet']['subnet']['id']
self.create_project_octavia(protocol_type="HTTP", protocol_port="80",
lb_algorithm="ROUND_ROBIN",
vip_subnet_id=subnet_id, hm_type='PING',
timeout=self.hm_timeout,
max_retries=self.hm_max_retries,
delay=self.hm_delay, default_pool=True)
self.check_project_lbaas()
@decorators.attr(type='nsxv3')
@decorators.idempotent_id('c5ac8546-6867-4b7a-8704-3843a11b1a34')
def test_verify_octavia_lb_port_id_rr_default_pool(self):
"""
This testcase is for verifying the loadbalancer with port-id and
the pool is created using lb option and attached to a listener
with default-pool option
"""
diction = self.deploy_octavia_topology()
self.start_web_servers(constants.HTTP_PORT)
net_id = diction['network']['id']
port_id = self.cmgr_adm.ports_client.create_port(
network_id=net_id)['port']['id']
self.addCleanup(test_utils.call_and_ignore_notfound_exc,
self.cmgr_adm.ports_client.delete_port, port_id)
self.create_project_octavia(protocol_type="HTTP", protocol_port="80",
lb_algorithm="ROUND_ROBIN",
vip_port_id=port_id, hm_type='PING',
timeout=self.hm_timeout,
max_retries=self.hm_max_retries,
delay=self.hm_delay, default_pool=True)
self.check_project_lbaas()
@decorators.attr(type='nsxv3')
@decorators.idempotent_id('c5ac8546-6867-4b7a-8704-3843a11a2b34')
def test_verify_octavia_lb_port_id_lc_default_pool(self):
"""
This testcase is for verifying the loadbalancer with port-id and
the pool is created using lb option and attached to a listener
with default-pool option, lease connection algorithm
"""
diction = self.deploy_octavia_topology()
self.start_web_servers(constants.HTTP_PORT)
net_id = diction['network']['id']
port_id = self.cmgr_adm.ports_client.create_port(
network_id=net_id)['port']['id']
self.addCleanup(test_utils.call_and_ignore_notfound_exc,
self.cmgr_adm.ports_client.delete_port, port_id)
self.create_project_octavia(protocol_type="HTTP", protocol_port="80",
lb_algorithm="LEAST_CONNECTIONS",
vip_port_id=port_id, hm_type='PING',
timeout=self.hm_timeout,
max_retries=self.hm_max_retries,
delay=self.hm_delay, default_pool=True)
self.check_project_lbaas()
@decorators.attr(type='nsxv3')
@decorators.idempotent_id('c5ac8546-6867-4b7a-8704-3843a12b1a34')
def test_verify_octavia_lb_port_id_source_ip_default_pool(self):
"""
This testcase is for verifying the loadbalancer with port-id and
the pool is created using lb option and attached to a listener
with default-pool option, source_ip algorithm.
"""
diction = self.deploy_octavia_topology()
self.start_web_servers(constants.HTTP_PORT)
net_id = diction['network']['id']
port_id = self.cmgr_adm.ports_client.create_port(
network_id=net_id)['port']['id']
self.addCleanup(test_utils.call_and_ignore_notfound_exc,
self.cmgr_adm.ports_client.delete_port, port_id)
self.create_project_octavia(protocol_type="HTTP", protocol_port="80",
lb_algorithm="SOURCE_IP",
vip_port_id=port_id, hm_type='PING',
timeout=self.hm_timeout,
max_retries=self.hm_max_retries,
delay=self.hm_delay, default_pool=True)
self.check_project_lbaas(source_ip=True)
@decorators.attr(type='nsxv3')
@decorators.idempotent_id('c5ac8546-5677-4b7a-8704-3843a12b1a34')
def test_verify_octavia_https_lb_port_id_source_ip_default_pool(self):
"""
This testcase is for verifying the loadbalancer with port-id and
the pool is created using lb option and attached to a listener
with default-pool option, source_ip algorithm, https protocol.
"""
diction = self.deploy_octavia_topology()
self.start_web_servers(constants.HTTP_PORT)
net_id = diction['network']['id']
port_id = self.cmgr_adm.ports_client.create_port(
network_id=net_id)['port']['id']
self.addCleanup(test_utils.call_and_ignore_notfound_exc,
self.cmgr_adm.ports_client.delete_port, port_id)
self.create_project_octavia(protocol_type="HTTPS", protocol_port="80",
lb_algorithm="SOURCE_IP",
vip_port_id=port_id, hm_type='PING',
timeout=self.hm_timeout,
max_retries=self.hm_max_retries,
delay=self.hm_delay, default_pool=True)
self.check_project_lbaas()
@decorators.attr(type='nsxv3')
@decorators.idempotent_id('c5ac8546-6867-4b7a-8544-3843a11b1a34')
def test_verify_octavia_https_lb_port_id_rr_default_pool(self):
"""
This testcase is for verifying the loadbalancer with port-id and
the pool is created using lb option and attached to a listener
with default-pool option, https traffic
"""
diction = self.deploy_octavia_topology()
self.start_web_servers(constants.HTTP_PORT)
net_id = diction['network']['id']
port_id = self.cmgr_adm.ports_client.create_port(
network_id=net_id)['port']['id']
self.addCleanup(test_utils.call_and_ignore_notfound_exc,
self.cmgr_adm.ports_client.delete_port, port_id)
self.create_project_octavia(protocol_type="HTTPS", protocol_port="80",
lb_algorithm="ROUND_ROBIN",
vip_port_id=port_id, hm_type='PING',
timeout=self.hm_timeout,
max_retries=self.hm_max_retries,
delay=self.hm_delay, default_pool=True)
self.check_project_lbaas()
@decorators.attr(type='nsxv3')
@decorators.idempotent_id('c5ac8546-6867-4b7a-8544-3843a11b1a34')
def test_verify_octavia_https_lb_port_id_lc_default_pool(self):
"""
This testcase is for verifying the loadbalancer with port-id and
the pool is created using lb option and attached to a listener
with default-pool option,least connections https traffic
"""
diction = self.deploy_octavia_topology()
self.start_web_servers(constants.HTTP_PORT)
net_id = diction['network']['id']
port_id = self.cmgr_adm.ports_client.create_port(
network_id=net_id)['port']['id']
self.addCleanup(test_utils.call_and_ignore_notfound_exc,
self.cmgr_adm.ports_client.delete_port, port_id)
self.create_project_octavia(protocol_type="HTTPS", protocol_port="80",
lb_algorithm="LEAST_CONNECTIONS",
vip_port_id=port_id, hm_type='PING',
timeout=self.hm_timeout,
max_retries=self.hm_max_retries,
delay=self.hm_delay, default_pool=True)
self.check_project_lbaas()
@decorators.attr(type='nsxv3')
@decorators.idempotent_id('c5ac8546-6867-4b7a-8704-3844b21b1a34')
def test_create_verify_octavia_lb_with_vip_net_id_qos_lc_hm_ping(self):
"""
This testcase creates an octavia Loadbalancer with vip-net-ip
option, and verifies the traffic on the loadbalancer vip
"""
diction = self.deploy_octavia_topology()
self.start_web_servers(constants.HTTP_PORT)
net_id = diction['network']['id']
policy = self.cmgr_adm.qos_client.create_qos_policy(
name='test-policy', description='test policy desc1',
shared=False)
self.addCleanup(test_utils.call_and_ignore_notfound_exc,
self.cmgr_adm.qos_client.delete_qos_policy,
policy['policy']['id'])
self.create_project_octavia(protocol_type="HTTP", protocol_port="80",
lb_algorithm="LEAST_CONNECTIONS",
vip_net_id=net_id, hm_type='PING',
timeout=self.hm_timeout,
max_retries=self.hm_max_retries,
delay=self.hm_delay,
qos_policy_id=policy['policy']['id'])
self.check_project_lbaas()
@decorators.attr(type='nsxv3')
@decorators.idempotent_id('c5ac8546-6867-4b7a-8544-3843a11b1a34')
def test_verify_octavia_https_lb_port_id_lc_default_pool_qos(self):
"""
This testcase is for verifying the loadbalancer with port-id and
the pool is created using lb option and attached to a listener
with default-pool option,least connections https traffic
"""
diction = self.deploy_octavia_topology()
self.start_web_servers(constants.HTTP_PORT)
net_id = diction['network']['id']
policy = self.cmgr_adm.qos_client.create_qos_policy(
name='test-policy', description='test policy desc1',
shared=False)
self.addCleanup(test_utils.call_and_ignore_notfound_exc,
self.cmgr_adm.qos_client.delete_qos_policy,
policy['policy']['id'])
port_id = self.cmgr_adm.ports_client.create_port(
network_id=net_id)['port']['id']
self.addCleanup(test_utils.call_and_ignore_notfound_exc,
self.cmgr_adm.ports_client.delete_port, port_id)
self.create_project_octavia(protocol_type="HTTP", protocol_port="80",
lb_algorithm="LEAST_CONNECTIONS",
vip_port_id=port_id, hm_type='PING',
timeout=self.hm_timeout,
max_retries=self.hm_max_retries,
delay=self.hm_delay, default_pool=True,
qos_policy_id=policy['policy']['id'])
self.check_project_lbaas()
@decorators.attr(type='nsxv3')
@decorators.idempotent_id('c5ac8546-6867-4b7a-8544-3843a11b1a23')
def test_verify_octavia_https_lb_port_id_rr_default_pool_qos(self):
"""
This testcase is for verifying the loadbalancer with port-id and
the pool is created using lb option and attached to a listener
with default-pool option,round_robin https traffic
"""
diction = self.deploy_octavia_topology()
self.start_web_servers(constants.HTTP_PORT)
net_id = diction['network']['id']
policy = self.cmgr_adm.qos_client.create_qos_policy(
name='test-policy', description='test policy desc1',
shared=False)
self.addCleanup(test_utils.call_and_ignore_notfound_exc,
self.cmgr_adm.qos_client.delete_qos_policy,
policy['policy']['id'])
port_id = self.cmgr_adm.ports_client.create_port(
network_id=net_id)['port']['id']
self.addCleanup(test_utils.call_and_ignore_notfound_exc,
self.cmgr_adm.ports_client.delete_port, port_id)
self.create_project_octavia(protocol_type="HTTP", protocol_port="80",
lb_algorithm="ROUND_ROBIN",
vip_port_id=port_id, hm_type='PING',
timeout=self.hm_timeout,
max_retries=self.hm_max_retries,
delay=self.hm_delay, default_pool=True,
qos_policy_id=policy['policy']['id'])
self.check_project_lbaas()
@decorators.attr(type='nsxv3')
@decorators.idempotent_id('c5ac8546-6867-4b7a-8544-3843a11b1a24')
def test_verify_octavia_http_lb_port_id_source_ip_default_pool_qos(self):
"""
This testcase is for verifying the loadbalancer with port-id and
the pool is created using lb option and attached to a listener
with default-pool option,SOURCE_IP https traffic
"""
diction = self.deploy_octavia_topology()
self.start_web_servers(constants.HTTP_PORT)
net_id = diction['network']['id']
policy = self.cmgr_adm.qos_client.create_qos_policy(
name='test-policy', description='test policy desc1',
shared=False)
self.addCleanup(test_utils.call_and_ignore_notfound_exc,
self.cmgr_adm.qos_client.delete_qos_policy,
policy['policy']['id'])
port_id = self.cmgr_adm.ports_client.create_port(
network_id=net_id)['port']['id']
self.addCleanup(test_utils.call_and_ignore_notfound_exc,
self.cmgr_adm.ports_client.delete_port, port_id)
self.create_project_octavia(protocol_type="HTTP", protocol_port="80",
lb_algorithm="SOURCE_IP",
vip_port_id=port_id, hm_type='PING',
timeout=self.hm_timeout,
max_retries=self.hm_max_retries,
delay=self.hm_delay, default_pool=True,
qos_policy_id=policy['policy']['id'])
self.check_project_lbaas(source_ip=True)
@decorators.attr(type='nsxv3')
@decorators.idempotent_id('c5ac8546-5677-4b7a-8704-3843a12b1a98')
def test_verify_octavia_https_lb_port_id_source_ipv6_default_pool(self):
"""
This testcase is for verifying the loadbalancer with port-id and
the pool is created using lb option and attached to a listener
with default-pool option, source_ip algorithm, https protocol.
"""
diction = self.deploy_octavia_topology(slaac=True)
net_id = diction['network']['id']
port_id = self.cmgr_adm.ports_client.create_port(
network_id=net_id)['port']['id']
self.addCleanup(test_utils.call_and_ignore_notfound_exc,
self.cmgr_adm.ports_client.delete_port, port_id)
self.create_project_octavia(protocol_type="HTTPS", protocol_port="80",
lb_algorithm="SOURCE_IP",
vip_port_id=port_id, hm_type='PING',
timeout=self.hm_timeout,
max_retries=self.hm_max_retries,
delay=self.hm_delay, default_pool=True,
create_fip=False)
@decorators.attr(type='nsxv3')
@decorators.idempotent_id('c5ac8546-6867-4b7a-8704-3844b11b1b43')
def test_ipv6__verify_octavia_lb_vip_net_id_ROUND_ROBIN_default_pool(self):
"""
This testcase is for verifying the loadbalancer with net-id and
the pool is created using lb option and attached to a listener
with default-pool option
"""
diction = self.deploy_octavia_topology()
self.start_web_servers(constants.HTTP_PORT)
net_id = diction['network']['id']
self.create_project_octavia(protocol_type="HTTP", protocol_port="80",
lb_algorithm="ROUND_ROBIN",
vip_net_id=net_id, hm_type='PING',
timeout=self.hm_timeout,
max_retries=self.hm_max_retries,
delay=self.hm_delay, default_pool=True,
fip_disassociate=True)
@decorators.attr(type='nsxv3')
@decorators.idempotent_id('c5ac8546-6867-4b7a-8544-3843a11b1a24')
def test_ipv6_verify_octavia_https_lb_port_id_source_ip_default_pool_qos(
self):
"""
This testcase is for verifying the loadbalancer with port-id and
the pool is created using lb option and attached to a listener
with default-pool option,SOURCE_IP https traffic
"""
diction = self.deploy_octavia_topology()
self.start_web_servers(constants.HTTP_PORT)
net_id = diction['network']['id']
policy = self.cmgr_adm.qos_client.create_qos_policy(
name='test-policy', description='test policy desc1',
shared=False)
self.addCleanup(test_utils.call_and_ignore_notfound_exc,
self.cmgr_adm.qos_client.delete_qos_policy,
policy['policy']['id'])
port_id = self.cmgr_adm.ports_client.create_port(
network_id=net_id)['port']['id']
self.addCleanup(test_utils.call_and_ignore_notfound_exc,
self.cmgr_adm.ports_client.delete_port, port_id)
self.create_project_octavia(protocol_type="HTTP", protocol_port="80",
lb_algorithm="SOURCE_IP",
vip_port_id=port_id, hm_type='PING',
timeout=self.hm_timeout,
max_retries=self.hm_max_retries,
delay=self.hm_delay, default_pool=True,
qos_policy_id=policy['policy']['id'],
fip_disassociate=True)
@decorators.attr(type='nsxv3')
@decorators.idempotent_id('ca5c5468-6768-4b7a-8704-3844b11b1a34')
def test_ipv6_create_REJECT_l7policies_listeneres(self):
"""
The Loadbalancer listener is created with allowed_cidrs specified
"""
diction = self.deploy_octavia_topology()
if not CONF.nsxv3.ens:
self.start_web_servers(constants.HTTP_PORT)
subnet_id = diction['subnet']['subnet']['id']
self.create_project_octavia(protocol_type="HTTP",
protocol_port="80",
lb_algorithm="ROUND_ROBIN",
vip_subnet_id=subnet_id,
l7policy=True, action='REJECT',
fip_disassociate=True)
@decorators.attr(type='nsxv3')
@decorators.idempotent_id('ca5c4368-6768-4b7a-8704-3844b11b1a34')
def test_ipv6_create_REDIRECT_TO_URL_l7policies_listeneres(self):
"""
The Loadbalancer listener is created with redirect_url l7policy
with no url specified.
"""
diction = self.deploy_octavia_topology()
if not CONF.nsxv3.ens:
self.start_web_servers(constants.HTTP_PORT)
subnet_id = diction['subnet']['subnet']['id']
self.assertRaises(exceptions.BadRequest,
self.create_project_octavia,
protocol_type="HTTP",
protocol_port="80",
lb_algorithm="ROUND_ROBIN",
vip_subnet_id=subnet_id,
l7policy=True,
action='REDIRECT_TO_URL',
fip_disassociate=True)
@decorators.attr(type='nsxv3')
@decorators.idempotent_id('c5ac8546-6867-4b7a-8544-3843a11b1a34')
def test_verify_octavia_lb_resource_status(self):
"""
Fetch the status of loadbalancer resources which uses the
api of openstack loadbalancer status show <lb>
"""
diction = self.deploy_octavia_topology()
self.start_web_servers(constants.HTTP_PORT)
net_id = diction['network']['id']
port_id = self.cmgr_adm.ports_client.create_port(
network_id=net_id)['port']['id']
self.addCleanup(test_utils.call_and_ignore_notfound_exc,
self.cmgr_adm.ports_client.delete_port, port_id)
self.create_project_octavia(protocol_type="HTTPS", protocol_port="80",
lb_algorithm="ROUND_ROBIN",
vip_port_id=port_id, hm_type='PING',
timeout=self.hm_timeout,
max_retries=self.hm_max_retries,
delay=self.hm_delay, default_pool=True)
lb_id = self.loadbalancer['id']
noerr, status_dict = self.get_status_lb_resources(lb_id)
self.assertTrue(noerr, status_dict)
@decorators.attr(type='nsxv3')
@decorators.idempotent_id('ca5c4368-6768-4b7a-8704-3844b11b1a34')
def test_verify_ipv6_octavia_lb_resource_status(self):
"""
Fetching status for ipv6 LB with show status api
"""
diction = self.deploy_octavia_topology()
if not CONF.nsxv3.ens:
self.start_web_servers(constants.HTTP_PORT)
subnet_id = diction['subnet']['subnet']['id']
self.create_project_octavia(protocol_type="HTTP",
protocol_port="80",
lb_algorithm="ROUND_ROBIN",
vip_subnet_id=subnet_id,
l7policy=True, action='REJECT',
fip_disassociate=True, hm_type='PING',
timeout=self.hm_timeout,
max_retries=self.hm_max_retries,
delay=self.hm_delay)
time.sleep(60)
lb_id = self.loadbalancer['id']
noerr, status_dict = self.get_status_lb_resources(lb_id)
self.assertTrue(noerr, status_dict)
@decorators.attr(type='nsxv3')
@decorators.idempotent_id('c5ac8546-6867-4b7a-8544-3843a11b1a34')
def test_verify_rbac_network_octavia_lb_admin(self):
"""
Fetch the status of loadbalancer resources which uses the
api of openstack loadbalancer status show <lb>
"""
diction = self.deploy_octavia_topology()
self.start_web_servers(constants.HTTP_PORT)
net_id = diction['network']['id']
port_id = self.cmgr_adm.ports_client.create_port(
network_id=net_id)['port']['id']
self.addCleanup(test_utils.call_and_ignore_notfound_exc,
self.cmgr_adm.ports_client.delete_port, port_id)
self.rbac_client.create_rbac_policy(action="access_as_shared",
object_type="network",
object_id=net_id,
target_tenant="admin")
self.create_project_octavia(protocol_type="HTTPS", protocol_port="80",
lb_algorithm="ROUND_ROBIN",
vip_port_id=port_id, hm_type='PING',
timeout=self.hm_timeout,
max_retries=self.hm_max_retries,
delay=self.hm_delay, default_pool=True)
def test_delete_octavia_lb_with_cascade(self):
"""
Create octavia LB and delete it with --cascade options
"""
diction = self.deploy_octavia_topology()
self.start_web_servers(constants.HTTP_PORT)
net_id = diction['network']['id']
port_id = self.cmgr_adm.ports_client.create_port(
network_id=net_id)['port']['id']
self.addCleanup(test_utils.call_and_ignore_notfound_exc,
self.cmgr_adm.ports_client.delete_port, port_id)
self.create_project_octavia(protocol_type="HTTPS", protocol_port="80",
lb_algorithm="ROUND_ROBIN",
vip_port_id=port_id, hm_type='PING',
timeout=self.hm_timeout,
max_retries=self.hm_max_retries,
delay=self.hm_delay, default_pool=True,
no_cleanup=True)
list_lb = []
noerr = 0
lb_id = self.loadbalancer['id']
self.octavia_admin_client.\
delete_octavia_load_balancer_with_cascade(lb_id)
try:
status = self.octavia_admin_client.\
wait_for_load_balancer_status(lb_id)
list_lb.append(lb_id)
list_lb.append(status['listeners'][0]['id'])
list_lb.append(status['pools'][0]['id'])
except lib_exc.NotFound:
noerr = 1
self.assertTrue(noerr, list_lb)
def test_create_update_verify_backend_octavia_lb(self):
"""
Create octavia LB and delete it with --cascade options
"""
diction = self.deploy_octavia_topology()
self.start_web_servers(constants.HTTP_PORT)
net_id = diction['network']['id']
port_id = self.cmgr_adm.ports_client.create_port(
network_id=net_id)['port']['id']
self.addCleanup(test_utils.call_and_ignore_notfound_exc,
self.cmgr_adm.ports_client.delete_port, port_id)
self.create_project_octavia(protocol_type="HTTPS", protocol_port="80",
lb_algorithm="ROUND_ROBIN",
vip_port_id=port_id, hm_type='PING',
timeout=self.hm_timeout,
max_retries=self.hm_max_retries,
delay=self.hm_delay, default_pool=True)
time.sleep(constants.SLEEP_BETWEEN_VIRTUAL_SEREVRS_OPEARTIONS)
backend_name = diction['router']['router']['id'][:5]
backend_status = self.nsxp.\
get_loadbalancers(backend_name=backend_name)[0]
noerr = self.verifyBackendStatus_octavia_lb(backend_status)
self.assertTrue(noerr, "Backend Verification failed")