def setUp(self):
super(ContainerShareDriverTestCase, self).setUp()
fake_utils.stub_out_utils_execute(self)
self._context = context.get_admin_context()
self._db = mock.Mock()
self.fake_conf = configuration.Configuration(None)
CONF.set_default('driver_handles_share_servers', True)
self._driver = driver.ContainerShareDriver(
configuration=self.fake_conf)
self.share = cont_fakes.fake_share()
self.access = cont_fakes.fake_access()
self.server = {
'public_address': self.fake_conf.lvm_share_export_ip,
'instance_id': 'LVM',
}
# Used only to test compatibility with share manager
self.share_server = "fake_share_server"
def setUp(self):
super(CmdConnectorTest, self).setUp()
self.configuration = conf.Configuration(None)
self.configuration.append_config_values = mock.Mock(return_value=0)
self.configuration.emc_nas_login = fakes.FakeData.emc_nas_login
self.configuration.emc_nas_password = fakes.FakeData.emc_nas_password
self.configuration.emc_nas_server = fakes.FakeData.emc_nas_server
self.sshpool = MockSSHPool()
with mock.patch.object(utils, "SSHPool",
mock.Mock(return_value=self.sshpool)):
self.CmdHelper = connector.SSHConnector(
configuration=self.configuration, debug=False)
utils.SSHPool.assert_called_once_with(
ip=fakes.FakeData.emc_nas_server,
port=22,
conn_timeout=None,
login=fakes.FakeData.emc_nas_login,
password=fakes.FakeData.emc_nas_password)
def setUp(self):
super(GaneshaNASHelper2TestCase, self).setUp()
CONF.set_default('ganesha_config_path', '/fakedir0/fakeconfig')
CONF.set_default('ganesha_db_path', '/fakedir1/fake.db')
CONF.set_default('ganesha_export_dir', '/fakedir0/export.d')
CONF.set_default('ganesha_export_template_dir',
'/fakedir2/faketempl.d')
CONF.set_default('ganesha_service_name', 'ganesha.fakeservice')
self._context = context.get_admin_context()
self._execute = mock.Mock(return_value=('', ''))
self.fake_conf = config.Configuration(None)
self.fake_conf_dir_path = '/fakedir0/exports.d'
self._helper = ganesha.GaneshaNASHelper2(self._execute,
self.fake_conf,
tag='faketag')
self._helper.ganesha = mock.Mock()
self._helper.export_template = {}
self.share = fake_share.fake_share()
self.rule1 = fake_share.fake_access(access_level='ro')
self.rule2 = fake_share.fake_access(access_level='rw',
access_to='10.0.0.2')
def setUp(self):
super(NativeProtocolHelperTestCase, self).setUp()
self.fake_conf = configuration.Configuration(None)
self._context = context.get_admin_context()
self._share = fake_share.fake_share_instance(share_proto='CEPHFS')
self.fake_conf.set_default('driver_handles_share_servers', False)
self.mock_object(driver, "rados_command")
driver.ceph_default_target = ('mon-mgr', )
self._native_protocol_helper = driver.NativeProtocolHelper(
None,
self.fake_conf,
rados_client=MockRadosModule.Rados(),
volname="cephfs")
self._rados_client = self._native_protocol_helper.rados_client
self._native_protocol_helper.get_mon_addrs = mock.Mock(
return_value=['1.2.3.4', '5.6.7.8'])
def setUp(self):
super(NetAppCDOTDataMotionTestCase, self).setUp()
self.backend = 'backend1'
self.mock_cmode_client = self.mock_object(client_cmode,
"NetAppCmodeClient",
mock.Mock())
self.config = configuration.Configuration(driver.share_opts,
config_group=self.backend)
self.config.append_config_values(na_opts.netapp_cluster_opts)
self.config.append_config_values(na_opts.netapp_connection_opts)
self.config.append_config_values(na_opts.netapp_basicauth_opts)
self.config.append_config_values(na_opts.netapp_transport_opts)
self.config.append_config_values(na_opts.netapp_support_opts)
self.config.append_config_values(na_opts.netapp_provisioning_opts)
self.config.append_config_values(na_opts.netapp_data_motion_opts)
CONF.set_override("share_backend_name",
self.backend,
group=self.backend,
enforce_type=True)
CONF.set_override("netapp_transport_type",
"https",
group=self.backend,
enforce_type=True)
CONF.set_override("netapp_login",
"fake_user",
group=self.backend,
enforce_type=True)
CONF.set_override("netapp_password",
"fake_password",
group=self.backend,
enforce_type=True)
CONF.set_override("netapp_server_hostname",
"fake_hostname",
group=self.backend,
enforce_type=True)
CONF.set_override("netapp_server_port",
8866,
group=self.backend,
enforce_type=True)
def setUp(self):
super(CephFSDriverTestCase, self).setUp()
self._execute = mock.Mock()
self.fake_conf = configuration.Configuration(None)
self._context = context.get_admin_context()
self._share = fake_share.fake_share(share_proto='CEPHFS')
self.fake_conf.set_default('driver_handles_share_servers', False)
self.fake_conf.set_default('cephfs_auth_id', 'manila')
self.mock_object(driver, "ceph_volume_client", MockVolumeClientModule)
self.mock_object(driver, "ceph_module_found", True)
self.mock_object(driver, "cephfs_share_path")
self.mock_object(driver, 'NativeProtocolHelper')
self.mock_object(driver, 'NFSProtocolHelper')
self._driver = (driver.CephFSDriver(execute=self._execute,
configuration=self.fake_conf))
self._driver.protocol_helper = mock.Mock()
self.mock_object(share_types, 'get_share_type_extra_specs',
mock.Mock(return_value={}))
def _setup_mocks_copy_share_data(self):
get_migration_info_value = {'mount': 'fake',
'umount': 'fake',
'access':
{'access_type': 'fake',
'access_to': 'fake'}}
self.mock_object(rpcapi.ShareAPI, 'get_migration_info',
mock.Mock(return_value=get_migration_info_value))
self.mock_object(driver.ShareDriver, 'get_migration_info',
mock.Mock(return_value=get_migration_info_value))
self.mock_object(share_utils.Copy, 'run')
self.mock_object(time, 'sleep')
driver.CONF.set_default('driver_handles_share_servers', False)
share_driver = driver.ShareDriver(
False, configuration=configuration.Configuration(None))
return share_driver
def test_migration_get_info(self, admin):
expected = {
'mount': 'mount -vt fake_proto /fake/fake_id %(path)s',
'unmount': 'umount -v %(path)s'
}
fake_share = {
'id': 'fake_id',
'share_proto': 'fake_proto',
'export_locations': [{
'path': '/fake/fake_id',
'is_admin_only': admin
}]
}
driver.CONF.set_default('driver_handles_share_servers', False)
share_driver = driver.ShareDriver(False)
share_driver.configuration = configuration.Configuration(None)
migration_info = share_driver.migration_get_info(
None, fake_share, "fake_server")
self.assertEqual(expected, migration_info)
def setUp(self):
super(GlusterfsShareDriverTestCase, self).setUp()
fake_utils.stub_out_utils_execute(self)
self._execute = fake_utils.fake_execute
self._context = context.get_admin_context()
self.addCleanup(fake_utils.fake_execute_set_repliers, [])
self.addCleanup(fake_utils.fake_execute_clear_log)
CONF.set_default('glusterfs_target', '127.0.0.1:/testvol')
CONF.set_default('glusterfs_mount_point_base', '/mnt/nfs')
CONF.set_default('reserved_share_percentage', 50)
CONF.set_default('glusterfs_server_password',
fake_remote_server_password)
CONF.set_default('glusterfs_path_to_private_key',
fake_path_to_private_key)
CONF.set_default('driver_handles_share_servers', False)
self.fake_conf = config.Configuration(None)
self._driver = glusterfs.GlusterfsShareDriver(
execute=self._execute, configuration=self.fake_conf)
self._driver.gluster_manager = mock.Mock(**fake_gluster_manager_attrs)
self._helper_nfs = mock.Mock()
self.share = fake_share.fake_share(share_proto='NFS')
def test_get_share_stats_refresh_true(self):
conf = configuration.Configuration(None)
expected_keys = [
'QoS_support',
'driver_version',
'share_backend_name',
'free_capacity_gb',
'total_capacity_gb',
'driver_handles_share_servers',
'reserved_percentage',
'vendor_name',
'storage_protocol',
]
share_driver = driver.ShareDriver(True, configuration=conf)
fake_stats = {'fake_key': 'fake_value'}
share_driver._stats = fake_stats
result = share_driver.get_share_stats(True)
self.assertNotEqual(fake_stats, result)
for key in expected_keys:
self.assertIn(key, result)
self.assertEqual('Open Source', result['vendor_name'])
def get_backend_configuration(backend_name):
config_stanzas = CONF.list_all_sections()
if backend_name not in config_stanzas:
msg = _("Could not find backend stanza %(backend_name)s in "
"configuration which is required for replication with "
"the backend. Available stanzas are %(stanzas)s")
params = {
"stanzas": config_stanzas,
"backend_name": backend_name,
}
raise exception.BadConfigurationException(reason=msg % params)
config = configuration.Configuration(driver.share_opts,
config_group=backend_name)
config.append_config_values(na_opts.netapp_cluster_opts)
config.append_config_values(na_opts.netapp_connection_opts)
config.append_config_values(na_opts.netapp_basicauth_opts)
config.append_config_values(na_opts.netapp_transport_opts)
config.append_config_values(na_opts.netapp_support_opts)
config.append_config_values(na_opts.netapp_provisioning_opts)
config.append_config_values(na_opts.netapp_replication_opts)
return config
def setUp(self):
super(SopShareDriverTestCase, self).setUp()
self._context = context.get_admin_context()
self.server = {
'instance_id': 'fake_instance_id',
'ip': 'fake_ip',
'username': '******',
'password': '******',
'pk_path': 'fake_pk_path',
'backend_details': {
'ip': '1.2.3.4',
'instance_id': 'fake',
},
}
CONF.set_default('hdssop_target', 'https://1.2.3.4')
CONF.set_default('hdssop_adminuser', 'fakeuser')
CONF.set_default('hdssop_adminpassword', 'fakepassword')
CONF.set_default('driver_handles_share_servers', False)
self.fake_conf = config.Configuration(None)
self._driver = sop.SopShareDriver(configuration=self.fake_conf)
self.share = fake_share.fake_share(share_proto='NFS')
self._driver.share_backend_name = 'HDS_SOP'
def setUp(self):
super(NetApp7modeDrvTestCase, self).setUp()
self._context = context.get_admin_context()
self._db = mock.Mock()
self.driver = driver.NetAppShareDriver(
self._db, configuration=configuration.Configuration(None))
self.driver._client = mock.Mock()
self.driver._client.send_request = mock.Mock()
self.share = {
'id': 'fake_uuid',
'tenant_id': 'fake_tenant_id',
'name': 'fake_name',
'size': 1,
'share_proto': 'fake'
}
self.snapshot = {
'id': 'fake_snapshot_uuid',
'tenant_id': 'fake_tenant_id',
'share_id': 'fake_share_id'
}
self.helper = mock.Mock()
self.driver._helpers = {'FAKE': self.helper}
self.driver._licenses = ['fake']
def test_get_export_locations_with_export_ips_configured(self):
fake_conf = configuration.Configuration(None)
conf_args_list = [
('cephfs_ganesha_server_ip', '1.2.3.4'),
('cephfs_ganesha_export_ips', '127.0.0.1,fd3f:c057:1192:1::1,::1')]
for args in conf_args_list:
fake_conf.set_default(*args)
helper = driver.NFSProtocolHelper(
self._execute,
fake_conf,
ceph_vol_client=MockVolumeClientModule.CephFSVolumeClient()
)
cephfs_volume = {"mount_path": "/foo/bar"}
ret = helper.get_export_locations(self._share, cephfs_volume)
self.assertEqual(
[
{
'path': '127.0.0.1:/foo/bar',
'is_admin_only': False,
'metadata': {},
},
{
'path': '[fd3f:c057:1192:1::1]:/foo/bar',
'is_admin_only': False,
'metadata': {},
},
{
'path': '[::1]:/foo/bar',
'is_admin_only': False,
'metadata': {},
},
], ret)
def test_init_identify_local_host(self, ganesha_server_ip):
self.mock_object(driver.LOG, 'info')
fake_conf = configuration.Configuration(None)
conf_args_list = [('cephfs_ganesha_server_ip', ganesha_server_ip),
('cephfs_ganesha_server_username', 'fake_username'),
('cephfs_ganesha_server_password', 'fakepwd'),
('cephfs_ganesha_path_to_private_key',
'fakepathtokey')]
for args in conf_args_list:
fake_conf.set_default(*args)
driver.NFSProtocolHelper(
self._execute,
fake_conf,
ceph_vol_client=MockVolumeClientModule.CephFSVolumeClient())
driver.ganesha_utils.RootExecutor.assert_has_calls(
[mock.call(self._execute)])
if ganesha_server_ip:
self.assertFalse(driver.socket.gethostname.called)
self.assertFalse(driver.LOG.info.called)
else:
driver.socket.gethostname.assert_called_once_with()
driver.LOG.info.assert_called_once()
def setUp(self):
super(GlusterfsDirectoryMappedLayoutTestCase, self).setUp()
fake_utils.stub_out_utils_execute(self)
self._execute = fake_utils.fake_execute
self._context = context.get_admin_context()
self.addCleanup(fake_utils.fake_execute_set_repliers, [])
self.addCleanup(fake_utils.fake_execute_clear_log)
CONF.set_default('glusterfs_target', '127.0.0.1:/testvol')
CONF.set_default('glusterfs_mount_point_base', '/mnt/nfs')
CONF.set_default('glusterfs_server_password',
fake_remote_server_password)
CONF.set_default('glusterfs_path_to_private_key',
fake_path_to_private_key)
self.fake_driver = mock.Mock()
self.mock_object(self.fake_driver, '_execute', self._execute)
self.fake_driver.GLUSTERFS_VERSION_MIN = (3, 6)
self.fake_conf = config.Configuration(None)
self.mock_object(common.GlusterManager, 'make_gluster_call')
self._layout = layout_directory.GlusterfsDirectoryMappedLayout(
self.fake_driver, configuration=self.fake_conf)
self._layout.gluster_manager = mock.Mock(**fake_gluster_manager_attrs)
self.share = fake_share.fake_share(share_proto='NFS')
def setUp(self):
super(DockerExecHelperTestCase, self).setUp()
self.fake_conf = configuration.Configuration(None)
self.fake_conf.container_image_name = "fake_image"
self.DockerExecHelper = container_helper.DockerExecHelper(
configuration=self.fake_conf)
def setUp(self):
super(GlusterfsVolumeMappedLayoutTestCase, self).setUp()
fake_utils.stub_out_utils_execute(self)
self._execute = fake_utils.fake_execute
self._context = context.get_admin_context()
self.glusterfs_target1 = 'root@host1:/gv1'
self.glusterfs_target2 = 'root@host2:/gv2'
self.glusterfs_server1 = 'root@host1'
self.glusterfs_server2 = 'root@host2'
self.glusterfs_server1_volumes = 'manila-share-1-1G\nshare1'
self.glusterfs_server2_volumes = 'manila-share-2-2G\nshare2'
self.share1 = new_share(
export_location=self.glusterfs_target1,
status=constants.STATUS_AVAILABLE)
self.share2 = new_share(
export_location=self.glusterfs_target2,
status=constants.STATUS_AVAILABLE)
gmgr = common.GlusterManager
self.gmgr1 = gmgr(self.glusterfs_server1, self._execute, None, None,
requires={'volume': False})
self.gmgr2 = gmgr(self.glusterfs_server2, self._execute, None, None,
requires={'volume': False})
self.glusterfs_volumes_dict = (
{'root@host1:/manila-share-1-1G': {'size': 1},
'root@host2:/manila-share-2-2G': {'size': 2}})
self.glusterfs_used_vols = set([
'root@host1:/manila-share-1-1G',
'root@host2:/manila-share-2-2G'])
CONF.set_default('glusterfs_servers',
[self.glusterfs_server1, self.glusterfs_server2])
CONF.set_default('glusterfs_server_password',
'fake_password')
CONF.set_default('glusterfs_path_to_private_key',
'/fakepath/to/privatekey')
CONF.set_default('glusterfs_volume_pattern',
'manila-share-\d+-#{size}G$')
CONF.set_default('driver_handles_share_servers', False)
self.fake_driver = mock.Mock()
self.mock_object(self.fake_driver, '_execute',
self._execute)
self.fake_driver.GLUSTERFS_VERSION_MIN = (3, 6)
self.fake_conf = config.Configuration(None)
self.mock_object(tempfile, 'mkdtemp',
mock.Mock(return_value='/tmp/tmpKGHKJ'))
self.mock_object(common.GlusterManager, 'make_gluster_call')
self.fake_private_storage = mock.Mock()
with mock.patch.object(layout_volume.GlusterfsVolumeMappedLayout,
'_glustermanager',
side_effect=[self.gmgr1, self.gmgr2]):
self._layout = layout_volume.GlusterfsVolumeMappedLayout(
self.fake_driver, configuration=self.fake_conf,
private_storage=self.fake_private_storage)
self._layout.glusterfs_versions = {self.glusterfs_server1: ('3', '6'),
self.glusterfs_server2: ('3', '7')}
self.addCleanup(fake_utils.fake_execute_set_repliers, [])
self.addCleanup(fake_utils.fake_execute_clear_log)
def test_init_nosupp_layout(self):
conf = config.Configuration(None)
conf.glusterfs_share_layout = 'nonsense_layout'
self.assertRaises(exception.GlusterfsException,
GlusterfsFakeShareDriver, False, configuration=conf)
def setUp(self):
super(LVMHelperTestCase, self).setUp()
self.share = fake_share()
self.fake_conf = configuration.Configuration(None)
self.LVMHelper = storage_helper.LVMHelper(configuration=self.fake_conf)
def setUp(self):
super(LVMHelperTestCase, self).setUp()
self.share = fake_share()
self.fake_conf = configuration.Configuration(None)
self.fake_conf.container_volume_mount_path = "/tmp/shares"
self.LVMHelper = storage_helper.LVMHelper(configuration=self.fake_conf)
def _setup(self):
fake_conf = config.Configuration(None)
fake_layout = mock.Mock()
self.mock_object(importutils, "import_object",
mock.Mock(return_value=fake_layout))
return fake_conf, fake_layout
class WindowsSMBHelperTestCase(test.TestCase):
_FAKE_SERVER = {'public_address': mock.sentinel.public_address}
_FAKE_SHARE_NAME = "fake_share_name"
_FAKE_SHARE = "\\\\%s\\%s" % (_FAKE_SERVER['public_address'],
_FAKE_SHARE_NAME)
_FAKE_SHARE_LOCATION = os.path.join(
configuration.Configuration(None).share_mount_path, _FAKE_SHARE_NAME)
_FAKE_ACCOUNT_NAME = 'FakeDomain\\FakeUser'
_FAKE_RW_ACC_RULE = {
'access_to': _FAKE_ACCOUNT_NAME,
'access_level': constants.ACCESS_LEVEL_RW,
'access_type': 'user',
}
def setUp(self):
self._remote_exec = mock.Mock()
fake_conf = configuration.Configuration(None)
self._win_smb_helper = windows_smb_helper.WindowsSMBHelper(
self._remote_exec, fake_conf)
super(WindowsSMBHelperTestCase, self).setUp()
def test_init_helper(self):
self._win_smb_helper.init_helper(mock.sentinel.server)
self._remote_exec.assert_called_once_with(mock.sentinel.server,
"Get-SmbShare")
@ddt.data(True, False)
@mock.patch.object(windows_smb_helper.WindowsSMBHelper, '_share_exists')
def test_create_exports(self, share_exists, mock_share_exists):
mock_share_exists.return_value = share_exists
result = self._win_smb_helper.create_exports(self._FAKE_SERVER,
self._FAKE_SHARE_NAME)
if not share_exists:
cmd = [
'New-SmbShare', '-Name', self._FAKE_SHARE_NAME, '-Path',
self._win_smb_helper._windows_utils.normalize_path(
self._FAKE_SHARE_LOCATION), '-ReadAccess',
"*%s" % self._win_smb_helper._NULL_SID
]
self._remote_exec.assert_called_once_with(self._FAKE_SERVER, cmd)
else:
self.assertFalse(self._remote_exec.called)
expected_exports = [
{
'is_admin_only': False,
'metadata': {
'export_location_metadata_example': 'example'
},
'path': self._FAKE_SHARE
},
]
self.assertEqual(expected_exports, result)
@mock.patch.object(windows_smb_helper.WindowsSMBHelper, '_share_exists')
def test_remove_exports(self, mock_share_exists):
mock_share_exists.return_value = True
self._win_smb_helper.remove_exports(mock.sentinel.server,
mock.sentinel.share_name)
cmd = ['Remove-SmbShare', '-Name', mock.sentinel.share_name, "-Force"]
self._remote_exec.assert_called_once_with(mock.sentinel.server, cmd)
@mock.patch.object(windows_utils.WindowsUtils,
'get_volume_path_by_mount_path')
@mock.patch.object(windows_smb_helper.WindowsSMBHelper,
'_get_share_path_by_name')
def test_get_volume_path_by_share_name(self, mock_get_share_path,
mock_get_vol_path):
mock_get_share_path.return_value = self._FAKE_SHARE_LOCATION
volume_path = self._win_smb_helper._get_volume_path_by_share_name(
mock.sentinel.server, self._FAKE_SHARE_NAME)
mock_get_share_path.assert_called_once_with(mock.sentinel.server,
self._FAKE_SHARE_NAME)
mock_get_vol_path.assert_called_once_with(mock.sentinel.server,
self._FAKE_SHARE_LOCATION)
self.assertEqual(mock_get_vol_path.return_value, volume_path)
@ddt.data({
'raw_out': '',
'expected': []
}, {
'raw_out': '{"key": "val"}',
'expected': [{
"key": "val"
}]
}, {
'raw_out': '[{"key": "val"}, {"key2": "val2"}]',
'expected': [{
"key": "val"
}, {
"key2": "val2"
}]
})
@ddt.unpack
def test_get_acls_helper(self, raw_out, expected):
self._remote_exec.return_value = (raw_out, mock.sentinel.err)
rules = self._win_smb_helper._get_acls(mock.sentinel.server,
self._FAKE_SHARE_NAME)
self.assertEqual(expected, rules)
expected_cmd = ('Get-SmbShareAccess -Name %s | '
'Select-Object @("Name", "AccountName", '
'"AccessControlType", "AccessRight") | '
'ConvertTo-JSON -Compress') % self._FAKE_SHARE_NAME
self._remote_exec.assert_called_once_with(mock.sentinel.server,
expected_cmd)
@mock.patch.object(windows_smb_helper.WindowsSMBHelper, '_get_acls')
def test_get_access_rules(self, mock_get_acls):
helper = self._win_smb_helper
valid_acl = {
'AccountName': self._FAKE_ACCOUNT_NAME,
'AccessRight': helper._WIN_ACCESS_RIGHT_FULL,
'AccessControlType': helper._WIN_ACL_ALLOW,
}
valid_acls = [
valid_acl,
dict(valid_acl, AccessRight=helper._WIN_ACCESS_RIGHT_CHANGE),
dict(valid_acl, AccessRight=helper._WIN_ACCESS_RIGHT_READ)
]
# Those are rules that were not added by us and are expected to
# be ignored. When encountering such a rule, a warning message
# will be logged.
ignored_acls = [
dict(valid_acl, AccessRight=helper._WIN_ACCESS_RIGHT_CUSTOM),
dict(valid_acl, AccessControlType=helper._WIN_ACL_DENY)
]
mock_get_acls.return_value = valid_acls + ignored_acls
# There won't be multiple access rules for the same account,
# but we'll ignore this fact for the sake of this test.
expected_rules = [
self._FAKE_RW_ACC_RULE, self._FAKE_RW_ACC_RULE,
dict(self._FAKE_RW_ACC_RULE,
access_level=constants.ACCESS_LEVEL_RO)
]
rules = helper.get_access_rules(mock.sentinel.server,
mock.sentinel.share_name)
self.assertEqual(expected_rules, rules)
mock_get_acls.assert_called_once_with(mock.sentinel.server,
mock.sentinel.share_name)
@mock.patch.object(windows_smb_helper.WindowsSMBHelper, '_refresh_acl')
def test_grant_share_access(self, mock_refresh_acl):
self._win_smb_helper._grant_share_access(mock.sentinel.server,
mock.sentinel.share_name,
constants.ACCESS_LEVEL_RW,
mock.sentinel.username)
cmd = [
"Grant-SmbShareAccess", "-Name", mock.sentinel.share_name,
"-AccessRight", "Change", "-AccountName",
"'%s'" % mock.sentinel.username, "-Force"
]
self._remote_exec.assert_called_once_with(mock.sentinel.server, cmd)
mock_refresh_acl.assert_called_once_with(mock.sentinel.server,
mock.sentinel.share_name)
def test_refresh_acl(self):
self._win_smb_helper._refresh_acl(mock.sentinel.server,
mock.sentinel.share_name)
cmd = ['Set-SmbPathAcl', '-ShareName', mock.sentinel.share_name]
self._remote_exec.assert_called_once_with(mock.sentinel.server, cmd)
@mock.patch.object(windows_smb_helper.WindowsSMBHelper, '_refresh_acl')
def test_revoke_share_access(self, mock_refresh_acl):
self._win_smb_helper._revoke_share_access(mock.sentinel.server,
mock.sentinel.share_name,
mock.sentinel.username)
cmd = [
"Revoke-SmbShareAccess", "-Name", mock.sentinel.share_name,
"-AccountName",
'"%s"' % mock.sentinel.username, "-Force"
]
self._remote_exec.assert_called_once_with(mock.sentinel.server, cmd)
mock_refresh_acl.assert_called_once_with(mock.sentinel.server,
mock.sentinel.share_name)
def test_update_access_invalid_type(self):
invalid_access_rule = dict(self._FAKE_RW_ACC_RULE, access_type='ip')
self.assertRaises(exception.InvalidShareAccess,
self._win_smb_helper.update_access,
mock.sentinel.server, mock.sentinel.share_name,
[invalid_access_rule], [], [])
def test_update_access_invalid_level(self):
invalid_access_rule = dict(self._FAKE_RW_ACC_RULE,
access_level='fake_level')
self.assertRaises(exception.InvalidShareAccessLevel,
self._win_smb_helper.update_access,
mock.sentinel.server, mock.sentinel.share_name, [],
[invalid_access_rule], [])
@mock.patch.object(windows_smb_helper.WindowsSMBHelper,
'_revoke_share_access')
def test_update_access_deleting_invalid_rule(self, mock_revoke):
# We want to make sure that we allow deleting invalid rules.
invalid_access_rule = dict(self._FAKE_RW_ACC_RULE,
access_level='fake_level')
delete_rules = [invalid_access_rule, self._FAKE_RW_ACC_RULE]
self._win_smb_helper.update_access(mock.sentinel.server,
mock.sentinel.share_name, [], [],
delete_rules)
mock_revoke.assert_called_once_with(
mock.sentinel.server, mock.sentinel.share_name,
self._FAKE_RW_ACC_RULE['access_to'])
@mock.patch.object(windows_smb_helper.WindowsSMBHelper,
'validate_access_rules')
@mock.patch.object(windows_smb_helper.WindowsSMBHelper, 'get_access_rules')
@mock.patch.object(windows_smb_helper.WindowsSMBHelper,
'_grant_share_access')
@mock.patch.object(windows_smb_helper.WindowsSMBHelper,
'_revoke_share_access')
def test_update_access(self, mock_revoke, mock_grant,
mock_get_access_rules, mock_validate):
added_rules = [mock.MagicMock(), mock.MagicMock()]
deleted_rules = [mock.MagicMock(), mock.MagicMock()]
self._win_smb_helper.update_access(mock.sentinel.server,
mock.sentinel.share_name, [],
added_rules, deleted_rules)
mock_revoke.assert_has_calls([
mock.call(mock.sentinel.server, mock.sentinel.share_name,
deleted_rule['access_to'])
for deleted_rule in deleted_rules
])
mock_grant.assert_has_calls([
mock.call(mock.sentinel.server, mock.sentinel.share_name,
added_rule['access_level'], added_rule['access_to'])
for added_rule in added_rules
])
@mock.patch.object(windows_smb_helper.WindowsSMBHelper,
'_get_rule_updates')
@mock.patch.object(windows_smb_helper.WindowsSMBHelper,
'validate_access_rules')
@mock.patch.object(windows_smb_helper.WindowsSMBHelper, 'get_access_rules')
@mock.patch.object(windows_smb_helper.WindowsSMBHelper,
'_grant_share_access')
@mock.patch.object(windows_smb_helper.WindowsSMBHelper,
'_revoke_share_access')
def test_update_access_maintenance(self, mock_revoke, mock_grant,
mock_get_access_rules, mock_validate,
mock_get_rule_updates):
all_rules = mock.MagicMock()
added_rules = [mock.MagicMock(), mock.MagicMock()]
deleted_rules = [mock.MagicMock(), mock.MagicMock()]
mock_get_rule_updates.return_value = [added_rules, deleted_rules]
self._win_smb_helper.update_access(mock.sentinel.server,
mock.sentinel.share_name, all_rules,
[], [])
mock_get_access_rules.assert_called_once_with(mock.sentinel.server,
mock.sentinel.share_name)
mock_get_rule_updates.assert_called_once_with(
existing_rules=mock_get_access_rules.return_value,
requested_rules=all_rules)
mock_revoke.assert_has_calls([
mock.call(mock.sentinel.server, mock.sentinel.share_name,
deleted_rule['access_to'])
for deleted_rule in deleted_rules
])
mock_grant.assert_has_calls([
mock.call(mock.sentinel.server, mock.sentinel.share_name,
added_rule['access_level'], added_rule['access_to'])
for added_rule in added_rules
])
def test_get_rule_updates(self):
req_rule_0 = self._FAKE_RW_ACC_RULE
req_rule_1 = dict(self._FAKE_RW_ACC_RULE, access_to='fake_acc')
curr_rule_0 = dict(
self._FAKE_RW_ACC_RULE,
access_to=self._FAKE_RW_ACC_RULE['access_to'].upper())
curr_rule_1 = dict(self._FAKE_RW_ACC_RULE, access_to='fake_acc2')
curr_rule_2 = dict(req_rule_1, access_level=constants.ACCESS_LEVEL_RO)
expected_added_rules = [req_rule_1]
expected_deleted_rules = [curr_rule_1, curr_rule_2]
existing_rules = [curr_rule_0, curr_rule_1, curr_rule_2]
requested_rules = [req_rule_0, req_rule_1]
(added_rules, deleted_rules) = self._win_smb_helper._get_rule_updates(
existing_rules, requested_rules)
self.assertEqual(expected_added_rules, added_rules)
self.assertEqual(expected_deleted_rules, deleted_rules)
def test_get_share_name(self):
result = self._win_smb_helper._get_share_name(self._FAKE_SHARE)
self.assertEqual(self._FAKE_SHARE_NAME, result)
def test_get_share_path_by_name(self):
self._remote_exec.return_value = (self._FAKE_SHARE_LOCATION,
mock.sentinel.std_err)
result = self._win_smb_helper._get_share_path_by_name(
mock.sentinel.server, mock.sentinel.share_name)
cmd = ('Get-SmbShare -Name %s | '
'Select-Object -ExpandProperty Path' % mock.sentinel.share_name)
self._remote_exec.assert_called_once_with(mock.sentinel.server,
cmd,
check_exit_code=True)
self.assertEqual(self._FAKE_SHARE_LOCATION, result)
@mock.patch.object(windows_smb_helper.WindowsSMBHelper,
'_get_share_path_by_name')
def test_get_share_path_by_export_location(self,
mock_get_share_path_by_name):
mock_get_share_path_by_name.return_value = mock.sentinel.share_path
result = self._win_smb_helper.get_share_path_by_export_location(
mock.sentinel.server, self._FAKE_SHARE)
mock_get_share_path_by_name.assert_called_once_with(
mock.sentinel.server, self._FAKE_SHARE_NAME)
self.assertEqual(mock.sentinel.share_path, result)
@mock.patch.object(windows_smb_helper.WindowsSMBHelper,
'_get_share_path_by_name')
def test_share_exists(self, mock_get_share_path_by_name):
result = self._win_smb_helper._share_exists(mock.sentinel.server,
mock.sentinel.share_name)
mock_get_share_path_by_name.assert_called_once_with(
mock.sentinel.server,
mock.sentinel.share_name,
ignore_missing=True)
self.assertTrue(result)
class WindowsSMBHelperTestCase(test.TestCase):
_FAKE_SERVER = {'public_address': mock.sentinel.public_address}
_FAKE_SHARE_NAME = "fake_share_name"
_FAKE_SHARE = "\\\\%s\\%s" % (_FAKE_SERVER['public_address'],
_FAKE_SHARE_NAME)
_FAKE_SHARE_LOCATION = os.path.join(
configuration.Configuration(None).share_mount_path,
_FAKE_SHARE_NAME)
def setUp(self):
self._remote_exec = mock.Mock()
fake_conf = configuration.Configuration(None)
self._win_smb_helper = windows_smb_helper.WindowsSMBHelper(
self._remote_exec, fake_conf)
super(WindowsSMBHelperTestCase, self).setUp()
def test_init_helper(self):
self._win_smb_helper.init_helper(mock.sentinel.server)
self._remote_exec.assert_called_once_with(mock.sentinel.server,
"Get-SmbShare")
@ddt.data(True, False)
@mock.patch.object(windows_smb_helper.WindowsSMBHelper, '_share_exists')
def test_create_export(self, share_exists, mock_share_exists):
mock_share_exists.return_value = share_exists
result = self._win_smb_helper.create_export(self._FAKE_SERVER,
self._FAKE_SHARE_NAME)
if not share_exists:
cmd = ['New-SmbShare', '-Name', self._FAKE_SHARE_NAME, '-Path',
self._win_smb_helper._windows_utils.normalize_path(
self._FAKE_SHARE_LOCATION)]
self._remote_exec.assert_called_once_with(self._FAKE_SERVER, cmd)
else:
self.assertFalse(self._remote_exec.called)
self.assertEqual(self._FAKE_SHARE, result)
@mock.patch.object(windows_smb_helper.WindowsSMBHelper, '_share_exists')
def test_remove_export(self, mock_share_exists):
mock_share_exists.return_value = True
self._win_smb_helper.remove_export(mock.sentinel.server,
mock.sentinel.share_name)
cmd = ['Remove-SmbShare', '-Name', mock.sentinel.share_name, "-Force"]
self._remote_exec.assert_called_once_with(mock.sentinel.server, cmd)
@mock.patch.object(windows_utils.WindowsUtils,
'get_volume_path_by_mount_path')
@mock.patch.object(windows_smb_helper.WindowsSMBHelper,
'_get_share_path_by_name')
def test_get_volume_path_by_share_name(self, mock_get_share_path,
mock_get_vol_path):
mock_get_share_path.return_value = self._FAKE_SHARE_LOCATION
volume_path = self._win_smb_helper._get_volume_path_by_share_name(
mock.sentinel.server, self._FAKE_SHARE_NAME)
mock_get_share_path.assert_called_once_with(mock.sentinel.server,
self._FAKE_SHARE_NAME)
mock_get_vol_path.assert_called_once_with(mock.sentinel.server,
self._FAKE_SHARE_LOCATION)
self.assertEqual(mock_get_vol_path.return_value, volume_path)
@ddt.data('ip', 'user')
@mock.patch.object(windows_smb_helper.WindowsSMBHelper,
'_grant_share_access')
@mock.patch.object(windows_smb_helper.WindowsSMBHelper,
'_grant_share_path_access')
def test_allow_access(self, access_type, mock_grant_share_access,
mock_grant_share_path_access):
mock_args = (mock.sentinel.server, mock.sentinel.share_name,
access_type, mock.sentinel.access_level,
mock.sentinel.username)
if access_type != 'user':
self.assertRaises(exception.InvalidShareAccess,
self._win_smb_helper.allow_access,
*mock_args)
else:
self._win_smb_helper.allow_access(*mock_args)
mock_grant_share_access.assert_called_once_with(
mock.sentinel.server,
mock.sentinel.share_name,
mock.sentinel.access_level,
mock.sentinel.username)
mock_grant_share_path_access.assert_called_once_with(
mock.sentinel.server,
mock.sentinel.share_name,
mock.sentinel.access_level,
mock.sentinel.username)
@mock.patch.object(windows_smb_helper.WindowsSMBHelper, '_refresh_acl')
def test_grant_share_access(self, mock_refresh_acl):
self._win_smb_helper._grant_share_access(mock.sentinel.server,
mock.sentinel.share_name,
constants.ACCESS_LEVEL_RW,
mock.sentinel.username)
cmd = ["Grant-SmbShareAccess", "-Name", mock.sentinel.share_name,
"-AccessRight", "Change",
"-AccountName", mock.sentinel.username, "-Force"]
self._remote_exec.assert_called_once_with(mock.sentinel.server, cmd)
mock_refresh_acl.assert_called_once_with(mock.sentinel.server,
mock.sentinel.share_name)
@mock.patch.object(windows_smb_helper.WindowsSMBHelper,
'_get_volume_path_by_share_name')
def test_grant_share_path_access(self, mock_get_vol_path):
fake_vol_path = 'fake_vol_path'
mock_get_vol_path.return_value = fake_vol_path
self._win_smb_helper._grant_share_path_access(
mock.sentinel.server,
mock.sentinel.share_name,
constants.ACCESS_LEVEL_RW,
mock.sentinel.username)
expected_ace = '"%s:(OI)(CI)M"' % mock.sentinel.username
cmd = ["icacls", '"%s"' % fake_vol_path, "/grant",
expected_ace, "/t", "/c"]
self._remote_exec.assert_called_once_with(mock.sentinel.server, cmd)
def test_refresh_acl(self):
self._win_smb_helper._refresh_acl(mock.sentinel.server,
mock.sentinel.share_name)
cmd = ['Set-SmbPathAcl', '-ShareName', mock.sentinel.share_name]
self._remote_exec.assert_called_once_with(mock.sentinel.server, cmd)
@mock.patch.object(windows_smb_helper.WindowsSMBHelper,
'_revoke_share_path_access')
@mock.patch.object(windows_smb_helper.WindowsSMBHelper,
'_revoke_share_access')
def test_deny_access(self, mock_revoke_share_path_access,
mock_revoke_share_access):
mock_access = {'access_to': mock.sentinel.username}
self._win_smb_helper.deny_access(mock.sentinel.server,
mock.sentinel.share_name,
mock_access)
mock_revoke_share_access.assert_called_once_with(
mock.sentinel.server,
mock.sentinel.share_name,
mock.sentinel.username)
mock_revoke_share_path_access.assert_called_once_with(
mock.sentinel.server,
mock.sentinel.share_name,
mock.sentinel.username)
@mock.patch.object(windows_smb_helper.WindowsSMBHelper, '_refresh_acl')
def test_revoke_share_access(self, mock_refresh_acl):
self._win_smb_helper._revoke_share_access(mock.sentinel.server,
mock.sentinel.share_name,
mock.sentinel.username)
cmd = ["Revoke-SmbShareAccess", "-Name", mock.sentinel.share_name,
"-AccountName", mock.sentinel.username, "-Force"]
self._remote_exec.assert_called_once_with(mock.sentinel.server, cmd)
mock_refresh_acl.assert_called_once_with(mock.sentinel.server,
mock.sentinel.share_name)
@mock.patch.object(windows_smb_helper.WindowsSMBHelper,
'_get_volume_path_by_share_name')
def test_revoke_share_path_access(self, mock_get_vol_path):
fake_vol_path = 'fake_vol_path'
mock_get_vol_path.return_value = fake_vol_path
self._win_smb_helper._revoke_share_path_access(
mock.sentinel.server,
mock.sentinel.share_name,
mock.sentinel.username)
cmd = ["icacls", '"%s"' % fake_vol_path,
"/remove", mock.sentinel.username, "/t", "/c"]
self._remote_exec.assert_called_once_with(mock.sentinel.server, cmd)
def test_get_share_name(self):
result = self._win_smb_helper._get_share_name(self._FAKE_SHARE)
self.assertEqual(self._FAKE_SHARE_NAME, result)
def test_exports_for_share(self):
result = self._win_smb_helper.get_exports_for_share(
self._FAKE_SERVER, self._FAKE_SHARE_LOCATION)
self.assertEqual([self._FAKE_SHARE], result)
def test_get_share_path_by_name(self):
self._remote_exec.return_value = (self._FAKE_SHARE_LOCATION,
mock.sentinel.std_err)
result = self._win_smb_helper._get_share_path_by_name(
mock.sentinel.server,
mock.sentinel.share_name)
cmd = ('Get-SmbShare -Name %s | '
'Select-Object -ExpandProperty Path' % mock.sentinel.share_name)
self._remote_exec.assert_called_once_with(mock.sentinel.server,
cmd,
check_exit_code=True)
self.assertEqual(self._FAKE_SHARE_LOCATION, result)
@mock.patch.object(windows_smb_helper.WindowsSMBHelper,
'_get_share_path_by_name')
def test_get_share_path_by_export_location(self,
mock_get_share_path_by_name):
mock_get_share_path_by_name.return_value = mock.sentinel.share_path
result = self._win_smb_helper.get_share_path_by_export_location(
mock.sentinel.server, self._FAKE_SHARE)
mock_get_share_path_by_name.assert_called_once_with(
mock.sentinel.server, self._FAKE_SHARE_NAME)
self.assertEqual(mock.sentinel.share_path, result)
@mock.patch.object(windows_smb_helper.WindowsSMBHelper,
'_get_share_path_by_name')
def test_share_exists(self, mock_get_share_path_by_name):
result = self._win_smb_helper._share_exists(mock.sentinel.server,
mock.sentinel.share_name)
mock_get_share_path_by_name.assert_called_once_with(
mock.sentinel.server,
mock.sentinel.share_name,
ignore_missing=True)
self.assertTrue(result)
def test_init(self):
self.assertRaises(IndexError,
layout.GlusterfsShareDriverBase,
False,
configuration=config.Configuration(None))
def setUp(self):
super(NetAppClusteredDrvTestCase, self).setUp()
self._context = context.get_admin_context()
self._db = mock.Mock()
self.driver = driver.NetAppClusteredShareDriver(
self._db, configuration=configuration.Configuration(None))
self.driver._client = mock.Mock()
self.driver._client.send_request = mock.Mock()
self._vserver_client = mock.Mock()
self._vserver_client.send_request = mock.Mock()
driver.NetAppApiClient = mock.Mock(return_value=self._vserver_client)
self.share = {
'id': 'fake_uuid',
'project_id': 'fake_tenant_id',
'name': 'fake_name',
'size': 1,
'share_proto': 'fake',
'share_network_id': 'fake_net_id',
'share_server_id': 'fake-share-srv-id',
'network_info': {
'network_allocations': [{
'ip_address': 'ip'
}]
}
}
self.snapshot = {
'id': 'fake_snapshot_uuid',
'project_id': 'fake_tenant_id',
'share_id': 'fake_share_id',
'share': self.share
}
self.security_service = {
'id': 'fake_id',
'domain': 'FAKE',
'server': 'fake_server',
'user': '******',
'password': '******'
}
self.share_server = {
'backend_details': {
'vserver_name': 'fake_vserver'
}
}
self.helper = mock.Mock()
self.driver._helpers = {'FAKE': self.helper}
self.driver._licenses = ['fake']
self.network_info = {
'server_id':
'fake_server_id',
'cidr':
'10.0.0.0/24',
'security_services': [
'fake_ldap',
'fake_kerberos',
'fake_ad',
],
'segmentation_id':
'1000',
'network_allocations': [
{
'id': 'fake_na_id_1',
'ip_address': 'fake_ip_1',
},
{
'id': 'fake_na_id_2',
'ip_address': 'fake_ip_2',
},
],
}
def test__verify_share_server_handling_valid_cases(self, opt, allowed):
conf = configuration.Configuration(None)
self.mock_object(conf, 'safe_get', mock.Mock(return_value=opt))
share_driver = driver.ShareDriver(allowed, configuration=conf)
self.assertTrue(conf.safe_get.celled)
self.assertEqual(opt, share_driver.driver_handles_share_servers)
def test__try_execute(self):
execute_mixin = ShareDriverWithExecuteMixin(
True, configuration=configuration.Configuration(None))
self.assertRaises(exception.ProcessExecutionError,
execute_mixin._try_execute)
import ddt
from oslo_config import cfg
import requests
import six
from manila.common import constants as const
from manila import context
from manila import exception
from manila.share import configuration
from manila.share.drivers.tegile import tegile
from manila import test
CONF = cfg.CONF
test_config = configuration.Configuration(None)
test_config.tegile_nas_server = 'some-ip'
test_config.tegile_nas_login = '******'
test_config.tegile_nas_password = '******'
test_config.reserved_share_percentage = 10
test_config.max_over_subscription_ratio = 30.0
test_share = {
'host': 'node#fake_pool',
'name': 'testshare',
'id': 'a24c2ee8-525a-4406-8ccd-8d38688f8e9e',
'share_proto': 'NFS',
'size': 10,
}
test_share_cifs = {
