Debian Codegraph @

rally-jobs/plugins/vpn_base.py

raw
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)