Debian Codegraph @

neutron_vpnaas/tests/unit/db/vpn/test_vpn_agentschedulers_db.py

raw
1 # Copyright 2023 SysEleven GmbH.
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 from unittest import mock
16
17 from neutron.api import extensions
18 from neutron.api import wsgi
19 from neutron.common.ovn import constants as ovn_constants
20 from neutron import policy
21 from neutron.tests.common import helpers
22 from neutron.tests.common import test_db_base_plugin_v2 as test_plugin
23 from neutron.tests.unit.api import test_extensions
24 from neutron.tests.unit.extensions import test_l3
25 from neutron.tests.unit import testlib_api
26 from neutron_lib import context
27 from neutron_lib.db import api as db_api
28 from neutron_lib import exceptions as n_exc
29 from neutron_lib.plugins import constants as plugin_constants
30 from neutron_lib.plugins import directory
31 from neutron_lib import rpc as n_rpc
32 from oslo_db import exception as db_exc
33 import oslo_messaging
34 from oslo_utils import uuidutils
35 from sqlalchemy import orm
36 from webob import exc
37
38 from neutron_vpnaas.api.rpc.agentnotifiers import vpn_rpc_agent_api
39 from neutron_vpnaas.extensions import vpn_agentschedulers
40 from neutron_vpnaas.services.vpn.common import constants
41 from neutron_vpnaas.tests.unit.db.vpn import test_vpn_db
42
43
44 VPN_HOSTA = "host-1"
45 VPN_HOSTB = "host-2"
46
47
48 class VPNAgentSchedulerTestMixIn:
49 def _request_list(self, path, admin_context=True,
50 expected_code=exc.HTTPOk.code):
51 req = self._path_req(path, admin_context=admin_context)
52 res = req.get_response(self.ext_api)
53 self.assertEqual(expected_code, res.status_int)
54 return self.deserialize(self.fmt, res)
55
56 def _path_req(self, path, method='GET', data=None,
57 query_string=None,
58 admin_context=True):
59 content_type = 'application/%s' % self.fmt
60 body = None
61 if data is not None: # empty dict is valid
62 body = wsgi.Serializer().serialize(data, content_type)
63 if admin_context:
64 return testlib_api.create_request(
65 path, body, content_type, method, query_string=query_string)
66 else:
67 return testlib_api.create_request(
68 path, body, content_type, method, query_string=query_string,
69 context=context.Context('', 'tenant_id'))
70
71 def _path_create_request(self, path, data, admin_context=True):
72 return self._path_req(path, method='POST', data=data,
73 admin_context=admin_context)
74
75 def _path_show_request(self, path, admin_context=True):
76 return self._path_req(path, admin_context=admin_context)
77
78 def _path_delete_request(self, path, admin_context=True):
79 return self._path_req(path, method='DELETE',
80 admin_context=admin_context)
81
82 def _path_update_request(self, path, data, admin_context=True):
83 return self._path_req(path, method='PUT', data=data,
84 admin_context=admin_context)
85
86 def _list_routers_hosted_by_vpn_agent(self, agent_id,
87 expected_code=exc.HTTPOk.code,
88 admin_context=True):
89 path = "/agents/{}/{}.{}".format(agent_id,
90 vpn_agentschedulers.VPN_ROUTERS,
91 self.fmt)
92 return self._request_list(path, expected_code=expected_code,
93 admin_context=admin_context)
94
95 def _add_router_to_vpn_agent(self, id, router_id,
96 expected_code=exc.HTTPCreated.code,
97 admin_context=True):
98 path = "/agents/{}/{}.{}".format(id,
99 vpn_agentschedulers.VPN_ROUTERS,
100 self.fmt)
101 req = self._path_create_request(path,
102 {'router_id': router_id},
103 admin_context=admin_context)
104 res = req.get_response(self.ext_api)
105 self.assertEqual(expected_code, res.status_int)
106
107 def _list_vpn_agents_hosting_router(self, router_id,
108 expected_code=exc.HTTPOk.code,
109 admin_context=True):
110 path = "/routers/{}/{}.{}".format(router_id,
111 vpn_agentschedulers.VPN_AGENTS,
112 self.fmt)
113 return self._request_list(path, expected_code=expected_code,
114 admin_context=admin_context)
115
116 def _remove_router_from_vpn_agent(self, id, router_id,
117 expected_code=exc.HTTPNoContent.code,
118 admin_context=True):
119 path = "/agents/{}/{}/{}.{}".format(id,
120 vpn_agentschedulers.VPN_ROUTERS,
121 router_id,
122 self.fmt)
123 req = self._path_delete_request(path, admin_context=admin_context)
124 res = req.get_response(self.ext_api)
125 self.assertEqual(expected_code, res.status_int)
126
127
128 class VPNAgentSchedulerTestCaseBase(test_vpn_db.VPNTestMixin,
129 test_l3.L3NatTestCaseMixin,
130 VPNAgentSchedulerTestMixIn,
131 test_plugin.NeutronDbPluginV2TestCase):
132 fmt = 'json'
133
134 def setUp(self):
135 # NOTE(ivasilevskaya) mocking this way allows some control over mocked
136 # client like further method mocking with asserting calls
137 self.client_mock = mock.MagicMock(name="mocked client")
138 mock.patch.object(
139 n_rpc, 'get_client').start().return_value = self.client_mock
140
141 service_plugins = {
142 'vpnaas_plugin': 'neutron_vpnaas.services.vpn.ovn_plugin.'
143 'VPNOVNPlugin'}
144 plugin_str = 'neutron.tests.unit.extensions.test_l3.TestL3NatIntPlugin'
145 super().setUp(plugin_str, service_plugins=service_plugins)
146
147 ext_mgr = extensions.PluginAwareExtensionManager.get_instance()
148 self.ext_api = test_extensions.setup_extensions_middleware(ext_mgr)
149 self.adminContext = context.get_admin_context()
150
151 self.core_plugin = directory.get_plugin()
152 self.core_plugin.get_agents = \
153 mock.MagicMock(side_effect=self._get_agents)
154 self.core_plugin.get_agent = \
155 mock.MagicMock(side_effect=self._get_agent)
156 self._agents = {}
157 self._vpn_agents_by_host = {}
158
159 self.service_plugin = directory.get_plugin(plugin_constants.VPN)
160 policy.init()
161
162 def _get_agents(self, context, filters=None):
163 if not filters:
164 return self._agents.values()
165
166 agents = []
167 for agent in self._agents.values():
168 for key, values in filters.items():
169 if agent[key] not in values:
170 break
171 else:
172 agents.append(agent)
173 return agents
174
175 def _get_agent(self, context, agent_id):
176 try:
177 return self._agents[agent_id]
178 except KeyError:
179 raise n_exc.agent.AgentNotFound(id=agent_id)
180
181 def _get_any_metadata_agent_id(self):
182 for agent in self._agents.values():
183 if agent['agent_type'] == ovn_constants.OVN_METADATA_AGENT:
184 return agent['id']
185
186 def _take_down_vpn_agent(self, host):
187 self._vpn_agents_by_host[host]['alive'] = False
188
189 def _get_another_agent_host(self, host):
190 for agent in self._vpn_agents_by_host.values():
191 if agent['host'] != host:
192 return agent['host']
193
194 def _register_agent_states(self):
195 self._register_vpn_agent(host=VPN_HOSTA)
196 self._register_vpn_agent(host=VPN_HOSTB)
197 self._register_metadata_agent(host=VPN_HOSTA)
198 self._register_metadata_agent(host=VPN_HOSTB)
199
200 def _register_vpn_agent(self, host=None):
201 agent = {
202 'id': uuidutils.generate_uuid(),
203 'binary': "neutron-ovn-vpn-agent",
204 'host': host,
205 'availability_zone': helpers.DEFAULT_AZ,
206 'topic': 'n/a',
207 'configurations': {},
208 'start_flag': True,
209 'agent_type': constants.AGENT_TYPE_VPN,
210 'alive': True,
211 'admin_state_up': True}
212 self._agents[agent['id']] = agent
213 self._vpn_agents_by_host[host] = agent
214
215 def _register_metadata_agent(self, host=None):
216 agent = {
217 'id': uuidutils.generate_uuid(),
218 'binary': "neutron-ovn-metadata-agent",
219 'host': host,
220 'availability_zone': helpers.DEFAULT_AZ,
221 'topic': 'n/a',
222 'configurations': {},
223 'start_flag': True,
224 'agent_type': ovn_constants.OVN_METADATA_AGENT,
225 'alive': True,
226 'admin_state_up': True}
227 self._agents[agent['id']] = agent
228
229
230 class VPNAgentSchedulerTestCase(VPNAgentSchedulerTestCaseBase):
231 def _take_down_agent_and_run_reschedule(self, host):
232 self._take_down_vpn_agent(host)
233 plugin = directory.get_plugin(plugin_constants.VPN)
234 plugin.reschedule_vpnservices_from_down_agents()
235
236 def _get_agent_host_by_router(self, router_id):
237 agents = self._list_vpn_agents_hosting_router(router_id)
238 return agents['agents'][0]['host']
239
240 def test_schedule_router(self):
241 self._register_agent_states()
242 with self.router() as router:
243 router_id = router['router']['id']
244 self.service_plugin.schedule_router(self.adminContext, router_id)
245 host = self._get_agent_host_by_router(router_id)
246
247 self.assertIn(host, (VPN_HOSTA, VPN_HOSTB))
248
249 def test_router_rescheduler_catches_rpc_db_and_reschedule_exceptions(self):
250 self._register_agent_states()
251 agent_a_id = self._vpn_agents_by_host[VPN_HOSTA]['id']
252
253 with self.router() as router:
254 router_id = router['router']['id']
255 self._add_router_to_vpn_agent(agent_a_id, router_id)
256 mock.patch.object(
257 self.service_plugin, 'reschedule_router',
258 side_effect=[
259 db_exc.DBError(), oslo_messaging.RemoteError(),
260 vpn_agentschedulers.RouterReschedulingFailed(
261 router_id='f'),
262 ValueError('this raises'),
263 Exception()
264 ]).start()
265 self._take_down_agent_and_run_reschedule(VPN_HOSTA) # DBError
266 self._take_down_agent_and_run_reschedule(VPN_HOSTA) # RemoteError
267 self._take_down_agent_and_run_reschedule(VPN_HOSTA) # schedule err
268 self._take_down_agent_and_run_reschedule(VPN_HOSTA) # Value error
269 self._take_down_agent_and_run_reschedule(VPN_HOSTA) # Exception
270
271 def test_router_rescheduler_catches_exceptions_on_fetching_bindings(self):
272 with mock.patch('neutron_lib.context.get_admin_context') as get_ctx:
273 mock_ctx = mock.Mock()
274 get_ctx.return_value = mock_ctx
275 mock_ctx.session.query.side_effect = db_exc.DBError()
276
277 # check that no exception is raised
278 self.service_plugin.reschedule_vpnservices_from_down_agents()
279
280 def test_router_rescheduler_iterates_after_reschedule_failure(self):
281 self._register_agent_states()
282 agent_a = self.service_plugin.get_vpn_agent_on_host(
283 self.adminContext, VPN_HOSTA)
284
285 with self.vpnservice() as s1, self.vpnservice() as s2:
286 # schedule the services to agent A
287 self.service_plugin.auto_schedule_routers(
288 self.adminContext, agent_a)
289
290 rs_mock = mock.patch.object(
291 self.service_plugin, 'reschedule_router',
292 side_effect=vpn_agentschedulers.RouterReschedulingFailed(
293 router_id='f'),
294 ).start()
295 self._take_down_agent_and_run_reschedule(VPN_HOSTA)
296 # make sure both had a reschedule attempt even though first failed
297 router_id_1 = s1['vpnservice']['router_id']
298 router_id_2 = s2['vpnservice']['router_id']
299 rs_mock.assert_has_calls(
300 [mock.call(mock.ANY, router_id_1, agent_a),
301 mock.call(mock.ANY, router_id_2, agent_a)],
302 any_order=True)
303
304 def test_router_is_not_rescheduled_from_alive_agent(self):
305 self._register_agent_states()
306 agent_a_id = self._vpn_agents_by_host[VPN_HOSTA]['id']
307
308 with self.router() as router:
309 router_id = router['router']['id']
310 self._add_router_to_vpn_agent(agent_a_id, router_id)
311
312 patch_func_str = ('neutron_vpnaas.db.vpn.vpn_agentschedulers_db.'
313 'VPNAgentSchedulerDbMixin.reschedule_router')
314 with mock.patch(patch_func_str) as rr:
315 # take down the unrelated agent and run reschedule check
316 self._take_down_agent_and_run_reschedule(VPN_HOSTB)
317 self.assertFalse(rr.called)
318
319 def test_router_reschedule_from_dead_agent(self):
320 self._register_agent_states()
321 agent_a_id = self._vpn_agents_by_host[VPN_HOSTA]['id']
322
323 with self.router() as router:
324 router_id = router['router']['id']
325 self._add_router_to_vpn_agent(agent_a_id, router_id)
326 host_before = self._get_agent_host_by_router(router_id)
327
328 self._take_down_agent_and_run_reschedule(VPN_HOSTA)
329 host_after = self._get_agent_host_by_router(router_id)
330
331 self.assertEqual(VPN_HOSTA, host_before)
332 self.assertEqual(VPN_HOSTB, host_after)
333
334 def test_router_reschedule_with_write_db_wrap(self):
335 self._register_agent_states()
336 agent_a = self.service_plugin.get_vpn_agent_on_host(
337 self.adminContext, VPN_HOSTA)
338
339 with self.vpnservice() as service:
340 # schedule the vpn routers to agent A
341 with db_api.CONTEXT_WRITER.using(self.adminContext):
342 self.service_plugin.auto_schedule_routers(
343 self.adminContext, agent_a)
344 ctxt_mock = mock.MagicMock()
345 call_mock = mock.MagicMock(
346 side_effect=[oslo_messaging.MessagingTimeout, None])
347 ctxt_mock.call = call_mock
348 self.client_mock.prepare = mock.MagicMock(return_value=ctxt_mock)
349 self._take_down_agent_and_run_reschedule(VPN_HOSTA)
350 self.assertEqual(2, call_mock.call_count)
351 # make sure vpn service was rescheduled even when first attempt
352 # failed to notify VPN agent
353 router_id = service['vpnservice']['router_id']
354 host = self._get_agent_host_by_router(router_id)
355
356 vpn_agents = self._list_vpn_agents_hosting_router(router_id)
357 self.assertEqual(1, len(vpn_agents['agents']))
358 self.assertEqual(VPN_HOSTB, host)
359
360 def test_router_reschedule_with_read_db_wrap(self):
361 self._register_agent_states()
362 agent_a = self.service_plugin.get_vpn_agent_on_host(
363 self.adminContext, VPN_HOSTA)
364
365 with self.vpnservice():
366 # schedule the vpn routers to agent A
367 with db_api.CONTEXT_READER.using(self.adminContext):
368 self.assertRaises(
369 TypeError,
370 self.service_plugin.auto_schedule_routers,
371 self.adminContext,
372 agent_a)
373
374 def test_router_reschedule_succeeded_after_failed_notification(self):
375 self._register_agent_states()
376 agent_a = self.service_plugin.get_vpn_agent_on_host(
377 self.adminContext, VPN_HOSTA)
378
379 with self.vpnservice() as service:
380 # schedule the vpn routers to agent A
381 self.service_plugin.auto_schedule_routers(
382 self.adminContext, agent_a)
383 ctxt_mock = mock.MagicMock()
384 call_mock = mock.MagicMock(
385 side_effect=[oslo_messaging.MessagingTimeout, None])
386 ctxt_mock.call = call_mock
387 self.client_mock.prepare = mock.MagicMock(return_value=ctxt_mock)
388 self._take_down_agent_and_run_reschedule(VPN_HOSTA)
389 self.assertEqual(2, call_mock.call_count)
390 # make sure vpn service was rescheduled even when first attempt
391 # failed to notify VPN agent
392 router_id = service['vpnservice']['router_id']
393 host = self._get_agent_host_by_router(router_id)
394
395 vpn_agents = self._list_vpn_agents_hosting_router(router_id)
396 self.assertEqual(1, len(vpn_agents['agents']))
397 self.assertEqual(VPN_HOSTB, host)
398
399 def test_router_reschedule_failed_notification_all_attempts(self):
400 self._register_agent_states()
401 agent_a = self.service_plugin.get_vpn_agent_on_host(
402 self.adminContext, VPN_HOSTA)
403
404 with self.vpnservice() as vpnservice:
405 # schedule the vpn routers to agent A
406 self.service_plugin.auto_schedule_routers(
407 self.adminContext, agent_a)
408 # mock client.prepare and context.call
409 ctxt_mock = mock.MagicMock()
410 call_mock = mock.MagicMock(
411 side_effect=oslo_messaging.MessagingTimeout)
412 ctxt_mock.call = call_mock
413 self.client_mock.prepare = mock.MagicMock(return_value=ctxt_mock)
414 # perform operations
415 self._take_down_agent_and_run_reschedule(VPN_HOSTA)
416 self.assertEqual(
417 vpn_rpc_agent_api.AGENT_NOTIFY_MAX_ATTEMPTS,
418 call_mock.call_count)
419 router_id = vpnservice['vpnservice']['router_id']
420 vpn_agents = self._list_vpn_agents_hosting_router(router_id)
421 self.assertEqual(0, len(vpn_agents['agents']))
422
423 def test_router_auto_schedule_with_hosted(self):
424 self._register_agent_states()
425 agent_a = self.service_plugin.get_vpn_agent_on_host(
426 self.adminContext, VPN_HOSTA)
427 agent_b = self.service_plugin.get_vpn_agent_on_host(
428 self.adminContext, VPN_HOSTB)
429
430 with self.vpnservice() as vpnservice:
431 self._register_agent_states()
432 ret_a = self.service_plugin.auto_schedule_routers(
433 self.adminContext, agent_a)
434 ret_b = self.service_plugin.auto_schedule_routers(
435 self.adminContext, agent_b)
436 router_id = vpnservice['vpnservice']['router_id']
437 vpn_agents = self._list_vpn_agents_hosting_router(router_id)
438 host = self._get_agent_host_by_router(router_id)
439 self.assertTrue(len(ret_a))
440 self.assertIn(router_id, ret_a)
441 self.assertFalse(len(ret_b))
442 self.assertEqual(1, len(vpn_agents['agents']))
443 self.assertEqual(VPN_HOSTA, host)
444
445 def test_add_router_to_vpn_agent(self):
446 self._register_agent_states()
447 agent_a = self.service_plugin.get_vpn_agent_on_host(
448 self.adminContext, VPN_HOSTA)
449 agent_a_id = agent_a['id']
450 agent_b = self.service_plugin.get_vpn_agent_on_host(
451 self.adminContext, VPN_HOSTB)
452 agent_b_id = agent_b['id']
453
454 with self.router() as router:
455 router_id = router['router']['id']
456 num_before_add = len(
457 self._list_routers_hosted_by_vpn_agent(
458 agent_a_id)['routers'])
459 self._add_router_to_vpn_agent(agent_a_id, router_id)
460 # add router again to same agent is fine
461 self._add_router_to_vpn_agent(agent_a_id, router_id)
462 # add router to a second agent is a conflict
463 self._add_router_to_vpn_agent(agent_b_id, router_id,
464 expected_code=exc.HTTPConflict.code)
465 num_after_add = len(
466 self._list_routers_hosted_by_vpn_agent(
467 agent_a_id)['routers'])
468 self.assertEqual(0, num_before_add)
469 self.assertEqual(1, num_after_add)
470
471 def test_add_router_to_vpn_agent_wrong_type(self):
472 self._register_agent_states()
473 agent_id = self._get_any_metadata_agent_id()
474
475 with self.router() as router:
476 router_id = router['router']['id']
477 # add_router_to_vpn_agent with a metadata agent id shall fail
478 self._add_router_to_vpn_agent(
479 agent_id, router_id,
480 expected_code=exc.HTTPNotFound.code)
481
482 def _test_add_router_to_vpn_agent_db_error(self, exception):
483 self._register_agent_states()
484 agent_id = self._vpn_agents_by_host[VPN_HOSTA]['id']
485
486 with self.router() as router, \
487 mock.patch.object(orm.Session, 'add', side_effect=exception):
488 router_id = router['router']['id']
489
490 self._add_router_to_vpn_agent(
491 agent_id, router_id,
492 expected_code=exc.HTTPConflict.code)
493
494 def test_add_router_to_vpn_agent_duplicate(self):
495 self._test_add_router_to_vpn_agent_db_error(db_exc.DBDuplicateEntry)
496
497 def test_add_router_to_vpn_agent_reference_error(self):
498 self._test_add_router_to_vpn_agent_db_error(
499 db_exc.DBReferenceError('', '', '', ''))
500
501 def test_add_router_to_vpn_agent_db_error(self):
502 self._test_add_router_to_vpn_agent_db_error(db_exc.DBError)
503
504 def test_list_routers_hosted_by_vpn_agent_with_invalid_agent(self):
505 invalid_agentid = 'non_existing_agent'
506 self._list_routers_hosted_by_vpn_agent(invalid_agentid,
507 exc.HTTPNotFound.code)
508
509 def test_remove_router_from_vpn_agent(self):
510 self._register_agent_states()
511 agent_id = self._vpn_agents_by_host[VPN_HOSTA]['id']
512
513 with self.router() as router:
514 router_id = router['router']['id']
515
516 self._add_router_to_vpn_agent(agent_id, router_id)
517 routers = self._list_routers_hosted_by_vpn_agent(agent_id)
518 num_before = len(routers['routers'])
519
520 self._remove_router_from_vpn_agent(agent_id, router_id)
521 routers = self._list_routers_hosted_by_vpn_agent(agent_id)
522 num_after = len(routers['routers'])
523
524 self.assertEqual(1, num_before)
525 self.assertEqual(0, num_after)
526
527 def test_remove_router_from_vpn_agent_wrong_agent(self):
528 self._register_agent_states()
529 agent_a_id = self._vpn_agents_by_host[VPN_HOSTA]['id']
530 agent_b_id = self._vpn_agents_by_host[VPN_HOSTB]['id']
531
532 with self.router() as router:
533 router_id = router['router']['id']
534
535 self._add_router_to_vpn_agent(agent_a_id, router_id)
536 routers = self._list_routers_hosted_by_vpn_agent(agent_a_id)
537 num_before = len(routers['routers'])
538
539 # try to remove router from wrong agent is not an error
540 self._remove_router_from_vpn_agent(agent_b_id, router_id)
541 routers = self._list_routers_hosted_by_vpn_agent(agent_a_id)
542 num_after = len(routers['routers'])
543
544 self.assertEqual(1, num_before)
545 self.assertEqual(1, num_after)
546
547 def test_remove_router_from_vpn_agent_unknown_agent(self):
548 self._register_agent_states()
549 agent_a_id = self._vpn_agents_by_host[VPN_HOSTA]['id']
550
551 with self.router() as router:
552 router_id = router['router']['id']
553
554 self._add_router_to_vpn_agent(agent_a_id, router_id)
555 routers = self._list_routers_hosted_by_vpn_agent(agent_a_id)
556 num_before = len(routers['routers'])
557
558 # try to remove router from unknown agent is an error
559 self._remove_router_from_vpn_agent(
560 'unknown-agent', router_id,
561 expected_code=exc.HTTPNotFound.code)
562 routers = self._list_routers_hosted_by_vpn_agent(agent_a_id)
563 num_after = len(routers['routers'])
564
565 self.assertEqual(1, num_before)
566 self.assertEqual(1, num_after)