Coverage for manila/tests/share/drivers/test_service_instance.py: 99%
1317 statements
« prev ^ index » next coverage.py v7.11.0, created at 2026-02-18 22:19 +0000
1# Copyright (c) 2014 NetApp, Inc.
2# Copyright (c) 2015 Mirantis, Inc.
3# All Rights Reserved.
4#
5# Licensed under the Apache License, Version 2.0 (the "License"); you may
6# not use this file except in compliance with the License. You may obtain
7# a copy of the License at
8#
9# http://www.apache.org/licenses/LICENSE-2.0
10#
11# Unless required by applicable law or agreed to in writing, software
12# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
13# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
14# License for the specific language governing permissions and limitations
15# under the License.
17"""Unit tests for the instance module."""
19import os
20import time
21from unittest import mock
23import ddt
24import netaddr
25from oslo_config import cfg
26from oslo_utils import importutils
28from manila import exception
29from manila.share import configuration
30from manila.share import driver # noqa
31from manila.share.drivers import service_instance
32from manila import test
33from manila.tests import fake_compute
34from manila.tests import fake_image
35from manila.tests import fake_network
36from manila.tests import utils as test_utils
38CONF = cfg.CONF
41def fake_get_config_option(key):
42 if key == 'driver_handles_share_servers':
43 return True
44 if key == 'service_instance_boot_from_volume':
45 return False
46 elif key == 'service_instance_password':
47 return None
48 elif key == 'service_instance_user':
49 return 'fake_user'
50 elif key == 'service_instance_flavor_id':
51 return '100'
52 elif key == 'service_instance_name_template':
53 return 'fake_manila_service_instance_%s'
54 elif key == 'service_image_name':
55 return 'fake_service_image_name'
56 elif key == 'manila_service_keypair_name':
57 return 'fake_manila_service_keypair_name'
58 elif key == 'path_to_private_key':
59 return 'fake_path_to_private_key'
60 elif key == 'path_to_public_key':
61 return 'fake_path_to_public_key'
62 elif key == 'max_time_to_build_instance':
63 return 500
64 elif key == 'connect_share_server_to_tenant_network':
65 return False
66 elif key == 'service_network_cidr':
67 return '99.254.0.0/24'
68 elif key == 'service_network_division_mask':
69 return 27
70 elif key == 'service_network_host':
71 return 'fake_service_network_host'
72 elif key == 'service_network_name':
73 return 'fake_service_network_name'
74 elif key == 'interface_driver':
75 return 'i.am.fake.VifDriver'
76 elif key == 'admin_network_id':
77 return None
78 elif key == 'admin_subnet_id':
79 return None
80 elif key == 'backend_availability_zone': 80 ↛ 83line 80 didn't jump to line 83 because the condition on line 80 was always true
81 return None
82 else:
83 return mock.Mock()
86class FakeServiceInstance(object):
88 def __init__(self, driver_config=None):
89 super(FakeServiceInstance, self).__init__()
90 self.compute_api = service_instance.compute.API()
91 self.volume_api = service_instance.volume.API()
92 self.admin_context = service_instance.context.get_admin_context()
93 self.driver_config = driver_config
95 def get_config_option(self, key):
96 return fake_get_config_option(key)
99class FakeNetworkHelper(service_instance.BaseNetworkhelper):
101 @property
102 def NAME(self):
103 return service_instance.NEUTRON_NAME
105 @property
106 def neutron_api(self):
107 if not hasattr(self, '_neutron_api'):
108 self._neutron_api = mock.Mock()
109 return self._neutron_api
111 def __init__(self, service_instance_manager):
112 self.get_config_option = service_instance_manager.get_config_option
114 def get_network_name(self, network_info):
115 """Return name of network."""
116 return 'fake_network_name'
118 def setup_connectivity_with_service_instances(self):
119 """Nothing to do in fake network helper."""
121 def setup_network(self, network_info):
122 """Combine fake network data."""
123 return dict()
125 def teardown_network(self, server_details):
126 """Nothing to do in fake network helper."""
129@ddt.ddt
130class ServiceInstanceManagerTestCase(test.TestCase):
131 """Test suite for service instance manager."""
133 def setUp(self):
134 super(ServiceInstanceManagerTestCase, self).setUp()
135 self.instance_id = 'fake_instance_id'
136 self.config = configuration.Configuration(None)
137 self.config.safe_get = mock.Mock(side_effect=fake_get_config_option)
138 self.mock_object(service_instance.compute, 'API', fake_compute.API)
139 self.mock_object(
140 service_instance.os.path, 'exists', mock.Mock(return_value=True))
141 self.mock_object(service_instance, 'NeutronNetworkHelper',
142 mock.Mock(side_effect=FakeNetworkHelper))
143 self._manager = service_instance.ServiceInstanceManager(self.config)
144 self._manager._load_public_key = mock.Mock(return_value='')
145 self.mock_object(time, 'sleep')
147 def test_get_config_option_from_driver_config(self):
148 username1 = 'fake_username_1_%s' % self.id()
149 username2 = 'fake_username_2_%s' % self.id()
150 config_data = dict(
151 DEFAULT=dict(service_instance_user=username1),
152 CUSTOM=dict(service_instance_user=username2))
153 with test_utils.create_temp_config_with_opts(config_data):
154 self.config = configuration.Configuration(
155 service_instance.common_opts, config_group='CUSTOM')
156 self._manager = service_instance.ServiceInstanceManager(
157 self.config)
158 result = self._manager.get_config_option('service_instance_user')
159 self.assertEqual(username2, result)
161 def test_get_config_option_from_common_config(self):
162 username = 'fake_username_%s' % self.id()
163 config_data = dict(DEFAULT=dict(service_instance_user=username))
164 with test_utils.create_temp_config_with_opts(config_data):
165 self._manager = service_instance.ServiceInstanceManager()
166 result = self._manager.get_config_option('service_instance_user')
167 self.assertEqual(username, result)
169 def test_get_neutron_network_helper(self):
170 # Mock it again, because it was called in setUp method.
171 self.mock_object(service_instance, 'NeutronNetworkHelper')
172 config_data = dict(DEFAULT=dict(service_instance_user='fake_username',
173 driver_handles_share_servers=True))
175 with test_utils.create_temp_config_with_opts(config_data):
176 self._manager = service_instance.ServiceInstanceManager()
177 self._manager.network_helper
178 service_instance.NeutronNetworkHelper.assert_called_once_with(
179 self._manager)
181 def test_init_with_driver_config_and_handling_of_share_servers(self):
182 self.mock_object(service_instance, 'NeutronNetworkHelper')
183 config_data = dict(CUSTOM=dict(
184 driver_handles_share_servers=True,
185 service_instance_user='fake_user'))
186 opts = service_instance.common_opts + driver.share_opts
187 with test_utils.create_temp_config_with_opts(config_data):
188 self.config = configuration.Configuration(opts, 'CUSTOM')
189 self._manager = service_instance.ServiceInstanceManager(
190 self.config)
191 self.assertTrue(
192 self._manager.get_config_option("driver_handles_share_servers"))
193 self.assertIsNotNone(self._manager.driver_config)
194 self.assertTrue(hasattr(self._manager, 'network_helper'))
195 self.assertTrue(service_instance.NeutronNetworkHelper.called)
197 def test_init_with_driver_config_and_wo_handling_of_share_servers(self):
198 self.mock_object(service_instance, 'NeutronNetworkHelper')
199 config_data = dict(CUSTOM=dict(
200 driver_handles_share_servers=False,
201 service_instance_user='fake_user'))
202 opts = service_instance.common_opts + driver.share_opts
203 with test_utils.create_temp_config_with_opts(config_data):
204 self.config = configuration.Configuration(opts, 'CUSTOM')
205 self._manager = service_instance.ServiceInstanceManager(
206 self.config)
207 self.assertIsNotNone(self._manager.driver_config)
208 self.assertFalse(hasattr(self._manager, 'network_helper'))
209 self.assertFalse(service_instance.NeutronNetworkHelper.called)
211 def test_init_with_common_config_and_handling_of_share_servers(self):
212 self.mock_object(service_instance, 'NeutronNetworkHelper')
213 config_data = dict(DEFAULT=dict(
214 service_instance_user='fake_username',
215 driver_handles_share_servers=True))
216 with test_utils.create_temp_config_with_opts(config_data):
217 self._manager = service_instance.ServiceInstanceManager()
218 self.assertTrue(
219 self._manager.get_config_option("driver_handles_share_servers"))
220 self.assertIsNone(self._manager.driver_config)
221 self.assertTrue(hasattr(self._manager, 'network_helper'))
222 self.assertTrue(service_instance.NeutronNetworkHelper.called)
224 def test_init_with_common_config_and_wo_handling_of_share_servers(self):
225 self.mock_object(service_instance, 'NeutronNetworkHelper')
226 config_data = dict(DEFAULT=dict(
227 service_instance_user='fake_username',
228 driver_handles_share_servers=False))
229 with test_utils.create_temp_config_with_opts(config_data):
230 self._manager = service_instance.ServiceInstanceManager()
231 self.assertEqual(
232 False,
233 self._manager.get_config_option("driver_handles_share_servers"))
234 self.assertIsNone(self._manager.driver_config)
235 self.assertFalse(hasattr(self._manager, 'network_helper'))
236 self.assertFalse(service_instance.NeutronNetworkHelper.called)
238 def test_no_service_user_defined(self):
239 group_name = 'GROUP_%s' % self.id()
240 config_data = {group_name: dict()}
241 with test_utils.create_temp_config_with_opts(config_data):
242 config = configuration.Configuration(
243 service_instance.common_opts, config_group=group_name)
244 self.assertRaises(
245 exception.ServiceInstanceException,
246 service_instance.ServiceInstanceManager, config)
248 def test_get_service_instance_name_using_driver_config(self):
249 fake_server_id = 'fake_share_server_id_%s' % self.id()
250 self.mock_object(service_instance, 'NeutronNetworkHelper')
251 config_data = dict(CUSTOM=dict(
252 driver_handles_share_servers=True,
253 service_instance_user='fake_user'))
254 opts = service_instance.common_opts + driver.share_opts
255 with test_utils.create_temp_config_with_opts(config_data):
256 self.config = configuration.Configuration(opts, 'CUSTOM')
257 self._manager = service_instance.ServiceInstanceManager(
258 self.config)
259 result = self._manager._get_service_instance_name(fake_server_id)
260 self.assertIsNotNone(self._manager.driver_config)
261 self.assertEqual(
262 self._manager.get_config_option(
263 "service_instance_name_template") % "%s_%s" % (
264 self._manager.driver_config.config_group, fake_server_id),
265 result)
266 self.assertTrue(
267 self._manager.get_config_option("driver_handles_share_servers"))
268 self.assertTrue(hasattr(self._manager, 'network_helper'))
269 self.assertTrue(service_instance.NeutronNetworkHelper.called)
271 def test_get_service_instance_name_using_default_config(self):
272 fake_server_id = 'fake_share_server_id_%s' % self.id()
273 config_data = dict(CUSTOM=dict(
274 service_instance_user='fake_user'))
275 with test_utils.create_temp_config_with_opts(config_data):
276 self._manager = service_instance.ServiceInstanceManager()
277 result = self._manager._get_service_instance_name(fake_server_id)
278 self.assertIsNone(self._manager.driver_config)
279 self.assertEqual(
280 self._manager.get_config_option(
281 "service_instance_name_template") % fake_server_id, result)
283 def test__check_server_availability_available_from_start(self):
284 fake_server = dict(
285 id='fake_server', ip='127.0.0.1',
286 username="manila", password="manila"
287 )
288 self.mock_object(service_instance.ssh_utils.SSHPool, 'create')
289 self.mock_object(service_instance.time, 'sleep')
290 self.mock_object(service_instance.time, 'time',
291 mock.Mock(return_value=0))
293 result = self._manager._check_server_availability(fake_server)
295 self.assertTrue(result)
296 service_instance.ssh_utils.SSHPool.create.assert_called_once_with(
297 quiet=True)
298 service_instance.time.time.assert_has_calls([
299 mock.call(), mock.call()])
300 service_instance.time.time.assert_has_calls([])
302 @ddt.data(True, False)
303 def test__check_server_availability_with_recall(self, is_ok):
304 fake_server = dict(
305 id='fake_server', ip='127.0.0.1',
306 username="manila", password="manila"
307 )
309 self.fake_time = 0
311 def fake_create(quiet=False):
312 if not (is_ok and self.fake_time > 1):
313 raise exception.SSHException
315 def fake_time():
316 return self.fake_time
318 def fake_sleep(time):
319 self.fake_time += 5
321 self.mock_object(service_instance.time, 'sleep',
322 mock.Mock(side_effect=fake_sleep))
323 self.mock_object(service_instance.ssh_utils.SSHPool, 'create',
324 mock.Mock(side_effect=fake_create))
325 self.mock_object(service_instance.time, 'time',
326 mock.Mock(side_effect=fake_time))
327 self._manager.max_time_to_build_instance = 6
329 result = self._manager._check_server_availability(fake_server)
331 if is_ok:
332 self.assertTrue(result)
333 else:
334 self.assertFalse(result)
335 service_instance.ssh_utils.SSHPool.create.assert_has_calls([
336 mock.call(quiet=True), mock.call(quiet=True)])
337 service_instance.time.time.assert_has_calls([
338 mock.call(), mock.call(), mock.call()])
339 service_instance.time.time.assert_has_calls([mock.call()])
341 def test_get_server_ip_found_in_networks_section(self):
342 ip = '10.0.0.1'
343 net_name = self._manager.get_config_option('service_network_name')
344 fake_server = dict(networks={net_name: [ip]})
345 result = self._manager._get_server_ip(fake_server, net_name)
346 self.assertEqual(ip, result)
348 def test_get_server_ip_found_in_addresses_section(self):
349 ip = '10.0.0.1'
350 net_name = self._manager.get_config_option('service_network_name')
351 fake_server = dict(addresses={net_name: [dict(addr=ip, version=4)]})
352 result = self._manager._get_server_ip(fake_server, net_name)
353 self.assertEqual(ip, result)
355 @ddt.data(
356 {},
357 {'networks': {fake_get_config_option('service_network_name'): []}},
358 {'addresses': {fake_get_config_option('service_network_name'): []}})
359 def test_get_server_ip_not_found(self, data):
360 self.assertRaises(
361 exception.ManilaException,
362 self._manager._get_server_ip, data,
363 fake_get_config_option('service_network_name'))
365 def test_security_group_name_not_specified(self):
366 self.mock_object(self._manager, 'get_config_option',
367 mock.Mock(return_value=None))
368 result = self._manager._get_or_create_security_groups(
369 self._manager.admin_context)
370 self.assertIsNone(result)
371 self._manager.get_config_option.assert_called_once_with(
372 'service_instance_security_group')
374 def test_security_group_name_from_config_and_sg_exist(self):
375 name = "fake_sg_name_from_config"
376 desc = "fake_sg_description"
377 fake_secgroup = {'id': 'fake_sg_id', 'name': name, 'description': desc}
378 self.mock_object(self._manager, 'get_config_option',
379 mock.Mock(return_value=name))
380 neutron_api = self._manager.network_helper.neutron_api
381 neutron_api.security_group_list.return_value = {
382 'security_groups': [fake_secgroup]}
384 result = self._manager._get_or_create_security_groups(
385 self._manager.admin_context)
387 self.assertEqual([fake_secgroup, ], result)
388 self._manager.get_config_option.assert_called_once_with(
389 'service_instance_security_group')
390 neutron_api.security_group_list.assert_called_once_with({"name": name})
392 @ddt.data(None, 'fake_name')
393 def test_security_group_creation_with_name_from_config(self, name):
394 config_name = "fake_sg_name_from_config"
395 desc = "fake_sg_description"
396 fake_secgroup = {'id': 'fake_sg_id', 'name': name, 'description': desc}
397 self.mock_object(self._manager, 'get_config_option',
398 mock.Mock(return_value=name or config_name))
399 neutron_api = self._manager.network_helper.neutron_api
400 neutron_api.security_group_list.return_value = {'security_groups': []}
401 neutron_api.security_group_create.return_value = {
402 'security_group': fake_secgroup,
403 }
405 result = self._manager._get_or_create_security_groups(
406 context=self._manager.admin_context,
407 name=name,
408 description=desc,
409 )
411 self.assertEqual([fake_secgroup, ], result)
412 if not name:
413 self._manager.get_config_option.assert_called_once_with(
414 'service_instance_security_group')
415 neutron_api.security_group_list.assert_called_once_with(
416 {"name": name or config_name})
417 neutron_api.security_group_create.assert_called_once_with(
418 name or config_name, desc)
420 @ddt.data(None, 'fake_name')
421 def test_security_group_creation_with_name_from_conf_allow_ssh(self, name):
422 def fake_secgroup(*args, **kwargs):
423 return {'security_group': {'id': 'fake_sg_id', 'name': args[0],
424 'description': args[1]}}
426 config_name = "fake_sg_name_from_config"
427 desc = "fake_sg_description"
428 self.mock_object(self._manager, 'get_config_option',
429 mock.Mock(return_value=name or config_name))
430 neutron_api = self._manager.network_helper.neutron_api
431 neutron_api.security_group_list.return_value = {'security_groups': []}
432 self.mock_object(neutron_api, 'security_group_create',
433 mock.Mock(side_effect=fake_secgroup))
434 fake_ssh_allow_subnet = dict(cidr="10.254.0.1/24",
435 id='allow_subnet_id')
436 ssh_sg_name = 'manila-service-subnet-{}'.format(
437 fake_ssh_allow_subnet['id'])
439 result = self._manager._get_or_create_security_groups(
440 context=self._manager.admin_context,
441 name=name,
442 description=desc,
443 allow_ssh_subnet=fake_ssh_allow_subnet
444 )
446 self.assertEqual([fake_secgroup(name if name else config_name,
447 desc)['security_group'],
448 fake_secgroup(ssh_sg_name, desc)['security_group']],
449 result)
450 if not name:
451 self._manager.get_config_option.assert_called_with(
452 'service_instance_security_group')
453 neutron_api.security_group_list.assert_has_calls([
454 mock.call({"name": name or config_name}),
455 mock.call({"name": ssh_sg_name})])
456 neutron_api.security_group_create.assert_has_calls([
457 mock.call(name or config_name, desc),
458 mock.call(ssh_sg_name, desc)])
460 def test_security_group_limit_ssh_invalid_subnet(self):
461 def fake_secgroup(*args, **kwargs):
462 return {'security_group': {'id': 'fake_sg_id', 'name': args[0],
463 'description': args[1]}}
465 config_name = "fake_sg_name_from_config"
466 desc = "fake_sg_description"
467 self.mock_object(self._manager, 'get_config_option',
468 mock.Mock(config_name))
469 neutron_api = self._manager.network_helper.neutron_api
470 neutron_api.security_group_list.return_value = {'security_groups': []}
471 self.mock_object(neutron_api, 'security_group_create',
472 mock.Mock(side_effect=fake_secgroup))
473 fake_ssh_allow_subnet = dict(id='allow_subnet_id')
474 self.assertRaises(exception.ManilaException,
475 self._manager._get_or_create_security_groups,
476 context=self._manager.admin_context,
477 name=None,
478 description=desc,
479 allow_ssh_subnet=fake_ssh_allow_subnet)
481 def test_security_group_two_sg_in_list(self):
482 name = "fake_name"
483 fake_secgroup1 = {'id': 'fake_sg_id1', 'name': name}
484 fake_secgroup2 = {'id': 'fake_sg_id2', 'name': name}
485 neutron_api = self._manager.network_helper.neutron_api
486 neutron_api.security_group_list.return_value = {
487 'security_groups': [fake_secgroup1, fake_secgroup2]}
489 self.assertRaises(exception.ServiceInstanceException,
490 self._manager._get_or_create_security_groups,
491 self._manager.admin_context,
492 name)
494 neutron_api.security_group_list.assert_called_once_with(
495 {"name": name})
497 @ddt.data(
498 dict(),
499 dict(service_port_id='fake_service_port_id'),
500 dict(public_port_id='fake_public_port_id'),
501 dict(service_port_id='fake_service_port_id',
502 public_port_id='fake_public_port_id'),
503 )
504 def test_set_up_service_instance(self, update_data):
505 fake_network_info = {'foo': 'bar', 'server_id': 'fake_server_id'}
506 fake_server = {
507 'id': 'fake', 'ip': '1.2.3.4', 'public_address': '1.2.3.4',
508 'pk_path': None, 'subnet_id': 'fake-subnet-id',
509 'router_id': 'fake-router-id',
510 'username': self._manager.get_config_option(
511 'service_instance_user'),
512 'admin_ip': 'admin_ip'}
513 fake_server.update(update_data)
514 expected_details = fake_server.copy()
515 expected_details.pop('pk_path')
516 expected_details['instance_id'] = expected_details.pop('id')
517 expected_instance_name = self._manager._get_service_instance_name(
518 fake_network_info['server_id'])
519 self.mock_object(self._manager, '_create_service_instance',
520 mock.Mock(return_value=fake_server))
521 self.mock_object(self._manager, '_check_server_availability')
523 result = self._manager.set_up_service_instance(
524 self._manager.admin_context, fake_network_info)
526 self._manager._create_service_instance.assert_called_once_with(
527 self._manager.admin_context,
528 expected_instance_name, fake_network_info)
529 self._manager._check_server_availability.assert_called_once_with(
530 expected_details)
531 self.assertEqual(expected_details, result)
533 def test_set_up_service_instance_not_available(self):
534 fake_network_info = {'foo': 'bar', 'server_id': 'fake_server_id'}
535 fake_server = {
536 'id': 'fake', 'ip': '1.2.3.4', 'public_address': '1.2.3.4',
537 'pk_path': None, 'subnet_id': 'fake-subnet-id',
538 'router_id': 'fake-router-id',
539 'username': self._manager.get_config_option(
540 'service_instance_user'),
541 'admin_ip': 'admin_ip'}
542 expected_details = fake_server.copy()
543 expected_details.pop('pk_path')
544 expected_details['instance_id'] = expected_details.pop('id')
545 expected_instance_name = self._manager._get_service_instance_name(
546 fake_network_info['server_id'])
547 self.mock_object(self._manager, '_create_service_instance',
548 mock.Mock(return_value=fake_server))
549 self.mock_object(self._manager, '_check_server_availability',
550 mock.Mock(return_value=False))
552 result = self.assertRaises(
553 exception.ServiceInstanceException,
554 self._manager.set_up_service_instance,
555 self._manager.admin_context, fake_network_info)
557 self.assertTrue(hasattr(result, 'detail_data'))
558 self.assertEqual(
559 {'server_details': expected_details}, result.detail_data)
560 self._manager._create_service_instance.assert_called_once_with(
561 self._manager.admin_context,
562 expected_instance_name, fake_network_info)
563 self._manager._check_server_availability.assert_called_once_with(
564 expected_details)
566 def test_ensure_server(self):
567 server_details = {'instance_id': 'fake_inst_id', 'ip': '1.2.3.4'}
568 fake_server = fake_compute.FakeServer()
569 self.mock_object(self._manager, '_check_server_availability',
570 mock.Mock(return_value=True))
571 self.mock_object(self._manager.compute_api, 'server_get',
572 mock.Mock(return_value=fake_server))
573 result = self._manager.ensure_service_instance(
574 self._manager.admin_context, server_details)
575 self._manager.compute_api.server_get.assert_called_once_with(
576 self._manager.admin_context, server_details['instance_id'])
577 self._manager._check_server_availability.assert_called_once_with(
578 server_details)
579 self.assertTrue(result)
581 def test_ensure_server_not_exists(self):
582 server_details = {'instance_id': 'fake_inst_id', 'ip': '1.2.3.4'}
583 self.mock_object(self._manager, '_check_server_availability',
584 mock.Mock(return_value=True))
585 self.mock_object(self._manager.compute_api, 'server_get',
586 mock.Mock(side_effect=exception.InstanceNotFound(
587 instance_id=server_details['instance_id'])))
588 result = self._manager.ensure_service_instance(
589 self._manager.admin_context, server_details)
590 self._manager.compute_api.server_get.assert_called_once_with(
591 self._manager.admin_context, server_details['instance_id'])
592 self.assertFalse(self._manager._check_server_availability.called)
593 self.assertFalse(result)
595 def test_ensure_server_exception(self):
596 server_details = {'instance_id': 'fake_inst_id', 'ip': '1.2.3.4'}
597 self.mock_object(self._manager, '_check_server_availability',
598 mock.Mock(return_value=True))
599 self.mock_object(self._manager.compute_api, 'server_get',
600 mock.Mock(side_effect=exception.ManilaException))
601 self.assertRaises(exception.ManilaException,
602 self._manager.ensure_service_instance,
603 self._manager.admin_context,
604 server_details)
605 self._manager.compute_api.server_get.assert_called_once_with(
606 self._manager.admin_context, server_details['instance_id'])
607 self.assertFalse(self._manager._check_server_availability.called)
609 def test_ensure_server_non_active(self):
610 server_details = {'instance_id': 'fake_inst_id', 'ip': '1.2.3.4'}
611 fake_server = fake_compute.FakeServer(status='ERROR')
612 self.mock_object(self._manager.compute_api, 'server_get',
613 mock.Mock(return_value=fake_server))
614 self.mock_object(self._manager, '_check_server_availability',
615 mock.Mock(return_value=True))
616 result = self._manager.ensure_service_instance(
617 self._manager.admin_context, server_details)
618 self.assertFalse(self._manager._check_server_availability.called)
619 self.assertFalse(result)
621 def test_ensure_server_no_instance_id(self):
622 # Tests that we avoid a KeyError if the share details don't have an
623 # instance_id key set (so we can't find the share instance).
624 self.assertFalse(self._manager.ensure_service_instance(
625 self._manager.admin_context, {'ip': '1.2.3.4'}))
627 def test_get_key_create_new(self):
628 keypair_name = self._manager.get_config_option(
629 'manila_service_keypair_name')
630 fake_keypair = fake_compute.FakeKeypair(name=keypair_name)
631 self.mock_object(self._manager.compute_api, 'keypair_list',
632 mock.Mock(return_value=[]))
633 self.mock_object(self._manager.compute_api, 'keypair_import',
634 mock.Mock(return_value=fake_keypair))
636 result = self._manager._get_key(self._manager.admin_context)
638 self.assertEqual(
639 (fake_keypair.name,
640 os.path.expanduser(self._manager.get_config_option(
641 'path_to_private_key'))),
642 result)
643 self._manager.compute_api.keypair_list.assert_called_once_with(
644 self._manager.admin_context)
645 self._manager.compute_api.keypair_import.assert_called_once_with(
646 self._manager.admin_context, keypair_name, '')
648 def test_get_key_exists(self):
649 fake_keypair = fake_compute.FakeKeypair(
650 name=self._manager.get_config_option(
651 'manila_service_keypair_name'),
652 public_key='fake_public_key')
653 self.mock_object(self._manager.compute_api, 'keypair_list',
654 mock.Mock(return_value=[fake_keypair]))
655 self.mock_object(self._manager.compute_api, 'keypair_import',
656 mock.Mock(return_value=fake_keypair))
657 self.mock_object(self._manager, '_load_public_key',
658 mock.Mock(return_value='fake_public_key'))
660 result = self._manager._get_key(self._manager.admin_context)
662 self._manager.compute_api.keypair_list.assert_called_once_with(
663 self._manager.admin_context)
664 self.assertFalse(self._manager.compute_api.keypair_import.called)
665 self.assertEqual(
666 (fake_keypair.name,
667 os.path.expanduser(self._manager.get_config_option(
668 'path_to_private_key'))),
669 result)
671 def test_get_key_exists_recreate(self):
672 fake_keypair = fake_compute.FakeKeypair(
673 name=self._manager.get_config_option(
674 'manila_service_keypair_name'),
675 public_key='fake_public_key1')
676 self.mock_object(self._manager.compute_api, 'keypair_list',
677 mock.Mock(return_value=[fake_keypair]))
678 self.mock_object(self._manager.compute_api, 'keypair_import',
679 mock.Mock(return_value=fake_keypair))
680 self.mock_object(self._manager.compute_api, 'keypair_delete')
681 self.mock_object(self._manager, '_load_public_key',
682 mock.Mock(return_value='fake_public_key2'))
684 result = self._manager._get_key(self._manager.admin_context)
686 self._manager.compute_api.keypair_list.assert_called_once_with(
687 self._manager.admin_context)
688 self._manager.compute_api.keypair_delete.assert_called_once_with(
689 self._manager.admin_context, fake_keypair.id)
690 self._manager.compute_api.keypair_import.assert_called_once_with(
691 self._manager.admin_context, fake_keypair.name, 'fake_public_key2')
692 self.assertEqual(
693 (fake_keypair.name,
694 os.path.expanduser(self._manager.get_config_option(
695 'path_to_private_key'))),
696 result)
698 def test_get_key_more_than_one_exist(self):
699 fake_keypair = fake_compute.FakeKeypair(
700 name=self._manager.get_config_option(
701 'manila_service_keypair_name'),
702 public_key='fake_public_key1')
703 self.mock_object(self._manager.compute_api, 'keypair_list',
704 mock.Mock(return_value=[fake_keypair, fake_keypair]))
706 self.assertRaises(
707 exception.ServiceInstanceException,
708 self._manager._get_key, self._manager.admin_context)
709 self._manager.compute_api.keypair_list.assert_called_once_with(
710 self._manager.admin_context)
712 def test_get_key_keypath_to_public_not_set(self):
713 self._manager.path_to_public_key = None
714 result = self._manager._get_key(self._manager.admin_context)
715 self.assertEqual((None, None), result)
717 def test_get_key_keypath_to_private_not_set(self):
718 self._manager.path_to_private_key = None
719 result = self._manager._get_key(self._manager.admin_context)
720 self.assertEqual((None, None), result)
722 def test_get_key_incorrect_keypath_to_public(self):
723 def exists_side_effect(path):
724 return False if path == 'fake_path' else True
726 self._manager.path_to_public_key = 'fake_path'
727 os_path_exists_mock = mock.Mock(side_effect=exists_side_effect)
728 with mock.patch.object(os.path, 'exists', os_path_exists_mock):
729 with mock.patch.object(os.path, 'expanduser',
730 mock.Mock(side_effect=lambda value: value)):
731 result = self._manager._get_key(self._manager.admin_context)
732 self.assertEqual((None, None), result)
734 def test_get_key_incorrect_keypath_to_private(self):
735 def exists_side_effect(path):
736 return False if path == 'fake_path' else True
738 self._manager.path_to_private_key = 'fake_path'
739 os_path_exists_mock = mock.Mock(side_effect=exists_side_effect)
740 with mock.patch.object(os.path, 'exists', os_path_exists_mock):
741 with mock.patch.object(os.path, 'expanduser',
742 mock.Mock(side_effect=lambda value: value)):
743 result = self._manager._get_key(self._manager.admin_context)
744 self.assertEqual((None, None), result)
746 def test_get_service_image(self):
747 fake_image1 = fake_image.FakeImage(
748 name=self._manager.get_config_option('service_image_name'),
749 status='active')
750 fake_image2 = fake_image.FakeImage(
751 name='service_image_name',
752 status='error')
753 fake_image3 = fake_image.FakeImage(
754 name='another-image',
755 status='active')
756 self.mock_object(self._manager.image_api, 'image_list',
757 mock.Mock(return_value=[fake_image1,
758 fake_image2,
759 fake_image3]))
761 result = self._manager._get_service_image(self._manager.admin_context)
762 self.assertEqual(fake_image1.id, result)
764 def test_get_service_image_not_found(self):
765 self.mock_object(self._manager.image_api, 'image_list',
766 mock.Mock(return_value=[]))
767 self.assertRaises(
768 exception.ServiceInstanceException,
769 self._manager._get_service_image, self._manager.admin_context)
771 def test_get_service_image_not_active(self):
772 fake_error_image = fake_image.FakeImage(
773 name='service_image_name',
774 status='error')
775 self.mock_object(self._manager.image_api, 'image_list',
776 mock.Mock(return_value=[fake_error_image]))
777 self.assertRaises(
778 exception.ServiceInstanceException,
779 self._manager._get_service_image, self._manager.admin_context)
781 def test_get_service_image_ambiguous(self):
782 fake_image1 = fake_image.FakeImage(
783 name=fake_get_config_option('service_image_name'),
784 status='active')
785 fake_images = [fake_image1, fake_image1]
786 self.mock_object(self._manager.image_api, 'image_list',
787 mock.Mock(return_value=fake_images))
788 self.assertRaises(
789 exception.ServiceInstanceException,
790 self._manager._get_service_image, self._manager.admin_context)
792 def test__delete_server_not_found(self):
793 self.mock_object(self._manager.compute_api, 'server_delete')
794 self.mock_object(
795 self._manager.compute_api, 'server_get',
796 mock.Mock(side_effect=exception.InstanceNotFound(
797 instance_id=self.instance_id)))
799 self._manager._delete_server(
800 self._manager.admin_context, self.instance_id)
802 self.assertFalse(self._manager.compute_api.server_delete.called)
803 self._manager.compute_api.server_get.assert_called_once_with(
804 self._manager.admin_context, self.instance_id)
806 def test__delete_server(self):
807 def fake_server_get(*args, **kwargs):
808 ctx = args[0]
809 if not hasattr(ctx, 'called'):
810 ctx.called = True
811 return
812 else:
813 raise exception.InstanceNotFound(instance_id=self.instance_id)
815 self.mock_object(self._manager.compute_api, 'server_delete')
816 self.mock_object(self._manager.compute_api, 'server_get',
817 mock.Mock(side_effect=fake_server_get))
819 self._manager._delete_server(
820 self._manager.admin_context, self.instance_id)
822 self._manager.compute_api.server_delete.assert_called_once_with(
823 self._manager.admin_context, self.instance_id)
824 self._manager.compute_api.server_get.assert_has_calls([
825 mock.call(self._manager.admin_context, self.instance_id),
826 mock.call(self._manager.admin_context, self.instance_id)])
828 def test__delete_server_found_always(self):
829 self.fake_time = 0
831 def fake_time():
832 return self.fake_time
834 def fake_sleep(time):
835 self.fake_time += 1
837 server_details = {'instance_id': 'fake_inst_id', 'status': 'ACTIVE'}
838 self.mock_object(self._manager.compute_api, 'server_delete')
839 self.mock_object(self._manager.compute_api, 'server_get',
840 mock.Mock(return_value=server_details))
841 self.mock_object(service_instance, 'time')
842 self.mock_object(
843 service_instance.time, 'time', mock.Mock(side_effect=fake_time))
844 self.mock_object(
845 service_instance.time, 'sleep', mock.Mock(side_effect=fake_sleep))
846 self.mock_object(self._manager, 'max_time_to_build_instance', 2)
848 self.assertRaises(
849 exception.ServiceInstanceException, self._manager._delete_server,
850 self._manager.admin_context, self.instance_id)
852 self._manager.compute_api.server_delete.assert_called_once_with(
853 self._manager.admin_context, self.instance_id)
854 service_instance.time.sleep.assert_has_calls(
855 [mock.call(mock.ANY) for i in range(2)])
856 service_instance.time.time.assert_has_calls(
857 [mock.call() for i in range(4)])
858 self._manager.compute_api.server_get.assert_has_calls(
859 [mock.call(self._manager.admin_context,
860 self.instance_id) for i in range(3)])
862 def test_delete_server_soft_deleted(self):
863 server_details = {'instance_id': 'fake_inst_id',
864 'status': 'SOFT_DELETED'}
865 self.mock_object(self._manager.compute_api, 'server_delete')
866 self.mock_object(self._manager.compute_api, 'server_get',
867 mock.Mock(return_value=server_details))
869 self._manager._delete_server(
870 self._manager.admin_context, self.instance_id)
872 self._manager.compute_api.server_delete.assert_called_once_with(
873 self._manager.admin_context, self.instance_id)
874 self._manager.compute_api.server_get.assert_has_calls([
875 mock.call(self._manager.admin_context, self.instance_id),
876 mock.call(self._manager.admin_context, self.instance_id)])
878 def test_delete_service_instance(self):
879 fake_server_details = dict(
880 router_id='foo', subnet_id='bar', instance_id='quuz')
881 self.mock_object(self._manager, '_delete_server')
882 self.mock_object(self._manager.network_helper, 'teardown_network')
884 self._manager.delete_service_instance(
885 self._manager.admin_context, fake_server_details)
887 self._manager._delete_server.assert_called_once_with(
888 self._manager.admin_context, fake_server_details['instance_id'])
889 self._manager.network_helper.teardown_network.assert_called_once_with(
890 fake_server_details)
892 @ddt.data(
893 *[{'service_config': service_config,
894 'tenant_config': tenant_config,
895 'server': server}
896 for service_config, tenant_config in (
897 ('fake_net_s', 'fake_net_t'),
898 ('fake_net_s', '12.34.56.78'),
899 ('98.76.54.123', 'fake_net_t'),
900 ('98.76.54.123', '12.34.56.78'))
901 for server in (
902 {'networks': {
903 'fake_net_s': ['foo', '98.76.54.123', 'bar'],
904 'fake_net_t': ['baar', '12.34.56.78', 'quuz']}},
905 {'addresses': {
906 'fake_net_s': [
907 {'addr': 'fake1'},
908 {'addr': '98.76.54.123'},
909 {'addr': 'fake2'}],
910 'fake_net_t': [
911 {'addr': 'fake3'},
912 {'addr': '12.34.56.78'},
913 {'addr': 'fake4'}],
914 }})])
915 @ddt.unpack
916 def test_get_common_server_valid_cases(self, service_config,
917 tenant_config, server):
918 self._get_common_server(service_config, tenant_config, server,
919 '98.76.54.123', '12.34.56.78', True)
921 @ddt.data(
922 *[{'service_config': service_config,
923 'tenant_config': tenant_config,
924 'server': server}
925 for service_config, tenant_config in (
926 ('fake_net_s', 'fake'),
927 ('fake', 'fake_net_t'),
928 ('fake', 'fake'),
929 ('98.76.54.123', '12.12.12.1212'),
930 ('12.12.12.1212', '12.34.56.78'),
931 ('12.12.12.1212', '12.12.12.1212'),
932 ('1001::1001', '1001::100G'),
933 ('1001::10G1', '1001::1001'),
934 )
935 for server in (
936 {'networks': {
937 'fake_net_s': ['foo', '98.76.54.123', 'bar'],
938 'fake_net_t': ['baar', '12.34.56.78', 'quuz']}},
939 {'addresses': {
940 'fake_net_s': [
941 {'addr': 'fake1'},
942 {'addr': '98.76.54.123'},
943 {'addr': 'fake2'}],
944 'fake_net_t': [
945 {'addr': 'fake3'},
946 {'addr': '12.34.56.78'},
947 {'addr': 'fake4'}],
948 }})])
949 @ddt.unpack
950 def test_get_common_server_invalid_cases(self, service_config,
951 tenant_config, server):
952 self._get_common_server(service_config, tenant_config, server,
953 '98.76.54.123', '12.34.56.78', False)
955 @ddt.data(
956 *[{'service_config': service_config,
957 'tenant_config': tenant_config,
958 'server': server}
959 for service_config, tenant_config in (
960 ('fake_net_s', '1001::1002'),
961 ('1001::1001', 'fake_net_t'),
962 ('1001::1001', '1001::1002'))
963 for server in (
964 {'networks': {
965 'fake_net_s': ['foo', '1001::1001'],
966 'fake_net_t': ['bar', '1001::1002']}},
967 {'addresses': {
968 'fake_net_s': [{'addr': 'foo'}, {'addr': '1001::1001'}],
969 'fake_net_t': [{'addr': 'bar'}, {'addr': '1001::1002'}]}})])
970 @ddt.unpack
971 def test_get_common_server_valid_ipv6_address(self, service_config,
972 tenant_config, server):
973 self._get_common_server(service_config, tenant_config, server,
974 '1001::1001', '1001::1002', True)
976 def _get_common_server(self, service_config, tenant_config,
977 server, service_address, network_address,
978 is_valid=True):
979 fake_instance_id = 'fake_instance_id'
980 fake_user = 'fake_user'
981 fake_pass = 'fake_pass'
982 fake_server = {'id': fake_instance_id}
983 fake_server.update(server)
984 expected = {
985 'backend_details': {
986 'username': fake_user,
987 'password': fake_pass,
988 'pk_path': self._manager.path_to_private_key,
989 'ip': service_address,
990 'public_address': network_address,
991 'instance_id': fake_instance_id,
992 }
993 }
995 def fake_get_config_option(attr):
996 if attr == 'service_net_name_or_ip':
997 return service_config
998 elif attr == 'tenant_net_name_or_ip':
999 return tenant_config
1000 elif attr == 'service_instance_name_or_id':
1001 return fake_instance_id
1002 elif attr == 'service_instance_user':
1003 return fake_user
1004 elif attr == 'service_instance_password': 1004 ↛ 1007line 1004 didn't jump to line 1007 because the condition on line 1004 was always true
1005 return fake_pass
1006 else:
1007 raise exception.ManilaException("Wrong test data provided.")
1009 self.mock_object(
1010 self._manager.compute_api, 'server_get_by_name_or_id',
1011 mock.Mock(return_value=fake_server))
1012 self.mock_object(
1013 self._manager, 'get_config_option',
1014 mock.Mock(side_effect=fake_get_config_option))
1016 if is_valid:
1017 actual = self._manager.get_common_server()
1018 self.assertEqual(expected, actual)
1019 else:
1020 self.assertRaises(
1021 exception.ManilaException,
1022 self._manager.get_common_server)
1023 self.assertTrue(
1024 self._manager.compute_api.server_get_by_name_or_id.called)
1026 def test___create_service_instance_with_sg_success(self):
1027 self.mock_object(service_instance, 'NeutronNetworkHelper',
1028 mock.Mock(side_effect=FakeNetworkHelper))
1029 config_data = dict(DEFAULT=dict(
1030 driver_handles_share_servers=True,
1031 service_instance_user='fake_user',
1032 limit_ssh_access=True))
1033 with test_utils.create_temp_config_with_opts(config_data):
1034 self._manager = service_instance.ServiceInstanceManager()
1036 server_create = dict(id='fakeid', status='CREATING', networks=dict())
1037 net_name = self._manager.get_config_option("service_network_name")
1038 sg = [{'id': 'fakeid', 'name': 'fakename'}, ]
1039 ip_address = 'fake_ip_address'
1040 service_image_id = 'fake_service_image_id'
1041 key_data = 'fake_key_name', 'fake_key_path'
1042 instance_name = 'fake_instance_name'
1043 network_info = dict()
1044 network_data = {'nics': ['fake_nic1', 'fake_nic2']}
1045 network_data['router'] = dict(id='fake_router_id')
1046 server_get = dict(
1047 id='fakeid', status='ACTIVE', networks={net_name: [ip_address]})
1048 network_data.update(dict(
1049 router_id='fake_router_id', subnet_id='fake_subnet_id',
1050 public_port=dict(id='fake_public_port',
1051 fixed_ips=[dict(ip_address=ip_address)]),
1052 service_port=dict(id='fake_service_port',
1053 fixed_ips=[{'ip_address': ip_address}]),
1054 admin_port={'id': 'fake_admin_port',
1055 'fixed_ips': [{'ip_address': ip_address}]},
1056 service_subnet={'id': 'fake_subnet_id',
1057 'cidr': '10.254.0.0/28'})
1058 )
1059 self.mock_object(service_instance.time, 'time',
1060 mock.Mock(return_value=5))
1061 self.mock_object(self._manager.network_helper, 'setup_network',
1062 mock.Mock(return_value=network_data))
1063 self.mock_object(self._manager.network_helper, 'get_network_name',
1064 mock.Mock(return_value=net_name))
1065 self.mock_object(self._manager, '_get_service_image',
1066 mock.Mock(return_value=service_image_id))
1067 self.mock_object(self._manager, '_get_key',
1068 mock.Mock(return_value=key_data))
1069 self.mock_object(self._manager, '_get_or_create_security_groups',
1070 mock.Mock(return_value=sg))
1071 self.mock_object(self._manager.compute_api, 'server_create',
1072 mock.Mock(return_value=server_create))
1073 self.mock_object(self._manager.compute_api, 'server_get',
1074 mock.Mock(return_value=server_get))
1075 self.mock_object(self._manager.compute_api,
1076 'add_security_group_to_server')
1077 expected = {
1078 'id': server_get['id'],
1079 'status': server_get['status'],
1080 'pk_path': key_data[1],
1081 'public_address': ip_address,
1082 'router_id': network_data.get('router_id'),
1083 'subnet_id': network_data.get('subnet_id'),
1084 'instance_id': server_get['id'],
1085 'ip': ip_address,
1086 'networks': server_get['networks'],
1087 'public_port_id': 'fake_public_port',
1088 'service_port_id': 'fake_service_port',
1089 'admin_port_id': 'fake_admin_port',
1090 'admin_ip': 'fake_ip_address',
1091 }
1093 result = self._manager._create_service_instance(
1094 self._manager.admin_context, instance_name, network_info)
1096 self.assertEqual(expected, result)
1097 self.assertTrue(service_instance.time.time.called)
1098 self._manager.network_helper.setup_network.assert_called_once_with(
1099 network_info)
1100 self._manager._get_service_image.assert_called_once_with(
1101 self._manager.admin_context)
1102 self._manager._get_key.assert_called_once_with(
1103 self._manager.admin_context)
1104 self._manager._get_or_create_security_groups.assert_called_once_with(
1105 self._manager.admin_context,
1106 allow_ssh_subnet=network_data['service_subnet'])
1107 self._manager.compute_api.server_create.assert_called_once_with(
1108 self._manager.admin_context, name=instance_name,
1109 image=service_image_id, flavor='100',
1110 key_name=key_data[0], nics=network_data['nics'],
1111 availability_zone=service_instance.CONF.storage_availability_zone)
1112 self._manager.compute_api.server_get.assert_called_once_with(
1113 self._manager.admin_context, server_create['id'])
1114 (self._manager.compute_api.add_security_group_to_server.
1115 assert_called_once_with(
1116 self._manager.admin_context,
1117 server_get['id'],
1118 sg[0]['id']))
1119 self._manager.network_helper.get_network_name.assert_has_calls([])
1121 def test___create_service_instance_with_bfv_with_image(self):
1122 self.mock_object(service_instance, 'NeutronNetworkHelper',
1123 mock.Mock(side_effect=FakeNetworkHelper))
1124 config_data = dict(DEFAULT=dict(
1125 service_instance_boot_from_volume=True,
1126 service_instance_boot_volume_size=100,
1127 service_instance_boot_volume_name_template="boo_vol_name_%s",
1128 driver_handles_share_servers=True,
1129 service_instance_user='fake_user',
1130 limit_ssh_access=True))
1131 with test_utils.create_temp_config_with_opts(config_data):
1132 self._manager = service_instance.ServiceInstanceManager()
1134 server_create = dict(id='fakeid', status='CREATING', networks=dict())
1135 net_name = self._manager.get_config_option("service_network_name")
1136 sg = [{'id': 'fakeid', 'name': 'fakename'}, ]
1137 ip_address = 'fake_ip_address'
1138 service_image_id = 'fake_service_image_id'
1139 key_data = 'fake_key_name', 'fake_key_path'
1140 instance_name = 'fake_instance_name'
1141 network_info = dict(server_id='fake_server')
1142 network_data = {'nics': ['fake_nic1', 'fake_nic2']}
1143 network_data['router'] = dict(id='fake_router_id')
1144 server_get = dict(
1145 id='fakeid', status='ACTIVE', networks={net_name: [ip_address]})
1146 block_device_mapping_v2 = [{
1147 'boot_index': 0, 'uuid': service_image_id,
1148 'source_type': 'image', 'destination_type': 'volume',
1149 'volume_size': 100, 'delete_on_termination': True
1150 }]
1151 network_data.update(dict(
1152 router_id='fake_router_id', subnet_id='fake_subnet_id',
1153 public_port=dict(id='fake_public_port',
1154 fixed_ips=[dict(ip_address=ip_address)]),
1155 service_port=dict(id='fake_service_port',
1156 fixed_ips=[{'ip_address': ip_address}]),
1157 admin_port={'id': 'fake_admin_port',
1158 'fixed_ips': [{'ip_address': ip_address}]},
1159 service_subnet={'id': 'fake_subnet_id',
1160 'cidr': '10.254.0.0/28'})
1161 )
1162 self.mock_object(service_instance.time, 'time',
1163 mock.Mock(return_value=5))
1164 self.mock_object(self._manager.network_helper, 'setup_network',
1165 mock.Mock(return_value=network_data))
1166 self.mock_object(self._manager.network_helper, 'get_network_name',
1167 mock.Mock(return_value=net_name))
1168 self.mock_object(self._manager, '_get_service_image',
1169 mock.Mock(return_value=service_image_id))
1170 self.mock_object(self._manager, '_get_key',
1171 mock.Mock(return_value=key_data))
1172 self.mock_object(self._manager, '_get_or_create_security_groups',
1173 mock.Mock(return_value=sg))
1174 self.mock_object(self._manager.compute_api, 'server_create',
1175 mock.Mock(return_value=server_create))
1176 self.mock_object(self._manager.compute_api, 'server_get',
1177 mock.Mock(return_value=server_get))
1178 self.mock_object(self._manager.compute_api,
1179 'add_security_group_to_server')
1180 self.mock_object(self._manager.volume_api, 'create')
1181 self.mock_object(self._manager.volume_api, 'wait_for_available_volume')
1182 expected = {
1183 'id': server_get['id'],
1184 'status': server_get['status'],
1185 'pk_path': key_data[1],
1186 'public_address': ip_address,
1187 'router_id': network_data.get('router_id'),
1188 'subnet_id': network_data.get('subnet_id'),
1189 'instance_id': server_get['id'],
1190 'ip': ip_address,
1191 'networks': server_get['networks'],
1192 'public_port_id': 'fake_public_port',
1193 'service_port_id': 'fake_service_port',
1194 'admin_port_id': 'fake_admin_port',
1195 'admin_ip': 'fake_ip_address',
1196 }
1198 result = self._manager._create_service_instance(
1199 self._manager.admin_context, instance_name, network_info)
1201 self.assertEqual(expected, result)
1202 self._manager.compute_api.server_create.assert_called_once_with(
1203 self._manager.admin_context, name=instance_name,
1204 image=None, flavor='100',
1205 key_name=key_data[0], nics=network_data['nics'],
1206 availability_zone=service_instance.CONF.storage_availability_zone,
1207 block_device_mapping_v2=block_device_mapping_v2,
1208 )
1209 self._manager.volume_api.create.assert_not_called()
1210 self._manager.volume_api.wait_for_available_volume.assert_not_called()
1212 def test___create_service_instance_with_bfv_with_vol(self):
1213 self.mock_object(service_instance, 'NeutronNetworkHelper',
1214 mock.Mock(side_effect=FakeNetworkHelper))
1215 config_data = dict(DEFAULT=dict(
1216 service_instance_boot_from_volume=True,
1217 service_instance_boot_volume_size=100,
1218 service_instance_boot_volume_type='lvm_test1',
1219 service_instance_base_boot_volume_id='fake_boot_base_vol',
1220 service_instance_boot_volume_delete_on_termination=False,
1221 driver_handles_share_servers=True,
1222 service_instance_user='fake_user',
1223 limit_ssh_access=True))
1224 with test_utils.create_temp_config_with_opts(config_data):
1225 self._manager = service_instance.ServiceInstanceManager()
1227 server_create = dict(id='fakeid', status='CREATING', networks=dict())
1228 net_name = self._manager.get_config_option("service_network_name")
1229 sg = [{'id': 'fakeid', 'name': 'fakename'}, ]
1230 ip_address = 'fake_ip_address'
1231 service_image_id = 'fake_service_image_id'
1232 key_data = 'fake_key_name', 'fake_key_path'
1233 instance_name = 'fake_instance_name'
1234 network_info = dict(server_id='fake_server')
1235 network_data = {'nics': ['fake_nic1', 'fake_nic2']}
1236 network_data['router'] = dict(id='fake_router_id')
1237 server_get = dict(
1238 id='fakeid', status='ACTIVE', networks={net_name: [ip_address]})
1239 block_device_mapping_v2 = [{
1240 'boot_index': 0, 'uuid': 'fake_vol',
1241 'source_type': 'volume', 'destination_type': 'volume',
1242 'delete_on_termination': False
1243 }]
1244 network_data.update(dict(
1245 router_id='fake_router_id', subnet_id='fake_subnet_id',
1246 public_port=dict(id='fake_public_port',
1247 fixed_ips=[dict(ip_address=ip_address)]),
1248 service_port=dict(id='fake_service_port',
1249 fixed_ips=[{'ip_address': ip_address}]),
1250 admin_port={'id': 'fake_admin_port',
1251 'fixed_ips': [{'ip_address': ip_address}]},
1252 service_subnet={'id': 'fake_subnet_id',
1253 'cidr': '10.254.0.0/28'})
1254 )
1255 fake_volume = {'status': 'creating', 'id': 'fake_vol'}
1256 fake_available_volume = {'status': 'available', 'id': 'fake_vol'}
1258 self.mock_object(service_instance.time, 'time',
1259 mock.Mock(return_value=5))
1260 self.mock_object(self._manager.network_helper, 'setup_network',
1261 mock.Mock(return_value=network_data))
1262 self.mock_object(self._manager.network_helper, 'get_network_name',
1263 mock.Mock(return_value=net_name))
1264 self.mock_object(self._manager, '_get_service_image',
1265 mock.Mock(return_value=service_image_id))
1266 self.mock_object(self._manager, '_get_key',
1267 mock.Mock(return_value=key_data))
1268 self.mock_object(self._manager, '_get_or_create_security_groups',
1269 mock.Mock(return_value=sg))
1270 self.mock_object(self._manager.compute_api, 'server_create',
1271 mock.Mock(return_value=server_create))
1272 self.mock_object(self._manager.compute_api, 'server_get',
1273 mock.Mock(return_value=server_get))
1274 self.mock_object(self._manager.compute_api,
1275 'add_security_group_to_server')
1276 self.mock_object(self._manager.volume_api, 'create',
1277 mock.Mock(return_value=fake_volume))
1278 self.mock_object(self._manager.volume_api, 'wait_for_available_volume',
1279 mock.Mock(return_value=fake_available_volume))
1280 expected = {
1281 'id': server_get['id'],
1282 'status': server_get['status'],
1283 'pk_path': key_data[1],
1284 'public_address': ip_address,
1285 'router_id': network_data.get('router_id'),
1286 'subnet_id': network_data.get('subnet_id'),
1287 'instance_id': server_get['id'],
1288 'ip': ip_address,
1289 'networks': server_get['networks'],
1290 'public_port_id': 'fake_public_port',
1291 'service_port_id': 'fake_service_port',
1292 'admin_port_id': 'fake_admin_port',
1293 'admin_ip': 'fake_ip_address',
1294 }
1296 result = self._manager._create_service_instance(
1297 self._manager.admin_context, instance_name, network_info)
1299 self.assertEqual(expected, result)
1300 self._manager.compute_api.server_create.assert_called_once_with(
1301 self._manager.admin_context, name=instance_name,
1302 image=None, flavor='100',
1303 key_name=key_data[0], nics=network_data['nics'],
1304 availability_zone=service_instance.CONF.storage_availability_zone,
1305 block_device_mapping_v2=block_device_mapping_v2,
1306 )
1307 self._manager.volume_api.create.assert_called_once_with(
1308 self._manager.admin_context,
1309 size=100, name='manila-share-fake_server-boot',
1310 description='', availability_zone='nova',
1311 source_volid='fake_boot_base_vol', volume_type='lvm_test1'
1312 )
1313 (self._manager.volume_api.wait_for_available_volume.
1314 assert_called_once_with(
1315 {'status': 'creating', 'id': 'fake_vol'},
1316 180,
1317 msg_error='Failed to create bootable volume',
1318 msg_timeout='Volume has not been created in 180s. Giving up')
1319 )
1321 def test___create_service_instance_neutron_no_admin_ip(self):
1322 self.mock_object(service_instance, 'NeutronNetworkHelper',
1323 mock.Mock(side_effect=FakeNetworkHelper))
1324 config_data = {'DEFAULT': {
1325 'driver_handles_share_servers': True,
1326 'service_instance_user': 'fake_user',
1327 'limit_ssh_access': True}}
1328 with test_utils.create_temp_config_with_opts(config_data):
1329 self._manager = service_instance.ServiceInstanceManager()
1331 server_create = {'id': 'fakeid', 'status': 'CREATING', 'networks': {}}
1332 net_name = self._manager.get_config_option("service_network_name")
1333 sg = {'id': 'fakeid', 'name': 'fakename'}
1334 ip_address = 'fake_ip_address'
1335 service_image_id = 'fake_service_image_id'
1336 key_data = 'fake_key_name', 'fake_key_path'
1337 instance_name = 'fake_instance_name'
1338 network_info = {}
1339 network_data = {
1340 'nics': ['fake_nic1', 'fake_nic2'],
1341 'router_id': 'fake_router_id', 'subnet_id': 'fake_subnet_id',
1342 'public_port': {'id': 'fake_public_port',
1343 'fixed_ips': [{'ip_address': ip_address}]},
1344 'service_port': {'id': 'fake_service_port',
1345 'fixed_ips': [{'ip_address': ip_address}]},
1346 'admin_port': {'id': 'fake_admin_port',
1347 'fixed_ips': []},
1348 'router': {'id': 'fake_router_id'},
1349 'service_subnet': {'id': 'fake_id',
1350 'cidr': '10.254.0.0/28'}
1351 }
1352 server_get = {
1353 'id': 'fakeid', 'status': 'ACTIVE', 'networks':
1354 {net_name: [ip_address]}}
1356 self.mock_object(service_instance.time, 'time',
1357 mock.Mock(return_value=5))
1358 self.mock_object(self._manager.network_helper, 'setup_network',
1359 mock.Mock(return_value=network_data))
1360 self.mock_object(self._manager.network_helper, 'get_network_name',
1361 mock.Mock(return_value=net_name))
1362 self.mock_object(self._manager, '_get_service_image',
1363 mock.Mock(return_value=service_image_id))
1364 self.mock_object(self._manager, '_get_key',
1365 mock.Mock(return_value=key_data))
1366 self.mock_object(self._manager, '_get_or_create_security_groups',
1367 mock.Mock(return_value=[sg, ]))
1368 self.mock_object(self._manager.compute_api, 'server_create',
1369 mock.Mock(return_value=server_create))
1370 self.mock_object(self._manager.compute_api, 'server_get',
1371 mock.Mock(return_value=server_get))
1372 self.mock_object(self._manager.compute_api,
1373 'add_security_group_to_server')
1375 self.assertRaises(
1376 exception.AdminIPNotFound, self._manager._create_service_instance,
1377 self._manager.admin_context, instance_name, network_info)
1379 self.assertTrue(service_instance.time.time.called)
1380 self._manager.network_helper.setup_network.assert_called_once_with(
1381 network_info)
1382 self._manager._get_service_image.assert_called_once_with(
1383 self._manager.admin_context)
1384 self._manager._get_key.assert_called_once_with(
1385 self._manager.admin_context)
1386 self._manager._get_or_create_security_groups.assert_called_once_with(
1387 self._manager.admin_context,
1388 allow_ssh_subnet=network_data['service_subnet'])
1389 self._manager.compute_api.server_create.assert_called_once_with(
1390 self._manager.admin_context, name=instance_name,
1391 image=service_image_id, flavor='100',
1392 key_name=key_data[0], nics=network_data['nics'],
1393 availability_zone=service_instance.CONF.storage_availability_zone)
1394 self._manager.compute_api.server_get.assert_called_once_with(
1395 self._manager.admin_context, server_create['id'])
1396 (self._manager.compute_api.add_security_group_to_server.
1397 assert_called_once_with(
1398 self._manager.admin_context, server_get['id'], sg['id']))
1399 self._manager.network_helper.get_network_name.assert_has_calls([])
1401 @ddt.data(
1402 dict(
1403 instance_id_included=False,
1404 mockobj=mock.Mock(side_effect=exception.ServiceInstanceException)),
1405 dict(
1406 instance_id_included=True,
1407 mockobj=mock.Mock(return_value=dict(id='fakeid', status='ERROR'))))
1408 @ddt.unpack
1409 def test___create_service_instance_failed_to_create(
1410 self, instance_id_included, mockobj):
1411 service_image_id = 'fake_service_image_id'
1412 key_data = 'fake_key_name', 'fake_key_path'
1413 instance_name = 'fake_instance_name'
1414 network_info = dict()
1415 network_data = dict(
1416 nics=['fake_nic1', 'fake_nic2'],
1417 router_id='fake_router_id', subnet_id='fake_subnet_id')
1418 self.mock_object(self._manager.network_helper, 'setup_network',
1419 mock.Mock(return_value=network_data))
1420 self.mock_object(self._manager, '_get_service_image',
1421 mock.Mock(return_value=service_image_id))
1422 self.mock_object(self._manager, '_get_key',
1423 mock.Mock(return_value=key_data))
1424 self.mock_object(
1425 self._manager.compute_api, 'server_create', mockobj)
1426 self.mock_object(
1427 self._manager, 'wait_for_instance_to_be_active',
1428 mock.Mock(side_effect=exception.ServiceInstanceException))
1430 try:
1431 self._manager._create_service_instance(
1432 self._manager.admin_context, instance_name, network_info)
1433 except exception.ServiceInstanceException as e:
1434 expected = dict(server_details=dict(
1435 subnet_id=network_data['subnet_id'],
1436 router_id=network_data['router_id']))
1437 if instance_id_included:
1438 expected['server_details']['instance_id'] = 'fakeid'
1439 self.assertEqual(expected, e.detail_data)
1440 else:
1441 raise exception.ManilaException('Expected error was not raised.')
1443 self._manager.network_helper.setup_network.assert_called_once_with(
1444 network_info)
1445 self._manager._get_service_image.assert_called_once_with(
1446 self._manager.admin_context)
1447 self._manager._get_key.assert_called_once_with(
1448 self._manager.admin_context)
1449 self._manager.compute_api.server_create.assert_called_once_with(
1450 self._manager.admin_context, name=instance_name,
1451 image=service_image_id, flavor='100',
1452 key_name=key_data[0], nics=network_data['nics'],
1453 availability_zone=service_instance.CONF.storage_availability_zone)
1455 def test___create_service_instance_limit_ssh_no_service_subnet(self):
1456 self.mock_object(service_instance, 'NeutronNetworkHelper',
1457 mock.Mock(side_effect=FakeNetworkHelper))
1458 config_data = dict(DEFAULT=dict(
1459 driver_handles_share_servers=True,
1460 service_instance_user='fake_user',
1461 limit_ssh_access=True))
1462 with test_utils.create_temp_config_with_opts(config_data):
1463 self._manager = service_instance.ServiceInstanceManager()
1465 server_create = dict(id='fakeid', status='CREATING', networks=dict())
1466 net_name = self._manager.get_config_option("service_network_name")
1467 ip_address = 'fake_ip_address'
1468 service_image_id = 'fake_service_image_id'
1469 key_data = 'fake_key_name', 'fake_key_path'
1470 instance_name = 'fake_instance_name'
1471 network_info = dict()
1472 network_data = {'nics': ['fake_nic1', 'fake_nic2']}
1473 network_data['router'] = dict(id='fake_router_id')
1474 server_get = dict(
1475 id='fakeid', status='ACTIVE', networks={net_name: [ip_address]})
1476 network_data.update(dict(
1477 router_id='fake_router_id', subnet_id='fake_subnet_id',
1478 public_port=dict(id='fake_public_port',
1479 fixed_ips=[dict(ip_address=ip_address)]),
1480 service_port=dict(id='fake_service_port',
1481 fixed_ips=[{'ip_address': ip_address}]),
1482 admin_port={'id': 'fake_admin_port',
1483 'fixed_ips': [{'ip_address': ip_address}]},)
1484 )
1485 self.mock_object(service_instance.time, 'time',
1486 mock.Mock(return_value=5))
1487 self.mock_object(self._manager.network_helper, 'setup_network',
1488 mock.Mock(return_value=network_data))
1489 self.mock_object(self._manager.network_helper, 'get_network_name',
1490 mock.Mock(return_value=net_name))
1491 self.mock_object(self._manager, '_get_service_image',
1492 mock.Mock(return_value=service_image_id))
1493 self.mock_object(self._manager, '_get_key',
1494 mock.Mock(return_value=key_data))
1495 self.mock_object(self._manager.compute_api, 'server_create',
1496 mock.Mock(return_value=server_create))
1497 self.mock_object(self._manager.compute_api, 'server_get',
1498 mock.Mock(return_value=server_get))
1500 self.assertRaises(exception.ManilaException,
1501 self._manager._create_service_instance,
1502 self._manager.admin_context, instance_name,
1503 network_info)
1505 def test___create_service_instance_failed_to_build(self):
1506 server_create = dict(id='fakeid', status='CREATING', networks=dict())
1507 service_image_id = 'fake_service_image_id'
1508 key_data = 'fake_key_name', 'fake_key_path'
1509 instance_name = 'fake_instance_name'
1510 network_info = dict()
1511 network_data = dict(
1512 nics=['fake_nic1', 'fake_nic2'],
1513 router_id='fake_router_id', subnet_id='fake_subnet_id')
1514 self.mock_object(self._manager.network_helper, 'setup_network',
1515 mock.Mock(return_value=network_data))
1516 self.mock_object(self._manager, '_get_service_image',
1517 mock.Mock(return_value=service_image_id))
1518 self.mock_object(self._manager, '_get_key',
1519 mock.Mock(return_value=key_data))
1520 self.mock_object(self._manager.compute_api, 'server_create',
1521 mock.Mock(return_value=server_create))
1522 self.mock_object(
1523 self._manager, 'wait_for_instance_to_be_active',
1524 mock.Mock(side_effect=exception.ServiceInstanceException))
1526 try:
1527 self._manager._create_service_instance(
1528 self._manager.admin_context, instance_name, network_info)
1529 except exception.ServiceInstanceException as e:
1530 self.assertEqual(
1531 dict(server_details=dict(subnet_id=network_data['subnet_id'],
1532 router_id=network_data['router_id'],
1533 instance_id=server_create['id'])),
1534 e.detail_data)
1535 else:
1536 raise exception.ManilaException('Expected error was not raised.')
1538 self._manager.network_helper.setup_network.assert_called_once_with(
1539 network_info)
1540 self._manager._get_service_image.assert_called_once_with(
1541 self._manager.admin_context)
1542 self._manager._get_key.assert_called_once_with(
1543 self._manager.admin_context)
1544 self._manager.compute_api.server_create.assert_called_once_with(
1545 self._manager.admin_context, name=instance_name,
1546 image=service_image_id, flavor='100',
1547 key_name=key_data[0], nics=network_data['nics'],
1548 availability_zone=service_instance.CONF.storage_availability_zone)
1550 @ddt.data(
1551 dict(name=None, path=None),
1552 dict(name=None, path='/tmp'))
1553 @ddt.unpack
1554 def test__create_service_instance_no_key_and_no_path(self, name, path):
1555 key_data = name, path
1556 self.mock_object(self._manager, '_get_service_image')
1557 self.mock_object(self._manager, '_get_key',
1558 mock.Mock(return_value=key_data))
1560 self.assertRaises(
1561 exception.ServiceInstanceException,
1562 self._manager._create_service_instance,
1563 self._manager.admin_context, 'fake_instance_name', dict())
1565 self._manager._get_service_image.assert_called_once_with(
1566 self._manager.admin_context)
1567 self._manager._get_key.assert_called_once_with(
1568 self._manager.admin_context)
1570 @mock.patch('time.sleep')
1571 @mock.patch('time.time')
1572 def _test_wait_for_instance(self, mock_time, mock_sleep,
1573 server_get_side_eff=None,
1574 expected_try_count=1,
1575 expected_sleep_count=0,
1576 expected_ret_val=None,
1577 expected_exc=None):
1578 mock_server_get = mock.Mock(side_effect=server_get_side_eff)
1579 self.mock_object(self._manager.compute_api, 'server_get',
1580 mock_server_get)
1582 self.fake_time = 0
1584 def fake_time():
1585 return self.fake_time
1587 def fake_sleep(sleep_time):
1588 self.fake_time += sleep_time
1590 # Note(lpetrut): LOG methods can call time.time
1591 mock_time.side_effect = fake_time
1592 mock_sleep.side_effect = fake_sleep
1593 timeout = 3
1595 if expected_exc:
1596 self.assertRaises(
1597 expected_exc,
1598 self._manager.wait_for_instance_to_be_active,
1599 instance_id=mock.sentinel.instance_id,
1600 timeout=timeout)
1601 else:
1602 instance = self._manager.wait_for_instance_to_be_active(
1603 instance_id=mock.sentinel.instance_id,
1604 timeout=timeout)
1605 self.assertEqual(expected_ret_val, instance)
1607 mock_server_get.assert_has_calls(
1608 [mock.call(self._manager.admin_context,
1609 mock.sentinel.instance_id)] * expected_try_count)
1610 mock_sleep.assert_has_calls([mock.call(1)] * expected_sleep_count)
1612 def test_wait_for_instance_timeout(self):
1613 server_get_side_eff = [
1614 exception.InstanceNotFound(
1615 instance_id=mock.sentinel.instance_id),
1616 {'status': 'BUILDING'},
1617 {'status': 'ACTIVE'}]
1618 # Note that in this case, although the status is active, the
1619 # 'networks' field is missing.
1620 self._test_wait_for_instance( # pylint: disable=no-value-for-parameter
1621 server_get_side_eff=server_get_side_eff,
1622 expected_exc=exception.ServiceInstanceException,
1623 expected_try_count=3,
1624 expected_sleep_count=3)
1626 def test_wait_for_instance_error_state(self):
1627 mock_instance = {'status': 'ERROR'}
1628 self._test_wait_for_instance( # pylint: disable=no-value-for-parameter
1629 server_get_side_eff=[mock_instance],
1630 expected_exc=exception.ServiceInstanceException,
1631 expected_try_count=1)
1633 def test_wait_for_instance_available(self):
1634 mock_instance = {'status': 'ACTIVE',
1635 'networks': mock.sentinel.networks}
1636 self._test_wait_for_instance( # pylint: disable=no-value-for-parameter
1637 server_get_side_eff=[mock_instance],
1638 expected_try_count=1,
1639 expected_ret_val=mock_instance)
1641 def test_reboot_server(self):
1642 fake_server = {'instance_id': mock.sentinel.instance_id}
1643 soft_reboot = True
1645 mock_reboot = mock.Mock()
1646 self.mock_object(self._manager.compute_api, 'server_reboot',
1647 mock_reboot)
1649 self._manager.reboot_server(fake_server, soft_reboot)
1651 mock_reboot.assert_called_once_with(self._manager.admin_context,
1652 fake_server['instance_id'],
1653 soft_reboot)
1656class BaseNetworkHelperTestCase(test.TestCase):
1657 """Tests Base network helper for service instance."""
1659 def test_instantiate_valid(self):
1660 class FakeNetworkHelper(service_instance.BaseNetworkhelper):
1661 @property
1662 def NAME(self):
1663 return 'fake_NAME'
1665 def __init__(self, service_instance_manager):
1666 self.fake_init = 'fake_init_value'
1668 def get_network_name(self, network_info):
1669 return 'fake_network_name'
1671 def setup_connectivity_with_service_instances(self):
1672 return 'fake_setup_connectivity_with_service_instances'
1674 def setup_network(self, network_info):
1675 return 'fake_setup_network'
1677 def teardown_network(self, server_details):
1678 return 'fake_teardown_network'
1680 instance = FakeNetworkHelper('fake')
1682 attrs = [
1683 'fake_init', 'NAME', 'get_network_name', 'teardown_network',
1684 'setup_connectivity_with_service_instances', 'setup_network',
1685 ]
1686 for attr in attrs:
1687 self.assertTrue(hasattr(instance, attr))
1688 self.assertEqual('fake_init_value', instance.fake_init)
1689 self.assertEqual('fake_NAME', instance.NAME)
1690 self.assertEqual(
1691 'fake_network_name', instance.get_network_name('fake'))
1692 self.assertEqual(
1693 'fake_setup_connectivity_with_service_instances',
1694 instance.setup_connectivity_with_service_instances())
1695 self.assertEqual('fake_setup_network', instance.setup_network('fake'))
1696 self.assertEqual(
1697 'fake_teardown_network', instance.teardown_network('fake'))
1699 def test_instantiate_invalid(self):
1700 self.assertRaises(
1701 TypeError, service_instance.BaseNetworkhelper, 'fake')
1704@ddt.ddt
1705class NeutronNetworkHelperTestCase(test.TestCase):
1706 """Tests Neutron network helper for service instance."""
1708 def setUp(self):
1709 super(NeutronNetworkHelperTestCase, self).setUp()
1710 self.mock_object(importutils, 'import_class')
1711 self.fake_manager = FakeServiceInstance()
1713 def _init_neutron_network_plugin(self):
1714 self.mock_object(
1715 service_instance.NeutronNetworkHelper, '_get_service_network_id',
1716 mock.Mock(return_value='fake_service_network_id'))
1717 return service_instance.NeutronNetworkHelper(self.fake_manager)
1719 def test_init_neutron_network_plugin(self):
1720 instance = self._init_neutron_network_plugin()
1721 self.assertEqual(service_instance.NEUTRON_NAME, instance.NAME)
1722 attrs = [
1723 'neutron_api', 'vif_driver', 'service_network_id',
1724 'connect_share_server_to_tenant_network', 'get_config_option']
1725 for attr in attrs:
1726 self.assertTrue(hasattr(instance, attr), "No attr '%s'" % attr)
1727 (service_instance.NeutronNetworkHelper._get_service_network_id.
1728 assert_called_once_with())
1729 self.assertEqual('DEFAULT', instance.neutron_api.config_group_name)
1731 def test_init_neutron_network_plugin_with_driver_config_group(self):
1732 self.fake_manager.driver_config = mock.Mock()
1733 self.fake_manager.driver_config.config_group = (
1734 'fake_config_group')
1735 self.fake_manager.driver_config.network_config_group = None
1736 instance = self._init_neutron_network_plugin()
1737 self.assertEqual('fake_config_group',
1738 instance.neutron_api.config_group_name)
1740 def test_init_neutron_network_plugin_with_network_config_group(self):
1741 self.fake_manager.driver_config = mock.Mock()
1742 self.fake_manager.driver_config.config_group = (
1743 "fake_config_group")
1744 self.fake_manager.driver_config.network_config_group = (
1745 "fake_network_config_group")
1746 instance = self._init_neutron_network_plugin()
1747 self.assertEqual('fake_network_config_group',
1748 instance.neutron_api.config_group_name)
1750 def test_admin_project_id(self):
1751 instance = self._init_neutron_network_plugin()
1752 admin_project_id = 'fake_admin_project_id'
1753 self.mock_class('manila.network.neutron.api.API', mock.Mock())
1754 instance.neutron_api.admin_project_id = admin_project_id
1755 self.assertEqual(admin_project_id, instance.admin_project_id)
1757 def test_get_network_name(self):
1758 network_info = dict(neutron_net_id='fake_neutron_net_id')
1759 network = dict(name='fake_network_name')
1760 instance = self._init_neutron_network_plugin()
1761 self.mock_object(
1762 instance.neutron_api, 'get_network',
1763 mock.Mock(return_value=network))
1765 result = instance.get_network_name(network_info)
1767 self.assertEqual(network['name'], result)
1768 instance.neutron_api.get_network.assert_called_once_with(
1769 network_info['neutron_net_id'])
1771 def test_get_service_network_id_none_exist(self):
1772 service_network_name = fake_get_config_option('service_network_name')
1773 network = dict(id='fake_network_id')
1774 admin_project_id = 'fake_admin_project_id'
1775 self.mock_object(
1776 service_instance.neutron.API, 'get_all_admin_project_networks',
1777 mock.Mock(return_value=[]))
1778 self.mock_object(
1779 service_instance.neutron.API, 'admin_project_id',
1780 mock.Mock(return_value=admin_project_id))
1781 self.mock_object(
1782 service_instance.neutron.API, 'network_create',
1783 mock.Mock(return_value=network))
1784 instance = service_instance.NeutronNetworkHelper(self.fake_manager)
1786 result = instance._get_service_network_id()
1788 self.assertEqual(network['id'], result)
1789 self.assertTrue(service_instance.neutron.API.
1790 get_all_admin_project_networks.called)
1791 service_instance.neutron.API.network_create.assert_has_calls([
1792 mock.call(instance.admin_project_id, service_network_name)])
1794 def test_get_service_network_id_one_exist(self):
1795 service_network_name = fake_get_config_option('service_network_name')
1796 network = dict(id='fake_network_id', name=service_network_name)
1797 admin_project_id = 'fake_admin_project_id'
1798 self.mock_object(
1799 service_instance.neutron.API, 'get_all_admin_project_networks',
1800 mock.Mock(return_value=[network]))
1801 self.mock_object(
1802 service_instance.neutron.API, 'admin_project_id',
1803 mock.Mock(return_value=admin_project_id))
1804 instance = service_instance.NeutronNetworkHelper(self.fake_manager)
1806 result = instance._get_service_network_id()
1808 self.assertEqual(network['id'], result)
1809 self.assertTrue(service_instance.neutron.API.
1810 get_all_admin_project_networks.called)
1812 def test_get_service_network_id_two_exist(self):
1813 service_network_name = fake_get_config_option('service_network_name')
1814 network = dict(id='fake_network_id', name=service_network_name)
1815 self.mock_object(
1816 service_instance.neutron.API, 'get_all_admin_project_networks',
1817 mock.Mock(return_value=[network, network]))
1819 helper = service_instance.NeutronNetworkHelper(self.fake_manager)
1820 self.assertRaises(exception.ManilaException,
1821 lambda: helper.service_network_id)
1823 (service_instance.neutron.API.get_all_admin_project_networks.
1824 assert_has_calls([mock.call()]))
1826 @ddt.data(dict(), dict(subnet_id='foo'), dict(router_id='bar'))
1827 def test_teardown_network_no_service_data(self, server_details):
1828 fake_ports = [
1829 {'device_id': 'fake_device_id',
1830 'device_owner': 'compute:foo'},
1831 ]
1832 self.mock_object(
1833 service_instance.neutron.API, 'update_subnet')
1834 self.mock_object(
1835 service_instance.neutron.API, 'list_ports',
1836 mock.Mock(return_value=fake_ports))
1837 instance = self._init_neutron_network_plugin()
1838 self.mock_object(
1839 service_instance.neutron.API, 'router_remove_interface')
1841 instance.teardown_network(server_details)
1843 self.assertFalse(
1844 service_instance.neutron.API.router_remove_interface.called)
1846 @ddt.data(
1847 *[dict(server_details=sd, fail=f) for f in (True, False)
1848 for sd in (dict(service_port_id='fake_service_port_id'),
1849 dict(public_port_id='fake_public_port_id'),
1850 dict(service_port_id='fake_service_port_id',
1851 public_port_id='fake_public_port_id'))]
1852 )
1853 @ddt.unpack
1854 def test_teardown_network_with_ports(self, server_details, fail):
1855 instance = self._init_neutron_network_plugin()
1856 self.mock_object(
1857 service_instance.neutron.API, 'router_remove_interface')
1858 if fail:
1859 delete_port_mock = mock.Mock(
1860 side_effect=exception.NetworkException(code=404))
1861 else:
1862 delete_port_mock = mock.Mock()
1863 self.mock_object(instance.neutron_api, 'delete_port', delete_port_mock)
1864 self.mock_object(service_instance.LOG, 'debug')
1866 instance.teardown_network(server_details)
1868 self.assertFalse(instance.neutron_api.router_remove_interface.called)
1869 self.assertEqual(
1870 len(server_details),
1871 len(instance.neutron_api.delete_port.mock_calls))
1872 for k, v in server_details.items():
1873 self.assertIn(
1874 mock.call(v), instance.neutron_api.delete_port.mock_calls)
1875 if fail:
1876 service_instance.LOG.debug.assert_has_calls([
1877 mock.call(mock.ANY, mock.ANY) for sd in server_details
1878 ])
1879 else:
1880 service_instance.LOG.debug.assert_has_calls([])
1882 @ddt.data(
1883 dict(service_port_id='fake_service_port_id'),
1884 dict(public_port_id='fake_public_port_id'),
1885 dict(service_port_id='fake_service_port_id',
1886 public_port_id='fake_public_port_id'),
1887 )
1888 def test_teardown_network_with_ports_unhandled_exception(self,
1889 server_details):
1890 instance = self._init_neutron_network_plugin()
1891 self.mock_object(
1892 service_instance.neutron.API, 'router_remove_interface')
1893 delete_port_mock = mock.Mock(
1894 side_effect=exception.NetworkException(code=500))
1895 self.mock_object(
1896 service_instance.neutron.API, 'delete_port', delete_port_mock)
1897 self.mock_object(service_instance.LOG, 'debug')
1899 self.assertRaises(
1900 exception.NetworkException,
1901 instance.teardown_network,
1902 server_details,
1903 )
1905 self.assertFalse(
1906 service_instance.neutron.API.router_remove_interface.called)
1907 service_instance.neutron.API.delete_port.assert_called_once_with(
1908 mock.ANY)
1909 service_instance.LOG.debug.assert_has_calls([])
1911 def test_teardown_network_with_wrong_ports(self):
1912 instance = self._init_neutron_network_plugin()
1913 self.mock_object(
1914 service_instance.neutron.API, 'router_remove_interface')
1915 self.mock_object(
1916 service_instance.neutron.API, 'delete_port')
1917 self.mock_object(service_instance.LOG, 'debug')
1919 instance.teardown_network(dict(foo_id='fake_service_port_id'))
1921 service_instance.neutron.API.router_remove_interface.assert_has_calls(
1922 [])
1923 service_instance.neutron.API.delete_port.assert_has_calls([])
1924 service_instance.LOG.debug.assert_has_calls([])
1926 def test_teardown_network_subnet_is_used(self):
1927 server_details = dict(subnet_id='foo', router_id='bar')
1928 fake_ports = [
1929 {'device_id': 'fake_device_id',
1930 'device_owner': 'compute:foo'},
1931 ]
1932 instance = self._init_neutron_network_plugin()
1933 self.mock_object(
1934 service_instance.neutron.API, 'router_remove_interface')
1935 self.mock_object(
1936 service_instance.neutron.API, 'update_subnet')
1937 self.mock_object(
1938 service_instance.neutron.API, 'list_ports',
1939 mock.Mock(return_value=fake_ports))
1941 instance.teardown_network(server_details)
1943 self.assertFalse(
1944 service_instance.neutron.API.router_remove_interface.called)
1945 self.assertFalse(service_instance.neutron.API.update_subnet.called)
1946 service_instance.neutron.API.list_ports.assert_called_once_with(
1947 fields=['device_id', 'device_owner'], fixed_ips=['subnet_id=foo'])
1949 def test_teardown_network_subnet_not_used(self):
1950 server_details = dict(subnet_id='foo', router_id='bar')
1951 fake_ports = [
1952 {'device_id': 'fake_device_id',
1953 'device_owner': 'network:router_interface'},
1954 {'device_id': 'fake_device_id',
1955 'device_owner': 'compute'},
1956 {'device_id': '',
1957 'device_owner': 'compute'},
1958 ]
1959 instance = self._init_neutron_network_plugin()
1960 self.mock_object(
1961 service_instance.neutron.API, 'router_remove_interface')
1962 self.mock_object(
1963 service_instance.neutron.API, 'update_subnet')
1964 self.mock_object(
1965 service_instance.neutron.API, 'list_ports',
1966 mock.Mock(return_value=fake_ports))
1968 instance.teardown_network(server_details)
1970 (service_instance.neutron.API.router_remove_interface.
1971 assert_called_once_with('bar', 'foo'))
1972 (service_instance.neutron.API.update_subnet.
1973 assert_called_once_with('foo', ''))
1974 service_instance.neutron.API.list_ports.assert_called_once_with(
1975 fields=['device_id', 'device_owner'], fixed_ips=['subnet_id=foo'])
1977 def test_teardown_network_subnet_not_used_with_no_router_id(self):
1978 server_details = dict(subnet_id='foo')
1979 fake_ports = [
1980 {'device_id': 'fake_device_id',
1981 'device_owner': 'compute'},
1982 {'device_id': '',
1983 'device_owner': 'compute'},
1984 ]
1985 instance = self._init_neutron_network_plugin()
1986 self.mock_object(
1987 service_instance.neutron.API, 'router_remove_interface')
1988 self.mock_object(
1989 service_instance.neutron.API, 'update_subnet')
1990 self.mock_object(
1991 service_instance.neutron.API, 'list_ports',
1992 mock.Mock(return_value=fake_ports))
1994 instance.teardown_network(server_details)
1995 self.assertFalse(
1996 service_instance.neutron.API.router_remove_interface.called)
1997 (service_instance.neutron.API.update_subnet.
1998 assert_called_once_with('foo', ''))
1999 service_instance.neutron.API.list_ports.assert_called_once_with(
2000 fields=['device_id', 'device_owner'], fixed_ips=['subnet_id=foo'])
2002 def test_teardown_network_subnet_not_used_and_get_error_404(self):
2003 server_details = dict(subnet_id='foo', router_id='bar')
2004 fake_ports = [
2005 {'device_id': 'fake_device_id',
2006 'device_owner': 'fake'},
2007 ]
2008 instance = self._init_neutron_network_plugin()
2009 self.mock_object(
2010 service_instance.neutron.API, 'router_remove_interface',
2011 mock.Mock(side_effect=exception.NetworkException(code=404)))
2012 self.mock_object(
2013 service_instance.neutron.API, 'update_subnet')
2014 self.mock_object(
2015 service_instance.neutron.API, 'list_ports',
2016 mock.Mock(return_value=fake_ports))
2018 instance.teardown_network(server_details)
2020 (service_instance.neutron.API.router_remove_interface.
2021 assert_called_once_with('bar', 'foo'))
2022 (service_instance.neutron.API.update_subnet.
2023 assert_called_once_with('foo', ''))
2024 service_instance.neutron.API.list_ports.assert_called_once_with(
2025 fields=['device_id', 'device_owner'], fixed_ips=['subnet_id=foo'])
2027 def test_teardown_network_subnet_not_used_get_unhandled_error(self):
2028 server_details = dict(subnet_id='foo', router_id='bar')
2029 fake_ports = [
2030 {'device_id': 'fake_device_id',
2031 'device_owner': 'fake'},
2032 ]
2033 instance = self._init_neutron_network_plugin()
2034 self.mock_object(
2035 service_instance.neutron.API, 'router_remove_interface',
2036 mock.Mock(side_effect=exception.NetworkException(code=500)))
2037 self.mock_object(
2038 service_instance.neutron.API, 'update_subnet')
2039 self.mock_object(
2040 service_instance.neutron.API, 'list_ports',
2041 mock.Mock(return_value=fake_ports))
2043 self.assertRaises(
2044 exception.NetworkException,
2045 instance.teardown_network, server_details)
2047 (service_instance.neutron.API.router_remove_interface.
2048 assert_called_once_with('bar', 'foo'))
2049 self.assertFalse(service_instance.neutron.API.update_subnet.called)
2050 service_instance.neutron.API.list_ports.assert_called_once_with(
2051 fields=['device_id', 'device_owner'], fixed_ips=['subnet_id=foo'])
2053 def test_setup_network_and_connect_share_server_to_tenant_net(self):
2054 def fake_create_port(*aargs, **kwargs):
2055 if aargs[1] == 'fake_service_network_id':
2056 return self.service_port
2057 elif aargs[1] == 'fake_tenant_network_id': 2057 ↛ 2060line 2057 didn't jump to line 2060 because the condition on line 2057 was always true
2058 return self.public_port
2059 else:
2060 raise exception.ManilaException('Got unexpected data')
2062 admin_project_id = 'fake_admin_project_id'
2063 network_info = dict(
2064 neutron_net_id='fake_tenant_network_id',
2065 neutron_subnet_id='fake_tenant_subnet_id')
2066 cidr = '13.0.0.0/24'
2067 self.service_port = dict(
2068 id='fake_service_port_id',
2069 fixed_ips=[dict(ip_address='fake_service_port_ip_address')])
2070 self.public_port = dict(
2071 id='fake_tenant_port_id',
2072 fixed_ips=[dict(ip_address='fake_public_port_ip_address')])
2073 service_subnet = dict(id='fake_service_subnet')
2074 instance = self._init_neutron_network_plugin()
2075 instance.connect_share_server_to_tenant_network = True
2076 self.mock_object(instance, '_get_service_network_id',
2077 mock.Mock(return_value='fake_service_network_id'))
2078 self.mock_object(
2079 service_instance.neutron.API, 'admin_project_id',
2080 mock.Mock(return_value=admin_project_id))
2081 self.mock_object(
2082 service_instance.neutron.API, 'create_port',
2083 mock.Mock(side_effect=fake_create_port))
2084 self.mock_object(
2085 service_instance.neutron.API, 'subnet_create',
2086 mock.Mock(return_value=service_subnet))
2087 self.mock_object(
2088 instance, 'setup_connectivity_with_service_instances',
2089 mock.Mock(return_value=service_subnet))
2090 self.mock_object(
2091 instance, '_get_cidr_for_subnet', mock.Mock(return_value=cidr))
2092 self.mock_object(
2093 instance, '_get_service_subnet', mock.Mock(return_value=None))
2094 expected = {
2095 'ip_address': self.public_port['fixed_ips'][0]['ip_address'],
2096 'public_port': self.public_port,
2097 'service_port': self.service_port,
2098 'service_subnet': service_subnet,
2099 'ports': [self.public_port, self.service_port],
2100 'nics': [{'port-id': self.public_port['id']},
2101 {'port-id': self.service_port['id']}]}
2103 result = instance.setup_network(network_info)
2105 self.assertEqual(expected, result)
2106 (instance.setup_connectivity_with_service_instances.
2107 assert_called_once_with())
2108 instance._get_service_subnet.assert_called_once_with(mock.ANY)
2109 instance._get_cidr_for_subnet.assert_called_once_with()
2110 self.assertTrue(service_instance.neutron.API.subnet_create.called)
2111 self.assertTrue(service_instance.neutron.API.create_port.called)
2113 def test_setup_network_and_connect_share_server_to_tenant_net_admin(self):
2114 def fake_create_port(*aargs, **kwargs):
2115 if aargs[1] == 'fake_admin_network_id':
2116 return self.admin_port
2117 elif aargs[1] == 'fake_tenant_network_id': 2117 ↛ 2120line 2117 didn't jump to line 2120 because the condition on line 2117 was always true
2118 return self.public_port
2119 else:
2120 raise exception.ManilaException('Got unexpected data')
2122 admin_project_id = 'fake_admin_project_id'
2123 network_info = {
2124 'neutron_net_id': 'fake_tenant_network_id',
2125 'neutron_subnet_id': 'fake_tenant_subnet_id'}
2126 self.admin_port = {
2127 'id': 'fake_admin_port_id',
2128 'fixed_ips': [{'ip_address': 'fake_admin_port_ip_address'}]}
2129 self.public_port = {
2130 'id': 'fake_tenant_port_id',
2131 'fixed_ips': [{'ip_address': 'fake_public_port_ip_address'}]}
2132 instance = self._init_neutron_network_plugin()
2133 instance.use_admin_port = True
2134 instance.use_service_network = False
2135 instance.admin_network_id = 'fake_admin_network_id'
2136 instance.admin_subnet_id = 'fake_admin_subnet_id'
2137 instance.connect_share_server_to_tenant_network = True
2138 self.mock_object(
2139 service_instance.neutron.API, 'admin_project_id',
2140 mock.Mock(return_value=admin_project_id))
2141 self.mock_object(
2142 service_instance.neutron.API, 'create_port',
2143 mock.Mock(side_effect=fake_create_port))
2144 self.mock_object(
2145 instance, 'setup_connectivity_with_service_instances')
2146 expected = {
2147 'ip_address': self.public_port['fixed_ips'][0]['ip_address'],
2148 'public_port': self.public_port,
2149 'admin_port': self.admin_port,
2150 'ports': [self.public_port, self.admin_port],
2151 'nics': [{'port-id': self.public_port['id']},
2152 {'port-id': self.admin_port['id']}]}
2154 result = instance.setup_network(network_info)
2156 self.assertEqual(expected, result)
2157 (instance.setup_connectivity_with_service_instances.
2158 assert_called_once_with())
2159 self.assertTrue(service_instance.neutron.API.create_port.called)
2161 @ddt.data(None, exception.NetworkException(code=400))
2162 def test_setup_network_using_router_success(self, return_obj):
2163 admin_project_id = 'fake_admin_project_id'
2164 network_info = dict(
2165 neutron_net_id='fake_tenant_network_id',
2166 neutron_subnet_id='fake_tenant_subnet_id')
2167 cidr = '13.0.0.0/24'
2168 self.admin_port = {
2169 'id': 'fake_admin_port_id',
2170 'fixed_ips': [{'ip_address': 'fake_admin_port_ip_address'}]}
2171 self.service_port = dict(
2172 id='fake_service_port_id',
2173 fixed_ips=[dict(ip_address='fake_service_port_ip_address')])
2174 service_subnet = dict(id='fake_service_subnet')
2175 instance = self._init_neutron_network_plugin()
2176 instance.use_admin_port = True
2177 instance.admin_network_id = 'fake_admin_network_id'
2178 instance.admin_subnet_id = 'fake_admin_subnet_id'
2179 instance.connect_share_server_to_tenant_network = False
2180 self.mock_object(instance, '_get_service_network_id',
2181 mock.Mock(return_value='fake_service_network_id'))
2182 router = dict(id='fake_router_id')
2183 self.mock_object(
2184 service_instance.neutron.API, 'admin_project_id',
2185 mock.Mock(return_value=admin_project_id))
2186 self.mock_object(
2187 service_instance.neutron.API, 'create_port',
2188 mock.Mock(side_effect=[self.service_port, self.admin_port]))
2189 self.mock_object(
2190 service_instance.neutron.API, 'subnet_create',
2191 mock.Mock(return_value=service_subnet))
2192 self.mock_object(
2193 instance, '_get_private_router', mock.Mock(return_value=router))
2194 self.mock_object(
2195 service_instance.neutron.API, 'router_add_interface',
2196 mock.Mock(side_effect=return_obj))
2197 self.mock_object(instance, 'setup_connectivity_with_service_instances')
2198 self.mock_object(
2199 instance, '_get_cidr_for_subnet', mock.Mock(return_value=cidr))
2200 self.mock_object(
2201 instance, '_get_service_subnet', mock.Mock(return_value=None))
2202 expected = {
2203 'ip_address': self.service_port['fixed_ips'][0]['ip_address'],
2204 'service_port': self.service_port,
2205 'service_subnet': service_subnet,
2206 'admin_port': self.admin_port, 'router': router,
2207 'ports': [self.service_port, self.admin_port],
2208 'nics': [{'port-id': self.service_port['id']},
2209 {'port-id': self.admin_port['id']}]}
2211 result = instance.setup_network(network_info)
2213 self.assertEqual(expected, result)
2214 (instance.setup_connectivity_with_service_instances.
2215 assert_called_once_with())
2216 instance._get_service_subnet.assert_called_once_with(mock.ANY)
2217 instance._get_cidr_for_subnet.assert_called_once_with()
2218 self.assertTrue(service_instance.neutron.API.subnet_create.called)
2219 self.assertTrue(service_instance.neutron.API.create_port.called)
2220 instance._get_private_router.assert_called_once_with(
2221 network_info['neutron_net_id'], network_info['neutron_subnet_id'])
2222 (service_instance.neutron.API.router_add_interface.
2223 assert_called_once_with(router['id'], service_subnet['id']))
2225 def test_setup_network_using_router_addon_of_interface_failed(self):
2226 network_info = dict(
2227 neutron_net_id='fake_tenant_network_id',
2228 neutron_subnet_id='fake_tenant_subnet_id')
2229 service_subnet = dict(id='fake_service_subnet')
2230 instance = self._init_neutron_network_plugin()
2231 instance.connect_share_server_to_tenant_network = False
2232 self.mock_object(instance, '_get_service_network_id',
2233 mock.Mock(return_value='fake_service_network_id'))
2234 router = dict(id='fake_router_id')
2235 self.mock_object(
2236 instance, '_get_private_router', mock.Mock(return_value=router))
2237 self.mock_object(
2238 service_instance.neutron.API, 'router_add_interface',
2239 mock.Mock(side_effect=exception.NetworkException(code=500)))
2240 self.mock_object(
2241 instance, '_get_service_subnet',
2242 mock.Mock(return_value=service_subnet))
2244 self.assertRaises(
2245 exception.NetworkException,
2246 instance.setup_network, network_info)
2248 instance._get_service_subnet.assert_called_once_with(mock.ANY)
2249 instance._get_private_router.assert_called_once_with(
2250 network_info['neutron_net_id'], network_info['neutron_subnet_id'])
2251 (service_instance.neutron.API.router_add_interface.
2252 assert_called_once_with(router['id'], service_subnet['id']))
2254 def test_setup_network_using_router_connectivity_verification_fail(self):
2255 admin_project_id = 'fake_admin_project_id'
2256 network_info = dict(
2257 neutron_net_id='fake_tenant_network_id',
2258 neutron_subnet_id='fake_tenant_subnet_id')
2259 cidr = '13.0.0.0/24'
2260 self.service_port = dict(
2261 id='fake_service_port_id',
2262 fixed_ips=[dict(ip_address='fake_service_port_ip_address')])
2263 service_subnet = dict(id='fake_service_subnet')
2264 instance = self._init_neutron_network_plugin()
2265 instance.connect_share_server_to_tenant_network = False
2266 self.mock_object(instance, '_get_service_network_id',
2267 mock.Mock(return_value='fake_service_network_id'))
2268 router = dict(id='fake_router_id')
2269 self.mock_object(
2270 service_instance.neutron.API, 'admin_project_id',
2271 mock.Mock(return_value=admin_project_id))
2272 self.mock_object(
2273 service_instance.neutron.API, 'create_port',
2274 mock.Mock(return_value=self.service_port))
2275 self.mock_object(
2276 service_instance.neutron.API, 'subnet_create',
2277 mock.Mock(return_value=service_subnet))
2278 self.mock_object(service_instance.neutron.API, 'delete_port')
2279 self.mock_object(
2280 instance, '_get_private_router', mock.Mock(return_value=router))
2281 self.mock_object(
2282 service_instance.neutron.API, 'router_add_interface')
2283 self.mock_object(
2284 instance, 'setup_connectivity_with_service_instances',
2285 mock.Mock(side_effect=exception.ManilaException('Fake')))
2286 self.mock_object(
2287 instance, '_get_cidr_for_subnet', mock.Mock(return_value=cidr))
2288 self.mock_object(
2289 instance, '_get_service_subnet', mock.Mock(return_value=None))
2291 self.assertRaises(
2292 exception.ManilaException, instance.setup_network, network_info)
2294 (instance.setup_connectivity_with_service_instances.
2295 assert_called_once_with())
2296 instance._get_service_subnet.assert_called_once_with(mock.ANY)
2297 instance._get_cidr_for_subnet.assert_called_once_with()
2298 self.assertTrue(service_instance.neutron.API.subnet_create.called)
2299 self.assertTrue(service_instance.neutron.API.create_port.called)
2300 instance._get_private_router.assert_called_once_with(
2301 network_info['neutron_net_id'], network_info['neutron_subnet_id'])
2302 (service_instance.neutron.API.router_add_interface.
2303 assert_called_once_with(router['id'], service_subnet['id']))
2304 service_instance.neutron.API.delete_port.assert_has_calls([
2305 mock.call(self.service_port['id'])])
2307 def test__get_cidr_for_subnet_success(self):
2308 expected = (
2309 fake_get_config_option('service_network_cidr').split('/')[0] +
2310 '/' + str(
2311 fake_get_config_option('service_network_division_mask')))
2312 instance = self._init_neutron_network_plugin()
2313 self.mock_object(
2314 instance, '_get_all_service_subnets', mock.Mock(return_value=[]))
2316 result = instance._get_cidr_for_subnet()
2318 self.assertEqual(expected, result)
2319 instance._get_all_service_subnets.assert_called_once_with()
2321 def test__get_cidr_for_subnet_failure(self):
2322 subnets = []
2323 serv_cidr = netaddr.IPNetwork(
2324 fake_get_config_option('service_network_cidr'))
2325 division_mask = fake_get_config_option('service_network_division_mask')
2326 for subnet in serv_cidr.subnet(division_mask):
2327 subnets.append(dict(cidr=str(subnet.cidr)))
2328 instance = self._init_neutron_network_plugin()
2329 self.mock_object(
2330 instance, '_get_all_service_subnets',
2331 mock.Mock(return_value=subnets))
2333 self.assertRaises(
2334 exception.ServiceInstanceException,
2335 instance._get_cidr_for_subnet)
2337 instance._get_all_service_subnets.assert_called_once_with()
2339 def test_setup_connectivity_with_service_instances(self):
2340 instance = self._init_neutron_network_plugin()
2341 instance.use_admin_port = True
2342 instance.admin_network_id = 'fake_admin_network_id'
2343 instance.admin_subnet_id = 'fake_admin_subnet_id'
2344 interface_name_service = 'fake_interface_name_service'
2345 interface_name_admin = 'fake_interface_name_admin'
2346 fake_division_mask = fake_get_config_option(
2347 'service_network_division_mask')
2348 fake_subnet_service = fake_network.FakeSubnet(
2349 cidr='10.254.0.0/%s' % fake_division_mask)
2350 fake_subnet_admin = fake_network.FakeSubnet(id='fake_admin_subnet_id',
2351 cidr='10.0.0.0/24')
2352 fake_service_port = fake_network.FakePort(fixed_ips=[
2353 {'subnet_id': fake_subnet_service['id'],
2354 'ip_address': '10.254.0.2'}], mac_address='fake_mac_address')
2355 fake_admin_port = fake_network.FakePort(fixed_ips=[
2356 {'subnet_id': fake_subnet_admin['id'], 'ip_address': '10.0.0.4'}],
2357 mac_address='fake_mac_address')
2359 self.mock_object(instance, '_get_service_port',
2360 mock.Mock(side_effect=[fake_service_port,
2361 fake_admin_port]))
2362 self.mock_object(instance, '_add_fixed_ips_to_service_port',
2363 mock.Mock(return_value=fake_service_port))
2364 self.mock_object(instance.vif_driver, 'get_device_name',
2365 mock.Mock(side_effect=[interface_name_service,
2366 interface_name_admin]))
2367 self.mock_object(instance.neutron_api, 'get_subnet',
2368 mock.Mock(side_effect=[fake_subnet_service,
2369 fake_subnet_admin,
2370 fake_subnet_admin]))
2371 self.mock_object(instance.vif_driver, 'plug')
2372 device_mock = mock.Mock()
2373 self.mock_object(service_instance.ip_lib, 'IPDevice',
2374 mock.Mock(return_value=device_mock))
2376 instance.setup_connectivity_with_service_instances()
2378 instance._get_service_port.assert_has_calls([
2379 mock.call(instance.service_network_id, None, 'manila-share'),
2380 mock.call('fake_admin_network_id', 'fake_admin_subnet_id',
2381 'manila-admin-share')])
2382 instance.vif_driver.get_device_name.assert_has_calls([
2383 mock.call(fake_service_port), mock.call(fake_admin_port)])
2384 instance.vif_driver.plug.assert_has_calls([
2385 mock.call(interface_name_service, fake_service_port['id'],
2386 fake_service_port['mac_address']),
2387 mock.call(interface_name_admin, fake_admin_port['id'],
2388 fake_admin_port['mac_address'])])
2389 instance.neutron_api.get_subnet.assert_has_calls([
2390 mock.call(fake_subnet_service['id']),
2391 mock.call(fake_subnet_admin['id'])])
2392 instance.vif_driver.init_l3.assert_has_calls([
2393 mock.call(interface_name_service,
2394 ['10.254.0.2/%s' % fake_division_mask],
2395 clear_cidrs=[]),
2396 mock.call(interface_name_admin, ['10.0.0.4/24'],
2397 clear_cidrs=[fake_subnet_admin['cidr']])])
2398 service_instance.ip_lib.IPDevice.assert_has_calls([
2399 mock.call(interface_name_service),
2400 mock.call(interface_name_admin)])
2402 def test__get_service_port_none_exist(self):
2403 instance = self._init_neutron_network_plugin()
2404 admin_project_id = 'fake_admin_project_id'
2405 fake_port_values = {'device_id': 'manila-share',
2406 'binding:host_id': 'fake_service_network_host'}
2407 self.mock_object(
2408 service_instance.neutron.API, 'admin_project_id',
2409 mock.Mock(return_value=admin_project_id))
2410 fake_service_port = fake_network.FakePort(device_id='manila-share')
2411 self.mock_object(instance.neutron_api, 'list_ports',
2412 mock.Mock(return_value=[]))
2413 self.flags(host='fake-host')
2414 self.mock_object(instance.neutron_api, 'create_port',
2415 mock.Mock(return_value=fake_service_port))
2416 self.mock_object(instance.neutron_api, 'update_port_fixed_ips',
2417 mock.Mock(return_value=fake_service_port))
2419 result = instance._get_service_port(instance.service_network_id,
2420 None, 'manila-share')
2422 instance.neutron_api.list_ports.assert_called_once_with(
2423 **fake_port_values)
2424 instance.neutron_api.create_port.assert_called_once_with(
2425 instance.admin_project_id, instance.service_network_id,
2426 device_id='manila-share', device_owner='manila:share',
2427 host_id='fake_service_network_host',
2428 subnet_id=None, port_security_enabled=False)
2429 self.assertFalse(instance.neutron_api.update_port_fixed_ips.called)
2430 self.assertEqual(fake_service_port, result)
2432 def test__get_service_port_one_exist_on_same_host(self):
2433 instance = self._init_neutron_network_plugin()
2434 fake_port_values = {'device_id': 'manila-share',
2435 'binding:host_id': 'fake_service_network_host'}
2436 fake_service_port = fake_network.FakePort(**fake_port_values)
2437 self.flags(host='fake-host')
2438 self.mock_object(instance.neutron_api, 'list_ports',
2439 mock.Mock(return_value=[fake_service_port]))
2440 self.mock_object(instance.neutron_api, 'create_port',
2441 mock.Mock(return_value=fake_service_port))
2442 self.mock_object(instance.neutron_api, 'update_port_fixed_ips',
2443 mock.Mock(return_value=fake_service_port))
2445 result = instance._get_service_port(instance.service_network_id,
2446 None, 'manila-share')
2448 instance.neutron_api.list_ports.assert_called_once_with(
2449 **fake_port_values)
2450 self.assertFalse(instance.neutron_api.create_port.called)
2451 self.assertFalse(instance.neutron_api.update_port_fixed_ips.called)
2452 self.assertEqual(fake_service_port, result)
2454 def test__get_service_port_default_host(self):
2455 self.mock_object(self.fake_manager, 'get_config_option',
2456 mock.Mock(return_value=None))
2457 instance = self._init_neutron_network_plugin()
2458 admin_project_id = 'fake_admin_project_id'
2459 fake_port = {'device_id': 'manila-share',
2460 'binding:host_id': 'fake-host'}
2461 self.mock_object(
2462 service_instance.neutron.API, 'admin_project_id',
2463 mock.Mock(return_value=admin_project_id))
2464 fake_service_port = fake_network.FakePort(**fake_port)
2465 self.mock_object(instance.neutron_api, 'list_ports',
2466 mock.Mock(return_value=[]))
2467 self.flags(host='fake-host')
2468 self.mock_object(instance.neutron_api, 'create_port',
2469 mock.Mock(return_value=fake_service_port))
2470 self.mock_object(instance.neutron_api, 'update_port_fixed_ips',
2471 mock.Mock(return_value=fake_service_port))
2473 result = instance._get_service_port(instance.service_network_id,
2474 None, 'manila-share')
2475 instance.neutron_api.create_port.assert_called_once_with(
2476 instance.admin_project_id, instance.service_network_id,
2477 device_id='manila-share', device_owner='manila:share',
2478 host_id='fake-host', subnet_id=None,
2479 port_security_enabled=False)
2480 self.assertEqual(fake_service_port, result)
2482 def test__get_service_port_one_exist_on_different_host(self):
2483 instance = self._init_neutron_network_plugin()
2484 admin_project_id = 'fake_admin_project_id'
2485 fake_port = {'device_id': 'manila-share',
2486 'binding:host_id': 'fake_service_network_host'}
2487 self.mock_object(
2488 service_instance.neutron.API, 'admin_project_id',
2489 mock.Mock(return_value=admin_project_id))
2490 fake_service_port = fake_network.FakePort(**fake_port)
2491 self.mock_object(instance.neutron_api, 'list_ports',
2492 mock.Mock(return_value=[]))
2493 self.flags(host='fake-host')
2494 self.mock_object(instance.neutron_api, 'create_port',
2495 mock.Mock(return_value=fake_service_port))
2496 self.mock_object(instance.neutron_api, 'update_port_fixed_ips',
2497 mock.Mock(return_value=fake_service_port))
2499 result = instance._get_service_port(instance.service_network_id,
2500 None, 'manila-share')
2502 instance.neutron_api.list_ports.assert_called_once_with(
2503 **fake_port)
2504 instance.neutron_api.create_port.assert_called_once_with(
2505 instance.admin_project_id, instance.service_network_id,
2506 device_id='manila-share', device_owner='manila:share',
2507 host_id='fake_service_network_host', subnet_id=None,
2508 port_security_enabled=False)
2509 self.assertFalse(instance.neutron_api.update_port_fixed_ips.called)
2510 self.assertEqual(fake_service_port, result)
2512 def test__get_service_port_two_exist_on_same_host(self):
2513 instance = self._init_neutron_network_plugin()
2514 fake_service_port = fake_network.FakePort(**{
2515 'device_id': 'manila-share', 'binding:host_id': 'fake-host'})
2516 self.mock_object(
2517 instance.neutron_api, 'list_ports',
2518 mock.Mock(return_value=[fake_service_port, fake_service_port]))
2519 self.flags(host='fake-host')
2520 self.mock_object(instance.neutron_api, 'create_port',
2521 mock.Mock(return_value=fake_service_port))
2522 self.assertRaises(
2523 exception.ServiceInstanceException, instance._get_service_port,
2524 instance.service_network_id, None, 'manila-share')
2525 self.assertFalse(instance.neutron_api.create_port.called)
2527 def test__add_fixed_ips_to_service_port(self):
2528 ip_address1 = '13.0.0.13'
2529 subnet_id1 = 'fake_subnet_id1'
2530 subnet_id2 = 'fake_subnet_id2'
2531 port = dict(id='fooport', fixed_ips=[dict(
2532 subnet_id=subnet_id1, ip_address=ip_address1)])
2533 expected = mock.Mock()
2534 network = dict(subnets=[subnet_id1, subnet_id2])
2535 instance = self._init_neutron_network_plugin()
2536 self.mock_object(instance.neutron_api, 'get_network',
2537 mock.Mock(return_value=network))
2538 self.mock_object(instance.neutron_api, 'update_port_fixed_ips',
2539 mock.Mock(return_value=expected))
2541 result = instance._add_fixed_ips_to_service_port(port)
2543 self.assertEqual(expected, result)
2544 instance.neutron_api.get_network.assert_called_once_with(
2545 instance.service_network_id)
2546 instance.neutron_api.update_port_fixed_ips.assert_called_once_with(
2547 port['id'], dict(fixed_ips=[
2548 dict(subnet_id=subnet_id1, ip_address=ip_address1),
2549 dict(subnet_id=subnet_id2)]))
2551 def test__get_private_router_success(self):
2552 instance = self._init_neutron_network_plugin()
2553 network = fake_network.FakeNetwork()
2554 subnet = fake_network.FakeSubnet(gateway_ip='fake_ip')
2555 router = fake_network.FakeRouter(id='fake_router_id')
2556 port = fake_network.FakePort(fixed_ips=[
2557 dict(subnet_id=subnet['id'],
2558 ip_address=subnet['gateway_ip'])],
2559 device_id=router['id'])
2560 self.mock_object(instance.neutron_api, 'get_subnet',
2561 mock.Mock(return_value=subnet))
2562 self.mock_object(instance.neutron_api, 'list_ports',
2563 mock.Mock(return_value=[port]))
2564 self.mock_object(instance.neutron_api, 'show_router',
2565 mock.Mock(return_value=router))
2567 result = instance._get_private_router(network['id'], subnet['id'])
2569 self.assertEqual(router, result)
2570 instance.neutron_api.get_subnet.assert_called_once_with(subnet['id'])
2571 instance.neutron_api.list_ports.assert_called_once_with(
2572 network_id=network['id'])
2573 instance.neutron_api.show_router.assert_called_once_with(router['id'])
2575 def test__get_private_router_no_gateway(self):
2576 instance = self._init_neutron_network_plugin()
2577 subnet = fake_network.FakeSubnet(gateway_ip='')
2578 self.mock_object(instance.neutron_api, 'get_subnet',
2579 mock.Mock(return_value=subnet))
2581 self.assertRaises(
2582 exception.ServiceInstanceException,
2583 instance._get_private_router, 'fake_network_id', subnet['id'])
2585 instance.neutron_api.get_subnet.assert_called_once_with(
2586 subnet['id'])
2588 def test__get_private_router_subnet_is_not_attached_to_the_router(self):
2589 instance = self._init_neutron_network_plugin()
2590 network_id = 'fake_network_id'
2591 subnet = fake_network.FakeSubnet(gateway_ip='fake_ip')
2592 self.mock_object(instance.neutron_api, 'get_subnet',
2593 mock.Mock(return_value=subnet))
2594 self.mock_object(instance.neutron_api, 'list_ports',
2595 mock.Mock(return_value=[]))
2597 self.assertRaises(
2598 exception.ServiceInstanceException,
2599 instance._get_private_router, network_id, subnet['id'])
2601 instance.neutron_api.get_subnet.assert_called_once_with(
2602 subnet['id'])
2603 instance.neutron_api.list_ports.assert_called_once_with(
2604 network_id=network_id)
2606 def test__get_service_subnet_none_found(self):
2607 subnet_name = 'fake_subnet_name'
2608 instance = self._init_neutron_network_plugin()
2609 self.mock_object(instance, '_get_all_service_subnets',
2610 mock.Mock(return_value=[]))
2612 result = instance._get_service_subnet(subnet_name)
2614 self.assertIsNone(result)
2615 instance._get_all_service_subnets.assert_called_once_with()
2617 def test__get_service_subnet_unused_found(self):
2618 subnet_name = 'fake_subnet_name'
2619 subnets = [fake_network.FakeSubnet(id='foo', name=''),
2620 fake_network.FakeSubnet(id='bar', name='quuz')]
2621 instance = self._init_neutron_network_plugin()
2622 self.mock_object(instance.neutron_api, 'update_subnet')
2623 self.mock_object(instance, '_get_all_service_subnets',
2624 mock.Mock(return_value=subnets))
2626 result = instance._get_service_subnet(subnet_name)
2628 self.assertEqual(subnets[0], result)
2629 instance._get_all_service_subnets.assert_called_once_with()
2630 instance.neutron_api.update_subnet.assert_called_once_with(
2631 subnets[0]['id'], subnet_name)
2633 def test__get_service_subnet_one_found(self):
2634 subnet_name = 'fake_subnet_name'
2635 subnets = [fake_network.FakeSubnet(id='foo', name='quuz'),
2636 fake_network.FakeSubnet(id='bar', name=subnet_name)]
2637 instance = self._init_neutron_network_plugin()
2638 self.mock_object(instance, '_get_all_service_subnets',
2639 mock.Mock(return_value=subnets))
2641 result = instance._get_service_subnet(subnet_name)
2643 self.assertEqual(subnets[1], result)
2644 instance._get_all_service_subnets.assert_called_once_with()
2646 def test__get_service_subnet_two_found(self):
2647 subnet_name = 'fake_subnet_name'
2648 subnets = [fake_network.FakeSubnet(id='foo', name=subnet_name),
2649 fake_network.FakeSubnet(id='bar', name=subnet_name)]
2650 instance = self._init_neutron_network_plugin()
2651 self.mock_object(instance, '_get_all_service_subnets',
2652 mock.Mock(return_value=subnets))
2654 self.assertRaises(
2655 exception.ServiceInstanceException,
2656 instance._get_service_subnet, subnet_name)
2658 instance._get_all_service_subnets.assert_called_once_with()
2660 def test__get_all_service_subnets(self):
2661 subnet_id1 = 'fake_subnet_id1'
2662 subnet_id2 = 'fake_subnet_id2'
2663 instance = self._init_neutron_network_plugin()
2664 network = dict(subnets=[subnet_id1, subnet_id2])
2665 self.mock_object(instance.neutron_api, 'get_subnet',
2666 mock.Mock(side_effect=lambda s_id: dict(id=s_id)))
2667 self.mock_object(instance.neutron_api, 'get_network',
2668 mock.Mock(return_value=network))
2670 result = instance._get_all_service_subnets()
2672 self.assertEqual([dict(id=subnet_id1), dict(id=subnet_id2)], result)
2673 instance.neutron_api.get_network.assert_called_once_with(
2674 instance.service_network_id)
2675 instance.neutron_api.get_subnet.assert_has_calls([
2676 mock.call(subnet_id1), mock.call(subnet_id2)])