Debian Codegraph @

neutron_vpnaas/tests/unit/services/vpn/service_drivers/test_ipsec.py

raw
1 # Copyright 2013, Nachi Ueno, NTT I3, Inc.
2 # All Rights Reserved.
3 #
4 # Licensed under the Apache License, Version 2.0 (the "License"); you may
5 # not use this file except in compliance with the License. You may obtain
6 # a copy of the License at
7 #
8 # http://www.apache.org/licenses/LICENSE-2.0
9 #
10 # Unless required by applicable law or agreed to in writing, software
11 # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
12 # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
13 # License for the specific language governing permissions and limitations
14 # under the License.
15
16 from unittest import mock
17
18 from neutron.db import servicetype_db as st_db
19 from neutron_lib import context as n_ctx
20 from neutron_lib.plugins import constants
21 from neutron_lib.plugins import directory
22 from oslo_utils import uuidutils
23
24 from neutron_vpnaas.services.vpn import plugin as vpn_plugin
25 from neutron_vpnaas.services.vpn.service_drivers import ipsec as ipsec_driver
26 from neutron_vpnaas.services.vpn.service_drivers import ipsec_validator
27 from neutron_vpnaas.tests import base
28
29
30 _uuid = uuidutils.generate_uuid
31
32 FAKE_SERVICE_ID = _uuid()
33 FAKE_VPN_CONNECTION = {
34 'vpnservice_id': FAKE_SERVICE_ID
35 }
36 FAKE_ROUTER_ID = _uuid()
37 FAKE_VPN_SERVICE = {
38 'router_id': FAKE_ROUTER_ID
39 }
40 FAKE_HOST = 'fake_host'
41 FAKE_CONN_ID = _uuid()
42
43 IPSEC_SERVICE_DRIVER = ('neutron_vpnaas.services.vpn.service_drivers.'
44 'ipsec.IPsecVPNDriver')
45
46
47 class FakeSqlQueryObject(dict):
48 """To fake SqlAlchemy query object and access keys as attributes."""
49
50 def __init__(self, **entries):
51 self.__dict__.update(entries)
52 super().__init__(**entries)
53
54
55 class TestValidatorSelection(base.BaseTestCase):
56
57 def setUp(self):
58 super().setUp()
59 vpnaas_provider = [{
60 'service_type': constants.VPN,
61 'name': 'vpnaas',
62 'driver': IPSEC_SERVICE_DRIVER,
63 'default': True
64 }]
65 # override the default service provider
66 self.service_providers = (
67 mock.patch.object(st_db.ServiceTypeManager,
68 'get_service_providers').start())
69 self.service_providers.return_value = vpnaas_provider
70 mock.patch('neutron_lib.rpc.Connection').start()
71 stm = st_db.ServiceTypeManager()
72 stm.get_provider_names_by_resource_ids = mock.Mock(
73 return_value={})
74 mock.patch('neutron.db.servicetype_db.ServiceTypeManager.get_instance',
75 return_value=stm).start()
76 mock.patch('neutron_vpnaas.db.vpn.vpn_db.VPNPluginDb.get_vpnservices',
77 return_value=[]).start()
78 self.vpn_plugin = vpn_plugin.VPNDriverPlugin()
79
80 def test_reference_driver_used(self):
81 default_provider = self.vpn_plugin.default_provider
82 default_driver = self.vpn_plugin.drivers[default_provider]
83 self.assertIsInstance(default_driver.validator,
84 ipsec_validator.IpsecVpnValidator)
85
86
87 class TestIPsecDriver(base.BaseTestCase):
88 def setUp(self):
89 super().setUp()
90 mock.patch('neutron_lib.rpc.Connection').start()
91
92 l3_agent = mock.Mock()
93 l3_agent.host = FAKE_HOST
94 plugin = mock.Mock()
95 plugin.get_l3_agents_hosting_routers.return_value = [l3_agent]
96 directory.add_plugin(constants.CORE, plugin)
97 directory.add_plugin(constants.L3, plugin)
98 self.svc_plugin = mock.Mock()
99 self.svc_plugin.get_l3_agents_hosting_routers.return_value = [l3_agent]
100 self._fake_vpn_router_id = _uuid()
101 self.svc_plugin.get_vpnservice_router_id.return_value = \
102 self._fake_vpn_router_id
103 self.driver = ipsec_driver.IPsecVPNDriver(self.svc_plugin)
104 self.validator = ipsec_validator.IpsecVpnValidator(self.driver)
105 self.context = n_ctx.get_admin_context()
106
107 def _test_update(self, func, args, additional_info=None):
108 ctxt = n_ctx.Context('', 'somebody')
109 with mock.patch.object(self.driver.agent_rpc.client, 'cast'
110 ) as rpc_mock, \
111 mock.patch.object(self.driver.agent_rpc.client, 'prepare'
112 ) as prepare_mock:
113 prepare_mock.return_value = self.driver.agent_rpc.client
114 func(ctxt, *args)
115
116 prepare_args = {'server': 'fake_host', 'version': '1.0'}
117 prepare_mock.assert_called_once_with(**prepare_args)
118
119 rpc_mock.assert_called_once_with(ctxt, 'vpnservice_updated',
120 **additional_info)
121
122 def test_create_ipsec_site_connection(self):
123 self._test_update(self.driver.create_ipsec_site_connection,
124 [FAKE_VPN_CONNECTION],
125 {'router': {'id': self._fake_vpn_router_id}})
126
127 def test_update_ipsec_site_connection(self):
128 self._test_update(self.driver.update_ipsec_site_connection,
129 [FAKE_VPN_CONNECTION, FAKE_VPN_CONNECTION],
130 {'router': {'id': self._fake_vpn_router_id}})
131
132 def test_delete_ipsec_site_connection(self):
133 self._test_update(self.driver.delete_ipsec_site_connection,
134 [FAKE_VPN_CONNECTION],
135 {'router': {'id': self._fake_vpn_router_id}})
136
137 def test_update_vpnservice(self):
138 self._test_update(self.driver.update_vpnservice,
139 [FAKE_VPN_SERVICE, FAKE_VPN_SERVICE],
140 {'router': {'id': FAKE_VPN_SERVICE['router_id']}})
141
142 def test_delete_vpnservice(self):
143 self._test_update(self.driver.delete_vpnservice,
144 [FAKE_VPN_SERVICE],
145 {'router': {'id': FAKE_VPN_SERVICE['router_id']}})
146
147 def prepare_dummy_query_objects(self, info):
148 """Create fake query objects to test dict creation for sync oper."""
149 external_ip = '10.0.0.99'
150 peer_address = '10.0.0.2'
151 peer_endpoints = info.get('peer_endpoints', [])
152 local_endpoints = info.get('local_endpoints', [])
153 peer_cidrs = info.get('peer_cidrs', ['40.4.0.0/24', '50.5.0.0/24'])
154 peer_id = info.get('peer_id', '30.30.0.0')
155 local_id = info.get('local_id', '')
156
157 fake_ikepolicy = FakeSqlQueryObject(id='foo-ike', name='ike-name')
158 fake_ipsecpolicy = FakeSqlQueryObject(id='foo-ipsec')
159
160 fake_peer_cidrs_list = [
161 FakeSqlQueryObject(cidr=cidr, ipsec_site_connection_id='conn-id')
162 for cidr in peer_cidrs]
163
164 peer_epg_id = 'peer-epg-id' if peer_endpoints else None
165 local_epg_id = 'local-epg-id' if local_endpoints else None
166
167 fake_ipsec_conn = FakeSqlQueryObject(id='conn-id',
168 peer_id=peer_id,
169 peer_address=peer_address,
170 local_id=local_id,
171 ikepolicy=fake_ikepolicy,
172 ipsecpolicy=fake_ipsecpolicy,
173 peer_ep_group_id=peer_epg_id,
174 local_ep_group_id=local_epg_id,
175 peer_cidrs=fake_peer_cidrs_list)
176
177 if peer_endpoints:
178 fake_peer_ep_group = FakeSqlQueryObject(id=peer_epg_id)
179 fake_peer_ep_group.endpoints = [
180 FakeSqlQueryObject(endpoint=ep,
181 endpoint_group_id=peer_epg_id)
182 for ep in peer_endpoints]
183 fake_ipsec_conn.peer_ep_group = fake_peer_ep_group
184
185 if local_endpoints:
186 fake_local_ep_group = FakeSqlQueryObject(id=local_epg_id)
187 fake_local_ep_group.endpoints = [
188 FakeSqlQueryObject(endpoint=ep,
189 endpoint_group_id=local_epg_id)
190 for ep in local_endpoints]
191 fake_ipsec_conn.local_ep_group = fake_local_ep_group
192 subnet_id = None
193 else:
194 subnet_id = 'foo-subnet-id'
195
196 fake_gw_port = {'fixed_ips': [{'ip_address': external_ip}]}
197 fake_router = FakeSqlQueryObject(gw_port=fake_gw_port)
198 fake_vpnservice = FakeSqlQueryObject(id='foo-vpn-id', name='foo-vpn',
199 description='foo-vpn-service',
200 admin_state_up=True,
201 status='active',
202 external_v4_ip=external_ip,
203 external_v6_ip=None,
204 subnet_id=subnet_id,
205 router_id='foo-router-id',
206 project_id='foo-project-id')
207 if local_endpoints:
208 fake_vpnservice.subnet = None
209 else:
210 fake_subnet = FakeSqlQueryObject(id=subnet_id,
211 name='foo-subnet',
212 cidr='9.0.0.0/16',
213 network_id='foo-net-id')
214 fake_vpnservice.subnet = fake_subnet
215 fake_vpnservice.router = fake_router
216 fake_vpnservice.ipsec_site_connections = [fake_ipsec_conn]
217 return fake_vpnservice
218
219 def build_expected_dict(self, info):
220 """Create the expected dict used in sync operations.
221
222 The default is to use non-endpoint groups, where the peer CIDRs come
223 from the peer_cidrs arguments, the local CIDRs come from the (sole)
224 subnet CIDR, and there is subnet info. Tests will customize the peer
225 ID and peer CIDRs.
226 """
227
228 external_ip = '10.0.0.99'
229 peer_id = info.get('peer_id', '30.30.0.0')
230 peer_cidrs = info.get('peer_cidrs', ['40.4.0.0/24', '50.5.0.0/24'])
231 local_id = info.get('local_id', '')
232
233 return {'name': 'foo-vpn',
234 'id': 'foo-vpn-id',
235 'description': 'foo-vpn-service',
236 'admin_state_up': True,
237 'status': 'active',
238 'external_v4_ip': external_ip,
239 'external_v6_ip': None,
240 'router_id': 'foo-router-id',
241 'subnet': {'cidr': '9.0.0.0/16',
242 'id': 'foo-subnet-id',
243 'name': 'foo-subnet',
244 'network_id': 'foo-net-id'},
245 'subnet_id': 'foo-subnet-id',
246 'external_ip': external_ip,
247 'project_id': 'foo-project-id',
248 'tenant_id': 'foo-project-id',
249 'ipsec_site_connections': [
250 {'id': 'conn-id',
251 'peer_id': peer_id,
252 'external_ip': external_ip,
253 'peer_address': '10.0.0.2',
254 'local_id': local_id,
255 'ikepolicy': {'id': 'foo-ike',
256 'name': 'ike-name'},
257 'ipsecpolicy': {'id': 'foo-ipsec'},
258 'peer_ep_group_id': None,
259 'local_ep_group_id': None,
260 'peer_cidrs': peer_cidrs,
261 'local_cidrs': ['9.0.0.0/16'],
262 'local_ip_vers': 4}
263 ]}
264
265 def build_expected_dict_for_endpoints(self, info):
266 """Create the expected dict used in sync operations for endpoints.
267
268 The local and peer CIDRs come from the endpoint groups (with the
269 local CIDR translated from the corresponding subnets specified).
270 Tests will customize CIDRs, and the subnet, which is needed for
271 backward compatibility with agents, during rolling upgrades.
272 """
273
274 external_ip = '10.0.0.99'
275 peer_id = '30.30.0.0'
276 local_id = info.get('local_id', '')
277 return {'name': 'foo-vpn',
278 'id': 'foo-vpn-id',
279 'description': 'foo-vpn-service',
280 'admin_state_up': True,
281 'status': 'active',
282 'external_v4_ip': external_ip,
283 'external_v6_ip': None,
284 'router_id': 'foo-router-id',
285 'subnet': None,
286 'subnet_id': None,
287 'external_ip': external_ip,
288 'project_id': 'foo-project-id',
289 'tenant_id': 'foo-project-id',
290 'ipsec_site_connections': [
291 {'id': 'conn-id',
292 'peer_id': peer_id,
293 'external_ip': external_ip,
294 'peer_address': '10.0.0.2',
295 'local_id': local_id,
296 'ikepolicy': {'id': 'foo-ike',
297 'name': 'ike-name'},
298 'ipsecpolicy': {'id': 'foo-ipsec'},
299 'peer_ep_group_id': 'peer-epg-id',
300 'local_ep_group_id': 'local-epg-id',
301 'peer_cidrs': info['peers'],
302 'local_cidrs': info['locals'],
303 'local_ip_vers': info['vers']}
304 ]}
305
306 def test_make_vpnservice_dict_peer_id_is_ipaddr(self):
307 """Peer ID as IP should be copied as-is, when creating dict."""
308 subnet_cidr_map = {}
309 peer_id_as_ip = {'peer_id': '10.0.0.2'}
310 fake_service = self.prepare_dummy_query_objects(peer_id_as_ip)
311 expected_dict = self.build_expected_dict(peer_id_as_ip)
312 actual_dict = self.driver.make_vpnservice_dict(fake_service,
313 subnet_cidr_map)
314 self.assertEqual(expected_dict, actual_dict)
315
316 # make sure that ipsec_site_conn peer_id is not updated by
317 # _make_vpnservice_dict (bug #1423244)
318 self.assertEqual(peer_id_as_ip['peer_id'],
319 fake_service.ipsec_site_connections[0].peer_id)
320
321 def test_make_vpnservice_dict_peer_id_is_string(self):
322 """Peer ID as string should have '@' prepended, when creating dict."""
323 subnet_cidr_map = {}
324 peer_id_as_name = {'peer_id': 'foo.peer.id'}
325 fake_service = self.prepare_dummy_query_objects(peer_id_as_name)
326 expected_peer_id = {'peer_id': '@foo.peer.id'}
327 expected_dict = self.build_expected_dict(expected_peer_id)
328 actual_dict = self.driver.make_vpnservice_dict(fake_service,
329 subnet_cidr_map)
330 self.assertEqual(expected_dict, actual_dict)
331
332 # make sure that ipsec_site_conn peer_id is not updated by
333 # _make_vpnservice_dict (bug #1423244)
334 self.assertEqual(peer_id_as_name['peer_id'],
335 fake_service.ipsec_site_connections[0].peer_id)
336
337 def test_make_vpnservice_dict_peer_cidrs_from_peer_cidr_table(self):
338 """Peer CIDRs list populated from peer_cidr table.
339
340 User provides peer CIDRs as parameters to IPSec site-to-site
341 connection API, and they are stored in the peercidrs table.
342 """
343 subnet_cidr_map = {}
344 peer_cidrs = {'peer_cidrs': ['80.0.0.0/24', '90.0.0.0/24']}
345 fake_service = self.prepare_dummy_query_objects(peer_cidrs)
346 expected_dict = self.build_expected_dict(peer_cidrs)
347 actual_dict = self.driver.make_vpnservice_dict(fake_service,
348 subnet_cidr_map)
349 self.assertEqual(expected_dict, actual_dict)
350
351 def test_make_vpnservice_dict_cidrs_from_endpoints(self):
352 """CIDRs list populated from local and peer endpoints.
353
354 User provides peer and local endpoint group IDs in the IPSec
355 site-to-site connection API. The endpoint groups contains peer
356 CIDRs and local subnets (which will be mapped to CIDRs).
357 """
358 # Cannot have peer CIDRs specified, when using endpoint group
359 subnet_cidr_map = {'local-sn1': '5.0.0.0/16',
360 'local-sn2': '5.1.0.0/16'}
361 endpoint_groups = {'peer_cidrs': [],
362 'peer_endpoints': ['80.0.0.0/24', '90.0.0.0/24'],
363 'local_endpoints': ['local-sn1', 'local-sn2']}
364
365 expected_cidrs = {'peers': ['80.0.0.0/24', '90.0.0.0/24'],
366 'locals': ['5.0.0.0/16', '5.1.0.0/16'],
367 'vers': 4}
368 fake_service = self.prepare_dummy_query_objects(endpoint_groups)
369 expected_dict = self.build_expected_dict_for_endpoints(expected_cidrs)
370 expected_dict['subnet'] = {'cidr': '5.0.0.0/16'}
371 actual_dict = self.driver.make_vpnservice_dict(fake_service,
372 subnet_cidr_map)
373 self.assertEqual(expected_dict, actual_dict)
374
375 def test_make_vpnservice_dict_v6_cidrs_from_endpoints(self):
376 """IPv6 CIDRs list populated from local and peer endpoints."""
377 # Cannot have peer CIDRs specified, when using endpoint group
378 subnet_cidr_map = {'local-sn1': '2002:0a00:0000::/48',
379 'local-sn2': '2002:1400:0000::/48'}
380 endpoint_groups = {'peer_cidrs': [],
381 'peer_endpoints': ['2002:5000:0000::/48',
382 '2002:5a00:0000::/48'],
383 'local_endpoints': ['local-sn1', 'local-sn2']}
384
385 expected_cidrs = {'peers': ['2002:5000:0000::/48',
386 '2002:5a00:0000::/48'],
387 'locals': ['2002:0a00:0000::/48',
388 '2002:1400:0000::/48'],
389 'vers': 6}
390 fake_service = self.prepare_dummy_query_objects(endpoint_groups)
391 expected_dict = self.build_expected_dict_for_endpoints(expected_cidrs)
392 expected_dict['subnet'] = {'cidr': '2002:0a00:0000::/48'}
393 actual_dict = self.driver.make_vpnservice_dict(fake_service,
394 subnet_cidr_map)
395 self.assertEqual(expected_dict, actual_dict)
396
397 def test_get_external_ip_based_on_ipv4_peer(self):
398 vpnservice = mock.Mock()
399 vpnservice.external_v4_ip = '10.0.0.99'
400 vpnservice.external_v6_ip = '2001::1'
401 ipsec_sitecon = {'id': FAKE_CONN_ID, 'peer_address': '10.0.0.9'}
402 ip_to_use = self.driver.get_external_ip_based_on_peer(vpnservice,
403 ipsec_sitecon)
404 self.assertEqual('10.0.0.99', ip_to_use)
405
406 def test_get_external_ip_based_on_ipv6_peer(self):
407 vpnservice = mock.Mock()
408 vpnservice.external_v4_ip = '10.0.0.99'
409 vpnservice.external_v6_ip = '2001::1'
410 ipsec_sitecon = {'id': FAKE_CONN_ID, 'peer_address': '2001::5'}
411 ip_to_use = self.driver.get_external_ip_based_on_peer(vpnservice,
412 ipsec_sitecon)
413 self.assertEqual('2001::1', ip_to_use)
414
415 def test_get_ipv4_gw_ip(self):
416 vpnservice = mock.Mock()
417 vpnservice.router.gw_port = {'fixed_ips':
418 [{'ip_address': '10.0.0.99'}]}
419 v4_ip, v6_ip = self.driver._get_gateway_ips(vpnservice.router)
420 self.assertEqual('10.0.0.99', v4_ip)
421 self.assertIsNone(v6_ip)
422
423 def test_get_ipv6_gw_ip(self):
424 vpnservice = mock.Mock()
425 vpnservice.router.gw_port = {'fixed_ips': [{'ip_address': '2001::1'}]}
426 v4_ip, v6_ip = self.driver._get_gateway_ips(vpnservice.router)
427 self.assertIsNone(v4_ip)
428 self.assertEqual('2001::1', v6_ip)
429
430 def test_get_both_gw_ips(self):
431 vpnservice = mock.Mock()
432 vpnservice.router.gw_port = {'fixed_ips': [{'ip_address': '10.0.0.99'},
433 {'ip_address': '2001::1'}]}
434 v4_ip, v6_ip = self.driver._get_gateway_ips(vpnservice.router)
435 self.assertEqual('10.0.0.99', v4_ip)
436 self.assertEqual('2001::1', v6_ip)
437
438 def test_use_first_gw_ips_when_multiples(self):
439 vpnservice = mock.Mock()
440 vpnservice.router.gw_port = {'fixed_ips': [{'ip_address': '10.0.0.99'},
441 {'ip_address': '20.0.0.99'},
442 {'ip_address': '2001::1'},
443 {'ip_address': 'fd00::4'}]}
444 v4_ip, v6_ip = self.driver._get_gateway_ips(vpnservice.router)
445 self.assertEqual('10.0.0.99', v4_ip)
446 self.assertEqual('2001::1', v6_ip)
447
448 def test_store_gw_ips_on_service_create(self):
449 vpnservice = mock.Mock()
450 self.svc_plugin._get_vpnservice.return_value = vpnservice
451 vpnservice.router.gw_port = {'fixed_ips': [{'ip_address': '10.0.0.99'},
452 {'ip_address': '2001::1'}]}
453 ctxt = n_ctx.Context('', 'somebody')
454 vpnservice_dict = {'id': FAKE_SERVICE_ID,
455 'router_id': FAKE_ROUTER_ID}
456 self.driver.create_vpnservice(ctxt, vpnservice_dict)
457 self.svc_plugin.set_external_tunnel_ips.assert_called_once_with(
458 ctxt, FAKE_SERVICE_ID, v4_ip='10.0.0.99', v6_ip='2001::1')
459
460 def test_validate_ipsec_policy(self):
461 # Validate IPsec Policy transform_protocol
462 ipsec_policy = {'transform_protocol': 'ah-esp'}
463 self.assertRaises(ipsec_validator.IpsecValidationFailure,
464 self.validator.validate_ipsec_policy,
465 self.context, ipsec_policy)