def setUp(self):
super(NFSHelperTestCase, self).setUp()
fake_utils.stub_out_utils_execute(self.stubs)
self.fake_conf = manila.share.configuration.Configuration(None)
self._ssh_exec = mock.Mock(return_value=('', ''))
self._execute = mock.Mock(return_value=('', ''))
self._helper = generic.NFSHelper(self._execute, self._ssh_exec,
self.fake_conf)
ip = '10.254.0.3'
self.server = fake_compute.FakeServer(
ip=ip, public_address=ip, instance_id='fake_instance_id')
def test_attach_volume_error(self):
fake_server = fake_compute.FakeServer()
availiable_volume = fake_volume.FakeVolume()
error_volume = fake_volume.FakeVolume(status='error')
self.stubs.Set(self._driver.compute_api, 'instance_volume_attach',
mock.Mock())
self.stubs.Set(self._driver.volume_api, 'get',
mock.Mock(return_value=error_volume))
self.assertRaises(exception.ManilaException,
self._driver._attach_volume, self._context,
self.share, fake_server, availiable_volume)
def test_ensure_server_non_active(self):
server_details = {'instance_id': 'fake_inst_id', 'ip': '1.2.3.4'}
fake_server = fake_compute.FakeServer(status='ERROR')
self.stubs.Set(self._manager.compute_api, 'server_get',
mock.Mock(return_value=fake_server))
self.stubs.Set(self._manager, '_check_server_availability',
mock.Mock(return_value=True))
result = self._manager.ensure_service_instance(self._context,
server_details)
self.assertFalse(self._manager._check_server_availability.called)
self.assertFalse(result)
def test_allow_access(self):
fake_server = fake_compute.FakeServer(ip='10.254.0.3')
self._helper.allow_access(fake_server, 'volume-00001', 'ip',
'10.0.0.2')
local_path = os.path.join(CONF.share_mount_path, 'volume-00001')
self._ssh_exec.assert_has_calls([
mock.call(fake_server, ['sudo', 'exportfs']),
mock.call(fake_server, [
'sudo', 'exportfs', '-o', 'rw,no_subtree_check', ':'.join(
['10.0.0.2', local_path])
])
])
def test_ensure_server(self):
server_details = {'instance_id': 'fake_inst_id', 'ip': '1.2.3.4'}
fake_server = fake_compute.FakeServer()
self.stubs.Set(self._manager, '_check_server_availability',
mock.Mock(return_value=True))
self.stubs.Set(self._manager.compute_api, 'server_get',
mock.Mock(return_value=fake_server))
result = self._manager.ensure_service_instance(self._context,
server_details)
self._manager.compute_api.server_get.assert_called_once_with(
self._context, server_details['instance_id'])
self._manager._check_server_availability.assert_called_once_with(
server_details)
self.assertTrue(result)
def test_create_service_instance_error(self):
fake_server = fake_compute.FakeServer(status='ERROR')
fake_port = fake_network.FakePort()
fake_security_group = fake_compute.FakeSecurityGroup()
fake_network_data = {
'ports': [fake_port],
}
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, '_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_network_data))
self.stubs.Set(self._manager,
'_setup_connectivity_with_service_instances',
mock.Mock())
self.stubs.Set(self._manager.compute_api, 'server_create',
mock.Mock(return_value=fake_server))
self.stubs.Set(self._manager.compute_api, 'server_get',
mock.Mock(return_value=fake_server))
self.stubs.Set(service_instance.socket, 'socket', mock.Mock())
self.assertRaises(exception.ManilaException,
self._manager._create_service_instance,
self._context, 'fake-inst-name', 'fake-neutron-net',
'fake-neutron-subnet')
self._manager._get_service_image.assert_called_once_with(self._context)
self._manager._get_key.assert_called_once_with(self._context)
self._manager._get_or_create_security_group.assert_called_once_with(
self._context)
self._manager._setup_network_for_instance.assert_called_once_with(
'fake-neutron-net', 'fake-neutron-subnet')
self._manager._setup_connectivity_with_service_instances.\
assert_called_once_with()
self._manager.compute_api.server_create.assert_called_once_with(
self._context,
name='fake-inst-name',
image='fake_image_id',
flavor=100,
key_name='fake_key_name',
nics=[{
'port-id': fake_port['id']
}])
self.assertFalse(self._manager.compute_api.server_get.called)
self.assertFalse(service_instance.socket.socket.called)
def test_allow_access(self):
fake_server = fake_compute.FakeServer()
access = {'access_type': 'ip', 'access_to': 'fake_dest'}
self.stubs.Set(self._driver, 'get_service_instance',
mock.Mock(return_value=fake_server))
self._driver.allow_access(self._context, self.share, access,
share_server=self.server)
self._driver.get_service_instance.assert_called_once()
self._driver._helpers[self.share['share_proto']].\
allow_access.assert_called_once_with(
self.server['backend_details'],
self.share['name'],
access['access_type'],
access['access_to'])
def test_delete_share(self):
fake_server = fake_compute.FakeServer()
self.stubs.Set(self._driver, 'get_service_instance',
mock.Mock(return_value=fake_server))
self.stubs.Set(self._driver, '_unmount_device', mock.Mock())
self.stubs.Set(self._driver, '_detach_volume', mock.Mock())
self.stubs.Set(self._driver, '_deallocate_container', mock.Mock())
self._driver.delete_share(self._context, self.share,
share_server=self.server)
self._driver.get_service_instance.assert_called_once()
self._driver._unmount_device.assert_called_once()
self._driver._detach_volume.assert_called_once()
self._driver._deallocate_container.assert_called_once()
def test_ensure_server_not_exists(self):
server_details = {'instance_id': 'fake_inst_id', 'ip': '1.2.3.4'}
fake_server = fake_compute.FakeServer()
self.stubs.Set(self._manager, '_check_server_availability',
mock.Mock(return_value=True))
self.stubs.Set(
self._manager.compute_api, 'server_get',
mock.Mock(side_effect=exception.InstanceNotFound(
instance_id=server_details['instance_id'])))
result = self._manager.ensure_service_instance(self._context,
server_details)
self._manager.compute_api.server_get.\
assert_called_once_with(self._context,
server_details['instance_id'])
self.assertFalse(self._manager._check_server_availability.called)
self.assertFalse(result)
def test_create_service_instance(self):
fake_server = fake_compute.FakeServer()
fake_port = fake_network.FakePort()
fake_security_group = fake_compute.FakeSecurityGroup()
fake_instance_name = 'fake_instance_name'
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-subnet', 'fake-router',
fake_port['id'])))
self.stubs.Set(self._manager,
'_setup_connectivity_with_service_instances',
mock.Mock())
self.stubs.Set(self._manager.compute_api, 'server_create',
mock.Mock(return_value=fake_server))
self.stubs.Set(self._manager, '_get_server_ip',
mock.Mock(return_value='fake_ip'))
self.stubs.Set(self._manager, '_get_or_create_security_group',
mock.Mock(return_value=fake_security_group))
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, fake_instance_name, 'fake-net', 'fake-subnet')
self._manager._get_service_image.assert_called_once()
self._manager._get_key.assert_called_once()
self._manager._setup_network_for_instance.assert_called_once()
self._manager._setup_connectivity_with_service_instances.\
assert_called_once()
self._manager.compute_api.server_create.assert_called_once_with(
self._context,
name=fake_instance_name,
image='fake_image_id',
flavor=CONF.service_instance_flavor_id,
key_name='fake_key_name',
nics=[{
'port-id': fake_port['id']
}])
service_instance.socket.socket.assert_called_once()
self.assertEqual(result, fake_server)
def test_attach_volume_not_attached(self):
fake_server = fake_compute.FakeServer()
availiable_volume = fake_volume.FakeVolume()
attached_volume = fake_volume.FakeVolume(status='in-use')
self.stubs.Set(self._driver.compute_api, 'instance_volume_attach',
mock.Mock())
self.stubs.Set(self._driver.volume_api, 'get',
mock.Mock(return_value=attached_volume))
result = self._driver._attach_volume(self._context, self.share,
'fake_inst_id', availiable_volume)
self._driver.compute_api.instance_volume_attach.\
assert_called_once_with(self._context, 'fake_inst_id',
availiable_volume['id'])
self._driver.volume_api.get.\
assert_called_once_with(self._context, attached_volume['id'])
self.assertEqual(result, attached_volume)
def test_detach_volume_detached(self):
fake_server = fake_compute.FakeServer()
availiable_volume = fake_volume.FakeVolume()
attached_volume = fake_volume.FakeVolume(status='in-use')
self.stubs.Set(self._driver, '_get_volume',
mock.Mock(return_value=attached_volume))
self.stubs.Set(self._driver.compute_api, 'instance_volumes_list',
mock.Mock(return_value=[]))
self.stubs.Set(self._driver.volume_api, 'get',
mock.Mock(return_value=availiable_volume))
self.stubs.Set(self._driver.compute_api, 'instance_volume_detach',
mock.Mock())
self._driver._detach_volume(self._context, self.share,
self.server['backend_details'])
self.assertFalse(self._driver.volume_api.get.called)
self.assertFalse(
self._driver.compute_api.instance_volume_detach.called)
