Beispiel #1
0
    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)
Beispiel #2
0
    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)
Beispiel #3
0
    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')
Beispiel #4
0
    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)
Beispiel #5
0
    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)
Beispiel #6
0
    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)
Beispiel #7
0
    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')
Beispiel #8
0
    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)
Beispiel #9
0
    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]))
Beispiel #10
0
    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]))
Beispiel #11
0
    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')
Beispiel #12
0
    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')
Beispiel #13
0
    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')
Beispiel #14
0
    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)
Beispiel #15
0
    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])
        )
Beispiel #16
0
    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 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')
Beispiel #18
0
    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)
Beispiel #19
0
    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')
Beispiel #20
0
    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)
Beispiel #21
0
    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={}))
Beispiel #22
0
 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)
Beispiel #23
0
    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)
Beispiel #24
0
    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)
Beispiel #25
0
 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)
Beispiel #26
0
 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)
Beispiel #27
0
    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)
Beispiel #28
0
 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)
Beispiel #29
0
 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)
Beispiel #30
0
    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)
Beispiel #31
0
    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)
Beispiel #32
0
    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)
Beispiel #33
0
 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)
Beispiel #34
0
    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)
Beispiel #35
0
    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)
Beispiel #36
0
 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)
Beispiel #37
0
    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)
Beispiel #38
0
    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)
Beispiel #39
0
    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()
Beispiel #40
0
    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])
        ))
Beispiel #41
0
    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()
Beispiel #42
0
    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)
Beispiel #43
0
 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)
Beispiel #44
0
    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])
        ))
Beispiel #45
0
    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()
Beispiel #46
0
    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()
Beispiel #47
0
    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)
Beispiel #48
0
    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)
Beispiel #49
0
    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)
Beispiel #50
0
 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)
Beispiel #51
0
 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()
Beispiel #53
0
    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')
Beispiel #54
0
    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())
Beispiel #55
0
    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(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')
Beispiel #57
0
    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)
Beispiel #58
0
 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)
Beispiel #59
0
    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')