1870 lines
83 KiB
Python
1870 lines
83 KiB
Python
# 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 time
|
|
|
|
from neutron_lib import constants as nl_constants
|
|
|
|
from tempest.common.utils.linux import remote_client
|
|
from tempest import config
|
|
from tempest.lib.common.utils import data_utils
|
|
from tempest.lib.common.utils import test_utils
|
|
from tempest.lib import exceptions as lib_exc
|
|
|
|
from vmware_nsx_tempest_plugin._i18n import _
|
|
from vmware_nsx_tempest_plugin.common import constants
|
|
from vmware_nsx_tempest_plugin.lib import traffic_manager
|
|
from vmware_nsx_tempest_plugin.services import designate_base
|
|
from vmware_nsx_tempest_plugin.services import fwaas_client as FWAASC
|
|
from vmware_nsx_tempest_plugin.services.lbaas import health_monitors_client
|
|
from vmware_nsx_tempest_plugin.services.lbaas import listeners_client
|
|
from vmware_nsx_tempest_plugin.services.lbaas import load_balancers_client
|
|
from vmware_nsx_tempest_plugin.services.lbaas import members_client
|
|
from vmware_nsx_tempest_plugin.services.lbaas import pools_client
|
|
from vmware_nsx_tempest_plugin.services import nsx_client
|
|
from vmware_nsx_tempest_plugin.services import openstack_network_clients
|
|
|
|
|
|
LOG = constants.log.getLogger(__name__)
|
|
|
|
CONF = config.CONF
|
|
|
|
RULE_TYPE_BANDWIDTH_LIMIT = "bandwidth_limit"
|
|
RULE_TYPE_DSCP_MARK = "dscp_marking"
|
|
|
|
|
|
# It includes feature related function such CRUD Mdproxy, L2GW or QoS
|
|
class FeatureManager(traffic_manager.IperfManager,
|
|
designate_base.DnsClientBase):
|
|
|
|
@classmethod
|
|
def setup_clients(cls):
|
|
"""Create various client connections. Such as NSXv3 and L2 Gateway.
|
|
|
|
"""
|
|
super(FeatureManager, cls).setup_clients()
|
|
try:
|
|
manager = getattr(cls.os_admin, "manager", cls.os_admin)
|
|
net_client = getattr(manager, "networks_client")
|
|
_params = manager.default_params_withy_timeout_values.copy()
|
|
except AttributeError as attribute_err:
|
|
LOG.warning(
|
|
"Failed to locate the attribute, Error: %(err_msg)s",
|
|
{"err_msg": attribute_err.__str__()})
|
|
_params = {}
|
|
cls.l2gw_client = openstack_network_clients.L2GatewayClient(
|
|
net_client.auth_provider,
|
|
net_client.service,
|
|
net_client.region,
|
|
net_client.endpoint_type,
|
|
**_params)
|
|
cls.nsx_client = nsx_client.NSXClient(
|
|
CONF.network.backend,
|
|
CONF.nsxv3.nsx_manager,
|
|
CONF.nsxv3.nsx_user,
|
|
CONF.nsxv3.nsx_password)
|
|
cls.l2gwc_client = openstack_network_clients.L2GatewayConnectionClient(
|
|
net_client.auth_provider,
|
|
net_client.service,
|
|
net_client.region,
|
|
net_client.endpoint_type,
|
|
**_params)
|
|
cls.load_balancers_client = \
|
|
load_balancers_client.get_client(cls.os_primary)
|
|
cls.listeners_client = listeners_client.get_client(cls.os_primary)
|
|
cls.pools_client = pools_client.get_client(cls.os_primary)
|
|
cls.members_client = members_client.get_client(cls.os_primary)
|
|
cls.health_monitors_client = \
|
|
health_monitors_client.get_client(cls.os_primary)
|
|
cls.load_balancers_admin_client = \
|
|
load_balancers_client.get_client(cls.os_admin)
|
|
cls.listeners_admin_client = listeners_client.get_client(cls.os_admin)
|
|
cls.pools_admin_client = pools_client.get_client(cls.os_admin)
|
|
cls.members_admin_client = members_client.get_client(cls.os_admin)
|
|
cls.health_monitors_admin_client = \
|
|
health_monitors_client.get_client(cls.os_admin)
|
|
cls.fwaas_v2_client = openstack_network_clients.FwaasV2Client(
|
|
net_client.auth_provider,
|
|
net_client.service,
|
|
net_client.region,
|
|
net_client.endpoint_type,
|
|
**_params)
|
|
cls.fwaasv1_client = FWAASC.get_client(cls.manager)
|
|
cls.vpnaas_client = openstack_network_clients.VPNClient(
|
|
net_client.auth_provider,
|
|
net_client.service,
|
|
net_client.region,
|
|
net_client.endpoint_type,
|
|
**_params)
|
|
cls.qos_policy_client = openstack_network_clients.QosPoliciesClient(
|
|
net_client.auth_provider,
|
|
net_client.service,
|
|
net_client.region,
|
|
net_client.endpoint_type,
|
|
**_params)
|
|
cls.qos_bw_client = openstack_network_clients.QosBWLimitClient(
|
|
net_client.auth_provider,
|
|
net_client.service,
|
|
net_client.region,
|
|
net_client.endpoint_type,
|
|
**_params)
|
|
cls.qos_dscp_client = openstack_network_clients.QosDscpClient(
|
|
net_client.auth_provider,
|
|
net_client.service,
|
|
net_client.region,
|
|
net_client.endpoint_type,
|
|
**_params)
|
|
net_client.service = 'load-balancer'
|
|
cls.octavia_admin_client = openstack_network_clients.\
|
|
OctaviaLB_Client(net_client.auth_provider,
|
|
net_client.service,
|
|
net_client.region,
|
|
net_client.endpoint_type,
|
|
**_params)
|
|
cls.octavia_admin_listener_client = openstack_network_clients.\
|
|
OctaviaListenersClient(net_client.auth_provider,
|
|
net_client.service,
|
|
net_client.region,
|
|
net_client.endpoint_type,
|
|
**_params)
|
|
cls.octavia_admin_pools_client = openstack_network_clients.\
|
|
OctaviaPoolsClient(net_client.auth_provider,
|
|
net_client.service,
|
|
net_client.region,
|
|
net_client.endpoint_type,
|
|
**_params)
|
|
cls.octavia_hm_client = openstack_network_clients.\
|
|
OctaviaHealthMonitorClient(net_client.auth_provider,
|
|
net_client.service,
|
|
net_client.region,
|
|
net_client.endpoint_type,
|
|
**_params)
|
|
cls.octavia_admin_members_client = openstack_network_clients.\
|
|
OctaviaMembersClient(net_client.auth_provider,
|
|
net_client.service,
|
|
net_client.region,
|
|
net_client.endpoint_type,
|
|
**_params)
|
|
cls.octavia_admin_l7policies_client = openstack_network_clients.\
|
|
OctaviaL7PolicyClient(net_client.auth_provider,
|
|
net_client.service,
|
|
net_client.region,
|
|
net_client.endpoint_type,
|
|
**_params)
|
|
cls.octavia_admin_l7rules_client = openstack_network_clients.\
|
|
OctaviaL7RulesClient(net_client.auth_provider,
|
|
net_client.service,
|
|
net_client.region,
|
|
net_client.endpoint_type,
|
|
**_params)
|
|
net_client.service = 'dns'
|
|
cls.zones_v2_client = openstack_network_clients.ZonesV2Client(
|
|
net_client.auth_provider,
|
|
net_client.service,
|
|
net_client.region,
|
|
net_client.endpoint_type,
|
|
**_params)
|
|
cls.ptr_client = openstack_network_clients.DesignatePtrClient(
|
|
net_client.auth_provider,
|
|
net_client.service,
|
|
net_client.region,
|
|
net_client.endpoint_type,
|
|
**_params)
|
|
net_client.service = 'key-manager'
|
|
cls.secret_client = openstack_network_clients.SecretClient(
|
|
net_client.auth_provider,
|
|
net_client.service,
|
|
net_client.region,
|
|
net_client.endpoint_type,
|
|
**_params)
|
|
cls.container_client = openstack_network_clients.ContainerClient(
|
|
net_client.auth_provider,
|
|
net_client.service,
|
|
net_client.region,
|
|
net_client.endpoint_type,
|
|
**_params)
|
|
|
|
#
|
|
# FwaasV2 base class
|
|
#
|
|
def create_firewall_rule(self, **kwargs):
|
|
fw_rule = self.fwaas_v2_client.create_firewall_v2_rule(**kwargs)
|
|
self.addCleanup(
|
|
test_utils.call_and_ignore_notfound_exc,
|
|
self.fwaas_v2_client.delete_firewall_v2_rule,
|
|
fw_rule["firewall_rule"]["id"])
|
|
return fw_rule
|
|
|
|
def create_firewall_policy(self, **kwargs):
|
|
fw_policy = self.fwaas_v2_client.create_firewall_v2_policy(**kwargs)
|
|
self.addCleanup(
|
|
test_utils.call_and_ignore_notfound_exc,
|
|
self.fwaas_v2_client.delete_firewall_v2_policy,
|
|
fw_policy["firewall_policy"]["id"])
|
|
return fw_policy
|
|
|
|
def create_firewall_group(self, **kwargs):
|
|
fw_group = self.fwaas_v2_client.create_firewall_v2_group(**kwargs)
|
|
self.addCleanup(
|
|
test_utils.call_and_ignore_notfound_exc,
|
|
self.fwaas_v2_client.delete_firewall_v2_group,
|
|
fw_group["firewall_group"]["id"])
|
|
return fw_group
|
|
|
|
def update_firewall_group(self, group_id, **kwargs):
|
|
fw_group = self.fwaas_v2_client.update_firewall_v2_group(group_id,
|
|
**kwargs)
|
|
return fw_group
|
|
|
|
def update_firewall_policy(self, policy_id, **kwargs):
|
|
return self.fwaas_v2_client.update_firewall_v2_policy(policy_id,
|
|
**kwargs)
|
|
|
|
def update_firewall_rule(self, rule_id, **kwargs):
|
|
return self.fwaas_v2_client.update_firewall_v2_rule(rule_id,
|
|
**kwargs)
|
|
|
|
def show_firewall_group(self, group_id):
|
|
fw_group = self.fwaas_v2_client.show_firewall_v2_group(group_id)
|
|
return fw_group
|
|
|
|
def show_firewall_rule(self, rule_id):
|
|
fw_rule = self.fwaas_v2_client.show_firewall_v2_rule(rule_id)
|
|
return fw_rule
|
|
|
|
def show_firewall_policy(self, policy_id):
|
|
fw_policy = self.fwaas_v2_client.show_firewall_v2_policy(policy_id)
|
|
return fw_policy
|
|
|
|
#
|
|
# FwaasV1 base class
|
|
#
|
|
def _create_firewall_rule_name(self, body):
|
|
firewall_rule_name = body['firewall_rule']['name']
|
|
firewall_rule_name = "Fwaas-" + firewall_rule_name
|
|
return firewall_rule_name
|
|
|
|
def _delete_rule_if_exists(self, rule_id):
|
|
# delete rule, if it exists
|
|
try:
|
|
self.fwaasv1_client.delete_firewall_rule(rule_id)
|
|
# if rule is not found, this means it was deleted in the test
|
|
except lib_exc.NotFound:
|
|
pass
|
|
|
|
def _delete_firewall_if_exists(self, fw_id):
|
|
# delete firewall, if it exists
|
|
try:
|
|
self.fwaasv1_client.delete_firewall(fw_id)
|
|
# if firewall is not found, this means it was deleted in the test
|
|
except lib_exc.NotFound:
|
|
pass
|
|
self.fwaasv1_client.wait_for_resource_deletion(fw_id)
|
|
|
|
def create_fw_v1_rule(self, **kwargs):
|
|
body = self.fwaasv1_client.create_firewall_rule(
|
|
name=data_utils.rand_name("fw-rule"),
|
|
**kwargs)
|
|
fw_rule = body['firewall_rule']
|
|
self.addCleanup(test_utils.call_and_ignore_notfound_exc,
|
|
self.fwaasv1_client.delete_firewall_rule,
|
|
fw_rule['id'])
|
|
return fw_rule
|
|
|
|
def create_fw_v1_policy(self, **kwargs):
|
|
body = self.fwaasv1_client.create_firewall_policy(
|
|
name=data_utils.rand_name("fw-policy"),
|
|
**kwargs)
|
|
fw_policy = body['firewall_policy']
|
|
self.addCleanup(test_utils.call_and_ignore_notfound_exc,
|
|
self.fwaasv1_client.delete_firewall_policy,
|
|
fw_policy['id'])
|
|
return fw_policy
|
|
|
|
def insert_fw_v1_rule_in_policy(self, firewall_policy_id, firewall_rule_id,
|
|
insert_after, insert_before):
|
|
self.fwaasv1_client.insert_firewall_rule_in_policy(firewall_policy_id,
|
|
firewall_rule_id,
|
|
insert_after,
|
|
insert_before)
|
|
|
|
def delete_fw_v1_and_wait(self, firewall_id):
|
|
self.fwaasv1_client.delete_firewall(firewall_id)
|
|
self._wait_firewall_while(firewall_id, [nl_constants.PENDING_DELETE],
|
|
not_found_ok=True)
|
|
|
|
def _delete_policy_if_exists(self, policy_id):
|
|
# delete policy, if it exists
|
|
try:
|
|
self.fwaasv1_client.delete_firewall_policy(policy_id)
|
|
# if policy is not found, this means it was deleted in the test
|
|
except lib_exc.NotFound:
|
|
pass
|
|
|
|
def create_fw_v1(self, **kwargs):
|
|
body = self.fwaasv1_client.create_firewall(
|
|
name=data_utils.rand_name("fw"),
|
|
**kwargs)
|
|
fw = body['firewall']
|
|
self.addCleanup(test_utils.call_and_ignore_notfound_exc,
|
|
self.delete_fw_v1_and_wait,
|
|
fw['id'])
|
|
return fw
|
|
|
|
def update_fw_v1(self, firewall_id, **kwargs):
|
|
body = self.fwaasv1_client.update_firewall(firewall_id, **kwargs)
|
|
return body
|
|
|
|
def show_fw_v1(self, firewall_id):
|
|
body = self.fwaasv1_client.show_firewall(firewall_id)
|
|
return body
|
|
|
|
def _wait_fw_v1_while(self, firewall_id, statuses, not_found_ok=False):
|
|
start = int(time.time())
|
|
if not_found_ok:
|
|
expected_exceptions = (lib_exc.NotFound)
|
|
else:
|
|
expected_exceptions = ()
|
|
while True:
|
|
try:
|
|
fw = self.fwaasv1_client.show_firewall(firewall_id)
|
|
except expected_exceptions:
|
|
break
|
|
status = fw['firewall']['status']
|
|
if status not in statuses:
|
|
break
|
|
if int(time.time()) - start >= self.fwaasv1_client.build_timeout:
|
|
msg = ("Firewall %(firewall)s failed to reach "
|
|
"non PENDING status (current %(status)s)") % {
|
|
"firewall": firewall_id,
|
|
"status": status,
|
|
}
|
|
raise lib_exc.TimeoutException(msg)
|
|
time.sleep(constants.NSX_BACKEND_VERY_SMALL_TIME_INTERVAL)
|
|
|
|
def _wait_fw_v1_ready(self, firewall_id):
|
|
self._wait_firewall_while(firewall_id,
|
|
[nl_constants.PENDING_CREATE,
|
|
nl_constants.PENDING_UPDATE])
|
|
|
|
def _wait_fw_v1_until_ready(self, fw_id):
|
|
target_states = ('ACTIVE', 'CREATED')
|
|
|
|
def _wait():
|
|
firewall = self.fwaasv1_client.show_firewall(fw_id)
|
|
firewall = firewall['firewall']
|
|
return firewall['status'] in target_states
|
|
if not test_utils.call_until_true(_wait, CONF.network.build_timeout,
|
|
CONF.network.build_interval):
|
|
m = ("Timed out waiting for firewall %s to reach %s state(s)" %
|
|
(fw_id, target_states))
|
|
raise lib_exc.TimeoutException(m)
|
|
|
|
def create_fw_v1_basic_topo(self, router_type, protocol_name,
|
|
policy=None):
|
|
rtr_kwargs = {"router_type": "exclusive",
|
|
"admin_state_up": "True"}
|
|
router = self.create_topology_router("fire-1", **rtr_kwargs)
|
|
body = self.fwaasv1_client.create_fw_v1_rule(
|
|
name=data_utils.rand_name("fw-rule"),
|
|
action="allow",
|
|
protocol=protocol_name)
|
|
fw_rule_id1 = body['firewall_rule']['id']
|
|
self._create_firewall_rule_name(body)
|
|
self.addCleanup(self._delete_rule_if_exists, fw_rule_id1)
|
|
# Create firewall policy
|
|
if not policy:
|
|
body = self.fwaasv1_client.create_fw_v1_policy(
|
|
name=data_utils.rand_name("fw-policy"))
|
|
fw_policy_id = body['firewall_policy']['id']
|
|
self.addCleanup(self._delete_policy_if_exists, fw_policy_id)
|
|
# Insert rule to firewall policy
|
|
self.fwaasv1_client.insert_firewall_rule_in_policy(
|
|
fw_policy_id, fw_rule_id1, '', '')
|
|
else:
|
|
fw_policy_id = policy
|
|
# Create firewall
|
|
firewall_1 = self.fwaasv1_client.create_fw_v1(
|
|
name=data_utils.rand_name("firewall"),
|
|
firewall_policy_id=fw_policy_id,
|
|
router_ids=[router['id']])
|
|
created_firewall = firewall_1['firewall']
|
|
self.addCleanup(self._delete_firewall_if_exists,
|
|
created_firewall['id'])
|
|
# Wait for the firewall resource to become ready
|
|
self._wait_fw_v1_until_ready(created_firewall['id'])
|
|
|
|
def ping_between_vms_different_router_uniscale(self, icmp_succeed=True):
|
|
"""
|
|
Receives topology servers dictionary as input and finds all the
|
|
servers list checks NS and EW Traffic
|
|
"""
|
|
for server in self.servers_details.values():
|
|
ip_address = server[0]['floating_ips'][0]['floating_ip_address']
|
|
ssh_source = self._get_remote_client(ip_address, use_password=True)
|
|
self.\
|
|
test_fip_check_server_and_project_network_connectivity(
|
|
server,
|
|
should_connect=icmp_succeed)
|
|
for remote_server in self.servers_details.values():
|
|
if remote_server[0]['name'] != server[0]['name']:
|
|
remote_ip = remote_server[0][
|
|
'addresses'].values()[0][0]['addr']
|
|
self.check_remote_connectivity(ssh_source, remote_ip,
|
|
should_succeed=True)
|
|
#
|
|
# L2Gateway base class. To get basics of L2GW.
|
|
#
|
|
|
|
def create_l2gw(self, l2gw_name, l2gw_param):
|
|
"""Creates L2GW and returns the response.
|
|
|
|
:param l2gw_name: name of the L2GW
|
|
:param l2gw_param: L2GW parameters
|
|
|
|
:return: response of L2GW create API
|
|
|
|
"""
|
|
LOG.info("l2gw name: %(name)s, l2gw_param: %(devices)s ",
|
|
{"name": l2gw_name, "devices": l2gw_param})
|
|
devices = []
|
|
for device_dict in l2gw_param:
|
|
interface = [{"name": device_dict["iname"],
|
|
"segmentation_id": device_dict[
|
|
"vlans"]}] if "vlans" in device_dict else [
|
|
{"name": device_dict["iname"]}]
|
|
device = {"device_name": device_dict["dname"],
|
|
"interfaces": interface}
|
|
devices.append(device)
|
|
l2gw_request_body = {"devices": devices}
|
|
LOG.info(" l2gw_request_body: %s", l2gw_request_body)
|
|
rsp = self.l2gw_client.create_l2_gateway(
|
|
name=l2gw_name, **l2gw_request_body)
|
|
LOG.info(" l2gw response: %s", rsp)
|
|
self.addCleanup(
|
|
test_utils.call_and_ignore_notfound_exc,
|
|
self.l2gw_client.delete_l2_gateway, rsp[constants.L2GW]["id"])
|
|
return rsp, devices
|
|
|
|
def delete_l2gw(self, l2gw_id):
|
|
"""Delete L2gw.
|
|
|
|
:param l2gw_id: L2GW id to delete l2gw.
|
|
|
|
:return: response of the l2gw delete API.
|
|
|
|
"""
|
|
LOG.info("L2GW id: %(id)s to be deleted.", {"id": l2gw_id})
|
|
rsp = self.l2gw_client.delete_l2_gateway(l2gw_id)
|
|
LOG.info("response : %(rsp)s", {"rsp": rsp})
|
|
return rsp
|
|
|
|
def update_l2gw(self, l2gw_id, l2gw_new_name, devices):
|
|
"""Update existing L2GW.
|
|
|
|
:param l2gw_id: L2GW id to update its parameters.
|
|
:param l2gw_new_name: name of the L2GW.
|
|
:param devices: L2GW parameters.
|
|
|
|
:return: Response of the L2GW update API.
|
|
|
|
"""
|
|
rsp = self.l2gw_client.update_l2_gateway(l2gw_id,
|
|
name=l2gw_new_name, **devices)
|
|
return rsp
|
|
|
|
def nsx_bridge_cluster_info(self):
|
|
"""Collect the device and interface name of the nsx brdige cluster.
|
|
|
|
:return: nsx bridge id and display name.
|
|
|
|
"""
|
|
response = self.nsx_client.get_bridge_cluster_info()
|
|
if len(response) == 0:
|
|
raise RuntimeError(_("NSX bridge cluster information is null"))
|
|
return [(x.get("id"), x.get("display_name")) for x in response]
|
|
|
|
def nsx_bridge_profile_info(self):
|
|
"""Collect the device and interface name of the nsx brdige profile.
|
|
|
|
:return: nsx bridge id and display name.
|
|
|
|
"""
|
|
response = self.nsx_client.get_bridge_profile_info()
|
|
if len(response) == 0:
|
|
raise RuntimeError(_("NSX bridge profile information is null"))
|
|
return [(x.get("id"), x.get("display_name")) for x in response]
|
|
|
|
def nsx_transport_zone_info(self):
|
|
"""Collect the Vlan Transport zone.
|
|
|
|
:return: nsx vlan transport zone.
|
|
|
|
"""
|
|
response = self.nsx_client.get_transport_zones()
|
|
if len(response) == 0:
|
|
raise RuntimeError(_("NSX bridge profile information is null"))
|
|
vlan_zone = None
|
|
for zone in response:
|
|
if zone['transport_type'] == 'VLAN':
|
|
if zone['display_name'] == 'transportzone2':
|
|
vlan_zone = zone['id']
|
|
if vlan_zone:
|
|
return vlan_zone
|
|
else:
|
|
raise RuntimeError(_("Vlan Transport zone not found"))
|
|
|
|
def create_l2gw_connection(self, l2gwc_param):
|
|
"""Creates L2GWC and return the response.
|
|
|
|
:param l2gwc_param: L2GWC parameters.
|
|
|
|
:return: response of L2GWC create API.
|
|
|
|
"""
|
|
LOG.info("l2gwc param: %(param)s ", {"param": l2gwc_param})
|
|
l2gwc_request_body = {"l2_gateway_id": l2gwc_param["l2_gateway_id"],
|
|
"network_id": l2gwc_param["network_id"]}
|
|
if "segmentation_id" in l2gwc_param:
|
|
l2gwc_request_body["segmentation_id"] = l2gwc_param[
|
|
"segmentation_id"]
|
|
LOG.info("l2gwc_request_body: %s", l2gwc_request_body)
|
|
rsp = self.l2gwc_client.create_l2_gateway_connection(
|
|
**l2gwc_request_body)
|
|
LOG.info("l2gwc response: %s", rsp)
|
|
self.addCleanup(
|
|
test_utils.call_and_ignore_notfound_exc,
|
|
self.l2gwc_client.delete_l2_gateway_connection,
|
|
rsp[constants.L2GWC]["id"])
|
|
return rsp
|
|
|
|
def delete_l2gw_connection(self, l2gwc_id):
|
|
"""Delete L2GWC and returns the response.
|
|
|
|
:param l2gwc_id: L2GWC id to delete L2GWC.
|
|
|
|
:return: response of the l2gwc delete API.
|
|
|
|
"""
|
|
LOG.info("L2GW connection id: %(id)s to be deleted",
|
|
{"id": l2gwc_id})
|
|
rsp = self.l2gwc_client.delete_l2_gateway_connection(l2gwc_id)
|
|
LOG.info("response : %(rsp)s", {"rsp": rsp})
|
|
return rsp
|
|
|
|
#
|
|
# LBAAS section.
|
|
#
|
|
def delete_loadbalancer_resources(self, lb_id, admin=None):
|
|
"""Deletion of lbaas resources.
|
|
|
|
:param lb_id: Load Balancer ID.
|
|
|
|
"""
|
|
if admin:
|
|
lb_client = self.load_balancers_admin_client
|
|
else:
|
|
lb_client = self.load_balancers_client
|
|
statuses = lb_client.show_load_balancer_status_tree(lb_id)
|
|
statuses = statuses.get('statuses', statuses)
|
|
lb = statuses.get('loadbalancer')
|
|
for listener in lb.get('listeners', []):
|
|
for policy in listener.get('l7policies'):
|
|
test_utils.call_and_ignore_notfound_exc(
|
|
self.l7policies_client.delete_policy,
|
|
policy.get('id'))
|
|
for pool in listener.get('pools'):
|
|
if admin:
|
|
self.delete_lb_pool_resources(lb_id, pool, admin=admin)
|
|
else:
|
|
self.delete_lb_pool_resources(lb_id, pool)
|
|
if admin:
|
|
test_utils.call_and_ignore_notfound_exc(
|
|
self.listeners_admin_client.delete_listener,
|
|
listener.get('id'))
|
|
self.load_balancers_admin_client.\
|
|
wait_for_load_balancer_status(lb_id)
|
|
else:
|
|
test_utils.call_and_ignore_notfound_exc(
|
|
self.listeners_client.delete_listener,
|
|
listener.get('id'))
|
|
self.wait_for_load_balancer_status(lb_id)
|
|
# delete pools not attached to listener, but loadbalancer
|
|
for pool in lb.get('pools', []):
|
|
if admin:
|
|
self.delete_lb_pool_resources(lb_id, pool, admin=admin)
|
|
else:
|
|
self.delete_lb_pool_resources(lb_id, pool)
|
|
test_utils.call_and_ignore_notfound_exc(
|
|
lb_client.delete_load_balancer, lb_id)
|
|
lb_client.wait_for_load_balancer_status(
|
|
lb_id, is_delete_op=True)
|
|
lbs = lb_client.list_load_balancers()['loadbalancers']
|
|
self.assertEqual(0, len(lbs))
|
|
|
|
def delete_lb_pool_healthmonitor(self, pool, admin=None):
|
|
"""Deletion of lb health pool and monitor.
|
|
"""
|
|
if admin:
|
|
test_utils.call_and_ignore_notfound_exc(
|
|
self.health_monitors_admin_client.delete_health_monitor,
|
|
pool.get('pool')['healthmonitor_id'])
|
|
else:
|
|
test_utils.call_and_ignore_notfound_exc(
|
|
self.health_monitors_client.delete_health_monitor,
|
|
pool.get('pool')['healthmonitor_id'])
|
|
if admin:
|
|
test_utils.call_and_ignore_notfound_exc(
|
|
self.pools_admin_client.delete_pool, pool.get('pool')['id'])
|
|
else:
|
|
test_utils.call_and_ignore_notfound_exc(
|
|
self.pools_client.delete_pool, pool.get('pool')['id'])
|
|
|
|
def delete_lb_pool_resources(self, lb_id, pool, admin=None):
|
|
"""Deletion of lbaas pool resources.
|
|
|
|
:param lb_id: Load Balancer ID.
|
|
:param pool: pool information.
|
|
|
|
"""
|
|
pool_id = pool.get('id')
|
|
hm = pool.get('healthmonitor')
|
|
if hm:
|
|
if admin:
|
|
test_utils.call_and_ignore_notfound_exc(
|
|
self.health_monitors_admin_client.delete_health_monitor,
|
|
pool.get('healthmonitor').get('id'))
|
|
self.load_balancers_admin_client.wait_for_load_balancer_status(
|
|
lb_id)
|
|
else:
|
|
test_utils.call_and_ignore_notfound_exc(
|
|
self.health_monitors_client.delete_health_monitor,
|
|
pool.get('healthmonitor').get('id'))
|
|
self.wait_for_load_balancer_status(lb_id)
|
|
if admin:
|
|
test_utils.call_and_ignore_notfound_exc(
|
|
self.pools_admin_client.delete_pool, pool.get('id'))
|
|
self.load_balancers_admin_client.\
|
|
wait_for_load_balancer_status(lb_id)
|
|
else:
|
|
test_utils.call_and_ignore_notfound_exc(
|
|
self.pools_client.delete_pool, pool.get('id'))
|
|
self.wait_for_load_balancer_status(lb_id)
|
|
for member in pool.get('members', []):
|
|
if admin:
|
|
test_utils.call_and_ignore_notfound_exc(
|
|
self.members_admin_client.delete_member,
|
|
pool_id, member.get('id'))
|
|
self.load_balancers_admin_client.\
|
|
wait_for_load_balancer_status(lb_id)
|
|
else:
|
|
test_utils.call_and_ignore_notfound_exc(
|
|
self.members_client.delete_member,
|
|
pool_id, member.get('id'))
|
|
self.wait_for_load_balancer_status(lb_id)
|
|
|
|
def start_web_servers(self, protocol_port):
|
|
"""Start web server.
|
|
|
|
:param protocol_port: Port number.
|
|
|
|
"""
|
|
for server_name in self.topology_servers.keys():
|
|
server = self.servers_details[server_name].server
|
|
self.start_web_server(protocol_port, server, server_name)
|
|
|
|
def _wait_firewall_while(self, fw_group_id, statuses, not_found_ok=False):
|
|
if not_found_ok:
|
|
expected_exceptions = (lib_exc.NotFound)
|
|
else:
|
|
expected_exceptions = ()
|
|
while True:
|
|
try:
|
|
fw = self.show_firewall_group(fw_group_id)
|
|
except expected_exceptions:
|
|
break
|
|
status = fw['firewall_group']['status']
|
|
if status not in statuses:
|
|
break
|
|
|
|
def _wait_firewall_ready(self, fw_group_id):
|
|
time.sleep(constants.NSX_BACKEND_VERY_SMALL_TIME_INTERVAL)
|
|
self._wait_firewall_while(fw_group_id,
|
|
[nl_constants.PENDING_CREATE,
|
|
nl_constants.PENDING_UPDATE])
|
|
|
|
def wait_for_load_balancer_status(self, lb_id):
|
|
# Wait for load balancer become ONLINE and ACTIVE
|
|
self.load_balancers_client.wait_for_load_balancer_status(lb_id)
|
|
|
|
def create_addtional_lbaas_members(self, protocol_port):
|
|
"""Create Additional members in pool.
|
|
|
|
:param protocol_port: Port number.
|
|
|
|
"""
|
|
for server_name in self.topology_servers.keys():
|
|
if server_name in self.server_names:
|
|
continue
|
|
fip_data = self.servers_details[server_name].floating_ips[0]
|
|
fixed_ip_address = fip_data['fixed_ip_address']
|
|
self._disassociate_floating_ip(fip_data)
|
|
pool_id = self.pool['id']
|
|
vip_subnet_id = self.topology_subnets["subnet_lbaas_1"]['id']
|
|
lb_id = self.loadbalancer['id']
|
|
self.members_client.create_member(
|
|
pool_id, subnet_id=vip_subnet_id,
|
|
address=fixed_ip_address,
|
|
protocol_port=protocol_port)
|
|
self.wait_for_load_balancer_status(lb_id)
|
|
|
|
def check_lbaas_project_weight_values(self, count=2, HTTPS=None,
|
|
member_count=None,
|
|
barbican_http=None,
|
|
hash_persistence=False):
|
|
vip = self.vip_ip_address
|
|
time.sleep(constants.SLEEP_BETWEEN_VIRTUAL_SEREVRS_OPEARTIONS)
|
|
if HTTPS is None:
|
|
self.do_http_request(vip=vip, send_counts=self.poke_counters)
|
|
else:
|
|
self.do_https_request(vip=vip, send_counts=self.poke_counters)
|
|
# ROUND_ROUBIN, so equal counts
|
|
if CONF.nsxv3.ens:
|
|
vms = len(self.topology_servers.keys())
|
|
if vms:
|
|
self.assertEqual(self.http_cnt["Welcome vm"] / 2, 3 * vms,
|
|
"LB fails with weighted values")
|
|
else:
|
|
pass
|
|
elif barbican_http:
|
|
no_of_vms = len(self.http_cnt)
|
|
# if source_ip persistence enabled then the count
|
|
# remains 1 as only one server will be actively responding
|
|
if hash_persistence:
|
|
self.assertEqual(no_of_vms, 1)
|
|
else:
|
|
if no_of_vms:
|
|
if (self.http_cnt['server_lbaas_2'] <
|
|
(self.poke_counters / no_of_vms)):
|
|
self.assertGreater(self.http_cnt['server_lbaas_3'],
|
|
self.poke_counters / no_of_vms)
|
|
elif (self.http_cnt['server_lbaas_3'] >
|
|
(self.poke_counters / no_of_vms)):
|
|
self.assertLess(self.http_cnt['server_lbaas_3'],
|
|
self.poke_counters / no_of_vms)
|
|
else:
|
|
self.assertEqual(self.http_cnt['server_lbaas_3'],
|
|
self.poke_counters / no_of_vms,
|
|
"LB fails with weighted values")
|
|
else:
|
|
no_of_vms = len(self.http_cnt)
|
|
# if source_ip persistence enabled then the count
|
|
# remains 1 as only one server will be actively responding
|
|
if hash_persistence:
|
|
self.assertEqual(no_of_vms, 1)
|
|
else:
|
|
if no_of_vms:
|
|
if (self.http_cnt['server_lbaas_0'] <
|
|
(self.poke_counters / no_of_vms)):
|
|
self.assertGreater(self.http_cnt['server_lbaas_1'],
|
|
self.poke_counters / no_of_vms)
|
|
elif (self.http_cnt['server_lbaas_0'] >
|
|
(self.poke_counters / no_of_vms)):
|
|
self.assertLess(self.http_cnt['server_lbaas_1'],
|
|
self.poke_counters / no_of_vms)
|
|
else:
|
|
self.assertEqual(self.http_cnt['server_lbaas_1'],
|
|
self.poke_counters / no_of_vms,
|
|
"LB fails with weighted values")
|
|
|
|
def check_project_lbaas(self, count=2, HTTPS=None):
|
|
i = 0
|
|
time.sleep(constants.SLEEP_BETWEEN_VIRTUAL_SEREVRS_OPEARTIONS)
|
|
vip = self.vip_ip_address
|
|
self.do_http_request(vip=vip, send_counts=self.poke_counters)
|
|
# ROUND_ROUBIN, so equal counts
|
|
no_of_vms = len(self.http_cnt)
|
|
if CONF.nsxv3.ens:
|
|
vms = len(self.topology_servers.keys())
|
|
if self.http_cnt["Welcome vm"] == self.poke_counters:
|
|
self.assertEqual(self.http_cnt["Welcome vm"] / vms,
|
|
3 * vms)
|
|
else:
|
|
for server_name in self.topology_servers.keys():
|
|
if i < count:
|
|
i += 1
|
|
self.assertEqual(self.poke_counters / no_of_vms,
|
|
self.http_cnt[server_name])
|
|
else:
|
|
break
|
|
|
|
def count_response(self, response):
|
|
response = response.decode('utf-8')
|
|
if response in self.http_cnt:
|
|
self.http_cnt[response] += 1
|
|
else:
|
|
self.http_cnt[response] = 1
|
|
|
|
def update_members_weight(self, weight):
|
|
for server in self.members:
|
|
self.members_client.update_member(
|
|
self.pool['id'], server['member']['id'], weight=weight)
|
|
weight += weight
|
|
|
|
def update_pool_algorithm(self, algo):
|
|
self.pools_client.update_pool(self.pool['id'],
|
|
lb_algorithm=algo)
|
|
|
|
def create_project_lbaas(self, protocol_type,
|
|
protocol_port, lb_algorithm,
|
|
hm_type, member_count=2,
|
|
max_vms=None, weight=None,
|
|
fip_disassociate=None, barbican=False,
|
|
pool_protocol=None, pool_port=None,
|
|
vip_subnet_id=None, barbican_container=None,
|
|
lb_id=None, count=None,
|
|
clean_up=None, persistence=False,
|
|
persistence_cookie_name=None,
|
|
persistence_type=None,
|
|
create_fip=True, external_subnet=None):
|
|
count = 0
|
|
lb_name = None
|
|
session_persistence = {}
|
|
if persistence:
|
|
if persistence_type:
|
|
session_persistence["type"] = persistence_type
|
|
if persistence_cookie_name:
|
|
session_persistence["cookie_name"] = persistence_cookie_name
|
|
if vip_subnet_id is None:
|
|
vip_subnet_id = self.topology_subnets["subnet_lbaas_1"]['id']
|
|
if lb_id is None:
|
|
lb_name = data_utils.rand_name(self.namestart)
|
|
if barbican:
|
|
self.loadbalancer = self.\
|
|
load_balancers_admin_client.\
|
|
create_load_balancer(name=lb_name,
|
|
vip_subnet_id=vip_subnet_id
|
|
)['loadbalancer']
|
|
lb_id = self.loadbalancer['id']
|
|
self.addCleanup(
|
|
self.load_balancers_admin_client.delete_load_balancer,
|
|
self.loadbalancer['id'])
|
|
self.load_balancers_admin_client.wait_for_load_balancer_status(
|
|
lb_id)
|
|
elif external_subnet:
|
|
self.loadbalancer = self.\
|
|
load_balancers_admin_client.\
|
|
create_load_balancer(name=lb_name,
|
|
vip_subnet_id=external_subnet
|
|
)['loadbalancer']
|
|
lb_id = self.loadbalancer['id']
|
|
if clean_up is None:
|
|
self.addCleanup(
|
|
self.load_balancers_admin_client.delete_load_balancer,
|
|
self.loadbalancer['id'])
|
|
self.load_balancers_admin_client.wait_for_load_balancer_status(
|
|
lb_id)
|
|
else:
|
|
self.loadbalancer = self.\
|
|
load_balancers_client.\
|
|
create_load_balancer(name=lb_name,
|
|
vip_subnet_id=vip_subnet_id
|
|
)['loadbalancer']
|
|
lb_id = self.loadbalancer['id']
|
|
self.wait_for_load_balancer_status(lb_id)
|
|
|
|
if barbican:
|
|
listener_name = data_utils.rand_name("tempest_lb")
|
|
self.listener = self.listeners_admin_client.\
|
|
create_listener(loadbalancer_id=lb_id, protocol=protocol_type,
|
|
protocol_port=protocol_port,
|
|
name=listener_name,
|
|
default_tls_container_ref=barbican_container
|
|
["container_ref"])['listener']
|
|
if clean_up is None:
|
|
self.addCleanup(
|
|
self.listeners_admin_client.delete_listener,
|
|
self.listener['id'])
|
|
self.load_balancers_admin_client.wait_for_load_balancer_status(
|
|
lb_id)
|
|
elif external_subnet:
|
|
listener_name = data_utils.rand_name("tempest_lb")
|
|
self.listener = self.listeners_admin_client.\
|
|
create_listener(loadbalancer_id=lb_id, protocol=protocol_type,
|
|
protocol_port=protocol_port,
|
|
name=listener_name)['listener']
|
|
if clean_up is None:
|
|
self.addCleanup(
|
|
self.listeners_admin_client.delete_listener,
|
|
self.listener['id'])
|
|
self.load_balancers_admin_client.wait_for_load_balancer_status(
|
|
lb_id)
|
|
else:
|
|
self.listener = self.listeners_client.create_listener(
|
|
loadbalancer_id=lb_id, protocol=protocol_type,
|
|
protocol_port=protocol_port, name=lb_name)['listener']
|
|
self.wait_for_load_balancer_status(lb_id)
|
|
if barbican:
|
|
if lb_name is not None:
|
|
self.pool = self.pools_admin_client.create_pool(
|
|
listener_id=self.listener['id'],
|
|
lb_algorithm=lb_algorithm, protocol=pool_protocol,
|
|
name=lb_name)['pool']
|
|
else:
|
|
self.pool = self.pools_admin_client.create_pool(
|
|
listener_id=self.listener['id'],
|
|
lb_algorithm=lb_algorithm, protocol=pool_protocol,
|
|
name=lb_id)['pool']
|
|
self.load_balancers_admin_client.wait_for_load_balancer_status(
|
|
lb_id)
|
|
pool_id = self.pool['id']
|
|
if clean_up is None:
|
|
self.addCleanup(self.pools_admin_client.delete_pool, pool_id)
|
|
self.load_balancers_admin_client.wait_for_load_balancer_status(
|
|
lb_id)
|
|
elif external_subnet:
|
|
self.pool = self.pools_admin_client.create_pool(
|
|
listener_id=self.listener['id'],
|
|
lb_algorithm=lb_algorithm, protocol=protocol_type,
|
|
name=lb_name,
|
|
session_persistence=session_persistence)['pool']
|
|
pool_id = self.pool['id']
|
|
if clean_up is None:
|
|
self.addCleanup(self.pools_admin_client.delete_pool, pool_id)
|
|
self.load_balancers_admin_client.wait_for_load_balancer_status(
|
|
lb_id)
|
|
else:
|
|
self.pool = self.pools_client.create_pool(
|
|
listener_id=self.listener['id'],
|
|
lb_algorithm=lb_algorithm, protocol=protocol_type,
|
|
name=lb_name,
|
|
session_persistence=session_persistence)['pool']
|
|
self.wait_for_load_balancer_status(lb_id)
|
|
pool_id = self.pool['id']
|
|
if barbican or external_subnet:
|
|
self.healthmonitor = (
|
|
self.health_monitors_admin_client.create_health_monitor(
|
|
pool_id=pool_id, type=hm_type,
|
|
delay=self.hm_delay, max_retries=self.hm_max_retries,
|
|
timeout=self.hm_timeout))['healthmonitor']
|
|
self.load_balancers_admin_client.wait_for_load_balancer_status(
|
|
lb_id)
|
|
if clean_up is None:
|
|
self.addCleanup(
|
|
self.health_monitors_admin_client.delete_health_monitor,
|
|
self.healthmonitor['id'])
|
|
else:
|
|
self.healthmonitor = (
|
|
self.health_monitors_client.create_health_monitor(
|
|
pool_id=pool_id, type=hm_type,
|
|
delay=self.hm_delay, max_retries=self.hm_max_retries,
|
|
timeout=self.hm_timeout))
|
|
self.wait_for_load_balancer_status(lb_id)
|
|
self.members = []
|
|
for server_name in self.topology_servers.keys():
|
|
if count < member_count:
|
|
if create_fip:
|
|
fip_data = self.servers_details[server_name].\
|
|
floating_ips[0]
|
|
fixed_ip_address = fip_data['fixed_ip_address']
|
|
if fip_disassociate is None:
|
|
if barbican or external_subnet:
|
|
kwargs = dict(port_id=None)
|
|
self.cmgr_adm.floating_ips_client.\
|
|
update_floatingip(fip_data['id'],
|
|
**kwargs)['floatingip']
|
|
else:
|
|
self._disassociate_floating_ip(fip_data)
|
|
else:
|
|
net_name = self.servers_details[server_name][2][0]['name']
|
|
fixed_ip_address = self.servers_details[
|
|
server_name][0]['addresses'][net_name][0]['addr']
|
|
if weight:
|
|
weight += count
|
|
if barbican:
|
|
member = self.members_admin_client.create_member(
|
|
pool_id, subnet_id=vip_subnet_id,
|
|
address=fixed_ip_address,
|
|
protocol_port=pool_port,
|
|
weight=weight)['member']
|
|
elif external_subnet:
|
|
member = self.members_admin_client.create_member(
|
|
pool_id, subnet_id=vip_subnet_id,
|
|
address=fixed_ip_address,
|
|
protocol_port=protocol_port,
|
|
weight=weight)['member']
|
|
else:
|
|
member = self.members_client.create_member(
|
|
pool_id, subnet_id=vip_subnet_id,
|
|
address=fixed_ip_address,
|
|
protocol_port=protocol_port,
|
|
weight=weight)
|
|
else:
|
|
if barbican:
|
|
member = self.members_admin_client.create_member(
|
|
pool_id, subnet_id=vip_subnet_id,
|
|
address=fixed_ip_address,
|
|
protocol_port=pool_port)['member']
|
|
elif external_subnet:
|
|
member = self.members_admin_client.create_member(
|
|
pool_id, subnet_id=vip_subnet_id,
|
|
address=fixed_ip_address,
|
|
protocol_port=protocol_port)
|
|
else:
|
|
member = self.members_client.create_member(
|
|
pool_id, subnet_id=vip_subnet_id,
|
|
address=fixed_ip_address,
|
|
protocol_port=protocol_port)
|
|
if barbican or external_subnet:
|
|
self.load_balancers_admin_client.\
|
|
wait_for_load_balancer_status(lb_id)
|
|
else:
|
|
self.wait_for_load_balancer_status(lb_id)
|
|
if barbican or external_subnet:
|
|
if clean_up is None:
|
|
self.addCleanup(
|
|
self.members_admin_client.delete_member,
|
|
pool_id,
|
|
member['id'])
|
|
self.members.append(member)
|
|
self.server_names.append(server_name)
|
|
count += 1
|
|
else:
|
|
break
|
|
if not CONF.nsxv3.ens:
|
|
if barbican or external_subnet:
|
|
self.cmgr_adm.ports_client.update_port(
|
|
self.loadbalancer['vip_port_id'],
|
|
security_groups=[self.sg['id']])
|
|
else:
|
|
self.ports_client.update_port(
|
|
self.loadbalancer['vip_port_id'],
|
|
security_groups=[self.sg['id']])
|
|
# create lbaas public interface
|
|
if barbican or external_subnet:
|
|
if not hasattr(self, 'vip_ip_address'):
|
|
self.cmgr_adm.ports_client.update_port(
|
|
self.loadbalancer['vip_port_id'],
|
|
security_groups=[
|
|
self.sg['id']])
|
|
if external_subnet is None:
|
|
vip_fip = self.create_floatingip(
|
|
self.loadbalancer,
|
|
client=self.cmgr_adm.floating_ips_client,
|
|
port_id=self.loadbalancer['vip_port_id'])
|
|
self.vip_ip_address = vip_fip['floating_ip_address']
|
|
else:
|
|
self.vip_ip_address = self.loadbalancer['vip_address']
|
|
return dict(lb_id=lb_id,
|
|
vip_address=self.vip_ip_address,
|
|
pool_id=pool_id,
|
|
healthmonitor_id=self.healthmonitor['id'],
|
|
members=self.members,
|
|
listener_id=self.listener['id'])
|
|
else:
|
|
if create_fip:
|
|
vip_fip = \
|
|
self.create_floatingip(self.loadbalancer,
|
|
port_id=self.loadbalancer[
|
|
'vip_port_id'])
|
|
self.vip_ip_address = vip_fip['floating_ip_address']
|
|
else:
|
|
self.vip_ip_address = self.loadbalancer['vip_address']
|
|
pools = self.pools_client.show_pool(
|
|
self.pool['id'])
|
|
return dict(lb_id=lb_id, pool=pools,
|
|
vip_port=self.loadbalancer['vip_port_id'],
|
|
vip_ip=self.vip_ip_address)
|
|
|
|
def get_router_port(self, client):
|
|
"""List ports using admin creds """
|
|
ports_list = client.list_ports()
|
|
for port in ports_list['ports']:
|
|
port_info = client.show_port(port['id'])
|
|
if port_info['port']['device_owner'] == "network:router_interface":
|
|
return port_info['port']['id']
|
|
return None
|
|
|
|
# Vlan backed Tier-1 router operations
|
|
def check_downlink_port_created(self, router_op, subnet, port_id):
|
|
tag_hit = 0
|
|
backend_rtr_id = ''
|
|
all_routers = self.nsx.get_logical_routers()
|
|
for router in all_routers:
|
|
if router_op['name'] in router.get('display_name'):
|
|
backend_rtr_id = router['id']
|
|
rtr = {'id': backend_rtr_id}
|
|
break
|
|
if backend_rtr_id:
|
|
logical_rtr_ports = self.nsx.get_logical_router_ports(rtr)
|
|
for ports in logical_rtr_ports:
|
|
for rtr_tag in ports.get('tags'):
|
|
if rtr_tag['scope'] == "os-neutron-rport-id" and \
|
|
rtr_tag['tag'] == port_id:
|
|
tag_hit += 1
|
|
continue
|
|
if rtr_tag['scope'] == "os-subnet-id" and subnet['id'] == \
|
|
rtr_tag['tag']:
|
|
tag_hit += 1
|
|
ports_info = ports
|
|
break
|
|
if tag_hit == 2:
|
|
if ports_info.get('resource_type') \
|
|
== 'LogicalRouterDownLinkPort':
|
|
ip_address = ports_info.get('subnets')[
|
|
0].get('ip_addresses')
|
|
if ip_address:
|
|
if not self.\
|
|
cmgr_adm.subnets_client.show_subnet(
|
|
subnet['id']).get('subnet')[
|
|
'gateway_ip'] == ip_address[0]:
|
|
raise RuntimeError(
|
|
"Router centralized port ip doesn't "
|
|
"match with openstack subnet "
|
|
"gatewayip")
|
|
else:
|
|
pass
|
|
else:
|
|
raise RuntimeError(
|
|
"Router_port_id and subnet_id doesn't match at "
|
|
"the backend")
|
|
else:
|
|
raise RuntimeError("Router not created at the backend properly")
|
|
|
|
def check_centralized_port_created(self, router_op, subnet, port_id):
|
|
tag_hit = 0
|
|
backend_rtr_id = ''
|
|
all_routers = self.nsx.get_logical_routers()
|
|
for router in all_routers:
|
|
if router_op['name'] in router.get('display_name'):
|
|
backend_rtr_id = router['id']
|
|
rtr = {'id': backend_rtr_id}
|
|
break
|
|
if backend_rtr_id:
|
|
logical_rtr_ports = self.nsx.get_logical_router_ports(rtr)
|
|
for ports in logical_rtr_ports:
|
|
for rtr_tag in ports.get('tags'):
|
|
if rtr_tag['scope'] == "os-neutron-rport-id" and \
|
|
rtr_tag['tag'] == port_id:
|
|
tag_hit += 1
|
|
continue
|
|
if rtr_tag['scope'] == "os-subnet-id" and subnet['id'] == \
|
|
rtr_tag['tag']:
|
|
tag_hit += 1
|
|
ports_info = ports
|
|
break
|
|
if tag_hit == 2:
|
|
if ports_info.get(
|
|
'resource_type') \
|
|
== 'LogicalRouterCentralizedServicePort':
|
|
ip_address = ports_info.get('subnets')[
|
|
0].get('ip_addresses')
|
|
if ip_address:
|
|
if not self.cmgr_adm.subnets_client.\
|
|
show_subnet(subnet['id']).\
|
|
get('subnet')[
|
|
'gateway_ip'] == ip_address[0]:
|
|
raise RuntimeError(
|
|
"Router centralized port ip doesn't "
|
|
"match with openstack subnet "
|
|
"gatewayip")
|
|
else:
|
|
pass
|
|
else:
|
|
raise RuntimeError(
|
|
"Router_port_id and subnet_id doesn't match at "
|
|
"the backend")
|
|
else:
|
|
raise RuntimeError("Router not created at the backend properly")
|
|
|
|
#
|
|
# QoS base class. To get basics of QoS.
|
|
#
|
|
def get_qos_policy_id(self, policy_id_or_name):
|
|
policies = self.qos_policy_client.list_policies(name=policy_id_or_name)
|
|
policy_list = policies['policies']
|
|
if len(policy_list) > 0:
|
|
return policy_list[0]['id']
|
|
return policy_id_or_name
|
|
|
|
def create_qos_policy(self, name, description, shared, **kwargs):
|
|
result = self.qos_policy_client.create_policy(
|
|
name=name,
|
|
description=description,
|
|
shared=shared,
|
|
**kwargs
|
|
)
|
|
self.addCleanup(test_utils.call_and_ignore_notfound_exc,
|
|
self.qos_policy_client.delete_policy,
|
|
result['policy']['id'])
|
|
return result.get('policy', result)
|
|
|
|
def delete_qos_policy(self, policy_id):
|
|
result = self.qos_policy_client.delete_policy(policy_id)
|
|
return result.get('policy', result)
|
|
|
|
def list_qos_policies(self, **filters):
|
|
result = self.qos_policy_client.list_policies(**filters)
|
|
return result.get('policies', result)
|
|
|
|
def update_qos_policy(self, policy_id, **kwargs):
|
|
result = self.qos_policy_client.update_policy(policy_id, **kwargs)
|
|
return result.get('policy', result)
|
|
|
|
def show_qos_policy(self, policy_id, **fields):
|
|
result = self.qos_policy_client.show_policy(policy_id, **fields)
|
|
return result.get('policy', result)
|
|
|
|
#
|
|
# QoS bandwidth_limit
|
|
#
|
|
def create_bandwidth_limit_rule(self, policy_id,
|
|
max_kbps, max_burst_kbps,
|
|
**kwargs):
|
|
result = self.qos_bw_client.create_bandwidth_limit_rule(
|
|
policy_id,
|
|
max_kbps=max_kbps, max_burst_kbps=max_burst_kbps,
|
|
**kwargs)
|
|
self.addCleanup(test_utils.call_and_ignore_notfound_exc,
|
|
self.qos_bw_client.delete_bandwidth_limit_rule,
|
|
result['bandwidth_limit_rule']['id'], policy_id)
|
|
return result.get('bandwidth_limit_rule', result)
|
|
|
|
def delete_bandwidth_limit_rule(self, rule_id, policy_id):
|
|
result = self.qos_bw_client.delete_bandwidth_limit_rule(
|
|
rule_id, policy_id)
|
|
return result.get('bandwidth_limit_rule', result)
|
|
|
|
def update_bandwidth_limit_rule(self, rule_id, policy_id_or_name,
|
|
**kwargs):
|
|
policy_id = self.get_qos_policy_id(policy_id_or_name)
|
|
result = self.qos_bw_client.update_bandwidth_limit_rule(
|
|
rule_id, policy_id, **kwargs)
|
|
return result.get('bandwidth_limit_rule', result)
|
|
|
|
def list_bandwidth_limit_rules(self, policy_id, **filters):
|
|
result = self.qos_bw_client.list_bandwidth_limit_rules(
|
|
policy_id, **filters)
|
|
return result.get('bandwidth_limit_rules', result)
|
|
|
|
def show_bandwidth_limit_rule(self, rule_id, policy_id,
|
|
**fields):
|
|
result = self.qos_bw_client.show_bandwidth_limit_rule(
|
|
rule_id, policy_id)
|
|
return result.get('bandwidth_limit_rule', result)
|
|
|
|
#
|
|
# QoS DSCP Marking Rule
|
|
#
|
|
def create_dscp_marking_rule(self, policy_id, dscp_mark,
|
|
**kwargs):
|
|
policy_id = self.get_qos_policy_id(policy_id)
|
|
kwargs['dscp_mark'] = dscp_mark
|
|
result = self.qos_dscp_client.create_dscp_marking_rule(
|
|
policy_id, **kwargs)
|
|
self.addCleanup(test_utils.call_and_ignore_notfound_exc,
|
|
self.qos_dscp_client.delete_dscp_marking_rule,
|
|
result['dscp_marking_rule']['id'], policy_id)
|
|
return result.get('dscp_marking_rule', result)
|
|
|
|
def delete_dscp_marking_rule(self, rule_id, policy_id_or_name):
|
|
policy_id = self.get_qos_policy_id(policy_id_or_name)
|
|
result = self.qos_dscp_client.delete_dscp_marking_rule(rule_id,
|
|
policy_id)
|
|
return result.get('dscp_marking_rule', result)
|
|
|
|
def update_dscp_marking_rule(self, rule_id, policy_id_or_name,
|
|
**kwargs):
|
|
policy_id = self.get_qos_policy_id(policy_id_or_name)
|
|
result = self.qos_dscp_client.update_dscp_marking_rule(
|
|
rule_id, policy_id, **kwargs)
|
|
return result.get('dscp_marking_rule', result)
|
|
|
|
def list_dscp_marking_rules(self, policy_id_or_name, **filters):
|
|
policy_id = self.get_qos_policy_id(policy_id_or_name)
|
|
result = self.qos_dscp_client.list_dscp_marking_rules(
|
|
policy_id, **filters)
|
|
return result.get('dscp_marking_rules', result)
|
|
|
|
def show_dscp_marking_rule(self, rule_id, policy_id_or_name, **fields):
|
|
policy_id = self.get_qos_policy_id(policy_id_or_name)
|
|
result = self.qos_dscp_client.show_dscp_marking_rule(
|
|
rule_id, policy_id, **fields)
|
|
return result.get('dscp_marking_rule', result)
|
|
|
|
def list_rule_types(self):
|
|
result = self.types_client.list_rule_types()
|
|
return result.get('rule_types', result)
|
|
|
|
#
|
|
# Designate Zone
|
|
#
|
|
def rand_zone_name(name='', prefix=None, suffix='.com.'):
|
|
"""Generate a random zone name
|
|
:param str name: The name that you want to include
|
|
:param prefix: the exact text to start the string. Defaults to "rand"
|
|
:param suffix: the exact text to end the string
|
|
:return: a random zone name e.g. example.org.
|
|
:rtype: string
|
|
"""
|
|
name = 'tempest'
|
|
name = data_utils.rand_name(name=name, prefix=prefix)
|
|
zone_name = name + suffix
|
|
return zone_name
|
|
|
|
def rand_email(self, zone_name):
|
|
"""Generate a random zone name
|
|
:return: a random zone name e.g. example.org.
|
|
:rtype: string
|
|
"""
|
|
email_id = 'example@%s' % str(zone_name).rstrip('.')
|
|
return email_id
|
|
|
|
def create_zone(self, name=None, email=None, description=None,
|
|
wait_until=False, tenant_id=None):
|
|
"""Create a zone with the specified parameters.
|
|
:param name: The name of the zone.
|
|
Default: Random Value
|
|
:param email: The email for the zone.
|
|
Default: Random Value
|
|
:param description: A description of the zone.
|
|
Default: Random Value
|
|
:param wait_until: Block until the zone reaches the desired status
|
|
:return: A tuple with the server response and the created zone.
|
|
"""
|
|
if name is None:
|
|
name = self.rand_zone_name()
|
|
zone = {
|
|
'name': name,
|
|
'email': email or self.rand_email(name),
|
|
'description': description or data_utils.rand_name('test-zone'),
|
|
}
|
|
_, body = self.zones_v2_client.create_zone(wait_until, **zone)
|
|
self.addCleanup(test_utils.call_and_ignore_notfound_exc,
|
|
self.delete_zone, body['id'])
|
|
return body
|
|
|
|
def delete_zone(self, uuid):
|
|
"""Deletes a zone having the specified UUID.
|
|
:param uuid: The unique identifier of the zone.
|
|
:return: A tuple with the server response and the response body.
|
|
"""
|
|
_, body = self.zones_v2_client.delete_zone(uuid)
|
|
return body
|
|
|
|
def show_zone(self, uuid):
|
|
"""Gets a specific zone.
|
|
:param uuid: Unique identifier of the zone in UUID format.
|
|
:return: Serialized zone as a dictionary.
|
|
"""
|
|
return self.zones_v2_client.show_zone(uuid)
|
|
|
|
def list_zones(self):
|
|
"""Gets a list of zones.
|
|
:return: Serialized zones as a list.
|
|
"""
|
|
return self.zones_v2_client.list_zones()
|
|
|
|
def list_record_set_zone(self, uuid, user=None):
|
|
"""list recordsets of a zone.
|
|
:param uuid: The unique identifier of the zone.
|
|
"""
|
|
body = self.zones_v2_client.list_recordset_zone(uuid)
|
|
self.assertGreater(len(body), 0)
|
|
return body
|
|
|
|
def set_ptr_record(self, region, fip_id, ptrd_name):
|
|
"""list ptr recordsets associated with floating ip.
|
|
:param fip_id: Unique FloatingIP ID.
|
|
"""
|
|
ptr_id = region + ":" + fip_id
|
|
ptrd = {
|
|
"ptrdname": ptrd_name,
|
|
"description": "This is a floating ip PTR Domain Name",
|
|
"ttl": 600
|
|
}
|
|
_, body = self.ptr_client.set_fip_ptr_record(ptr_id, **ptrd)
|
|
return body
|
|
|
|
def show_ptr_record(self, region, fip_id, user=None):
|
|
"""list ptr recordsets associated with floating ip.
|
|
:param fip_id: Unique FloatingIP ID.
|
|
"""
|
|
ptr_id = region + ":" + fip_id
|
|
body = self.ptr_client.show_ptr_record(ptr_id)
|
|
return body
|
|
|
|
def _get_uuid(self, href):
|
|
return href.split('/')[-1]
|
|
|
|
def create_barbican_secret(self, **kwargs):
|
|
"""
|
|
Create barbican secret
|
|
"""
|
|
result = self.secret_client.create_secret(**kwargs)
|
|
uuid = self._get_uuid(result['secret_ref'])
|
|
self.addCleanup(test_utils.call_and_ignore_notfound_exc,
|
|
self.secret_client.delete_secret, uuid)
|
|
self.secret_client.add_acl_user_secret(
|
|
secret_id=uuid, user_id=CONF.barbican.barbican_user_id)
|
|
return result
|
|
|
|
def create_barbican_container(self, **kwargs):
|
|
"""
|
|
Create barbican secret container
|
|
"""
|
|
result = self.container_client.create_container(**kwargs)
|
|
uuid = self._get_uuid(result['container_ref'])
|
|
self.addCleanup(test_utils.call_and_ignore_notfound_exc,
|
|
self.container_client.delete_container, uuid)
|
|
self.container_client.add_acl_user_containers(
|
|
secret_id=uuid, user_id=CONF.barbican.barbican_user_id)
|
|
return result
|
|
|
|
def create_barbican_secret_conatainer(self, cert_file, key_file):
|
|
"""
|
|
Create barbican secrets with provided
|
|
cert file and key file.
|
|
Create barbican secret container with
|
|
created secrets and return secrets and container
|
|
"""
|
|
cert_file = open(cert_file, "r")
|
|
cert_content = cert_file.read()
|
|
secret_name1 = data_utils.rand_name(name='tempest-cert-secret')
|
|
kwargs = {"secret_type": 'passphrase',
|
|
"algorithm": constants.ALGORITHM,
|
|
"payload_content_type": constants.PAYLOAD_CONTENT_TYPE,
|
|
"mode": constants.MODE,
|
|
"bit_length": constants.BIT_LENGTH,
|
|
"payload": cert_content,
|
|
"name": secret_name1}
|
|
barbican_secret1 = self.create_barbican_secret(**kwargs)
|
|
cert_file = open(key_file, "r")
|
|
cert_content = cert_file.read()
|
|
secret_name2 = data_utils.rand_name(name='tempest-key-secret')
|
|
kwargs = {"secret_type": 'passphrase',
|
|
"algorithm": constants.ALGORITHM,
|
|
"payload_content_type": constants.PAYLOAD_CONTENT_TYPE,
|
|
"mode": constants.MODE,
|
|
"bit_length": constants.BIT_LENGTH,
|
|
"payload": cert_content,
|
|
"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)
|
|
secret_container_dict = dict(secret_1=barbican_secret1,
|
|
secret_2=barbican_secret2,
|
|
secret_container=barbican_container)
|
|
return secret_container_dict
|
|
|
|
def check_certificate_at_backend(self, should_present=True,
|
|
cert_conent=None):
|
|
"""
|
|
Check barbican certificate at backend
|
|
"""
|
|
# check certificate at backend
|
|
time.sleep(constants.NSX_BACKEND_VERY_SMALL_TIME_INTERVAL)
|
|
# nsx api call to get certificates from backend
|
|
certs = self.nsx.get_certificates()
|
|
Present = "False"
|
|
for cert in certs:
|
|
if cert['pem_encoded'] == cert_conent:
|
|
Present = "True"
|
|
if should_present:
|
|
self.assertIn(Present, "True")
|
|
else:
|
|
self.assertIn(Present, "False")
|
|
|
|
def delete_octavia_lb_resources(self, lb_id):
|
|
"""Deletion of lbaas resources.
|
|
|
|
:param lb_id: Load Balancer ID.
|
|
|
|
"""
|
|
oc_client = self.octavia_admin_client
|
|
statuses = oc_client.show_octavia_lb_status_tree(lb_id)
|
|
statuses = statuses.get('statuses', statuses)
|
|
lb = statuses.get('loadbalancer')
|
|
for listener in lb.get('listeners'):
|
|
for pool in listener.get('pools'):
|
|
self.delete_octavia_lb_pool_resources(lb_id, pool)
|
|
test_utils.call_and_ignore_notfound_exc(
|
|
self.octavia_admin_listener_client.delete_octavia_listener,
|
|
listener.get('id'))
|
|
self.wait_for_octavia_loadbalancer_status(lb_id)
|
|
# delete pools not attached to listener, but loadbalancer
|
|
tbdel = self.octavia_admin_pools_client.\
|
|
list_octavia_pools()['pools']
|
|
lb_pools = [pool for pool in tbdel
|
|
if pool['loadbalancers'][0]['id'] == lb_id]
|
|
for i in lb_pools:
|
|
pool_id = i['id']
|
|
self.octavia_admin_pools_client.delete_octavia_pool(pool_id)
|
|
self.wait_for_octavia_loadbalancer_status(lb_id)
|
|
test_utils.call_and_ignore_notfound_exc(
|
|
oc_client.delete_octavia_load_balancer, lb_id)
|
|
self.octavia_admin_client.\
|
|
wait_for_load_balancer_status(lb_id,
|
|
is_delete_op=True)
|
|
|
|
def delete_octavia_lb_pool_resources(self, lb_id, pool):
|
|
"""Deletion of lbaas pool resources.
|
|
|
|
:param lb_id: Load Balancer ID.
|
|
:param pool: pool information.
|
|
|
|
"""
|
|
pool_id = pool.get('id')
|
|
self.wait_for_octavia_loadbalancer_status(lb_id)
|
|
test_utils.call_and_ignore_notfound_exc(
|
|
self.octavia_admin_pools_client.delete_octavia_pool,
|
|
pool_id)
|
|
self.wait_for_octavia_loadbalancer_status(lb_id)
|
|
|
|
def wait_for_octavia_loadbalancer_status(self, lb_id):
|
|
self.octavia_admin_client.wait_for_load_balancer_status(lb_id)
|
|
|
|
def create_project_octavia(self, protocol_type,
|
|
protocol_port, lb_algorithm,
|
|
hm_type=None, member_count=2,
|
|
max_vms=None, weight=None,
|
|
fip_disassociate=None,
|
|
pool_protocol=None, pool_port=None,
|
|
vip_subnet_id=None,
|
|
lb_id=None, count=None,
|
|
clean_up=None, vip_net_id=None,
|
|
delay=None, max_retries=None,
|
|
timeout=None, default_pool=False,
|
|
vip_port_id=None, persistence=False,
|
|
persistence_type=None,
|
|
session_persistence=None,
|
|
persistence_cookie_name=None,
|
|
allowed_cidrs=None, l7policy=False, action=None,
|
|
redirect_url=None, l7rule=False,
|
|
compare_type=None,
|
|
type=None, value=None, barbican=False,
|
|
barbican_container=None, invert=None,
|
|
qos_policy_id=None, external=None,
|
|
external_subnet=None, create_fip=None):
|
|
count = 0
|
|
lb_name = None
|
|
if persistence:
|
|
session_persistence = {}
|
|
if persistence_type:
|
|
session_persistence["type"] = persistence_type
|
|
if persistence_cookie_name:
|
|
session_persistence["cookie_name"] = persistence_cookie_name
|
|
|
|
if lb_id is None:
|
|
lb_name = data_utils.rand_name(self.namestart)
|
|
if external:
|
|
self.loadbalancer = self.\
|
|
octavia_admin_client.\
|
|
create_octavia_load_balancer(
|
|
name=lb_name,
|
|
vip_subnet_id=external_subnet)['loadbalancer']
|
|
else:
|
|
self.loadbalancer = self.\
|
|
octavia_admin_client.\
|
|
create_octavia_load_balancer(
|
|
name=lb_name,
|
|
vip_subnet_id=vip_subnet_id,
|
|
vip_network_id=vip_net_id,
|
|
vip_port_id=vip_port_id,
|
|
vip_qos_policy_id=qos_policy_id,
|
|
admin_state_up=True)['loadbalancer']
|
|
lb_id = self.loadbalancer['id']
|
|
self.octavia_admin_client.wait_for_load_balancer_status(lb_id)
|
|
if barbican:
|
|
tls_id = barbican_container["container_ref"]
|
|
else:
|
|
tls_id = None
|
|
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=allowed_cidrs,
|
|
default_tls_container_ref=tls_id
|
|
)['listener']
|
|
self.octavia_admin_client.wait_for_load_balancer_status(lb_id)
|
|
if l7policy and action != 'REDIRECT_TO_POOL':
|
|
l7p = self.octavia_admin_l7policies_client.\
|
|
create_octavia_l7policies(listener_id=self.listener['id'],
|
|
name='l7p', action=action,
|
|
redirect_url=redirect_url)
|
|
self.octavia_admin_client.wait_for_load_balancer_status(lb_id)
|
|
if l7rule:
|
|
l7p_id = l7p['l7policy']['id']
|
|
self.octavia_admin_l7rules_client.create_octavia_l7rules(
|
|
l7policy_id=l7p_id, compare_type=compare_type, value=value,
|
|
type=type, invert=invert)
|
|
self.octavia_admin_client.wait_for_load_balancer_status(lb_id)
|
|
if default_pool:
|
|
self.pool = self.octavia_admin_pools_client.\
|
|
create_octavia_pool(loadbalancer_id=lb_id,
|
|
lb_algorithm=lb_algorithm,
|
|
protocol=protocol_type,
|
|
name=lb_name)
|
|
pool_id = self.pool['pool']['id']
|
|
self.octavia_admin_client.wait_for_load_balancer_status(lb_id)
|
|
self.octavia_admin_listener_client.\
|
|
update_octavia_listener(default_pool_id=pool_id,
|
|
listener_id=self.listener['id'])
|
|
self.octavia_admin_client.wait_for_load_balancer_status(lb_id)
|
|
else:
|
|
if barbican:
|
|
protocol_type = pool_protocol
|
|
self.pool = self.octavia_admin_pools_client.\
|
|
create_octavia_pool(listener_id=self.listener['id'],
|
|
lb_algorithm=lb_algorithm,
|
|
protocol=protocol_type,
|
|
name=lb_name,
|
|
session_persistence=session_persistence)
|
|
self.octavia_admin_client.wait_for_load_balancer_status(lb_id)
|
|
pool_id = self.pool['pool']['id']
|
|
if hm_type:
|
|
self.healthmonitor = self.octavia_hm_client.\
|
|
create_octavia_hm(pool_id=pool_id, type=hm_type, delay=delay,
|
|
timeout=timeout, max_retries=max_retries,
|
|
name=lb_name)
|
|
self.octavia_admin_client.wait_for_load_balancer_status(lb_id)
|
|
self.members = []
|
|
for server_name in self.topology_servers.keys():
|
|
if count < member_count:
|
|
if create_fip:
|
|
fip_data = self.servers_details[server_name].\
|
|
floating_ips[0]
|
|
if fip_disassociate is True:
|
|
x = str(
|
|
self.topology_servers[server_name]['addresses'].
|
|
keys()).split("'")[1]
|
|
m = self.topology_servers[server_name]
|
|
fixed_ip_address = m['addresses'][x][0]['addr']
|
|
else:
|
|
fixed_ip_address = fip_data['fixed_ip_address']
|
|
if fip_disassociate is None:
|
|
kwargs = dict(port_id=None)
|
|
self.cmgr_adm.floating_ips_client.\
|
|
update_floatingip(fip_data['id'],
|
|
**kwargs)['floatingip']
|
|
else:
|
|
net_name = self.servers_details[server_name][2][0]['name']
|
|
fixed_ip_address = self.servers_details[
|
|
server_name][0]['addresses'][net_name][0]['addr']
|
|
if weight:
|
|
weight += count
|
|
if barbican:
|
|
member = self.octavia_admin_members_client.\
|
|
create_octavia_member(pool_id,
|
|
subnet_id=vip_subnet_id,
|
|
address=fixed_ip_address,
|
|
protocol_port=pool_port,
|
|
weight=weight)
|
|
else:
|
|
member = self.octavia_admin_members_client.\
|
|
create_octavia_member(pool_id,
|
|
subnet_id=vip_subnet_id,
|
|
address=fixed_ip_address,
|
|
protocol_port=protocol_port,
|
|
weight=weight)
|
|
else:
|
|
member = self.octavia_admin_members_client.\
|
|
create_octavia_member(pool_id, subnet_id=vip_subnet_id,
|
|
address=fixed_ip_address,
|
|
protocol_port=protocol_port)
|
|
self.octavia_admin_client.wait_for_load_balancer_status(lb_id)
|
|
self.members.append(member)
|
|
self.server_names.append(server_name)
|
|
count += 1
|
|
else:
|
|
break
|
|
self.cmgr_adm.ports_client.\
|
|
update_port(self.loadbalancer['vip_port_id'],
|
|
security_groups=[self.sg['id']])
|
|
# create floatingip for public network
|
|
if create_fip is False:
|
|
self.vip_ip_address = self.loadbalancer['vip_port_id']
|
|
vip_fip = self.vip_ip_address
|
|
else:
|
|
self.cmgr_adm.ports_client.update_port(
|
|
self.loadbalancer['vip_port_id'],
|
|
security_groups=[
|
|
self.sg['id']])
|
|
if not external:
|
|
vip_fip = self.create_floatingip(
|
|
self.loadbalancer,
|
|
client=self.cmgr_adm.floating_ips_client,
|
|
port_id=self.loadbalancer['vip_port_id'])
|
|
self.vip_ip_address = vip_fip['floating_ip_address']
|
|
return dict(lb_id=lb_id,
|
|
vip_address=self.vip_ip_address,
|
|
pool_id=pool_id,
|
|
members=self.members,
|
|
listener_id=self.listener['id'],
|
|
vip_fip=vip_fip,
|
|
lb_vip=self.loadbalancer['vip_port_id'],
|
|
loadbalancer=self.loadbalancer)
|
|
|
|
def check_router_components_on_edge(self, router):
|
|
edge_ips = CONF.nsx_edge.nsx_edge_ip
|
|
nsx_dr_rtr_name = "DR-" + router['name']
|
|
dr_present = False
|
|
nsx_sr_rtr_name = "SR-" + router['name']
|
|
sr_present = False
|
|
for nsx_edge_ip in edge_ips:
|
|
ssh_client = remote_client.RemoteClient(
|
|
nsx_edge_ip, 'root', 'Admin!23Admin')
|
|
command = "nsxcli -c get logical-router | awk {'print $4'}"
|
|
data = ssh_client.exec_command(command)
|
|
result = data.split('\n')
|
|
present = False
|
|
present = [True for el in result if nsx_sr_rtr_name in el]
|
|
if present:
|
|
sr_present = True
|
|
present = False
|
|
present = [True for el in result if nsx_dr_rtr_name in el]
|
|
if present:
|
|
dr_present = True
|
|
return[{'dr_present': dr_present}, {'sr_present': sr_present}]
|
|
|
|
def create_project_octavia_scale(self, protocol_type,
|
|
protocol_port, lb_algorithm,
|
|
hm_type=None, member_count=2,
|
|
max_vms=None, weight=None,
|
|
fip_disassociate=None,
|
|
pool_protocol=None, pool_port=None,
|
|
vip_subnet_id=None,
|
|
lb_id=None, count=None,
|
|
clean_up=None, vip_net_id=None,
|
|
delay=None, max_retries=None,
|
|
timeout=None, default_pool=False,
|
|
vip_port_id=None, scale=None,
|
|
listener_count=None, pool_count=None,
|
|
lb_pool=False, allowed_cidrs=None):
|
|
count = 0
|
|
lb_name = None
|
|
lb_name = data_utils.rand_name(self.namestart)
|
|
if not listener_count:
|
|
listener_count = 1
|
|
if not pool_count:
|
|
pool_count = 1
|
|
self.pools = []
|
|
for i in range(scale):
|
|
self.loadbalancer = self.\
|
|
octavia_admin_client.\
|
|
create_octavia_load_balancer(name=lb_name,
|
|
vip_subnet_id=vip_subnet_id,
|
|
vip_network_id=vip_net_id,
|
|
)['loadbalancer']
|
|
lb_id = self.loadbalancer['id']
|
|
self.octavia_admin_client.wait_for_load_balancer_status(lb_id)
|
|
for lc in range(listener_count):
|
|
protocol_port = str(int(protocol_port) + 1)
|
|
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=allowed_cidrs
|
|
)['listener']
|
|
self.octavia_admin_client.wait_for_load_balancer_status(lb_id)
|
|
l_id = self.listener['id']
|
|
for x in range(pool_count):
|
|
if not lb_pool:
|
|
self.pool = self.octavia_admin_pools_client.\
|
|
create_octavia_pool(listener_id=l_id,
|
|
lb_algorithm=lb_algorithm,
|
|
protocol=protocol_type,
|
|
name=lb_name)
|
|
else:
|
|
self.pool = self.octavia_admin_pools_client.\
|
|
create_octavia_pool(loadbalancer_id=lb_id,
|
|
lb_algorithm=lb_algorithm,
|
|
protocol=protocol_type,
|
|
name=lb_name)
|
|
self.octavia_admin_client.\
|
|
wait_for_load_balancer_status(lb_id)
|
|
pool_id = self.pool['pool']['id']
|
|
self.octavia_admin_listener_client.\
|
|
update_octavia_listener(listener_id=l_id,
|
|
default_pool_id=pool_id)
|
|
self.octavia_admin_client.\
|
|
wait_for_load_balancer_status(lb_id)
|
|
if hm_type:
|
|
self.healthmonitor = self.octavia_hm_client.\
|
|
create_octavia_hm(pool_id=pool_id,
|
|
type=hm_type, delay=2,
|
|
timeout=2, max_retries=2,
|
|
name=lb_name)
|
|
self.octavia_admin_client.\
|
|
wait_for_load_balancer_status(lb_id)
|
|
self.members = []
|
|
count = 0
|
|
for server_name in self.topology_servers.keys():
|
|
if count < member_count:
|
|
fip_data = self.servers_details[server_name].\
|
|
floating_ips[0]
|
|
fixed_ip_address = fip_data['fixed_ip_address']
|
|
if fip_disassociate is None:
|
|
kwargs = dict(port_id=None)
|
|
self.cmgr_adm.floating_ips_client.\
|
|
update_floatingip(fip_data['id'],
|
|
**kwargs)['floatingip']
|
|
|
|
if weight:
|
|
weight += count
|
|
member = self.octavia_admin_members_client.\
|
|
create_octavia_member(
|
|
pool_id, subnet_id=vip_subnet_id,
|
|
address=fixed_ip_address,
|
|
protocol_port=protocol_port,
|
|
weight=weight)
|
|
else:
|
|
member = self.octavia_admin_members_client.\
|
|
create_octavia_member(
|
|
pool_id, subnet_id=vip_subnet_id,
|
|
address=fixed_ip_address,
|
|
protocol_port=protocol_port)
|
|
self.octavia_admin_client.\
|
|
wait_for_load_balancer_status(lb_id)
|
|
self.members.append(member)
|
|
self.server_names.append(server_name)
|
|
count += 1
|
|
else:
|
|
break
|
|
self.cmgr_adm.ports_client.\
|
|
update_port(self.loadbalancer['vip_port_id'],
|
|
security_groups=[self.sg['id']])
|
|
# create floatingip for public network
|
|
self.cmgr_adm.ports_client.update_port(
|
|
self.loadbalancer['vip_port_id'],
|
|
security_groups=[
|
|
self.sg['id']])
|
|
vip_fip = self.create_floatingip(
|
|
self.loadbalancer,
|
|
client=self.cmgr_adm.floating_ips_client,
|
|
port_id=self.loadbalancer['vip_port_id'])
|
|
self.vip_ip_address = vip_fip['floating_ip_address']
|
|
return 1
|