openstack
/
manila
Code Issues Proposed changes

Teardown/setup server enhancements 

1. Manager: pass neutron_net_id and neutron_subnet_id in
network_info to setup_server. Pass server_details and
security_services separately to teardown_server

2. Drivers: renamed setup_network/teardown_network methods
to setup_server/teardown_server

3. Generic: pass server backend_details to
set_up_service_instance and delete_service_instance

4 Service_instance: removed passing share_network_id to
setup_server. Return router_id and subnet_id from setup_server.
Added readable naming to service_subnet

Partially-Implements bp setup-teardown-server-enhancements
Change-Id: I9f5ff26fa2635e352043aedf8dde3514deaaba30
This commit is contained in:
Yulia Portnova 2014-06-25 15:30:33 +03:00
parent 33b5aacda3
commit 60211c5ff3
10 changed files with 221 additions and 155 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
manila/share/driver.py
View File

@ -145,12 +145,12 @@ class ShareDriver(object):
"""Returns number of network allocations for creating VIFs."""
pass
def setup_network(self, network_info, metadata=None):
"""Set up and configures VIFs with given network parameters."""
def setup_server(self, network_info, metadata=None):
"""Set up and configures share server with given network parameters."""
pass
def teardown_network(self, network_info):
"""Teardown previously configured VIFs for given network parameters."""
def teardown_server(self, server_details, security_services=None):
"""Teardown share server."""
pass
def _update_share_status(self):

30
manila/share/drivers/generic.py
View File

@ -226,7 +226,6 @@ class GenericShareDriver(driver.ExecuteMixin, driver.ShareDriver):
instance_id,
volume['id'],
)
t = time.time()
while time.time() - t < self.configuration.max_time_to_attach:
volume = self.volume_api.get(context, volume['id'])
@ -490,33 +489,30 @@ class GenericShareDriver(driver.ExecuteMixin, driver.ShareDriver):
# use service instance provided by Nova.
return 0
def setup_network(self, network_info, metadata=None):
sn_id = network_info["share_network_id"]
srv_id = network_info["id"]
msg = "Creating share infrastructure for share network '%s'."
LOG.debug(msg % sn_id)
def setup_server(self, network_info, metadata=None):
msg = "Creating share server '%s'."
LOG.debug(msg % network_info['server_id'])
server = self.service_instance_manager.set_up_service_instance(
context=self.admin_context,
share_server_id=srv_id,
share_network_id=sn_id
self.admin_context,
network_info['server_id'],
network_info['neutron_net_id'],
network_info['neutron_subnet_id'],
)
for helper in self._helpers.values():
helper.init_helper(server)
return server
def teardown_network(self, network_info):
sn_id = network_info["share_network_id"]
server_details = network_info.get("backend_details")
if not server_details:
LOG.warning(_("No backend details provided for service instance. "
"Passing"))
return
def teardown_server(self, server_details, security_services=None):
instance_id = server_details.get("instance_id")
msg = "Removing share infrastructure for service instance '%s'."
LOG.debug(msg % instance_id)
try:
self.service_instance_manager.delete_service_instance(
self.admin_context, sn_id, instance_id)
self.admin_context,
server_details['instance_id'],
server_details['subnet_id'],
server_details['router_id']
)
except Exception as e:
LOG.warning(e)

25
manila/share/drivers/netapp/cluster_mode.py
View File

