Debian Codegraph @

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

raw
1 # Copyright 2020, SysEleven GbmH
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 from unittest import mock
16
17 from neutron_lib import context as n_ctx
18 from neutron_lib.plugins import constants
19 from neutron_lib.plugins import directory
20 from oslo_utils import uuidutils
21
22 from neutron_vpnaas.services.vpn.service_drivers import ipsec_validator
23 from neutron_vpnaas.services.vpn.service_drivers \
24 import ovn_ipsec as ipsec_driver
25 from neutron_vpnaas.tests import base
26
27
28 _uuid = uuidutils.generate_uuid
29
30 FAKE_HOST = 'fake_host'
31 FAKE_TENANT_ID = 'tenant1'
32 FAKE_ROUTER_ID = _uuid()
33 FAKE_TRANSIT_IP_ADDRESS = '169.254.0.2'
34
35 FAKE_VPNSERVICE_1 = {
36 'id': _uuid(),
37 'router_id': FAKE_ROUTER_ID,
38 'tenant_id': FAKE_TENANT_ID
39 }
40
41 FAKE_VPNSERVICE_2 = {
42 'id': _uuid(),
43 'router_id': FAKE_ROUTER_ID,
44 'tenant_id': FAKE_TENANT_ID
45 }
46
47 FAKE_VPN_CONNECTION_1 = {
48 'vpnservice_id': FAKE_VPNSERVICE_1['id']
49 }
50
51
52 class FakeSqlQueryObject(dict):
53 """To fake SqlAlchemy query object and access keys as attributes."""
54
55 def __init__(self, **entries):
56 self.__dict__.update(entries)
57 super().__init__(**entries)
58
59
60 class FakeGatewayDB:
61 def __init__(self):
62 self.gateways_by_router = {}
63 self.gateways_by_id = {}
64
65 def create_gateway(self, context, gateway):
66 info = gateway['gateway']
67 fake_gw = {
68 'id': _uuid(),
69 'status': 'PENDING_CREATE',
70 'external_fixed_ips': [{'subnet_id': '1',
71 'ip_address': '10.2.3.4'}],
72 **info
73 }
74 self.gateways_by_router[info['router_id']] = fake_gw
75 self.gateways_by_id[fake_gw['id']] = fake_gw
76 return fake_gw
77
78 def update_gateway(self, context, gateway_id, gateway):
79 self.gateways_by_id[gateway_id].update(**gateway['gateway'])
80
81 def delete_gateway(self, context, gateway_id):
82 fake_gw = self.gateways_by_id.pop(gateway_id, None)
83 if fake_gw:
84 self.gateways_by_router.pop(fake_gw['router_id'])
85 return 1 if fake_gw else 0
86
87 def get_vpn_gw_dict_by_router_id(self, context, router_id, refresh=False):
88 return self.gateways_by_router.get(router_id)
89
90
91 class TestOvnIPsecDriver(base.BaseTestCase):
92 def setUp(self):
93 super().setUp()
94 mock.patch('neutron_lib.rpc.Connection').start()
95 self.create_port = \
96 mock.patch('neutron_lib.plugins.utils.create_port').start()
97 self.create_network = \
98 mock.patch('neutron_lib.plugins.utils.create_network').start()
99 self.create_subnet = \
100 mock.patch('neutron_lib.plugins.utils.create_subnet').start()
101
102 self.create_port.side_effect = lambda pl, c, p: {
103 'id': _uuid(),
104 'fixed_ips': [{'subnet_id': '1', 'ip_address': '10.1.1.2'}]}
105 self.create_network.side_effect = lambda pl, c, n: {'id': _uuid()}
106 self.create_subnet.side_effect = lambda pl, c, s: {'id': _uuid()}
107
108 vpn_agent = {'host': FAKE_HOST}
109
110 self.core_plugin = mock.Mock()
111 self.core_plugin.get_vpn_agents_hosting_routers.return_value = \
112 [vpn_agent]
113
114 directory.add_plugin(constants.CORE, self.core_plugin)
115
116 self._fake_router = FakeSqlQueryObject(
117 id=FAKE_ROUTER_ID,
118 gw_port=FakeSqlQueryObject(network_id=_uuid())
119 )
120
121 self.l3_plugin = mock.Mock()
122 self.l3_plugin.get_router.return_value = self._fake_router
123 directory.add_plugin(constants.L3, self.l3_plugin)
124
125 self.svc_plugin = mock.Mock()
126 self.svc_plugin.get_vpn_agents_hosting_routers.return_value = \
127 [vpn_agent]
128 self.svc_plugin.schedule_router.return_value = vpn_agent
129 self.svc_plugin._get_vpnservice.return_value = FakeSqlQueryObject(
130 router_id=FAKE_ROUTER_ID,
131 router=self._fake_router
132 )
133 self.svc_plugin.get_vpn_agent_on_host.return_value = {'id': FAKE_HOST}
134 self.svc_plugin.get_vpnservice.return_value = FAKE_VPNSERVICE_1
135 self.svc_plugin.get_vpnservice_router_id.return_value = FAKE_ROUTER_ID
136 self.driver = ipsec_driver.IPsecOvnVPNDriver(self.svc_plugin)
137 self.driver.make_vpnservice_dict = mock.Mock(
138 return_value={'id': FAKE_HOST})
139 self.validator = ipsec_validator.IpsecVpnValidator(self.driver)
140 self.context = n_ctx.get_admin_context()
141
142 def test_create_vpnservice(self):
143 mock.patch.object(self.driver.agent_rpc.client, 'cast')
144 mock.patch.object(self.driver.agent_rpc.client, 'prepare')
145 fake_gw_db = FakeGatewayDB()
146
147 self.svc_plugin.get_vpn_gw_dict_by_router_id.side_effect = \
148 fake_gw_db.get_vpn_gw_dict_by_router_id
149 self.svc_plugin.create_gateway.side_effect = fake_gw_db.create_gateway
150 self.svc_plugin.update_gateway.side_effect = fake_gw_db.update_gateway
151
152 self.driver.create_vpnservice(self.context, FAKE_VPNSERVICE_1)
153 self.svc_plugin.create_gateway.assert_called_once()
154
155 # check that the plugin utils create functions were called
156 self.create_port.assert_called()
157 self.create_network.assert_called_once()
158 self.create_subnet.assert_called_once()
159
160 # check that the core plugin create functions were not called directly
161 self.core_plugin.create_port.assert_not_called()
162 self.core_plugin.create_network.assert_not_called()
163 self.core_plugin.create_subnet.assert_not_called()
164
165 self.svc_plugin.reset_mock()
166
167 self.driver.create_vpnservice(self.context, FAKE_VPNSERVICE_2)
168 self.svc_plugin.create_gateway.assert_not_called()
169
170 def test_delete_vpnservice(self):
171 mock.patch.object(self.driver.agent_rpc.client, 'cast')
172 mock.patch.object(self.driver.agent_rpc.client, 'prepare')
173 fake_gw_db = FakeGatewayDB()
174 self.svc_plugin.get_vpn_gw_dict_by_router_id.side_effect = \
175 fake_gw_db.get_vpn_gw_dict_by_router_id
176 self.svc_plugin.create_gateway.side_effect = fake_gw_db.create_gateway
177 self.svc_plugin.update_gateway.side_effect = fake_gw_db.update_gateway
178 self.svc_plugin.delete_gateway.side_effect = fake_gw_db.delete_gateway
179
180 # create 2 VPN services on same router
181 self.driver.create_vpnservice(self.context, FAKE_VPNSERVICE_1)
182 self.driver.create_vpnservice(self.context, FAKE_VPNSERVICE_2)
183 self.svc_plugin.reset_mock()
184
185 # deleting one VPN service must not delete the VPN gateway
186 self.svc_plugin.get_vpnservices.return_value = [FAKE_VPNSERVICE_2]
187 self.driver.delete_vpnservice(self.context, FAKE_VPNSERVICE_1)
188 self.core_plugin.delete_port.assert_not_called()
189 self.core_plugin.delete_network.assert_not_called()
190 self.core_plugin.delete_subnet.assert_not_called()
191 self.svc_plugin.create_gateway.assert_not_called()
192 self.svc_plugin.delete_gateway.assert_not_called()
193
194 # deleting last VPN service shall delete the VPN gateway
195 self.svc_plugin.get_vpnservices.return_value = []
196 self.driver.delete_vpnservice(self.context, FAKE_VPNSERVICE_1)
197 self.core_plugin.delete_port.assert_called()
198 self.core_plugin.delete_network.assert_called_once()
199 self.core_plugin.delete_subnet.assert_called_once()
200 self.svc_plugin.create_gateway.assert_not_called()
201 self.svc_plugin.delete_gateway.assert_called_once()
202
203 def _test_ipsec_site_connection(self, old_peers, new_peers,
204 func, args,
205 expected_add, expected_remove):
206 self._fake_router['routes'] = [
207 {'destination': peer, 'nexthop': FAKE_TRANSIT_IP_ADDRESS}
208 for peer in old_peers
209 ]
210 transit_port = FakeSqlQueryObject(
211 id=_uuid(),
212 fixed_ips=[
213 {'subnet_id': _uuid(), 'ip_address': FAKE_TRANSIT_IP_ADDRESS}
214 ]
215 )
216 self.svc_plugin.get_vpn_gw_by_router_id.return_value = \
217 FakeSqlQueryObject(id=_uuid(),
218 router_id=FAKE_ROUTER_ID,
219 transit_port_id=transit_port.id,
220 transit_port=transit_port)
221
222 self.svc_plugin.get_peer_cidrs_for_router.return_value = new_peers
223
224 # create/update/delete_ipsec_site_connection
225 with mock.patch.object(self.driver.agent_rpc.client, 'cast'
226 ) as rpc_mock, \
227 mock.patch.object(self.driver.agent_rpc.client, 'prepare'
228 ) as prepare_mock:
229 prepare_mock.return_value = self.driver.agent_rpc.client
230 func(self.context, *args)
231
232 prepare_args = {'server': 'fake_host', 'version': '1.0'}
233 prepare_mock.assert_called_once_with(**prepare_args)
234
235 # check that agent RPC vpnservice_updated is called
236 rpc_mock.assert_called_once_with(self.context, 'vpnservice_updated',
237 router={'id': FAKE_ROUTER_ID})
238
239 # check that routes were updated
240 if expected_add:
241 expected_router = {'router': {'routes': [
242 {'destination': peer,
243 'nexthop': FAKE_TRANSIT_IP_ADDRESS}
244 for peer in expected_add
245 ]}}
246 self.l3_plugin.add_extraroutes.assert_called_once_with(
247 self.context, FAKE_ROUTER_ID, expected_router)
248 else:
249 self.l3_plugin.add_extraroutes.assert_not_called()
250
251 if expected_remove:
252 expected_router = {'router': {'routes': [
253 {'destination': peer,
254 'nexthop': FAKE_TRANSIT_IP_ADDRESS}
255 for peer in expected_remove
256 ]}}
257 self.l3_plugin.remove_extraroutes.assert_called_once_with(
258 self.context, FAKE_ROUTER_ID, expected_router)
259 else:
260 self.l3_plugin.remove_extraroutes.assert_not_called()
261
262 def test_create_ipsec_site_connection_1(self):
263 old_peers = []
264 new_peers = ['192.168.1.0/24']
265 expected_add = new_peers
266 expected_remove = []
267 self._test_ipsec_site_connection(
268 old_peers, new_peers,
269 self.driver.create_ipsec_site_connection,
270 [FAKE_VPN_CONNECTION_1],
271 expected_add, expected_remove
272 )
273
274 def test_create_ipsec_site_connection_2(self):
275 """Test creating a 2nd site connection."""
276 old_peers = ['192.168.1.0/24']
277 new_peers = ['192.168.1.0/24', '192.168.2.0/24']
278 expected_add = ['192.168.2.0/24']
279 expected_remove = []
280 self._test_ipsec_site_connection(
281 old_peers, new_peers,
282 self.driver.create_ipsec_site_connection,
283 [FAKE_VPN_CONNECTION_1],
284 expected_add, expected_remove
285 )
286
287 def test_update_ipsec_site_connection(self):
288 old_peers = ['192.168.1.0/24']
289 new_peers = ['192.168.2.0/24']
290 expected_add = new_peers
291 expected_remove = old_peers
292 self._test_ipsec_site_connection(
293 old_peers, new_peers,
294 self.driver.update_ipsec_site_connection,
295 [FAKE_VPN_CONNECTION_1, FAKE_VPN_CONNECTION_1],
296 expected_add, expected_remove
297 )
298
299 def test_delete_ipsec_site_connection(self):
300 old_peers = ['192.168.1.0/24', '192.168.2.0/24']
301 new_peers = ['192.168.2.0/24']
302 expected_add = []
303 expected_remove = ['192.168.1.0/24']
304 self._test_ipsec_site_connection(
305 old_peers, new_peers,
306 self.driver.delete_ipsec_site_connection,
307 [FAKE_VPN_CONNECTION_1],
308 expected_add, expected_remove
309 )
310
311
312 class TestOvnIPsecCallBackDriver(base.BaseTestCase):
313 def setUp(self):
314 super().setUp()
315 vpn_agent = {'host': FAKE_HOST}
316 self.core_plugin = mock.Mock()
317 self.core_plugin.get_vpn_agents_hosting_routers.return_value = \
318 [vpn_agent]
319
320 directory.add_plugin(constants.CORE, self.core_plugin)
321 self._fake_router = FakeSqlQueryObject(
322 id=FAKE_ROUTER_ID,
323 gw_port=FakeSqlQueryObject(network_id=_uuid())
324 )
325 self.svc_plugin = mock.Mock()
326 self.svc_plugin.get_vpn_agents_hosting_routers.return_value = \
327 [vpn_agent]
328 self.svc_plugin.schedule_router.return_value = vpn_agent
329 self.svc_plugin._get_vpnservice.return_value = FakeSqlQueryObject(
330 router_id=FAKE_ROUTER_ID,
331 router=self._fake_router
332 )
333 self.svc_plugin.get_vpn_agent_on_host.return_value = {'id': FAKE_HOST}
334 self.svc_plugin.get_vpnservice.return_value = FAKE_VPNSERVICE_1
335 self.svc_plugin.get_vpnservice_router_id.return_value = FAKE_ROUTER_ID
336 self.driver = ipsec_driver.IPsecOvnVPNDriver(self.svc_plugin)
337 self.driver.make_vpnservice_dict = mock.Mock(
338 return_value={'id': FAKE_HOST})
339
340 def test_get_vpn_services_on_host(self):
341 with mock.patch('neutron_lib.context.get_admin_context') as get_ctx:
342 mock_ctx = mock.Mock()
343 mock_ctx.session.query().join().join().filter.return_value = [
344 {'id': FAKE_HOST}]
345 get_ctx.return_value = mock_ctx
346 context = n_ctx.get_admin_context()
347 driver_callback = ipsec_driver.IPsecVpnOvnDriverCallBack(
348 self.driver)
349 self.assertEqual(
350 [{'id': FAKE_HOST}],
351 driver_callback.get_vpn_services_on_host(
352 context, FAKE_HOST)
353 )
354 self.svc_plugin.get_vpn_agent_on_host.assert_called_once_with(
355 mock.ANY, FAKE_HOST)
356 self.svc_plugin.auto_schedule_routers.assert_called_once_with(
357 mock.ANY, {'id': FAKE_HOST})