def _create_delete_access_rule(self, share_id, access_type, access_to,
microversion=None):
self.skip_if_microversion_not_supported(microversion)
if access_type not in self.access_types:
raise self.skipException(
"'%(access_type)s' access rules is disabled for protocol "
"'%(protocol)s'." % {"access_type": access_type,
"protocol": self.protocol})
access = self.user_client.access_allow(
share_id, access_type, access_to, self.access_level,
microversion=microversion)
self.assertEqual(share_id, access.get('share_id'))
self.assertEqual(access_type, access.get('access_type'))
self.assertEqual(access_to.replace('\\\\', '\\'),
access.get('access_to'))
self.assertEqual(self.access_level, access.get('access_level'))
if (api_versions.APIVersion(microversion) >=
api_versions.APIVersion("2.33")):
self.assertIn('access_key', access)
self.assertIn('created_at', access)
self.assertIn('updated_at', access)
elif (api_versions.APIVersion(microversion) >=
api_versions.APIVersion("2.21")):
self.assertIn('access_key', access)
else:
self.assertNotIn('access_key', access)
self.user_client.wait_for_access_rule_status(share_id, access['id'])
self.user_client.access_deny(share_id, access['id'])
self.user_client.wait_for_access_rule_deletion(share_id, access['id'])
self.assertRaises(tempest_lib_exc.NotFound,
self.user_client.get_access, share_id, access['id'])
def get_types(self, **kw):
req_version = self.default_headers['X-Openstack-Manila-Api-Version']
if not isinstance(req_version, api_versions.APIVersion):
req_version = api_versions.APIVersion(req_version)
response_body = {
'share_types': [{
'id': 1,
'name': 'test-type-1',
'extra_specs': {
'test1': 'test1'
},
'required_extra_specs': {
'test': 'test'
}
}, {
'id': 2,
'name': 'test-type-2',
'extra_specs': {
'test1': 'test1'
},
'required_extra_specs': {
'test': 'test'
}
}]
}
if req_version >= api_versions.APIVersion('2.46'):
response_body['share_types'][0]['is_default'] = False
response_body['share_types'][1]['is_default'] = False
return 200, {}, response_body
def test_get_string(self):
v1_string = "3.23"
v1 = api_versions.APIVersion(v1_string)
self.assertEqual(v1_string, v1.get_string())
self.assertRaises(ValueError,
api_versions.APIVersion().get_string)
def test_create_with_default_values(self, microversion, dhss):
manager = self._get_share_types_manager(microversion)
if (api_versions.APIVersion(microversion) >
api_versions.APIVersion("2.6")):
is_public_keyname = "share_type_access:is_public"
else:
is_public_keyname = "os-share-type-access:is_public"
expected_body = {
"share_type": {
"name": 'test-type-3',
is_public_keyname: True,
"extra_specs": {
"driver_handles_share_servers": dhss,
"snapshot_support": True,
}
}
}
with mock.patch.object(manager, '_create',
mock.Mock(return_value="fake")):
result = manager.create('test-type-3', dhss)
manager._create.assert_called_once_with(
"/types", expected_body, "share_type")
self.assertEqual("fake", result)
def test_requested_version_is_less_than_server_max(self):
self._mock_returned_server_version('2.17', '2.14')
max_version = api_versions.APIVersion('2.15')
manilaclient.API_MAX_VERSION = max_version
manilaclient.API_MIN_VERSION = api_versions.APIVersion('2.12')
version = api_versions.discover_version(self.fake_client, max_version)
self.assertEqual(api_versions.APIVersion('2.15'), version)
def test_pre_microversion_server(self):
self.fake_client.services.server_api_version.return_value = []
manilaclient.API_MAX_VERSION = api_versions.APIVersion("2.5")
manilaclient.API_MIN_VERSION = api_versions.APIVersion("2.5")
discovered_version = api_versions.discover_version(
self.fake_client, manilaclient.API_MAX_VERSION)
self.assertEqual("1.0", discovered_version.get_string())
self.assertTrue(self.fake_client.services.server_api_version.called)
def test_requested_version_is_downgraded(self):
server_end_version = '2.7'
self._mock_returned_server_version(server_end_version, '2.0')
max_version = api_versions.APIVersion("2.8")
manilaclient.API_MAX_VERSION = max_version
manilaclient.API_MIN_VERSION = api_versions.APIVersion("2.5")
version = api_versions.discover_version(self.fake_client, max_version)
self.assertEqual(api_versions.APIVersion(server_end_version), version)
def test_requested_version_is_too_old(self):
self._mock_returned_server_version('2.5', '2.0')
manilaclient.API_MAX_VERSION = api_versions.APIVersion("2.5")
manilaclient.API_MIN_VERSION = api_versions.APIVersion("2.5")
self.assertRaisesRegex(exceptions.UnsupportedVersion,
".*range is '2.0' to '2.5'.*",
api_versions.discover_version, self.fake_client,
api_versions.APIVersion("1.0"))
def test_update_share_type_quotas_positive(self, microversion):
if not utils.is_microversion_supported(microversion):
msg = "Microversion '%s' not supported." % microversion
raise self.skipException(msg)
# Get project quotas
cmd = 'quota-show --tenant-id %s ' % self.project_id
quotas_raw = self.admin_client.manila(cmd, microversion=microversion)
p_quotas = output_parser.details(quotas_raw)
# Define share type quotas
st_custom_quotas = {
'shares': _get_share_type_quota_values(p_quotas['shares']),
'snapshots': _get_share_type_quota_values(p_quotas['snapshots']),
'gigabytes': _get_share_type_quota_values(p_quotas['gigabytes']),
'snapshot_gigabytes': _get_share_type_quota_values(
p_quotas['snapshot_gigabytes']),
}
supports_share_replica_quotas = (
api_versions.APIVersion(microversion) >= api_versions.APIVersion(
REPLICA_QUOTAS_MICROVERSION))
if supports_share_replica_quotas:
st_custom_quotas['share_replicas'] = _get_share_type_quota_values(
p_quotas['share_replicas']
)
st_custom_quotas['replica_gigabytes'] = (
_get_share_type_quota_values(p_quotas['replica_gigabytes']))
replica_params = (' --share-replicas %s '
'--replica-gigabytes %s') % (
st_custom_quotas['share_replicas'],
st_custom_quotas['replica_gigabytes'])
# Update quotas for share type
cmd = ('quota-update %s --share-type %s '
'--shares %s --gigabytes %s --snapshots %s '
'--snapshot-gigabytes %s') % (
self.project_id, self.st_id,
st_custom_quotas['shares'],
st_custom_quotas['gigabytes'],
st_custom_quotas['snapshots'],
st_custom_quotas['snapshot_gigabytes'])
if supports_share_replica_quotas:
cmd += replica_params
self.admin_client.manila(cmd, microversion=microversion)
# Verify share type quotas
self._verify_current_st_quotas_equal_to(st_custom_quotas, microversion)
# Reset share type quotas
cmd = 'quota-delete --tenant-id %s --share-type %s' % (
self.project_id, self.st_id)
self.admin_client.manila(cmd, microversion=microversion)
# Verify share type quotas after reset
self._verify_current_st_quotas_equal_to(p_quotas, microversion)
def test_server_is_too_old(self):
self._mock_returned_server_version('2.2', '2.0')
manilaclient.API_MAX_VERSION = api_versions.APIVersion("2.10")
manilaclient.API_MIN_VERSION = api_versions.APIVersion("2.9")
self.assertRaises(exceptions.UnsupportedVersion,
api_versions.discover_version, self.fake_client,
api_versions.APIVersion("2.10"))
self.assertTrue(self.fake_client.services.server_api_version.called)
def test_server_and_client_max_are_same(self):
self._mock_returned_server_version('2.5', '2.0')
manilaclient.API_MAX_VERSION = api_versions.APIVersion("2.5")
manilaclient.API_MIN_VERSION = api_versions.APIVersion("2.5")
discovered_version = api_versions.discover_version(
self.fake_client, manilaclient.API_MAX_VERSION)
self.assertEqual("2.5", discovered_version.get_string())
self.assertTrue(self.fake_client.services.server_api_version.called)
def test_requested_version_in_range(self):
self._mock_returned_server_version('2.7', '2.4')
manilaclient.API_MAX_VERSION = api_versions.APIVersion("2.11")
manilaclient.API_MIN_VERSION = api_versions.APIVersion("2.1")
discovered_version = api_versions.discover_version(
self.fake_client, api_versions.APIVersion('2.7'))
self.assertEqual('2.7', discovered_version.get_string())
self.assertTrue(self.fake_client.services.server_api_version.called)
def test_server_is_too_new(self):
self._mock_returned_server_version('2.7', '2.4')
manilaclient.API_MAX_VERSION = api_versions.APIVersion("2.3")
manilaclient.API_MIN_VERSION = api_versions.APIVersion("2.1")
self.assertRaisesRegex(exceptions.UnsupportedVersion,
".*range is '2.4' to '2.7'.*",
api_versions.discover_version, self.fake_client,
api_versions.APIVersion("2.3"))
self.assertTrue(self.fake_client.services.server_api_version.called)
def test_server_without_microversion(self):
self._mock_returned_server_version(None, None)
manilaclient.API_MAX_VERSION = api_versions.APIVersion("2.11")
manilaclient.API_MIN_VERSION = api_versions.APIVersion("2.1")
discovered_version = api_versions.discover_version(
self.fake_client, api_versions.APIVersion('2.7'))
self.assertEqual(api_versions.DEPRECATED_VERSION,
discovered_version.get_string())
self.assertTrue(self.fake_client.services.server_api_version.called)
def test_force_delete_share_snapshot(self, microversion, snapshot):
manager = self._get_manager(microversion)
if (api_versions.APIVersion(microversion) >
api_versions.APIVersion("2.6")):
action_name = "force_delete"
else:
action_name = "os-force_delete"
with mock.patch.object(manager, "_action", mock.Mock()):
manager.force_delete(snapshot)
manager._action.assert_called_once_with(action_name, "1234")
def take_action(self, parsed_args):
share_client = self.app.client_manager.share
kwargs = {'name': parsed_args.name}
try:
kwargs['spec_driver_handles_share_servers'] = (
strutils.bool_from_string(
parsed_args.spec_driver_handles_share_servers,
strict=True))
except ValueError as e:
msg = ("Argument spec_driver_handles_share_servers "
"argument is not valid: %s" % str(e))
raise exceptions.CommandError(msg)
if parsed_args.description:
if share_client.api_version.matches(
api_versions.APIVersion("2.41"),
api_versions.APIVersion()):
kwargs['description'] = parsed_args.description
else:
raise exceptions.CommandError(
"Adding description to share type "
"is only available with API microversion >= 2.41")
if parsed_args.public:
kwargs['is_public'] = strutils.bool_from_string(parsed_args.public,
default=True)
extra_specs = {}
if parsed_args.extra_specs:
for item in parsed_args.extra_specs:
(key, value) = item.split('=', 1)
if key == 'driver_handles_share_servers':
msg = ("'driver_handles_share_servers' "
"is already set via positional argument.")
raise exceptions.CommandError(msg)
else:
extra_specs = utils.extract_extra_specs(
extra_specs, [item])
for key in constants.BOOL_SPECS:
value = getattr(parsed_args, key)
if value:
extra_specs = utils.extract_extra_specs(
extra_specs, [key + '=' + value])
kwargs['extra_specs'] = extra_specs
share_type = share_client.share_types.create(**kwargs)
formatted_type = format_share_type(share_type)
return (ATTRIBUTES,
oscutils.get_dict_properties(formatted_type._info, ATTRIBUTES))
def take_action(self, parsed_args):
share_client = self.app.client_manager.share
kwargs = {
'service_host': parsed_args.service_host,
'protocol': parsed_args.protocol,
'export_path': parsed_args.export_path,
'name': parsed_args.name,
'description': parsed_args.description
}
share_type = None
if parsed_args.share_type:
share_type = apiutils.find_resource(share_client.share_types,
parsed_args.share_type).id
kwargs['share_type'] = share_type
driver_options = None
if parsed_args.driver_options:
driver_options = utils.extract_properties(
parsed_args.driver_options)
kwargs['driver_options'] = driver_options
if parsed_args.public:
if share_client.api_version >= api_versions.APIVersion("2.8"):
kwargs['public'] = True
else:
raise exceptions.CommandError(
'Setting share visibility while adopting a share is '
'available only for API microversion >= 2.8')
if parsed_args.share_server_id:
if share_client.api_version >= api_versions.APIVersion("2.49"):
kwargs['share_server_id'] = parsed_args.share_server_id
else:
raise exceptions.CommandError(
'Selecting a share server ID is available only for '
'API microversion >= 2.49')
share = share_client.shares.manage(**kwargs)
if parsed_args.wait:
if not oscutils.wait_for_status(
status_f=share_client.shares.get,
res_id=share.id,
success_status=['available'],
error_status=['manage_error', 'error']):
LOG.error(_("ERROR: Share is in error state."))
share = apiutils.find_resource(share_client.shares, share.id)
share._info.pop('links', None)
return self.dict2columns(share._info)
def test_valid_instance_state(self, microversion, instance, state):
manager = self._get_manager(microversion)
if (api_versions.APIVersion(microversion) >
api_versions.APIVersion("2.6")):
action_name = "reset_status"
else:
action_name = "os-reset_status"
with mock.patch.object(manager, "_action", mock.Mock()):
manager.reset_state(instance, state)
manager._action.assert_called_once_with(
action_name, instance, {"status": state})
def take_action(self, parsed_args):
share_client = self.app.client_manager.share
share = apiutils.find_resource(share_client.shares, parsed_args.share)
if share_client.api_version >= api_versions.APIVersion("2.45"):
search_opts = {}
if parsed_args.properties:
search_opts = {
'metadata':
utils.extract_properties(parsed_args.properties)
}
access_list = share_client.share_access_rules.access_list(
share, search_opts)
elif parsed_args.properties:
raise exceptions.CommandError(
"Filtering access rules by properties is supported only "
"with API microversion 2.45 and beyond.")
else:
access_list = share.access_list()
list_of_keys = [
'id', 'access_type', 'access_to', 'access_level', 'state'
]
if share_client.api_version >= api_versions.APIVersion("2.21"):
list_of_keys.append('access_key')
if share_client.api_version >= api_versions.APIVersion("2.33"):
list_of_keys.append('created_at')
list_of_keys.append('updated_at')
if parsed_args.columns:
columns = parsed_args.columns.split(',')
for column in columns:
if column not in list_of_keys:
msg = ("No column named '%s'. Possible columns are: "
"'id', 'access_type', 'access_to', "
"'access_level', 'state', "
"'access_key'(API microversion 2.21 and beyond), "
"'created_at'(API microversion 2.33 and beyond), "
"'updated_at'(API microversion 2.33 and beyond)." %
column)
raise exceptions.CommandError(msg)
else:
columns = list_of_keys
values = (oscutils.get_item_properties(a, columns)
for a in access_list)
return (columns, values)
def test_manage_share(self,
microversion,
resource_path,
is_public=False,
share_server_id=None):
service_host = "fake_service_host"
protocol = "fake_protocol"
export_path = "fake_export_path"
driver_options = "fake_driver_options"
share_type = "fake_share_type"
name = "foo_name"
description = "bar_description"
expected_body = {
"service_host": service_host,
"share_type": share_type,
"protocol": protocol,
"export_path": export_path,
"driver_options": driver_options,
"name": name,
"description": description,
"share_server_id": share_server_id,
}
version = api_versions.APIVersion(microversion)
if version >= api_versions.APIVersion('2.8'):
expected_body["is_public"] = is_public
mock_microversion = mock.Mock(api_version=version)
manager = shares.ShareManager(api=mock_microversion)
with mock.patch.object(manager, "_create",
mock.Mock(return_value="fake")):
if version < api_versions.APIVersion('2.8'):
result = manager.manage(service_host, protocol, export_path,
driver_options, share_type, name,
description)
elif (api_versions.APIVersion('2.8') <= version <
api_versions.APIVersion('2.49')):
result = manager.manage(service_host, protocol, export_path,
driver_options, share_type, name,
description, is_public)
else:
result = manager.manage(service_host, protocol, export_path,
driver_options, share_type, name,
description, is_public,
share_server_id)
self.assertEqual(manager._create.return_value, result)
manager._create.assert_called_once_with(resource_path,
{"share": expected_body},
"share")
def _convert_to_api_version(version):
"""Convert version to an APIVersion object unless it already is one."""
if hasattr(version, 'get_major_version'):
api_version = version
else:
if version in ('1', '1.0'):
api_version = api_versions.APIVersion(
api_versions.DEPRECATED_VERSION)
elif version == '2':
api_version = api_versions.APIVersion(api_versions.MIN_VERSION)
else:
api_version = api_versions.APIVersion(version)
return api_version
def test_end_version_is_none(self, mock_versioned_method, mock_name):
func_name = 'foo'
mock_name.return_value = func_name
mock_versioned_method.side_effect = self._side_effect_of_vers_method
@api_versions.wraps('2.2')
def foo(*args, **kwargs):
pass
foo(self._get_obj_with_vers('2.4'))
mock_versioned_method.assert_called_once_with(
func_name, api_versions.APIVersion('2.2'),
api_versions.APIVersion(api_versions.MAX_VERSION), mock.ANY)
def test_reset_snapshot_state(self, microversion, snapshot):
manager = self._get_manager(microversion)
state = 'available'
if (api_versions.APIVersion(microversion) >
api_versions.APIVersion("2.6")):
action_name = "reset_status"
else:
action_name = "os-reset_status"
with mock.patch.object(manager, "_action", mock.Mock()):
manager.reset_state(snapshot, state)
manager._action.assert_called_once_with(action_name, snapshot,
{"status": state})
def test_create(self, microversion):
api_version = api_versions.APIVersion(microversion)
values = self.values.copy()
if (api_version >= api_versions.APIVersion("2.26")):
del (values['nova_net_id'])
body_expected = {share_networks.RESOURCE_NAME: values}
manager = share_networks.ShareNetworkManager(
fakes.FakeClient(api_version=api_version))
with mock.patch.object(manager, '_create', fakes.fake_create):
result = manager.create(**values)
self.assertEqual(result['url'], share_networks.RESOURCES_PATH)
self.assertEqual(result['resp_key'], share_networks.RESOURCE_NAME)
self.assertEqual(body_expected, result['body'])
def test_update_share_network(self, microversion, share_nw):
api_version = api_versions.APIVersion(microversion)
values = self.values.copy()
if (api_version >= api_versions.APIVersion("2.26")):
del (values['nova_net_id'])
body_expected = {share_networks.RESOURCE_NAME: values}
manager = share_networks.ShareNetworkManager(
fakes.FakeClient(api_version=api_version))
with mock.patch.object(manager, '_update', fakes.fake_update):
result = manager.update(share_nw, **values)
id = share_nw.id if hasattr(share_nw, 'id') else share_nw
self.assertEqual(result['url'], share_networks.RESOURCE_PATH % id)
self.assertEqual(result['resp_key'], share_networks.RESOURCE_NAME)
self.assertEqual(result['body'], body_expected)
def test_tenant_quotas_get(self, microversion):
tenant_id = 'test'
manager = self._get_manager(microversion)
resource_path = self._get_resource_path(microversion)
version = api_versions.APIVersion(microversion)
if version >= api_versions.APIVersion('2.25'):
expected_url = "%s/test/detail" % resource_path
else:
expected_url = ("%s/test" % resource_path)
with mock.patch.object(manager, '_get',
mock.Mock(return_value='fake_get')):
manager.get(tenant_id, detail=True)
manager._get.assert_called_once_with(expected_url, "quota_set")
def test_start_and_end_version_are_presented(self, mock_versioned_method,
mock_name):
func_name = "foo"
mock_name.return_value = func_name
mock_versioned_method.side_effect = self._side_effect_of_vers_method
@api_versions.wraps("2.2", "2.6")
def foo(*args, **kwargs):
pass
foo(self._get_obj_with_vers("2.4"))
mock_versioned_method.assert_called_once_with(
func_name, api_versions.APIVersion("2.2"),
api_versions.APIVersion("2.6"), mock.ANY)
def test_api_version_doesnt_match(self, mock_versioned_method, mock_name):
func_name = "foo"
mock_name.return_value = func_name
mock_versioned_method.side_effect = self._side_effect_of_vers_method
@api_versions.wraps("2.2", "2.6")
def foo(*args, **kwargs):
pass
self.assertRaises(exceptions.UnsupportedVersion, foo,
self._get_obj_with_vers("2.1"))
mock_versioned_method.assert_called_once_with(
func_name, api_versions.APIVersion("2.2"),
api_versions.APIVersion("2.6"), mock.ANY)
def _get_manager(self, microversion):
version = api_versions.APIVersion(microversion)
mock_microversion = mock.Mock(api_version=version)
return (
share_instance_export_locations.ShareInstanceExportLocationManager(
api=mock_microversion)
)
def get_share_group_types(self, **kw):
share_group_types = {
'share_group_types': [
{
'id': 1,
'name': 'test-group-type-1',
'group_specs': {
'key1': 'value1',
},
'share_types': [
'type1',
'type2',
],
'is_public': True,
}, {
'id': 2,
'name': 'test-type-2',
'group_specs': {
'key2': 'value2',
},
'share_types': [
'type3',
'type4',
],
'is_public': False,
},
],
}
req_version = self.default_headers['X-Openstack-Manila-Api-Version']
if req_version >= api_versions.APIVersion('2.46'):
share_group_types['share_group_types'][0]['is_default'] = False
share_group_types['share_group_types'][1]['is_default'] = False
return 200, {}, share_group_types