@ -35,7 +35,7 @@ from manila import utils
NETAPP_NAS_OPTS = [
cfg.StrOpt('netapp_vserver_name_template',
default='os_%(net_id)s',
default='os_%s',
help='Name template to use for new vserver.'),
cfg.StrOpt('netapp_lif_name_template',
default='os_%(net_allocation_id)s',
@ -126,9 +126,9 @@ class NetAppClusteredShareDriver(driver.NetAppShareDriver):
data['QoS_support'] = False
self._stats = data
def setup_network(self, network_info, metadata=None):
def setup_server(self, network_info, metadata=None):
"""Creates and configures new vserver."""
LOG.debug('Configuring network %s' % network_info['id'])
LOG.debug('Creating server %s' % network_info['server_id'])
vserver_name = self._vserver_create_if_not_exists(network_info)
return {'vserver_name': vserver_name}
@ -248,10 +248,6 @@ class NetAppClusteredShareDriver(driver.NetAppShareDriver):
self._helpers = {'CIFS': NetAppClusteredCIFSHelper(),
'NFS': NetAppClusteredNFSHelper()}
def _get_vserver_name(self, net_id):
return self.configuration.netapp_vserver_name_template \
% {'net_id': net_id}
def _vserver_exists(self, vserver_name):
args = {'query': {'vserver-info': {'vserver-name': vserver_name}}}
@ -264,7 +260,8 @@ class NetAppClusteredShareDriver(driver.NetAppShareDriver):
def _vserver_create_if_not_exists(self, network_info):
"""Creates vserver if not exists with given parameters."""
vserver_name = self._get_vserver_name(network_info['id'])
vserver_name = self.configuration.netapp_vserver_name_template % \
network_info['server_id']
vserver_client = driver.NetAppApiClient(
self.api_version, vserver=vserver_name,
configuration=self.configuration)
@ -669,7 +666,7 @@ class NetAppClusteredShareDriver(driver.NetAppShareDriver):
return helper.deny_access(context, share, access)
def _delete_vserver(self, vserver_name, vserver_client,
network_info=None):
security_services=None):
"""
Delete vserver.
@ -701,8 +698,8 @@ class NetAppClusteredShareDriver(driver.NetAppShareDriver):
"Vserver %s has shares.") % vserver_name
LOG.error(msg)
raise exception.NetAppException(msg)
if network_info and network_info.get('security_services'):
for service in network_info['security_services']:
if security_services:
for service in security_services:
if service['type'] == 'active_directory':
args = {'admin-password': service['password'],
'admin-username': service['sid']}
@ -718,14 +715,14 @@ class NetAppClusteredShareDriver(driver.NetAppShareDriver):
self._client.send_request('vserver-destroy',
{'vserver-name': vserver_name})
def teardown_network(self, network_info):
def teardown_server(self, server_details, security_services=None):
"""Teardown share network."""
vserver_name = self._get_vserver_name(network_info['id'])
vserver_name = server_details['vserver_name']
vserver_client = driver.NetAppApiClient(
self.api_version, vserver=vserver_name,
configuration=self.configuration)
self._delete_vserver(vserver_name, vserver_client,
network_info=network_info)
security_services=security_services)
class NetAppClusteredNFSHelper(driver.NetAppNFSHelper):

85
manila/share/drivers/service_instance.py
View File

@ -265,23 +265,27 @@ class ServiceInstanceManager(object):
'been deleted in %ss. Giving up.') %
self.max_time_to_build_instance)
def set_up_service_instance(self, context, share_server_id,
share_network_id):
def set_up_service_instance(self, context, instance_name, neutron_net_id,
neutron_subnet_id):
"""Finds or creates and sets up service vm.
:param context: defines context, that should be used
:param share_network_id: it provides network data for service VM
:param share_server_id: provides server id for service VM
:returns: dict with data for service VM
:param instance_name: provides name for service VM
:param neutron_net_id: provides network id for service VM
:param neutron_subnet_id: provides subnet id for service VM
:returns: dict with service instance details
:raises: exception.ServiceInstanceException
"""
server = self._create_service_instance(context,
share_network_id,
share_server_id)
instance_name,
neutron_net_id,
neutron_subnet_id)
return {'instance_id': server['id'],
'ip': server['ip'],
'pk_path': server['pk_path'],
'subnet_id': server['subnet_id'],
'router_id': server['router_id'],
'password': self.get_config_option(
'service_instance_password'),
'username': self.get_config_option('service_instance_user')}
@ -337,11 +341,10 @@ class ServiceInstanceManager(object):
raise exception.ServiceInstanceException(
_('Ambiguous image name.'))
def _create_service_instance(self, context, share_network_id,
share_server_id):
def _create_service_instance(self, context, instance_name, neutron_net_id,
neutron_subnet_id):
"""Creates service vm and sets up networking for it."""
service_image_id = self._get_service_image(context)
instance_name = self._get_service_instance_name(share_server_id)
with lock:
key_name, key_path = self._get_key(context)
@ -351,12 +354,14 @@ class ServiceInstanceManager(object):
'instance password nor key are available.'))
security_group = self._get_or_create_security_group(context)
port = self._setup_network_for_instance(share_network_id)
subnet_id, router_id, port_id = \
self._setup_network_for_instance(neutron_net_id,
neutron_subnet_id)
try:
self._setup_connectivity_with_service_instances()
except Exception as e:
LOG.debug(e)
self.neutron_api.delete_port(port['id'])
self.neutron_api.delete_port(port_id)
raise
service_instance = self.compute_api.server_create(context,
@ -364,7 +369,7 @@ class ServiceInstanceManager(object):
image=service_image_id,
flavor=self.get_config_option("service_instance_flavor_id"),
key_name=key_name,
nics=[{'port-id': port['id']}])
nics=[{'port-id': port_id}])
t = time.time()
while time.time() - t < self.max_time_to_build_instance:
@ -393,6 +398,9 @@ class ServiceInstanceManager(object):
service_instance['ip'] = self._get_server_ip(service_instance)
service_instance['pk_path'] = key_path
service_instance['router_id'] = router_id
service_instance['subnet_id'] = subnet_id
service_instance['port_id'] = port_id
if not self._check_server_availability(service_instance):
raise exception.ServiceInstanceException(
@ -417,17 +425,23 @@ class ServiceInstanceManager(object):
@lockutils.synchronized("_setup_network_for_instance", external=True,
lock_path="service_instance_locks")
def _setup_network_for_instance(self, share_network_id):
def _setup_network_for_instance(self, neutron_net_id, neutron_subnet_id):
"""Sets up network for service vm."""
service_subnet = self._get_service_subnet(share_network_id)
# We get/create subnet for service instance that is routed to
# subnet provided in args.
subnet_name = "routed_to_%s" % neutron_subnet_id
service_subnet = self._get_service_subnet(subnet_name)
if not service_subnet:
service_subnet = self.neutron_api.subnet_create(
self.service_tenant_id,
self.service_network_id,
share_network_id,
self._get_cidr_for_subnet())
self.service_tenant_id,
self.service_network_id,
subnet_name,
self._get_cidr_for_subnet()
)
private_router = self._get_private_router(share_network_id)
private_router = self._get_private_router(neutron_net_id,
neutron_subnet_id)
try:
self.neutron_api.router_add_interface(private_router['id'],
service_subnet['id'])
@ -439,24 +453,22 @@ class ServiceInstanceManager(object):
{'subnet_id': service_subnet['id'],
'router_id': private_router['id']})
return self.neutron_api.create_port(self.service_tenant_id,
port = self.neutron_api.create_port(self.service_tenant_id,
self.service_network_id,
subnet_id=service_subnet['id'],
device_owner='manila')
return service_subnet['id'], private_router['id'], port['id']
@lockutils.synchronized("_get_private_router", external=True,
lock_path="service_instance_locks")
def _get_private_router(self, share_network_id):
def _get_private_router(self, neutron_net_id, neutron_subnet_id):
"""Returns router attached to private subnet gateway."""
share_network = self.db.share_network_get(self.admin_context,
share_network_id)
private_subnet = self.neutron_api.get_subnet(
share_network['neutron_subnet_id'])
private_subnet = self.neutron_api.get_subnet(neutron_subnet_id)
if not private_subnet['gateway_ip']:
raise exception.ServiceInstanceException(
_('Subnet must have gateway.'))
private_network_ports = [p for p in self.neutron_api.list_ports(
network_id=share_network['neutron_net_id'])]
network_id=neutron_net_id)]
for p in private_network_ports:
fixed_ip = p['fixed_ips'][0]
if (fixed_ip['subnet_id'] == private_subnet['id'] and
@ -578,19 +590,16 @@ class ServiceInstanceManager(object):
else:
raise exception.ServiceInstanceException(_('No available cidrs.'))
def delete_service_instance(self, context, share_network_id,
instance_id):
def delete_service_instance(self, context, instance_id, subnet_id,
router_id):
"""Removes share infrastructure.
Deletes service vm and subnet, associated to share network.
"""
self._delete_server(context, instance_id)
subnet = self._get_service_subnet(share_network_id)
if subnet:
subnet_id = subnet['id']
router = self._get_private_router(share_network_id)
if router_id and subnet_id:
try:
self.neutron_api.router_remove_interface(router['id'],
self.neutron_api.router_remove_interface(router_id,
subnet_id)
except exception.NetworkException as e:
if e.kwargs['code'] != 404:
@ -598,7 +607,7 @@ class ServiceInstanceManager(object):
LOG.debug('Subnet %(subnet_id)s is not attached to the '
'router %(router_id)s.' %
{'subnet_id': subnet_id,
'router_id': router['id']})
'router_id': router_id})
self.neutron_api.update_subnet(subnet_id, '')
@lockutils.synchronized("_get_all_service_subnets", external=True,
@ -610,10 +619,10 @@ class ServiceInstanceManager(object):
@lockutils.synchronized("_get_service_subnet", external=True,
lock_path="service_instance_locks")
def _get_service_subnet(self, share_network_id):
def _get_service_subnet(self, subnet_name):
all_service_subnets = self._get_all_service_subnets()
service_subnets = [subnet for subnet in all_service_subnets
if subnet['name'] == share_network_id]
if subnet['name'] == subnet_name]
if len(service_subnets) == 1:
return service_subnets[0]
elif not service_subnets:
@ -622,7 +631,7 @@ class ServiceInstanceManager(object):
if unused_service_subnets:
service_subnet = unused_service_subnets[0]
self.neutron_api.update_subnet(service_subnet['id'],
share_network_id)
subnet_name)
return service_subnet
return None
else:

29
manila/share/manager.py
View File

@ -337,16 +337,17 @@ class ShareManager(manager.SchedulerDependentManager):
self._report_driver_status(context)
self._publish_service_capabilities(context)
def _form_network_info(self, context, share_server, share_network):
def _form_server_setup_info(self, context, share_server, share_network):
# Network info is used by driver for setting up share server
# and getting server info on share creation.
network_allocations = self.db.network_allocations_get_for_share_server(
context, share_server['id'])
network_info = {
'id': share_server['id'],
'share_network_id': share_server['share_network_id'],
'server_id': share_server['id'],
'segmentation_id': share_network['segmentation_id'],
'cidr': share_network['cidr'],
'neutron_net_id': share_network['neutron_net_id'],
'neutron_subnet_id': share_network['neutron_subnet_id'],
'security_services': share_network['security_services'],
'network_allocations': network_allocations,
'backend_details': share_server.get('backend_details'),
@ -371,10 +372,10 @@ class ShareManager(manager.SchedulerDependentManager):
share_network = self.db.share_network_get(context,
share_network['id'])
network_info = self._form_network_info(context, share_server,
share_network)
server_info = self.driver.setup_network(network_info,
metadata=metadata)
network_info = self._form_server_setup_info(context, share_server,
share_network)
server_info = self.driver.setup_server(network_info,
metadata=metadata)
if server_info and isinstance(server_info, dict):
self.db.share_server_backend_details_set(context,
share_server['id'],
@ -392,18 +393,16 @@ class ShareManager(manager.SchedulerDependentManager):
@lockutils.synchronized(share_server['share_network_id'])
def _teardown_server():
share_network = self.db.share_network_get(
context, share_server['share_network_id'])
network_info = self._form_network_info(context, share_server,
share_network)
self.db.share_server_update(context, share_server['id'],
{'status': constants.STATUS_DELETING})
sec_services = self.db.share_network_get(
context,
share_server['share_network_id'])['security_services']
try:
LOG.debug("Deleting share server")
self.driver.teardown_network(network_info)
except Exception as e:
self.driver.teardown_server(share_server['backend_details'],
security_services=sec_services)
except Exception:
with excutils.save_and_reraise_exception():
LOG.error(_("Share server %s failed on deletion.")
% share_server['id'])

4
manila/tests/api/v1/test_security_service.py
View File

@ -64,8 +64,10 @@ class ShareApiTest(test.TestCase):
def test_security_service_create(self):
sec_service = self.security_service.copy()
db.security_service_create = mock.Mock(
create_stub = mock.Mock(
return_value=sec_service)
self.stubs.Set(db, 'security_service_create', create_stub)
req = fakes.HTTPRequest.blank('/security-services')
res_dict = self.controller.create(
req, {"security_service": sec_service})

30
manila/tests/netapp/test_cmode_drv.py
View File

@ -103,10 +103,10 @@ class NetAppClusteredDrvTestCase(test.TestCase):
]
)
def test_setup_network(self):
def test_setup_server(self):
self.driver._vserver_create_if_not_exists = mock.Mock(
return_value='fake_vserver')
result = self.driver.setup_network({'id': 'fakeid'})
result = self.driver.setup_server({'server_id': 'fake_vserver'})
self.assertEqual(result, {'vserver_name': 'fake_vserver'})
def test_get_network_allocations_number(self):
@ -133,15 +133,14 @@ class NetAppClusteredDrvTestCase(test.TestCase):
el['num-records'] = 1
self.driver._vserver_exists = mock.Mock(return_value=True)
self._vserver_client.send_request = mock.Mock(return_value=el)
net_info = {
'security_services': [
{'sid': 'admin',
'password': 'pass',
'type': 'active_directory'}
]
}
self.driver._delete_vserver('fake', self._vserver_client,
network_info=net_info)
security_services = [
{'sid': 'admin',
'password': 'pass',
'type': 'active_directory'}
]
self.driver._delete_vserver('fake',
self._vserver_client,
security_services=security_services)
self._vserver_client.send_request.assert_has_calls([
mock.call('volume-get-iter'),
mock.call('volume-offline', {'name': 'root'}),
@ -440,12 +439,13 @@ class NetAppClusteredDrvTestCase(test.TestCase):
self.helper.deny_access.assert_called_ince_with(self._context,
self.share, access)
def test_teardown_network(self):
fake_net_info = {'id': 'fake'}
def test_teardown_server(self):
self.driver._delete_vserver = mock.Mock()
self.driver.teardown_network(fake_net_info)
sec_services = [{'fake': 'fake'}]
self.driver.teardown_server(server_details={'vserver_name': 'fake'},
security_services=sec_services)
self.driver._delete_vserver.assert_called_once_with(
'os_fake', self._vserver_client, network_info=fake_net_info)
'fake', self._vserver_client, security_services=sec_services)
class NetAppNFSHelperTestCase(test.TestCase):

81
manila/tests/test_service_instance.py
View File

@ -16,9 +16,10 @@
"""Unit tests for the instance module."""
import copy
import mock
import os
import mock
from manila import context
from manila import exception
from manila.openstack.common import lockutils
@ -213,6 +214,8 @@ class ServiceInstanceManagerTestCase(test.TestCase):
def test_set_up_service_instance(self):
fake_server = {'id': 'fake',
'ip': '1.2.3.4',
'subnet_id': 'fake-subnet-id',
'router_id': 'fake-router-id',
'pk_path': 'path'}
expected_details = fake_server.copy()
expected_details['instance_id'] = expected_details.pop('id')
@ -222,12 +225,14 @@ class ServiceInstanceManagerTestCase(test.TestCase):
mock.Mock(return_value='fake_ip'))
self.stubs.Set(self._manager.compute_api, 'server_list',
mock.Mock(return_value=[]))
create = mock.Mock(return_value=fake_server)
self.stubs.Set(self._manager, '_create_service_instance',
create)
mock.Mock(return_value=fake_server))
result = self._manager.set_up_service_instance(
self._context, share_server_id='fake_share_srv_id',
share_network_id='fake_share_network_id')
self._context,
'fake-inst-name',
'fake-net-id',
'fake-subnet-id')
self._manager.compute_api.server_list.assert_called_once()
self._manager._get_server_ip.assert_called_once()
@ -388,15 +393,16 @@ class ServiceInstanceManagerTestCase(test.TestCase):
fake_port = fake_network.FakePort()
fake_security_group = fake_compute.FakeSecurityGroup()
fake_instance_name = 'fake_instance_name'
sn_id = 'fake_sn_id'
srv_id = 'fake_srv_id'
self.stubs.Set(self._manager, '_get_service_image',
mock.Mock(return_value='fake_image_id'))
self.stubs.Set(self._manager, '_get_key',
mock.Mock(
return_value=('fake_key_name', 'fake_key_path')))
self.stubs.Set(self._manager, '_setup_network_for_instance',
mock.Mock(return_value=fake_port))
mock.Mock(return_value=('fake-subnet',
'fake-router',
fake_port['id'])))
self.stubs.Set(self._manager,
'_setup_connectivity_with_service_instances',
mock.Mock())
@ -409,8 +415,13 @@ class ServiceInstanceManagerTestCase(test.TestCase):
self.stubs.Set(service_instance.socket, 'socket', mock.Mock())
self.stubs.Set(self._manager, '_get_service_instance_name',
mock.Mock(return_value=fake_instance_name))
result = self._manager._create_service_instance(self._context, sn_id,
srv_id)
result = self._manager._create_service_instance(
self._context,
fake_instance_name,
'fake-net',
'fake-subnet'
)
self._manager._get_service_image.assert_called_once()
self._manager._get_key.assert_called_once()
@ -436,7 +447,9 @@ class ServiceInstanceManagerTestCase(test.TestCase):
self.stubs.Set(self._manager, '_get_or_create_security_group',
mock.Mock(return_value=fake_security_group))
self.stubs.Set(self._manager, '_setup_network_for_instance',
mock.Mock(return_value=fake_port))
mock.Mock(return_value=('fake-subnet',
'fake-router',
fake_port['id'])))
self.stubs.Set(self._manager,
'_setup_connectivity_with_service_instances',
mock.Mock())
@ -448,7 +461,10 @@ class ServiceInstanceManagerTestCase(test.TestCase):
self.assertRaises(exception.ManilaException,
self._manager._create_service_instance,
self._context, self.share, None)
self._context,
'fake-inst-name',
'fake-neutron-net',
'fake-neutron-subnet')
self._manager.compute_api.server_create.assert_called_once()
self.assertFalse(self._manager.compute_api.server_get.called)
@ -466,7 +482,9 @@ class ServiceInstanceManagerTestCase(test.TestCase):
self.stubs.Set(self._manager, '_get_or_create_security_group',
mock.Mock(return_value=fake_security_group))
self.stubs.Set(self._manager, '_setup_network_for_instance',
mock.Mock(return_value=fake_port))
mock.Mock(return_value=('fake-subnet',
'fake-router',
fake_port['id'])))
self.stubs.Set(self._manager,
'_setup_connectivity_with_service_instances',
mock.Mock(side_effect=exception.ManilaException))
@ -479,7 +497,10 @@ class ServiceInstanceManagerTestCase(test.TestCase):
self.assertRaises(exception.ManilaException,
self._manager._create_service_instance,
self._context, self.share, None)
self._context,
'fake-inst-name',
'fake-neutron-net',
'fake-neutron-subnet')
self._manager.neutron_api.delete_port.\
assert_called_once_with(fake_port['id'])
@ -494,7 +515,10 @@ class ServiceInstanceManagerTestCase(test.TestCase):
mock.Mock(return_value=(None, None)))
self.assertRaises(exception.ManilaException,
self._manager._create_service_instance,
self._context, self.share, None)
self._context,
'fake-inst-name',
'fake-neutron-net',
'fake-neutron-subnet')
def test_setup_network_for_instance(self):
fake_service_net = fake_network.FakeNetwork(subnets=[])
@ -517,26 +541,28 @@ class ServiceInstanceManagerTestCase(test.TestCase):
self.stubs.Set(self._manager, '_get_cidr_for_subnet',
mock.Mock(return_value='fake_cidr'))
result = self._manager._setup_network_for_instance('fake_share_net')
result = self._manager._setup_network_for_instance('fake-net',
'fake-subnet')
self._manager.neutron_api.get_network.\
assert_called_once_with(self._manager.service_network_id)
self._manager._get_private_router.\
assert_called_once_with('fake_share_net')
assert_called_once_with('fake-net', 'fake-subnet')
self._manager.neutron_api.router_add_interface.\
assert_called_once_with('fake_router_id', 'fake_subnet_id')
self._manager.neutron_api.subnet_create.assert_called_once_with(
self._manager.service_tenant_id,
self._manager.service_network_id,
'fake_share_net',
'fake_cidr')
self._manager.service_tenant_id,
self._manager.service_network_id,
'routed_to_fake-subnet',
'fake_cidr')
self._manager.neutron_api.create_port.assert_called_once_with(
self._manager.service_tenant_id,
self._manager.service_network_id,
subnet_id='fake_subnet_id',
device_owner='manila')
self._manager._get_cidr_for_subnet.assert_called_once()
self.assertEqual(result, fake_port)
self.assertEqual(result,
('fake_subnet_id', 'fake_router_id', fake_port['id']))
def test_get_private_router(self):
fake_net = fake_network.FakeNetwork()
@ -557,9 +583,8 @@ class ServiceInstanceManagerTestCase(test.TestCase):
self.stubs.Set(self._manager.neutron_api, 'show_router',
mock.Mock(return_value=fake_router))
result = self._manager._get_private_router(
{'neutron_subnet_id': fake_subnet['id'],
'neutron_net_id': fake_net['id']})
result = self._manager._get_private_router(fake_net['id'],
fake_subnet['id'])
self._manager.neutron_api.get_subnet.\
assert_called_once_with(fake_subnet['id'])
@ -582,9 +607,9 @@ class ServiceInstanceManagerTestCase(test.TestCase):
mock.Mock(return_value=[]))
self.assertRaises(exception.ManilaException,
self._manager._get_private_router,
{'neutron_subnet_id': fake_subnet['id'],
'neutron_net_id': fake_net['id']})
self._manager._get_private_router,
fake_net['id'],
fake_subnet['id'])
def test_setup_connectivity_with_service_instances(self):
fake_subnet = fake_network.FakeSubnet(cidr='10.254.0.0/29')

54
manila/tests/test_share.py
View File

@ -163,6 +163,18 @@ class ShareTestCase(test.TestCase):
srv['status'] = state
return db.share_network_create(context.get_admin_context(), srv)
@staticmethod
def _create_security_service(share_network_id=None):
service = {}
service['type'] = "FAKE"
service['project_id'] = 'fake-project-id'
service_ref = db.security_service_create(
context.get_admin_context(), service)
db.share_network_add_security_service(context.get_admin_context(),
share_network_id,
service_ref['id'])
return service_ref
def test_init_host_ensuring_shares(self):
"""Test init_host for ensuring shares and access rules."""
@ -442,6 +454,35 @@ class ShareTestCase(test.TestCase):
share_id
)
def test_delete_share_last_on_server_with_sec_services(self):
share_net = self._create_share_network()
sec_service = self._create_security_service(share_net['id'])
share_srv = self._create_share_server(
share_network_id=share_net['id'],
host=self.share_manager.host,
state='ACTIVE'
)
share = self._create_share(share_network_id=share_net['id'],
share_server_id=share_srv['id'])
share_id = share['id']
self.share_manager.driver = mock.Mock()
manager.CONF.delete_share_server_with_last_share = True
self.share_manager.delete_share(self.context, share_id)
self.assertTrue(self.share_manager.driver.teardown_server.called)
call_args = self.share_manager.driver.teardown_server.call_args[0]
call_kwargs = self.share_manager.driver.teardown_server.call_args[1]
self.assertEqual(
call_args[0],
share_srv.get('backend_details'))
self.assertEqual(
len(call_kwargs['security_services']), 1)
self.assertTrue(
call_kwargs['security_services'][0]['id'],
sec_service['id'])
def test_delete_share_last_on_server(self):
share_net = self._create_share_network()
share_srv = self._create_share_server(
@ -457,17 +498,8 @@ class ShareTestCase(test.TestCase):
self.share_manager.driver = mock.Mock()
manager.CONF.delete_share_server_with_last_share = True
self.share_manager.delete_share(self.context, share_id)
net_info = {
'id': share_srv['id'],
'share_network_id': share_srv['share_network_id'],
'segmentation_id': share_net['segmentation_id'],
'cidr': share_net['cidr'],
'security_services': [],
'network_allocations': [],
'backend_details': share_srv.get('backend_details'),
}
self.share_manager.driver.teardown_network.assert_called_once_with(
net_info
self.share_manager.driver.teardown_server.assert_called_once_with(
share_srv.get('backend_details'), security_services=[]
)
def test_delete_share_last_on_server_deletion_disabled(self):

30
manila/tests/test_share_generic.py
View File

@ -367,10 +367,10 @@ class GenericShareDriverTestCase(test.TestCase):
self.server['backend_details'])
self._driver.compute_api.instance_volume_detach.\
assert_called_once_with(
self._context,
self.server['backend_details']['instance_id'],
availiable_volume['id'])
assert_called_once_with(
self._context,
self.server['backend_details']['instance_id'],
availiable_volume['id'])
self._driver.volume_api.get.\
assert_called_once_with(self._context, availiable_volume['id'])
@ -553,29 +553,35 @@ class GenericShareDriverTestCase(test.TestCase):
def test_setup_network(self):
sim = self._driver.instance_manager
net_info = self.fake_sn.copy()
net_info['share_network_id'] = net_info['id']
self._driver.setup_network(net_info)
sim.get_service_instance.assert_called_once()
net_info = {'server_id': 'fake',
'neutron_net_id': 'fake-net-id',
'neutron_subnet_id': 'fake-subnet-id'}
self._driver.setup_server(net_info)
sim.set_up_service_instance.assert_called_once_with(
self._context,
'fake',
'fake-net-id',
'fake-subnet-id')
def test_setup_network_revert(self):
def raise_exception(*args, **kwargs):
raise exception.ServiceInstanceException
net_info = self.fake_sn.copy()
net_info['share_network_id'] = net_info['id']
net_info = {'server_id': 'fake',
'neutron_net_id': 'fake-net-id',
'neutron_subnet_id': 'fake-subnet-id'}
self.stubs.Set(self._driver.service_instance_manager,
'set_up_service_instance',
mock.Mock(side_effect=raise_exception))
self.assertRaises(exception.ServiceInstanceException,
self._driver.setup_network,
self._driver.setup_server,
net_info)
def test_teardown_network(self):
sim = self._driver.instance_manager
self._driver.service_instance_manager = sim
self._driver.teardown_network(self.fake_net_info)
self._driver.teardown_server(self.fake_net_info)
sim.delete_service_instance.assert_called_once()