def test_create_delete_multiple_shares(self): """Create/Delete multiple shares.""" share1 = fake_share.fake_share(id='fakeid1', share_proto='NFS', share_id='fakeshareid1') self.driver.create_share(self._context, share1) share2 = fake_share.fake_share(id='fakeid2', share_proto='CIFS', share_id='fakeshareid2') self.driver.create_share(self._context, share2) self.driver.delete_share(self._context, share1) self.driver.delete_share(self._context, share2)
def test_share_allow_deny_access(self): """Test share access allow any deny rules.""" share = fake_share.fake_share(id='fakeid', share_proto='NFS', share_id='fakeshareid') self.driver.create_share(self._context, share) access = fake_share.fake_access() # Attach server for accessing share with the fake access rules allow_access = self.driver._allow_access(self._context, share, access) self.assertEqual(allow_access['driver_volume_type'], share['share_proto']) self.assertEqual('1.1.1.1:3260', allow_access['data']['target_portal']) (srv_name, srv_params) = RUNTIME_VARS['servers'][0] self.assertEqual(srv_params['iscsi'], allow_access['data']['target_ip']) self.assertEqual(share['id'], allow_access['data']['id']) self.assertEqual('CHAP', allow_access['data']['auth_method']) self.assertEqual('test_chap_user', allow_access['data']['auth_username']) self.assertEqual('test_chap_secret', allow_access['data']['auth_password']) # Detach will not throw any error with missing access rules dup_access = fake_share.fake_access() self.driver._deny_access(self._context, share, dup_access) # Detach server from the share with deny access rules self.driver._deny_access(self._context, share, access) self.driver.delete_share(self._context, share)
def setUp(self): super(HitachiHSPTestCase, self).setUp() CONF.set_default('driver_handles_share_servers', False) CONF.hitachi_hsp_host = '172.24.47.190' CONF.hitachi_hsp_username = '******' CONF.hitachi_hsp_password = '******' CONF.hitachi_hsp_job_timeout = 300 self.fake_el = [{ "path": CONF.hitachi_hsp_host + ":/fakeinstanceid", "metadata": {}, "is_admin_only": False, }] self.fake_share = fake_share.fake_share(share_proto='nfs') self.fake_share_instance = fake_share.fake_share_instance( base_share=self.fake_share, export_locations=self.fake_el) self.fake_conf = manila.share.configuration.Configuration(None) self.fake_private_storage = mock.Mock() self.mock_object(rest.HSPRestBackend, "get_cluster", mock.Mock(return_value=fakes.hsp_cluster)) self._driver = driver.HitachiHSPDriver( configuration=self.fake_conf, private_storage=self.fake_private_storage) self._driver.backend_name = "HSP" self.mock_log = self.mock_object(driver, 'LOG')
def test_create_share_error(self): share = fake_share.fake_share(share_proto='NFS') self.assertRaises(exception.ShareBackendException, self._driver.create_share, self._context, share)
def test__get_share_instance_pnsp(self, share_proto): share = fake_share.fake_share(share_proto=share_proto) share_instance = fake_share.fake_share_instance(share, host="H@B#P") result = self.driver._get_share_instance_pnsp(share_instance) self.assertEqual(('P', 'share_fakeinstanceid', 1, share_proto), result)
def test_allow_access_with_incorrect_access_type(self): share = fake_share.fake_share(id='fakeid1', share_proto='NFS') access = fake_share.fake_access(access_type='fake_type') self.assertRaises(manila_exception.ZadaraInvalidShareAccessType, self.driver._allow_access, self._context, share, access)
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 test__generate_share_name(self): share = fake_share.fake_share() share_instance = fake_share.fake_share_instance(share, host="H@B#P") result = self.driver._generate_share_name(share_instance) self.assertEqual('share_fakeinstanceid', result)
def setUp(self): super(HDFSNativeShareDriverTestCase, self).setUp() self._context = context.get_admin_context() self._hdfs_execute = mock.Mock(return_value=('', '')) self.local_ip = '192.168.1.1' CONF.set_default('driver_handles_share_servers', False) CONF.set_default('hdfs_namenode_ip', self.local_ip) CONF.set_default('hdfs_ssh_name', 'fake_sshname') CONF.set_default('hdfs_ssh_pw', 'fake_sshpw') CONF.set_default('hdfs_ssh_private_key', 'fake_sshkey') self.fake_conf = config.Configuration(None) self._driver = hdfs_native.HDFSNativeShareDriver( execute=self._hdfs_execute, configuration=self.fake_conf) self.hdfs_bin = 'hdfs' self._driver._hdfs_bin = 'fake_hdfs_bin' self.share = fake_share.fake_share(share_proto='HDFS') self.snapshot = fake_share.fake_snapshot(share_proto='HDFS') self.access = fake_share.fake_access(access_type='user') self.fakesharepath = 'hdfs://1.2.3.4:5/share-0' self.fakesnapshotpath = '/share-0/.snapshot/snapshot-0' socket.gethostname = mock.Mock(return_value='testserver') socket.gethostbyname_ex = mock.Mock(return_value=( 'localhost', ['localhost.localdomain', 'testserver'], ['127.0.0.1', self.local_ip]))
def setUp(self): super(HDFSNativeShareDriverTestCase, self).setUp() self._context = context.get_admin_context() self._hdfs_execute = mock.Mock(return_value=('', '')) self.local_ip = '192.168.1.1' CONF.set_default('driver_handles_share_servers', False) CONF.set_default('hdfs_namenode_ip', self.local_ip) CONF.set_default('hdfs_ssh_name', 'fake_sshname') CONF.set_default('hdfs_ssh_pw', 'fake_sshpw') CONF.set_default('hdfs_ssh_private_key', 'fake_sshkey') self.fake_conf = config.Configuration(None) self._driver = hdfs_native.HDFSNativeShareDriver( execute=self._hdfs_execute, configuration=self.fake_conf) self.hdfs_bin = 'hdfs' self._driver._hdfs_bin = 'fake_hdfs_bin' self.share = fake_share.fake_share(share_proto='HDFS') self.snapshot = fake_share.fake_snapshot(share_proto='HDFS') self.access = fake_share.fake_access(access_type='user') self.fakesharepath = 'hdfs://1.2.3.4:5/share-0' self.fakesnapshotpath = '/share-0/.snapshot/snapshot-0' socket.gethostname = mock.Mock(return_value='testserver') socket.gethostbyname_ex = mock.Mock( return_value=('localhost', ['localhost.localdomain', 'testserver'], ['127.0.0.1', self.local_ip]))
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') CONF.set_default('ganesha_rados_store_enable', True) CONF.set_default('ganesha_rados_store_pool_name', 'ceph_pool') CONF.set_default('ganesha_rados_export_index', 'fake_index') CONF.set_default('ganesha_rados_export_counter', 'fake_counter') self._context = context.get_admin_context() self._execute = mock.Mock(return_value=('', '')) self.ceph_vol_client = mock.Mock() 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', ceph_vol_client=self.ceph_vol_client) 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(HDFSNativeShareDriverTestCase, self).setUp() self._context = context.get_admin_context() self._hdfs_execute = mock.Mock(return_value=("", "")) self.local_ip = "192.168.1.1" CONF.set_default("driver_handles_share_servers", False) CONF.set_default("hdfs_namenode_ip", self.local_ip) CONF.set_default("hdfs_ssh_name", "fake_sshname") CONF.set_default("hdfs_ssh_pw", "fake_sshpw") CONF.set_default("hdfs_ssh_private_key", "fake_sshkey") self.fake_conf = config.Configuration(None) self._driver = hdfs_native.HDFSNativeShareDriver(execute=self._hdfs_execute, configuration=self.fake_conf) self.hdfs_bin = "hdfs" self._driver._hdfs_bin = "fake_hdfs_bin" self.share = fake_share.fake_share(share_proto="HDFS") self.snapshot = fake_share.fake_snapshot(share_proto="HDFS") self.access = fake_share.fake_access(access_type="user") self.fakesharepath = "hdfs://1.2.3.4:5/share-0" self.fakesnapshotpath = "/share-0/.snapshot/snapshot-0" socket.gethostname = mock.Mock(return_value="testserver") socket.gethostbyname_ex = mock.Mock( return_value=("localhost", ["localhost.localdomain", "testserver"], ["127.0.0.1", self.local_ip]) )
def test_create_share_from_snapshot(self, share_proto): share = fake_share.fake_share(share_proto=share_proto) share_instance = fake_share.fake_share_instance(share, host="H@B#P") mock_cd = self.mock_object(self.driver, '_create_directory', mock.Mock(return_value='/fake/path')) mock_cns = self.mock_object(self.driver, '_create_nfs_share') mock_ccs = self.mock_object(self.driver, '_create_cifs_share') mock_sdq = self.mock_object(self.driver, '_set_directory_quota') mock_cdtd = self.mock_object(self.driver, '_clone_directory_to_dest') self.driver.ips = ['127.0.0.1'] locations = self.driver.create_share_from_snapshot( self._ctxt, share_instance, None) if share_proto == 'nfs': expect_locations = [{'path': r'127.0.0.1:/fake/path'}] self.assertEqual(locations, expect_locations) else: expect_locations = [{'path': r'\\127.0.0.1\share_fakeinstanceid'}] self.assertEqual(locations, expect_locations) mock_cd.assert_called_once_with(share_name='share_fakeinstanceid', pool_name='P') if share_proto == 'nfs': mock_cns.assert_called_once_with(share_path='/fake/path') elif share['share_proto'] is 'cifs': mock_ccs.assert_called_once_with(share_path='/fake/path', share_name='share_fakeinstanceid') mock_sdq.assert_called_once_with('/fake/path', share['size']) mock_cdtd.assert_called_once_with(snapshot=None, dest_path='/fake/path')
def test_extend_share(self): """Expand share test.""" share1 = fake_share.fake_share(id='fakeid1', share_proto='NFS', share_id='fakeshareid', size=10) share2 = fake_share.fake_share(id='fakeid2', share_proto='NFS', size=10) self.driver.create_share(self._context, share1) self.assertRaises(manila_exception.ZadaraShareNotFound, self.driver.extend_share, share2, 15) self.driver.extend_share(share1, 15) self.driver.delete_share(self._context, share1)
def test_create_share_from_snapshot(self, share_proto): share = fake_share.fake_share(share_proto=share_proto) share_instance = fake_share.fake_share_instance(share, host="H@B#P") mock_cd = self.mock_object(self.driver, '_create_directory', mock.Mock(return_value='/fake/path')) mock_cns = self.mock_object(self.driver, '_create_nfs_share') mock_ccs = self.mock_object(self.driver, '_create_cifs_share') mock_sdq = self.mock_object(self.driver, '_set_directory_quota') mock_cdtd = self.mock_object(self.driver, '_clone_directory_to_dest') self.driver.ips = ['127.0.0.1'] locations = self.driver.create_share_from_snapshot( self._ctxt, share_instance, None) if share_proto == 'nfs': expect_locations = [{'path': r'127.0.0.1:/fake/path'}] self.assertEqual(locations, expect_locations) else: expect_locations = [{'path': r'\\127.0.0.1\share_fakeinstanceid'}] self.assertEqual(locations, expect_locations) mock_cd.assert_called_once_with(share_name='share_fakeinstanceid', pool_name='P') if share_proto == 'nfs': mock_cns.assert_called_once_with(share_path='/fake/path') elif share['share_proto'] == 'cifs': mock_ccs.assert_called_once_with(share_path='/fake/path', share_name='share_fakeinstanceid') mock_sdq.assert_called_once_with('/fake/path', share['size']) mock_cdtd.assert_called_once_with(snapshot=None, dest_path='/fake/path')
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._snapshot = fake_share.fake_snapshot_instance() self.fake_conf.set_default('driver_handles_share_servers', False) self.fake_conf.set_default('cephfs_auth_id', 'manila') self.mock_object(driver, "rados_command") self.mock_object(driver, "rados", MockRadosModule) self.mock_object(driver, "json_command", MockCephArgparseModule) self.mock_object(driver, 'NativeProtocolHelper') self.mock_object(driver, 'NFSProtocolHelper') driver.ceph_default_target = ('mon-mgr', ) self._driver = (driver.CephFSDriver(execute=self._execute, configuration=self.fake_conf)) self._driver.protocol_helper = mock.Mock() type(self._driver).volname = mock.PropertyMock(return_value='cephfs') self.mock_object(share_types, 'get_share_type_extra_specs', mock.Mock(return_value={}))
def test_create_share_unsupported_proto(self): self._driver._get_share_path = mock.Mock() self.assertRaises(exception.HDFSException, self._driver.create_share, self._context, fake_share.fake_share(), share_server=None) self.assertFalse(self._driver._get_share_path.called)
def test_allow_access_with_incorrect_proto(self): share_server = fakes.SHARE_SERVER share = fake_share.fake_share(share_proto='FAKE_PROTO') access = fake_share.fake_access() self.assertRaises(exception.InvalidShare, self.connection.allow_access, None, share, access, share_server)
def test_create_share_from_snapshot_with_incorrect_proto(self): share_server = fakes.SHARE_SERVER share = fake_share.fake_share(share_proto='FAKE_PROTO') snapshot = fake_share.fake_snapshot() self.assertRaises(exception.InvalidShare, self.connection.create_share_from_snapshot, None, share, snapshot, share_server)
def test_deny_access_with_share_having_noaccess(self): access = fake_share.fake_access() share = fake_share.fake_share() export_dir_dict = {} self.mock_object(self._helper, '_get_export_dir_dict', mock.Mock(return_value=export_dir_dict)) self._helper.deny_access(None, share, access) self._helper._get_export_dir_dict.assert_called_once_with() self.assertFalse(self._helper.gluster_manager.gluster_call.called)
def test_delete_share_with_incorrect_proto(self): share_server = fakes.SHARE_SERVER share = fake_share.fake_share(share_proto='FAKE_PROTO') self.assertRaises(exception.InvalidShare, self.connection.delete_share, context=None, share=share, share_server=share_server)
def test_ces_get_export_options_invalid_option_rw(self): mock_out = {"ces:export_options": "access_type=rw"} self.mock_object(share_types, 'get_extra_specs_from_share', mock.Mock(return_value=mock_out)) access = self.access options_not_allowed = ['access_type=ro', 'access_type=rw'] share = fake_share.fake_share(share_type="fake_share_type") self.assertRaises(exception.InvalidInput, self._ces_helper.get_export_options, share, access, 'CES', options_not_allowed)
def test_create_share_unsupported_proto(self): self._driver.api.get_share_metadata = mock.Mock(return_value={}) self._driver._get_share_path = mock.Mock() self.assertRaises(exception.MapRFSException, self._driver.create_share, self._context, fake_share.fake_share(share_id=1), share_server=None) self.assertFalse(self._driver._get_share_path.called)
def test_extend_share(self): share = fake_share.fake_share() share_instance = fake_share.fake_share_instance(share, host="H@B#P") expect_share_path = r'/P/share_fakeinstanceid' mock_sdq = self.mock_object(self.driver, '_set_directory_quota') self.driver.extend_share(share_instance, 2) mock_sdq.assert_called_once_with(expect_share_path, 2)
def test_no_active_ctrl(self): share = fake_share.fake_share(id='fakeid', share_proto='NFS', share_id='fakeshareid') self.driver.create_share(self._context, share) access = fake_share.fake_access() RUNTIME_VARS['controllers'] = [] self.assertRaises(manila_exception.ZadaraVPSANoActiveController, self.driver._allow_access, self._context, share, access)
def setUp(self): """Setup the Qnap Driver Base TestCase.""" super(QnapShareDriverTestCase, self).setUp() self.mock_object(qnap.QnapShareDriver, '_create_api_executor') self.share = fake_share.fake_share( share_proto='NFS', id='shareId', display_name='fakeDisplayName', export_locations=[{'path': '1.2.3.4:/share/fakeShareName'}], host='QnapShareDriver', size=10)
def test_allow_access_with_share_having_access(self): access = fake_share.fake_access() share = fake_share.fake_share() export_list = ['10.0.0.1'] self.mock_object(self._helper, '_get_vol_exports', mock.Mock(return_value=export_list)) self._helper.allow_access(None, share, access) self._helper._get_vol_exports.assert_called_once_with() self.assertFalse(self._helper.gluster_manager.gluster_call.called)
def test_allow_access_with_share_having_access(self): access = fake_share.fake_access() share = fake_share.fake_share() export_dir_dict = {'fakename': ['10.0.0.1']} self.mock_object(self._helper, '_get_export_dir_dict', mock.Mock(return_value=export_dir_dict)) self._helper.gluster_manager.path = '/fakename' self._helper.allow_access(None, share, access) self._helper._get_export_dir_dict.assert_called_once_with() self.assertFalse(self._helper.gluster_manager.set_vol_option.called)
def setUp(self): super(MapRFSNativeShareDriverTestCase, self).setUp() self._context = context.get_admin_context() self._hdfs_execute = mock.Mock(return_value=('', '')) self.local_ip = '192.168.1.1' CONF.set_default('driver_handles_share_servers', False) CONF.set_default('maprfs_clinode_ip', [self.local_ip]) CONF.set_default('maprfs_ssh_name', 'fake_sshname') CONF.set_default('maprfs_ssh_pw', 'fake_sshpw') CONF.set_default('maprfs_ssh_private_key', 'fake_sshkey') CONF.set_default('maprfs_rename_managed_volume', True) self.fake_conf = config.Configuration(None) self.cluster_name = 'fake' export_locations = {0: {'path': '/share-0'}} export_locations[0]['el_metadata'] = {'volume-name': 'share-0'} self.share = fake_share.fake_share(share_proto='MAPRFS', name='share-0', size=2, share_id=1, export_locations=export_locations, export_location='/share-0') self.snapshot = fake_share.fake_snapshot(share_proto='MAPRFS', name='fake', share_name=self.share['name'], share_id=self.share['id'], share=self.share, share_instance=self.share, provider_location='fake') self.access = fake_share.fake_access(access_type='user', access_to='fake', access_level='rw') self.snapshot = self.snapshot.values self.snapshot.update(share_instance=self.share) self.export_path = 'maprfs:///share-0 -C -Z -N fake' self.fakesnapshot_path = '/share-0/.snapshot/snapshot-0' self.hadoop_bin = '/usr/bin/hadoop' self.maprcli_bin = '/usr/bin/maprcli' self.mock_object(utils, 'execute') self.mock_object(mapru.socket, 'gethostname', mock.Mock(return_value='testserver')) self.mock_object( mapru.socket, 'gethostbyname_ex', mock.Mock(return_value=('localhost', [ 'localhost.localdomain', mapru.socket.gethostname.return_value ], ['127.0.0.1', self.local_ip]))) self._driver = maprfs.MapRFSNativeShareDriver( configuration=self.fake_conf) self._driver.do_setup(self._context) self._driver.api.get_share_metadata = mock.Mock(return_value={}) self._driver.api.update_share_metadata = mock.Mock()
def setUp(self): super(GPFSShareDriverTestCase, self).setUp() self._context = context.get_admin_context() self._gpfs_execute = mock.Mock(return_value=('', '')) self._helper_fake = mock.Mock() CONF.set_default('driver_handles_share_servers', False) self.fake_conf = config.Configuration(None) self._driver = gpfs.GPFSShareDriver(execute=self._gpfs_execute, configuration=self.fake_conf) self._knfs_helper = gpfs.KNFSHelper(self._gpfs_execute, self.fake_conf) self._gnfs_helper = gpfs.GNFSHelper(self._gpfs_execute, self.fake_conf) self.fakedev = "/dev/gpfs0" self.fakefspath = "/gpfs0" self.fakesharepath = "/gpfs0/share-fakeid" self.fakesnapshotpath = "/gpfs0/.snapshots/snapshot-fakesnapshotid" self.mock_object(gpfs.os.path, 'exists', mock.Mock(return_value=True)) self._driver._helpers = { 'KNFS': self._helper_fake } self.share = fake_share.fake_share(share_proto='NFS') self.server = { 'backend_details': { 'ip': '1.2.3.4', 'instance_id': 'fake' } } self.access = fake_share.fake_access() self.snapshot = fake_share.fake_snapshot() self.local_ip = "192.11.22.1" self.remote_ip = "192.11.22.2" gpfs_nfs_server_list = [self.local_ip, self.remote_ip] self._knfs_helper.configuration.gpfs_nfs_server_list = \ gpfs_nfs_server_list self._gnfs_helper.configuration.gpfs_nfs_server_list = \ gpfs_nfs_server_list self._gnfs_helper.configuration.ganesha_config_path = \ "fake_ganesha_config_path" self.sshlogin = "******" self.sshkey = "fake_sshkey" self.gservice = "fake_ganesha_service" self._gnfs_helper.configuration.gpfs_ssh_login = self.sshlogin self._gnfs_helper.configuration.gpfs_ssh_private_key = self.sshkey self._gnfs_helper.configuration.ganesha_service_name = self.gservice self.mock_object(socket, 'gethostname', mock.Mock(return_value="testserver")) self.mock_object(socket, 'gethostbyname_ex', mock.Mock( return_value=('localhost', ['localhost.localdomain', 'testserver'], ['127.0.0.1', self.local_ip]) ))
def setUp(self): super(QuobyteShareDriverTestCase, self).setUp() self._context = context.get_admin_context() CONF.set_default('driver_handles_share_servers', False) self.fake_conf = config.Configuration(None) self._driver = quobyte.QuobyteShareDriver(configuration=self.fake_conf) self._driver.rpc = mock.Mock() self.share = fake_share.fake_share(share_proto='NFS') self.access = fake_share.fake_access()
def test_allow_access_with_share_having_access(self): access = fake_share.fake_access() share = fake_share.fake_share() export_dir_dict = {'fakename': ['10.0.0.1']} self.mock_object(self._helper, '_get_export_dir_dict', mock.Mock(return_value=export_dir_dict)) self._helper.gluster_manager.path = '/fakename' self._helper.allow_access(None, share, access) self._helper._get_export_dir_dict.assert_called_once_with() self.assertFalse(self._helper.gluster_manager.gluster_call.called)
def make_fake_share(self, name, proto="EOS"): fake_response = FakeResponse() share_location = BEGIN_PATH + fake_response.name + "/" + name return fake_share.fake_share(share_id="fake", display_name=name, display_description="fake", creator="fake_user", user_id="fake_id", share_proto=proto, size=1, metadata={'share_host': 'fake_location:/fake_share'}, export_location=share_location)
def setUp(self): super(MapRFSNativeShareDriverTestCase, self).setUp() self._context = context.get_admin_context() self._hdfs_execute = mock.Mock(return_value=('', '')) self.local_ip = '192.168.1.1' CONF.set_default('driver_handles_share_servers', False) CONF.set_default('maprfs_clinode_ip', [self.local_ip]) CONF.set_default('maprfs_ssh_name', 'fake_sshname') CONF.set_default('maprfs_ssh_pw', 'fake_sshpw') CONF.set_default('maprfs_ssh_private_key', 'fake_sshkey') CONF.set_default('maprfs_rename_managed_volume', True) self.fake_conf = config.Configuration(None) self.cluster_name = 'fake' export_locations = {0: {'path': '/share-0'}} export_locations[0]['el_metadata'] = { 'volume-name': 'share-0'} self.share = fake_share.fake_share(share_proto='MAPRFS', name='share-0', size=2, share_id=1, export_locations=export_locations, export_location='/share-0') self.snapshot = fake_share.fake_snapshot(share_proto='MAPRFS', name='fake', share_name=self.share['name'], share_id=self.share['id'], share=self.share, share_instance=self.share, provider_location='fake') self.access = fake_share.fake_access(access_type='user', access_to='fake', access_level='rw') self.snapshot = self.snapshot.values self.snapshot.update(share_instance=self.share) self.export_path = 'maprfs:///share-0 -C -Z -N fake' self.fakesnapshot_path = '/share-0/.snapshot/snapshot-0' self.hadoop_bin = '/usr/bin/hadoop' self.maprcli_bin = '/usr/bin/maprcli' self.mock_object(utils, 'execute') self.mock_object( mapru.socket, 'gethostname', mock.Mock(return_value='testserver')) self.mock_object( mapru.socket, 'gethostbyname_ex', mock.Mock(return_value=( 'localhost', ['localhost.localdomain', mapru.socket.gethostname.return_value], ['127.0.0.1', self.local_ip]))) self._driver = maprfs.MapRFSNativeShareDriver( configuration=self.fake_conf) self._driver.do_setup(self._context) self._driver.api.get_share_metadata = mock.Mock(return_value={}) self._driver.api.update_share_metadata = mock.Mock()
def test_allow_access_with_share_having_access(self, share_key, gmgr_path): access = fake_share.fake_access() share = fake_share.fake_share() export_dir_dict = {share_key: ['10.0.0.1']} self.mock_object(self._helper, '_get_export_dir_dict', mock.Mock(return_value=export_dir_dict)) self._helper.gluster_manager.path = gmgr_path self._helper.allow_access(None, share, access) self._helper._get_export_dir_dict.assert_called_once_with() self.assertFalse(self._helper.gluster_manager.gluster_call.called)
def test_create_share_from_snapshot(self): """Create a share from snapshot test.""" share1 = fake_share.fake_share(id='fakeid1', share_proto='NFS', share_id='fakeshareid1') share2 = fake_share.fake_share(id='fakeid2', share_proto='NFS', share_id='fakeshareid2') self.driver.create_share(self._context, share1) snapshot = fake_share.fake_snapshot(name='fakesnap', share=share1, share_name=share1['name'], share_id=share1['id'], share_instance_id=share1['id'], provider_location='fakelocation') self.driver.create_snapshot(self._context, snapshot) self.assertRaises( manila_exception.ManilaException, self.driver.create_share_from_snapshot, self._context, share2, { 'name': snapshot['name'], 'id': snapshot['id'], 'share': share2, 'share_instance_id': share2['id'] }) self.assertRaises( manila_exception.ManilaException, self.driver.create_share_from_snapshot, self._context, share2, { 'name': 'fakesnapname', 'id': 'fakesnapid', 'share': share1, 'share_instance_id': share1['id'] }) self.driver.create_share_from_snapshot(self._context, share2, snapshot) self.driver.delete_share(self._context, share1) self.driver.delete_share(self._context, share2)
def test_create_delete_share_snapshot(self): """Create/Delete share snapshot.""" share1 = fake_share.fake_share(id='fakeid1', share_proto='NFS', share_id='fakeshareid1') self.driver.create_share(self._context, share1) snapshot = fake_share.fake_snapshot(name='fakesnap', share=share1, share_name=share1['name'], share_id=share1['id'], provider_location='fakelocation') share2 = fake_share.fake_share(id='fakeid2', share_proto='NFS', share_id='fakeshareid2') self.assertRaises(manila_exception.ManilaException, self.driver.create_snapshot, self._context, { 'name': snapshot['name'], 'id': snapshot['id'], 'share': share2 }) self.driver.create_snapshot(self._context, snapshot) # Deleted should succeed for missing volume self.driver.delete_snapshot(self._context, { 'name': snapshot['name'], 'id': snapshot['id'], 'share': share2 }) # Deleted should succeed for missing snap self.driver.delete_snapshot(self._context, { 'name': 'wrong_snap', 'id': 'wrong_id', 'share': share1 }) self.driver.delete_snapshot(self._context, snapshot) self.driver.delete_share(self._context, share1)
def test_allow_access_with_share_having_noaccess(self): access = fake_share.fake_access() share = fake_share.fake_share() export_dir_dict = {'example.com': ['10.0.0.1']} export_str = '/example.com(10.0.0.1),/fakename(10.0.0.1)' args = ('volume', 'set', self._helper.gluster_manager.volume, NFS_EXPORT_DIR, export_str) self.mock_object(self._helper, '_get_export_dir_dict', mock.Mock(return_value=export_dir_dict)) self._helper.allow_access(None, share, access) self._helper._get_export_dir_dict.assert_called_once_with() self._helper.gluster_manager.gluster_call.assert_called_once_with( *args)
def setUp(self, mock_sv_instance_mgr, mock_smb_helper_cls, mock_utils_cls, mock_winrm_helper_cls): self.flags(driver_handles_share_servers=True) self._fake_conf = configuration.Configuration(None) self._share = fake_share.fake_share(share_proto="SMB") self._share_server = dict(backend_details=mock.sentinel.backend_details) self._drv = windows_drv.WindowsSMBDriver(configuration=self._fake_conf) self._drv._setup_helpers() self._remote_execute = mock_winrm_helper_cls.return_value self._windows_utils = mock_utils_cls.return_value self._smb_helper = mock_smb_helper_cls.return_value super(WindowsSMBDriverTestCase, self).setUp()
def test_delete_share_not_exist(self, share_proto): share = fake_share.fake_share(share_proto=share_proto) share_instance = fake_share.fake_share_instance(share, host="H@B#P") expect_share_path = r'/P/share_fakeinstanceid' mock_gns = self.mock_object(self.driver, '_get_nfs_share', mock.Mock(return_value=[])) mock_gcs = self.mock_object(self.driver, '_get_cifs_share', mock.Mock(return_value=[])) self.driver.delete_share(self._ctxt, share_instance) if share_proto == 'nfs': mock_gns.assert_called_once_with(expect_share_path) elif share_proto == 'cifs': mock_gcs.assert_called_once_with('share_fakeinstanceid')
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(share_proto='CEPHFS') self.fake_conf.set_default('driver_handles_share_servers', False) self.mock_object(driver, "cephfs_share_path") self._native_protocol_helper = driver.NativeProtocolHelper( None, self.fake_conf, ceph_vol_client=MockVolumeClientModule.CephFSVolumeClient())
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('reserved_share_percentage', 50) 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.share = fake_share.fake_share(share_proto='NFS')
def test_deny_access_with_share_having_access(self): access = fake_share.fake_access() share = fake_share.fake_share() export_list = ['10.0.0.1', '10.0.0.2'] self.mock_object(self._helper, '_get_vol_exports', mock.Mock(return_value=export_list)) self._helper.deny_access(None, share, access) self._helper._get_vol_exports.assert_called_once_with() export_str = '10.0.0.2' argseq = ((NFS_RPC_AUTH_ALLOW, export_str), (NFS_RPC_AUTH_REJECT, None)) self.assertEqual( [mock.call(*a) for a in argseq], self._helper.gluster_manager.set_vol_option.call_args_list)
def setUp(self): super(GaneshaNFSHelperTestCase, self).setUp() self.gluster_manager = mock.Mock(**fake_gluster_manager_attrs) self._execute = mock.Mock(return_value=('', '')) self._root_execute = mock.Mock(return_value=('', '')) self.access = fake_share.fake_access() self.fake_conf = config.Configuration(None) self.fake_template = {'key': 'value'} self.share = fake_share.fake_share() self.mock_object(glusterfs.ganesha_utils, 'RootExecutor', mock.Mock(return_value=self._root_execute)) self.mock_object(glusterfs.ganesha.GaneshaNASHelper, '__init__', mock.Mock()) self._helper = glusterfs.GaneshaNFSHelper( self._execute, self.fake_conf, gluster_manager=self.gluster_manager)
def test_ensure_share_None_share_fail(self, share_proto): share = fake_share.fake_share(share_proto=share_proto) share_instance = fake_share.fake_share_instance(share, host="H@B#P") mock_gns = self.mock_object(self.driver, '_get_nfs_share', mock.Mock(return_value=[])) mock_gcs = self.mock_object(self.driver, '_get_cifs_share', mock.Mock(return_value=[])) self.assertRaises(exception.ShareResourceNotFound, self.driver.ensure_share, self._ctxt, share_instance) if share_proto == 'nfs': mock_gns.assert_called_once_with(r'/P/share_fakeinstanceid') elif share['share_proto'] is 'cifs': mock_gcs.assert_called_once_with(r'share_fakeinstanceid')