| 1 |
# Copyright 2015 Hewlett-Packard Development Company, L.P. |
| 2 |
# |
| 3 |
# Licensed under the Apache License, Version 2.0 (the "License"); you may |
| 4 |
# not use this file except in compliance with the License. You may obtain |
| 5 |
# a copy of the License at |
| 6 |
# |
| 7 |
# http://www.apache.org/licenses/LICENSE-2.0 |
| 8 |
# |
| 9 |
# Unless required by applicable law or agreed to in writing, software |
| 10 |
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT |
| 11 |
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the |
| 12 |
# License for the specific language governing permissions and limitations |
| 13 |
# under the License. |
| 14 |
|
| 15 |
import concurrent.futures |
| 16 |
import re |
| 17 |
import threading |
| 18 |
import time |
| 19 |
|
| 20 |
from oslo_utils import uuidutils |
| 21 |
from rally.common import logging |
| 22 |
from rally.plugins.openstack import scenario as rally_base |
| 23 |
from rally.task import atomic |
| 24 |
|
| 25 |
import vpn_utils |
| 26 |
|
| 27 |
LOG = logging.getLogger(__name__) |
| 28 |
LOCK = threading.RLock() |
| 29 |
MAX_RESOURCES = 2 |
| 30 |
|
| 31 |
|
| 32 |
class VpnBase(rally_base.OpenStackScenario): |
| 33 |
|
| 34 |
def setup(self, **kwargs): |
| 35 |
"""Create and initialize data structures to hold various resources""" |
| 36 |
|
| 37 |
with LOCK: |
| 38 |
LOG.debug('SETUP RESOURCES') |
| 39 |
self.neutron_admin_client = self.admin_clients("neutron") |
| 40 |
if kwargs['use_admin_client']: |
| 41 |
self.neutron_client = self.neutron_admin_client |
| 42 |
self.keystone_client = self.admin_clients("keystone") |
| 43 |
self.nova_client = self.admin_clients("nova") |
| 44 |
else: |
| 45 |
self.neutron_client = self.clients("neutron") |
| 46 |
self.nova_client = self.clients("nova") |
| 47 |
self.suffixes = [uuidutils.generate_uuid(), |
| 48 |
uuidutils.generate_uuid()] |
| 49 |
self.remote_key_files = ['rally_keypair_' + x |
| 50 |
for x in self.suffixes] |
| 51 |
self.local_key_files = ['/tmp/' + x for x in self.remote_key_files] |
| 52 |
self.private_key_file = kwargs["private_key"] |
| 53 |
self.keypairs = [] |
| 54 |
self.tenant_ids = [] |
| 55 |
self.ns_controller_tuples = [] |
| 56 |
self.qrouterns_compute_tuples = [] |
| 57 |
self.router_ids = [] |
| 58 |
self.rally_router_gw_ips = [] |
| 59 |
self.rally_routers = [] |
| 60 |
self.rally_networks = [] |
| 61 |
self.rally_subnets = [] |
| 62 |
self.rally_cidrs = [] |
| 63 |
self.ike_policy = None |
| 64 |
self.ipsec_policy = None |
| 65 |
self.vpn_services = [] |
| 66 |
self.ipsec_site_connections = [] |
| 67 |
self.servers = [] |
| 68 |
self.server_private_ips = [] |
| 69 |
self.server_fips = [] |
| 70 |
|
| 71 |
def create_tenants(self): |
| 72 |
"""Create tenants""" |
| 73 |
|
| 74 |
for x in range(MAX_RESOURCES): |
| 75 |
tenant_id = vpn_utils.create_tenant( |
| 76 |
self.keystone_client, self.suffixes[x]) |
| 77 |
with LOCK: |
| 78 |
self.tenant_ids.append(tenant_id) |
| 79 |
|
| 80 |
def create_networks(self, **kwargs): |
| 81 |
"""Create networks to test vpn connectivity""" |
| 82 |
|
| 83 |
for x in range(MAX_RESOURCES): |
| 84 |
if self.tenant_ids: |
| 85 |
router, network, subnet, cidr = vpn_utils.create_network( |
| 86 |
self.neutron_client, self.neutron_admin_client, |
| 87 |
self.suffixes[x], tenant_id=self.tenant_ids[x], |
| 88 |
DVR_flag=kwargs["DVR_flag"], |
| 89 |
ext_net_name=kwargs["ext-net"]) |
| 90 |
else: |
| 91 |
router, network, subnet, cidr = vpn_utils.create_network( |
| 92 |
self.neutron_client, self.neutron_admin_client, |
| 93 |
self.suffixes[x], DVR_flag=kwargs["DVR_flag"], |
| 94 |
ext_net_name=kwargs["ext-net"]) |
| 95 |
with LOCK: |
| 96 |
self.rally_cidrs.append(cidr) |
| 97 |
self.rally_subnets.append(subnet) |
| 98 |
self.rally_networks.append(network) |
| 99 |
self.rally_routers.append(router) |
| 100 |
self.router_ids.append(router["router"]['id']) |
| 101 |
self.rally_router_gw_ips.append( |
| 102 |
router["router"]["external_gateway_info"] |
| 103 |
["external_fixed_ips"][0]["ip_address"]) |
| 104 |
|
| 105 |
if kwargs["DVR_flag"]: |
| 106 |
ns, controller = vpn_utils.wait_for_namespace_creation( |
| 107 |
"snat-", router["router"]['id'], |
| 108 |
kwargs['controller_creds'], |
| 109 |
self.private_key_file, |
| 110 |
kwargs['namespace_creation_timeout']) |
| 111 |
else: |
| 112 |
ns, controller = vpn_utils.wait_for_namespace_creation( |
| 113 |
"qrouter-", router["router"]['id'], |
| 114 |
kwargs['controller_creds'], |
| 115 |
self.private_key_file, |
| 116 |
kwargs['namespace_creation_timeout']) |
| 117 |
with LOCK: |
| 118 |
self.ns_controller_tuples.append((ns, controller)) |
| 119 |
|
| 120 |
def create_servers(self, **kwargs): |
| 121 |
"""Create servers""" |
| 122 |
|
| 123 |
for x in range(MAX_RESOURCES): |
| 124 |
kwargs.update({ |
| 125 |
"nics": |
| 126 |
[{"net-id": self.rally_networks[x]["network"]["id"]}], |
| 127 |
"sec_group_suffix": self.suffixes[x], |
| 128 |
"server_suffix": self.suffixes[x] |
| 129 |
}) |
| 130 |
keypair = vpn_utils.create_keypair( |
| 131 |
self.nova_client, self.suffixes[x]) |
| 132 |
server = vpn_utils.create_server( |
| 133 |
self.nova_client, keypair, **kwargs) |
| 134 |
vpn_utils.assert_server_status(server, **kwargs) |
| 135 |
with LOCK: |
| 136 |
self.servers.append(server) |
| 137 |
self.keypairs.append(keypair) |
| 138 |
self.server_private_ips.append(vpn_utils.get_server_ip( |
| 139 |
self.nova_client, server.id, self.suffixes[x])) |
| 140 |
if kwargs["DVR_flag"]: |
| 141 |
qrouter, compute = vpn_utils.wait_for_namespace_creation( |
| 142 |
"qrouter-", self.router_ids[x], |
| 143 |
kwargs['compute_creds'], |
| 144 |
self.private_key_file, |
| 145 |
kwargs['namespace_creation_timeout']) |
| 146 |
|
| 147 |
vpn_utils.write_key_to_compute_node( |
| 148 |
keypair, self.local_key_files[x], |
| 149 |
self.remote_key_files[x], compute, |
| 150 |
self.private_key_file) |
| 151 |
with LOCK: |
| 152 |
self.qrouterns_compute_tuples.append((qrouter, compute)) |
| 153 |
else: |
| 154 |
vpn_utils.write_key_to_local_path(self.keypairs[x], |
| 155 |
self.local_key_files[x]) |
| 156 |
fip = vpn_utils.add_floating_ip(self.nova_client, server) |
| 157 |
with LOCK: |
| 158 |
self.server_fips.append(fip) |
| 159 |
|
| 160 |
def check_route(self): |
| 161 |
"""Verify route exists between the router gateways""" |
| 162 |
|
| 163 |
LOG.debug("VERIFY ROUTE EXISTS BETWEEN THE ROUTER GATEWAYS") |
| 164 |
for tuple in self.ns_controller_tuples: |
| 165 |
for ip in self.rally_router_gw_ips: |
| 166 |
assert vpn_utils.ping_router_gateway( |
| 167 |
tuple, ip, self.private_key_file), ( |
| 168 |
"PING TO IP " + ip + " FAILED") |
| 169 |
|
| 170 |
@atomic.action_timer("_create_ike_policy") |
| 171 |
def _create_ike_policy(self, **kwargs): |
| 172 |
"""Create IKE policy |
| 173 |
|
| 174 |
:return: IKE policy |
| 175 |
""" |
| 176 |
LOG.debug('CREATING IKE_POLICY') |
| 177 |
ike_policy = self.neutron_client.create_ikepolicy({ |
| 178 |
"ikepolicy": { |
| 179 |
"phase1_negotiation_mode": |
| 180 |
kwargs.get("phase1_negotiation_mode", "main"), |
| 181 |
"auth_algorithm": kwargs.get("auth_algorithm", "sha1"), |
| 182 |
"encryption_algorithm": |
| 183 |
kwargs.get("encryption_algorithm", "aes-128"), |
| 184 |
"pfs": kwargs.get("pfs", "group5"), |
| 185 |
"lifetime": { |
| 186 |
"units": "seconds", |
| 187 |
"value": kwargs.get("value", 7200)}, |
| 188 |
"ike_version": kwargs.get("ike_version", "v1"), |
| 189 |
"name": "rally_ikepolicy" |
| 190 |
} |
| 191 |
}) |
| 192 |
return ike_policy |
| 193 |
|
| 194 |
@atomic.action_timer("_create_ipsec_policy") |
| 195 |
def _create_ipsec_policy(self, **kwargs): |
| 196 |
"""Create IPSEC policy |
| 197 |
|
| 198 |
:return: IPSEC policy |
| 199 |
""" |
| 200 |
LOG.debug('CREATING IPSEC_POLICY') |
| 201 |
ipsec_policy = self.neutron_client.create_ipsecpolicy({ |
| 202 |
"ipsecpolicy": { |
| 203 |
"name": "rally_ipsecpolicy", |
| 204 |
"transform_protocol": kwargs.get("transform_protocol", "esp"), |
| 205 |
"auth_algorithm": kwargs.get("auth_algorithm", "sha1"), |
| 206 |
"encapsulation_mode": |
| 207 |
kwargs.get("encapsulation_mode", "tunnel"), |
| 208 |
"encryption_algorithm": |
| 209 |
kwargs.get("encryption_algorithm", "aes-128"), |
| 210 |
"pfs": kwargs.get("pfs", "group5"), |
| 211 |
"lifetime": { |
| 212 |
"units": "seconds", |
| 213 |
"value": kwargs.get("value", 7200) |
| 214 |
} |
| 215 |
} |
| 216 |
}) |
| 217 |
return ipsec_policy |
| 218 |
|
| 219 |
@atomic.action_timer("_create_vpn_service") |
| 220 |
def _create_vpn_service(self, rally_subnet, rally_router, vpn_suffix=None): |
| 221 |
"""Create VPN service endpoints |
| 222 |
|
| 223 |
:param rally_subnet: local subnet |
| 224 |
:param rally_router: router endpoint |
| 225 |
:param vpn_suffix: suffix name for vpn service |
| 226 |
:return: VPN service |
| 227 |
""" |
| 228 |
LOG.debug('CREATING VPN_SERVICE') |
| 229 |
vpn_service = self.neutron_client.create_vpnservice({ |
| 230 |
"vpnservice": { |
| 231 |
"subnet_id": rally_subnet["subnet"]["id"], |
| 232 |
"router_id": rally_router["router"]["id"], |
| 233 |
"name": "rally_vpn_service_" + vpn_suffix, |
| 234 |
"admin_state_up": True |
| 235 |
} |
| 236 |
}) |
| 237 |
return vpn_service |
| 238 |
|
| 239 |
def create_vpn_services(self): |
| 240 |
"""Create VPN services""" |
| 241 |
|
| 242 |
for x in range(MAX_RESOURCES): |
| 243 |
vpn_service = self._create_vpn_service( |
| 244 |
self.rally_subnets[x], self.rally_routers[x], self.suffixes[x]) |
| 245 |
with LOCK: |
| 246 |
self.vpn_services.append(vpn_service) |
| 247 |
|
| 248 |
@atomic.action_timer("_create_ipsec_site_connection") |
| 249 |
def _create_ipsec_site_connection(self, local_index, peer_index, **kwargs): |
| 250 |
"""Create IPSEC site connection |
| 251 |
|
| 252 |
:param local_index: parameter to point to the local end-point |
| 253 |
:param peer_index: parameter to point to the peer end-point |
| 254 |
:return: IPSEC site connection |
| 255 |
""" |
| 256 |
LOG.debug('CREATING IPSEC_SITE_CONNECTION') |
| 257 |
ipsec_site_conn = self.neutron_client.create_ipsec_site_connection({ |
| 258 |
"ipsec_site_connection": { |
| 259 |
"psk": kwargs.get("secret", "secret"), |
| 260 |
"initiator": "bi-directional", |
| 261 |
"ipsecpolicy_id": self.ipsec_policy["ipsecpolicy"]["id"], |
| 262 |
"admin_state_up": True, |
| 263 |
"peer_cidrs": self.rally_cidrs[peer_index], |
| 264 |
"mtu": kwargs.get("mtu", "1500"), |
| 265 |
"ikepolicy_id": self.ike_policy["ikepolicy"]["id"], |
| 266 |
"dpd": { |
| 267 |
"action": "disabled", |
| 268 |
"interval": 60, |
| 269 |
"timeout": 240 |
| 270 |
}, |
| 271 |
"vpnservice_id": |
| 272 |
self.vpn_services[local_index]["vpnservice"]["id"], |
| 273 |
"peer_address": self.rally_router_gw_ips[peer_index], |
| 274 |
"peer_id": self.rally_router_gw_ips[peer_index], |
| 275 |
"name": "rally_ipsec_site_connection_" + |
| 276 |
self.suffixes[local_index] |
| 277 |
} |
| 278 |
}) |
| 279 |
return ipsec_site_conn |
| 280 |
|
| 281 |
def create_ipsec_site_connections(self, **kwargs): |
| 282 |
"""Create IPSEC site connections""" |
| 283 |
|
| 284 |
a = self._create_ipsec_site_connection(0, 1, **kwargs) |
| 285 |
b = self._create_ipsec_site_connection(1, 0, **kwargs) |
| 286 |
with LOCK: |
| 287 |
self.ipsec_site_connections = [a, b] |
| 288 |
|
| 289 |
def _get_resource(self, resource_tag, resource_id): |
| 290 |
"""Get the resource(vpn_service or ipsec_site_connection) |
| 291 |
|
| 292 |
:param resource_tag: "vpnservice" or "ipsec_site_connection" |
| 293 |
:param resource_id: id of the resource |
| 294 |
:return: resource (vpn_service or ipsec_site_connection) |
| 295 |
""" |
| 296 |
if resource_tag == "vpnservice": |
| 297 |
vpn_service = self.neutron_client.show_vpnservice(resource_id) |
| 298 |
if vpn_service: |
| 299 |
return vpn_service |
| 300 |
elif resource_tag == 'ipsec_site_connection': |
| 301 |
ipsec_site_conn = self.neutron_client.show_ipsec_site_connection( |
| 302 |
resource_id) |
| 303 |
if ipsec_site_conn: |
| 304 |
return ipsec_site_conn |
| 305 |
|
| 306 |
def _wait_for_status_change(self, resource, resource_tag, final_status, |
| 307 |
wait_timeout=60, check_interval=1): |
| 308 |
"""Wait for resource's status change |
| 309 |
|
| 310 |
Wait till the status of the resource changes to final state or till |
| 311 |
the time exceeds the wait_timeout value. |
| 312 |
:param resource: resource whose status has to be checked |
| 313 |
:param final_status: desired final status of the resource |
| 314 |
:param resource_tag: to identify the resource as vpnservice or |
| 315 |
ipsec_site_connection |
| 316 |
:param wait_timeout: timeout value in seconds |
| 317 |
:param check_interval: time to sleep before each check for the status |
| 318 |
change |
| 319 |
:return: resource |
| 320 |
""" |
| 321 |
LOG.debug('WAIT_FOR_%s_STATUS_CHANGE ', resource[resource_tag]['id']) |
| 322 |
|
| 323 |
start_time = time.time() |
| 324 |
while True: |
| 325 |
resource = self._get_resource( |
| 326 |
resource_tag, resource[resource_tag]['id']) |
| 327 |
current_status = resource[resource_tag]['status'] |
| 328 |
if current_status == final_status: |
| 329 |
return resource |
| 330 |
time.sleep(check_interval) |
| 331 |
if time.time() - start_time > wait_timeout: |
| 332 |
raise Exception( |
| 333 |
"Timeout waiting for resource {} to change to {} status". |
| 334 |
format(resource[resource_tag]['name'], final_status)) |
| 335 |
|
| 336 |
@atomic.action_timer("wait_time_for_status_change") |
| 337 |
def _assert_statuses(self, ipsec_site_conn, vpn_service, |
| 338 |
final_status, **kwargs): |
| 339 |
"""Assert statuses of vpn_service and ipsec_site_connection |
| 340 |
|
| 341 |
:param ipsec_site_conn: ipsec_site_connection object |
| 342 |
:param vpn_service: vpn_service object |
| 343 |
:param final_status: status of vpn and ipsec_site_connection object |
| 344 |
""" |
| 345 |
|
| 346 |
vpn_service = self._wait_for_status_change( |
| 347 |
vpn_service, |
| 348 |
resource_tag="vpnservice", |
| 349 |
final_status=final_status, |
| 350 |
wait_timeout=kwargs.get("vpn_service_creation_timeout"), |
| 351 |
check_interval=5) |
| 352 |
|
| 353 |
ipsec_site_conn = self._wait_for_status_change( |
| 354 |
ipsec_site_conn, |
| 355 |
resource_tag="ipsec_site_connection", |
| 356 |
final_status=final_status, |
| 357 |
wait_timeout=kwargs.get("ipsec_site_connection_creation_timeout"), |
| 358 |
check_interval=5) |
| 359 |
|
| 360 |
LOG.debug("VPN SERVICE STATUS %s", vpn_service['vpnservice']['status']) |
| 361 |
LOG.debug("IPSEC_SITE_CONNECTION STATUS %s", |
| 362 |
ipsec_site_conn['ipsec_site_connection']['status']) |
| 363 |
|
| 364 |
def assert_statuses(self, final_status, **kwargs): |
| 365 |
"""Assert active statuses for VPN services and VPN connections |
| 366 |
|
| 367 |
:param final_status: the final status you expect the resource to be in |
| 368 |
""" |
| 369 |
|
| 370 |
LOG.debug("ASSERTING ACTIVE STATUSES FOR VPN-SERVICES AND " |
| 371 |
"IPSEC-SITE-CONNECTIONS") |
| 372 |
for x in range(MAX_RESOURCES): |
| 373 |
self._assert_statuses( |
| 374 |
self.ipsec_site_connections[x], self.vpn_services[x], |
| 375 |
final_status, **kwargs) |
| 376 |
|
| 377 |
def _get_qg_interface(self, peer_index): |
| 378 |
"""Get the qg- interface |
| 379 |
|
| 380 |
:param peer_index: parameter to point to the local end-point |
| 381 |
:return: qg-interface |
| 382 |
""" |
| 383 |
qg = vpn_utils.get_interfaces( |
| 384 |
self.ns_controller_tuples[peer_index], |
| 385 |
self.private_key_file) |
| 386 |
p = re.compile(r"qg-\w+-\w+") |
| 387 |
for line in qg: |
| 388 |
m = p.search(line) |
| 389 |
if m: |
| 390 |
return m.group() |
| 391 |
return None |
| 392 |
|
| 393 |
@atomic.action_timer("_verify_vpn_connection") |
| 394 |
def _verify_vpn_connectivity(self, local_index, peer_index, **kwargs): |
| 395 |
"""Verify the vpn connectivity between the endpoints |
| 396 |
|
| 397 |
Get the qg- interface from the snat namespace corresponding to the |
| 398 |
peer router and start a tcp dump. Concurrently, SSH into the nova |
| 399 |
instance on the local subnet from the qrouter namespace and try |
| 400 |
to ping the nova instance on the peer subnet. Inspect the captured |
| 401 |
packets to see if they are encrypted. |
| 402 |
:param local_index: parameter to point to the local end-point |
| 403 |
:param peer_index: parameter to point to the peer end-point |
| 404 |
:return: True if vpn connectivity test passes |
| 405 |
False if the test fails |
| 406 |
""" |
| 407 |
qg_interface = self._get_qg_interface(peer_index) |
| 408 |
if qg_interface: |
| 409 |
with concurrent.futures.ThreadPoolExecutor(max_workers=2) as e: |
| 410 |
tcpdump_future = e.submit(vpn_utils.start_tcpdump, |
| 411 |
self.ns_controller_tuples[peer_index], |
| 412 |
qg_interface, self.private_key_file) |
| 413 |
if kwargs["DVR_flag"]: |
| 414 |
ssh_future = e.submit( |
| 415 |
vpn_utils.ssh_and_ping_server, |
| 416 |
self.server_private_ips[local_index], |
| 417 |
self.server_private_ips[peer_index], |
| 418 |
self.qrouterns_compute_tuples[local_index], |
| 419 |
self.remote_key_files[local_index], |
| 420 |
self.private_key_file) |
| 421 |
else: |
| 422 |
ssh_future = e.submit( |
| 423 |
vpn_utils.ssh_and_ping_server_with_fip, |
| 424 |
self.server_fips[local_index], |
| 425 |
self.server_private_ips[peer_index], |
| 426 |
self.local_key_files[local_index], |
| 427 |
self.private_key_file) |
| 428 |
|
| 429 |
assert ssh_future.result(), "SSH/Ping failed" |
| 430 |
for line in tcpdump_future.result(): |
| 431 |
if 'ESP' in line: |
| 432 |
return True |
| 433 |
return False |
| 434 |
|
| 435 |
def verify_vpn_connectivity(self, **kwargs): |
| 436 |
"""Verify VPN connectivity""" |
| 437 |
|
| 438 |
LOG.debug("VERIFY THE VPN CONNECTIVITY") |
| 439 |
with LOCK: |
| 440 |
assert self._verify_vpn_connectivity( |
| 441 |
0, 1, **kwargs), "VPN CONNECTION FAILED" |
| 442 |
with LOCK: |
| 443 |
assert self._verify_vpn_connectivity( |
| 444 |
1, 0, **kwargs), "VPN CONNECTION FAILED" |
| 445 |
|
| 446 |
def update_router(self, router_id, admin_state_up=False): |
| 447 |
"""Update router's admin_state_up field |
| 448 |
|
| 449 |
:param router_id: uuid of the router |
| 450 |
:param admin_state_up: True or False |
| 451 |
""" |
| 452 |
LOG.debug('UPDATE ROUTER') |
| 453 |
router_args = {'router': {'admin_state_up': admin_state_up}} |
| 454 |
self.neutron_client.update_router(router_id, router_args) |
| 455 |
|
| 456 |
@atomic.action_timer("_delete_ipsec_site_connection") |
| 457 |
def _delete_ipsec_site_connections(self): |
| 458 |
"""Delete IPSEC site connections""" |
| 459 |
|
| 460 |
for site_conn in self.ipsec_site_connections: |
| 461 |
LOG.debug("DELETING IPSEC_SITE_CONNECTION %s", |
| 462 |
site_conn['ipsec_site_connection']['id']) |
| 463 |
self.neutron_client.delete_ipsec_site_connection( |
| 464 |
site_conn['ipsec_site_connection']['id']) |
| 465 |
|
| 466 |
@atomic.action_timer("_delete_vpn_service") |
| 467 |
def _delete_vpn_services(self): |
| 468 |
"""Delete VPN service endpoints""" |
| 469 |
|
| 470 |
for vpn_service in self.vpn_services: |
| 471 |
LOG.debug("DELETING VPN_SERVICE %s", |
| 472 |
vpn_service['vpnservice']['id']) |
| 473 |
self.neutron_client.delete_vpnservice( |
| 474 |
vpn_service['vpnservice']['id']) |
| 475 |
|
| 476 |
@atomic.action_timer("_delete_ipsec_policy") |
| 477 |
def _delete_ipsec_policy(self): |
| 478 |
"""Delete IPSEC policy""" |
| 479 |
|
| 480 |
LOG.debug("DELETING IPSEC POLICY") |
| 481 |
if self.ipsec_policy: |
| 482 |
self.neutron_client.delete_ipsecpolicy( |
| 483 |
self.ipsec_policy['ipsecpolicy']['id']) |
| 484 |
|
| 485 |
@atomic.action_timer("_delete_ike_policy") |
| 486 |
def _delete_ike_policy(self): |
| 487 |
"""Delete IKE policy""" |
| 488 |
|
| 489 |
LOG.debug('DELETING IKE POLICY') |
| 490 |
if self.ike_policy: |
| 491 |
self.neutron_client.delete_ikepolicy( |
| 492 |
self.ike_policy['ikepolicy']['id']) |
| 493 |
|
| 494 |
@atomic.action_timer("cleanup") |
| 495 |
def cleanup(self): |
| 496 |
"""Clean the resources""" |
| 497 |
|
| 498 |
vpn_utils.delete_servers(self.nova_client, self.servers) |
| 499 |
if self.server_fips: |
| 500 |
vpn_utils.delete_floating_ips(self.nova_client, self.server_fips) |
| 501 |
vpn_utils.delete_keypairs(self.nova_client, self.keypairs) |
| 502 |
|
| 503 |
if self.qrouterns_compute_tuples: |
| 504 |
vpn_utils.delete_hosts_from_knownhosts_file( |
| 505 |
self.server_private_ips, self.qrouterns_compute_tuples, |
| 506 |
self.private_key_file) |
| 507 |
vpn_utils.delete_keyfiles( |
| 508 |
self.local_key_files, self.remote_key_files, |
| 509 |
self.qrouterns_compute_tuples, self.private_key_file) |
| 510 |
else: |
| 511 |
vpn_utils.delete_hosts_from_knownhosts_file( |
| 512 |
self.server_private_ips) |
| 513 |
vpn_utils.delete_keyfiles(self.local_key_files) |
| 514 |
|
| 515 |
self._delete_ipsec_site_connections() |
| 516 |
self._delete_vpn_services() |
| 517 |
self._delete_ipsec_policy() |
| 518 |
self._delete_ike_policy() |
| 519 |
vpn_utils.delete_networks( |
| 520 |
self.neutron_client, self.neutron_admin_client, self.rally_routers, |
| 521 |
self.rally_networks, self.rally_subnets) |
| 522 |
if self.tenant_ids: |
| 523 |
vpn_utils.delete_tenants(self.keystone_client, self.tenant_ids) |