def test_volume_type_create_then_destroy(self):
"""Ensure volume types can be created and deleted."""
prev_all_vtypes = volume_types.get_all_types(self.ctxt)
type_ref = volume_types.create(self.ctxt, self.vol_type1_name,
self.vol_type1_specs)
new = volume_types.get_volume_type_by_name(self.ctxt,
self.vol_type1_name)
LOG.info(_("Given data: %s"), self.vol_type1_specs)
LOG.info(_("Result data: %s"), new)
for k, v in self.vol_type1_specs.iteritems():
self.assertEqual(v, new['extra_specs'][k],
'one of fields doesnt match')
new_all_vtypes = volume_types.get_all_types(self.ctxt)
self.assertEqual(
len(prev_all_vtypes) + 1, len(new_all_vtypes),
'drive type was not created')
volume_types.destroy(self.ctxt, type_ref['id'])
new_all_vtypes = volume_types.get_all_types(self.ctxt)
self.assertEqual(prev_all_vtypes, new_all_vtypes,
'drive type was not deleted')
def test_volume_type_search_by_extra_spec(self):
"""Ensure volume types get by extra spec returns correct type."""
volume_types.create(self.ctxt, "type1", {"key1": "val1",
"key2": "val2"})
volume_types.create(self.ctxt, "type2", {"key2": "val2",
"key3": "val3"})
volume_types.create(self.ctxt, "type3", {"key3": "another_value",
"key4": "val4"})
vol_types = volume_types.get_all_types(
self.ctxt,
search_opts={'extra_specs': {"key1": "val1"}})
LOG.info("vol_types: %s" % vol_types)
self.assertEqual(1, len(vol_types))
self.assertIn("type1", vol_types.keys())
self.assertEqual({"key1": "val1", "key2": "val2"},
vol_types['type1']['extra_specs'])
vol_types = volume_types.get_all_types(
self.ctxt,
search_opts={'extra_specs': {"key2": "val2"}})
LOG.info("vol_types: %s" % vol_types)
self.assertEqual(2, len(vol_types))
self.assertIn("type1", vol_types.keys())
self.assertIn("type2", vol_types.keys())
vol_types = volume_types.get_all_types(
self.ctxt,
search_opts={'extra_specs': {"key3": "val3"}})
LOG.info("vol_types: %s" % vol_types)
self.assertEqual(1, len(vol_types))
self.assertIn("type2", vol_types.keys())
def test_volume_type_search_by_extra_spec(self):
"""Ensure volume types get by extra spec returns correct type."""
volume_types.create(self.ctxt, "type1", {"key1": "val1",
"key2": "val2"})
volume_types.create(self.ctxt, "type2", {"key2": "val2",
"key3": "val3"})
volume_types.create(self.ctxt, "type3", {"key3": "another_value",
"key4": "val4"})
vol_types = volume_types.get_all_types(
self.ctxt,
search_opts={'extra_specs': {"key1": "val1"}})
LOG.info("vol_types: %s" % vol_types)
self.assertEqual(len(vol_types), 1)
self.assertTrue("type1" in vol_types.keys())
self.assertEqual(vol_types['type1']['extra_specs'],
{"key1": "val1", "key2": "val2"})
vol_types = volume_types.get_all_types(
self.ctxt,
search_opts={'extra_specs': {"key2": "val2"}})
LOG.info("vol_types: %s" % vol_types)
self.assertEqual(len(vol_types), 2)
self.assertTrue("type1" in vol_types.keys())
self.assertTrue("type2" in vol_types.keys())
vol_types = volume_types.get_all_types(
self.ctxt,
search_opts={'extra_specs': {"key3": "val3"}})
LOG.info("vol_types: %s" % vol_types)
self.assertEqual(len(vol_types), 1)
self.assertTrue("type2" in vol_types.keys())
def test_volume_type_create_then_destroy(self):
"""Ensure volume types can be created and deleted."""
prev_all_vtypes = volume_types.get_all_types(self.ctxt)
type_ref = volume_types.create(self.ctxt,
self.vol_type1_name,
self.vol_type1_specs)
new = volume_types.get_volume_type_by_name(self.ctxt,
self.vol_type1_name)
LOG.info(_("Given data: %s"), self.vol_type1_specs)
LOG.info(_("Result data: %s"), new)
for k, v in self.vol_type1_specs.iteritems():
self.assertEqual(v, new['extra_specs'][k],
'one of fields does not match')
new_all_vtypes = volume_types.get_all_types(self.ctxt)
self.assertEqual(len(prev_all_vtypes) + 1,
len(new_all_vtypes),
'drive type was not created')
volume_types.destroy(self.ctxt, type_ref['id'])
new_all_vtypes = volume_types.get_all_types(self.ctxt)
self.assertEqual(prev_all_vtypes,
new_all_vtypes,
'drive type was not deleted')
def test_volume_type_search_by_extra_spec(self):
"""Ensure volume types get by extra spec returns correct type."""
volume_types.create(self.ctxt, "type1", {"key1": "val1",
"key2": "val2"})
volume_types.create(self.ctxt, "type2", {"key2": "val2",
"key3": "val3"})
volume_types.create(self.ctxt, "type3", {"key3": "another_value",
"key4": "val4"})
vol_types = volume_types.get_all_types(
self.ctxt,
search_opts={'extra_specs': {"key1": "val1"}})
self.assertEqual(1, len(vol_types))
self.assertIn("type1", vol_types.keys())
self.assertEqual({"key1": "val1", "key2": "val2"},
vol_types['type1']['extra_specs'])
vol_types = volume_types.get_all_types(
self.ctxt,
search_opts={'extra_specs': {"key2": "val2"}})
self.assertEqual(2, len(vol_types))
self.assertIn("type1", vol_types.keys())
self.assertIn("type2", vol_types.keys())
vol_types = volume_types.get_all_types(
self.ctxt,
search_opts={'extra_specs': {"key3": "val3"}})
self.assertEqual(1, len(vol_types))
self.assertIn("type2", vol_types.keys())
def test_volume_type_create_then_destroy(self):
"""Ensure volume types can be created and deleted."""
prev_all_vtypes = volume_types.get_all_types(self.ctxt)
# create
type_ref = volume_types.create(
self.ctxt, self.vol_type1_name, self.vol_type1_specs, description=self.vol_type1_description
)
new = volume_types.get_volume_type_by_name(self.ctxt, self.vol_type1_name)
LOG.info(_("Given data: %s"), self.vol_type1_specs)
LOG.info(_("Result data: %s"), new)
self.assertEqual(self.vol_type1_description, new["description"])
for k, v in self.vol_type1_specs.items():
self.assertEqual(v, new["extra_specs"][k], "one of fields does not match")
new_all_vtypes = volume_types.get_all_types(self.ctxt)
self.assertEqual(len(prev_all_vtypes) + 1, len(new_all_vtypes), "drive type was not created")
# update
new_type_name = self.vol_type1_name + "_updated"
new_type_desc = self.vol_type1_description + "_updated"
type_ref_updated = volume_types.update(self.ctxt, type_ref.id, new_type_name, new_type_desc)
self.assertEqual(new_type_name, type_ref_updated["name"])
self.assertEqual(new_type_desc, type_ref_updated["description"])
# destroy
volume_types.destroy(self.ctxt, type_ref["id"])
new_all_vtypes = volume_types.get_all_types(self.ctxt)
self.assertEqual(prev_all_vtypes, new_all_vtypes, "drive type was not deleted")
def test_volume_type_create_then_destroy_with_non_admin(self):
"""Ensure volume types can be created and deleted by non-admin user.
If a non-admn user is authorized at API, volume type operations
should be permitted.
"""
prev_all_vtypes = volume_types.get_all_types(self.ctxt)
self.ctxt = context.RequestContext("fake", "fake", is_admin=False)
# create
type_ref = volume_types.create(
self.ctxt, self.vol_type1_name, self.vol_type1_specs, description=self.vol_type1_description
)
new = volume_types.get_volume_type_by_name(self.ctxt, self.vol_type1_name)
self.assertEqual(self.vol_type1_description, new["description"])
new_all_vtypes = volume_types.get_all_types(self.ctxt)
self.assertEqual(len(prev_all_vtypes) + 1, len(new_all_vtypes), "drive type was not created")
# update
new_type_name = self.vol_type1_name + "_updated"
new_type_desc = self.vol_type1_description + "_updated"
type_ref_updated = volume_types.update(self.ctxt, type_ref.id, new_type_name, new_type_desc)
self.assertEqual(new_type_name, type_ref_updated["name"])
self.assertEqual(new_type_desc, type_ref_updated["description"])
# destroy
volume_types.destroy(self.ctxt, type_ref["id"])
new_all_vtypes = volume_types.get_all_types(self.ctxt)
self.assertEqual(prev_all_vtypes, new_all_vtypes, "drive type was not deleted")
def test_volume_type_create_then_destroy(self):
"""Ensure volume types can be created and deleted."""
project_id = fake.PROJECT_ID
prev_all_vtypes = volume_types.get_all_types(self.ctxt)
# create
type_ref = volume_types.create(self.ctxt,
self.vol_type1_name,
self.vol_type1_specs,
description=self.vol_type1_description,
projects=[project_id], is_public=False)
new = volume_types.get_volume_type_by_name(self.ctxt,
self.vol_type1_name)
self.assertEqual(self.vol_type1_description, new['description'])
for k, v in self.vol_type1_specs.items():
self.assertEqual(v, new['extra_specs'][k],
'one of fields does not match')
new_all_vtypes = volume_types.get_all_types(self.ctxt)
self.assertEqual(len(prev_all_vtypes) + 1,
len(new_all_vtypes),
'drive type was not created')
# Assert that volume type is associated to a project
vol_type_access = db.volume_type_access_get_all(self.ctxt,
type_ref['id'])
self.assertIn(project_id, [a.project_id for a in vol_type_access])
# update
new_type_name = self.vol_type1_name + '_updated'
new_type_desc = self.vol_type1_description + '_updated'
type_ref_updated = volume_types.update(self.ctxt,
type_ref.id,
new_type_name,
new_type_desc)
self.assertEqual(new_type_name, type_ref_updated['name'])
self.assertEqual(new_type_desc, type_ref_updated['description'])
# destroy
volume_types.destroy(self.ctxt, type_ref['id'])
new_all_vtypes = volume_types.get_all_types(self.ctxt)
self.assertEqual(prev_all_vtypes,
new_all_vtypes,
'drive type was not deleted')
# Assert that associated volume type access is deleted successfully
# on destroying the volume type
vol_type_access = db_api._volume_type_access_query(
self.ctxt).filter_by(volume_type_id=type_ref['id']).all()
self.assertFalse(vol_type_access)
def test_volume_type_create_then_destroy(self):
"""Ensure volume types can be created and deleted."""
project_id = fake.PROJECT_ID
prev_all_vtypes = volume_types.get_all_types(self.ctxt)
# create
type_ref = volume_types.create(self.ctxt,
self.vol_type1_name,
self.vol_type1_specs,
description=self.vol_type1_description,
projects=[project_id],
is_public=False)
new = volume_types.get_volume_type_by_name(self.ctxt,
self.vol_type1_name)
self.assertEqual(self.vol_type1_description, new['description'])
for k, v in self.vol_type1_specs.items():
self.assertEqual(v, new['extra_specs'][k],
'one of fields does not match')
new_all_vtypes = volume_types.get_all_types(self.ctxt)
self.assertEqual(
len(prev_all_vtypes) + 1, len(new_all_vtypes),
'drive type was not created')
# Assert that volume type is associated to a project
vol_type_access = db.volume_type_access_get_all(
self.ctxt, type_ref['id'])
self.assertIn(project_id, [a.project_id for a in vol_type_access])
# update
new_type_name = self.vol_type1_name + '_updated'
new_type_desc = self.vol_type1_description + '_updated'
volume_types.update(self.ctxt, type_ref.id, new_type_name,
new_type_desc)
type_ref_updated = volume_types.get_volume_type(self.ctxt, type_ref.id)
self.assertEqual(new_type_name, type_ref_updated['name'])
self.assertEqual(new_type_desc, type_ref_updated['description'])
# destroy
volume_types.destroy(self.ctxt, type_ref['id'])
new_all_vtypes = volume_types.get_all_types(self.ctxt)
self.assertEqual(prev_all_vtypes, new_all_vtypes,
'drive type was not deleted')
# Assert that associated volume type access is deleted successfully
# on destroying the volume type
with db_api.main_context_manager.reader.using(self.ctxt):
vol_type_access = db_api._volume_type_access_query(
self.ctxt).filter_by(volume_type_id=type_ref['id']).all()
self.assertEqual([], vol_type_access)
def _get_volume_types(self, req):
"""Helper function that returns a list of type dicts."""
params = req.params.copy()
marker, limit, offset = common.get_pagination_params(params)
sort_keys, sort_dirs = common.get_sort_params(params)
# NOTE(wanghao): Currently, we still only support to filter by
# is_public. If we want to filter by more args, we should set params
# to filters.
filters = {}
context = req.environ['cinder.context']
if not context.is_admin and self._validate_policy(context):
context = ctx.get_admin_context()
if context.is_admin:
# Only admin has query access to all volume types
filters['is_public'] = self._parse_is_public(
req.params.get('is_public', None))
else:
filters['is_public'] = True
utils.remove_invalid_filter_options(
context, filters, self._get_vol_type_filter_options())
limited_types = volume_types.get_all_types(context,
filters=filters,
marker=marker,
limit=limit,
sort_keys=sort_keys,
sort_dirs=sort_dirs,
offset=offset,
list_result=True)
return limited_types
def _get_volume_types(self, req):
"""Helper function that returns a list of type dicts."""
params = req.params.copy()
marker, limit, offset = common.get_pagination_params(params)
sort_keys, sort_dirs = common.get_sort_params(params)
# NOTE(wanghao): Currently, we still only support to filter by
# is_public. If we want to filter by more args, we should set params
# to filters.
filters = {}
context = req.environ['cinder.context']
if context.is_admin:
# Only admin has query access to all volume types
filters['is_public'] = self._parse_is_public(
req.params.get('is_public', None))
else:
filters['is_public'] = True
utils.remove_invalid_filter_options(context,
filters,
self._get_vol_type_filter_options()
)
limited_types = volume_types.get_all_types(context,
filters=filters,
marker=marker, limit=limit,
sort_keys=sort_keys,
sort_dirs=sort_dirs,
offset=offset,
list_result=True)
return limited_types
def test_get_all_volume_types(self):
"""Ensures that all volume types can be retrieved."""
with db_api.main_context_manager.writer.using(self.ctxt):
total_volume_types = self.ctxt.session.query(
models.VolumeType, ).count()
vol_types = volume_types.get_all_types(self.ctxt)
self.assertEqual(total_volume_types, len(vol_types))
def index(self, req):
"""Returns the list of volume types."""
context = req.environ['cinder.context']
vol_types = volume_types.get_all_types(context)
vol_types = list(vol_types.values())
req.cache_resource(vol_types, name='types')
return self._view_builder.index(req, vol_types)
def index(self, req):
"""Returns the list of volume types."""
context = req.environ['cinder.context']
vol_types = volume_types.get_all_types(context)
vol_types = list(vol_types.values())
req.cache_resource(vol_types, name='types')
return self._view_builder.index(req, vol_types)
def get_all(cls, context, inactive=0, search_opts=None):
types = volume_types.get_all_types(context, inactive, search_opts)
expected_attrs = ['extra_specs', 'projects']
return base.obj_make_list(context,
cls(context),
objects.VolumeType,
types.values(),
expected_attrs=expected_attrs)
def test_volume_type_search_by_extra_spec(self):
"""Ensure volume types get by extra spec returns correct type."""
volume_types.create(self.ctxt, "type1", {"key1": "val1", "key2": "val2"})
volume_types.create(self.ctxt, "type2", {"key2": "val2", "key3": "val3"})
volume_types.create(self.ctxt, "type3", {"key3": "another_value", "key4": "val4"})
vol_types = volume_types.get_all_types(self.ctxt, filters={"extra_specs": {"key1": "val1"}})
self.assertEqual(1, len(vol_types))
self.assertIn("type1", vol_types.keys())
self.assertEqual({"key1": "val1", "key2": "val2"}, vol_types["type1"]["extra_specs"])
vol_types = volume_types.get_all_types(self.ctxt, filters={"extra_specs": {"key2": "val2"}})
self.assertEqual(2, len(vol_types))
self.assertIn("type1", vol_types.keys())
self.assertIn("type2", vol_types.keys())
vol_types = volume_types.get_all_types(self.ctxt, filters={"extra_specs": {"key3": "val3"}})
self.assertEqual(1, len(vol_types))
self.assertIn("type2", vol_types.keys())
def get_all(cls, context, inactive=0, filters=None, marker=None,
limit=None, sort_keys=None, sort_dirs=None, offset=None):
types = volume_types.get_all_types(context, inactive, filters,
marker=marker, limit=limit,
sort_keys=sort_keys,
sort_dirs=sort_dirs, offset=offset)
expected_attrs = VolumeType._get_expected_attrs(context)
return base.obj_make_list(context, cls(context),
objects.VolumeType, types.values(),
expected_attrs=expected_attrs)
def test_volume_type_create_then_destroy(self):
"""Ensure volume types can be created and deleted."""
prev_all_vtypes = volume_types.get_all_types(self.ctxt)
# create
type_ref = volume_types.create(self.ctxt,
self.vol_type1_name,
self.vol_type1_specs,
description=self.vol_type1_description)
new = volume_types.get_volume_type_by_name(self.ctxt,
self.vol_type1_name)
LOG.info(_("Given data: %s"), self.vol_type1_specs)
LOG.info(_("Result data: %s"), new)
self.assertEqual(self.vol_type1_description, new['description'])
for k, v in self.vol_type1_specs.iteritems():
self.assertEqual(v, new['extra_specs'][k],
'one of fields does not match')
new_all_vtypes = volume_types.get_all_types(self.ctxt)
self.assertEqual(len(prev_all_vtypes) + 1,
len(new_all_vtypes),
'drive type was not created')
# update
new_type_name = self.vol_type1_name + '_updated'
new_type_desc = self.vol_type1_description + '_updated'
type_ref_updated = volume_types.update(self.ctxt,
type_ref.id,
new_type_name,
new_type_desc)
self.assertEqual(new_type_name, type_ref_updated['name'])
self.assertEqual(new_type_desc, type_ref_updated['description'])
# destroy
volume_types.destroy(self.ctxt, type_ref['id'])
new_all_vtypes = volume_types.get_all_types(self.ctxt)
self.assertEqual(prev_all_vtypes,
new_all_vtypes,
'drive type was not deleted')
def test_volume_type_create_then_destroy(self):
"""Ensure volume types can be created and deleted."""
prev_all_vtypes = volume_types.get_all_types(self.ctxt)
# create
type_ref = volume_types.create(self.ctxt,
self.vol_type1_name,
self.vol_type1_specs,
description=self.vol_type1_description)
new = volume_types.get_volume_type_by_name(self.ctxt,
self.vol_type1_name)
self.assertEqual(self.vol_type1_description, new['description'])
for k, v in self.vol_type1_specs.items():
self.assertEqual(v, new['extra_specs'][k],
'one of fields does not match')
new_all_vtypes = volume_types.get_all_types(self.ctxt)
self.assertEqual(len(prev_all_vtypes) + 1,
len(new_all_vtypes),
'drive type was not created')
# update
new_type_name = self.vol_type1_name + '_updated'
new_type_desc = self.vol_type1_description + '_updated'
type_ref_updated = volume_types.update(self.ctxt,
type_ref.id,
new_type_name,
new_type_desc)
self.assertEqual(new_type_name, type_ref_updated['name'])
self.assertEqual(new_type_desc, type_ref_updated['description'])
# destroy
volume_types.destroy(self.ctxt, type_ref['id'])
new_all_vtypes = volume_types.get_all_types(self.ctxt)
self.assertEqual(prev_all_vtypes,
new_all_vtypes,
'drive type was not deleted')
def _get_volume_types(self, req):
"""Helper function that returns a list of type dicts."""
filters = {}
context = req.environ['cinder.context']
if context.is_admin:
# Only admin has query access to all volume types
filters['is_public'] = self._parse_is_public(
req.params.get('is_public', None))
else:
filters['is_public'] = True
limited_types = volume_types.get_all_types(
context, search_opts=filters).values()
return limited_types
def _get_volume_types(self, req):
"""Helper function that returns a list of type dicts."""
filters = {}
context = req.environ['cinder.context']
if context.is_admin:
# Only admin has query access to all volume types
filters['is_public'] = self._parse_is_public(
req.params.get('is_public', None))
else:
filters['is_public'] = True
limited_types = volume_types.get_all_types(
context, search_opts=filters).values()
return limited_types
def test_volume_type_search_by_extra_spec_multiple(self):
"""Ensure volume types get by extra spec returns correct type."""
volume_types.create(self.ctxt, "type1", {"key1": "val1", "key2": "val2", "key3": "val3"})
volume_types.create(self.ctxt, "type2", {"key2": "val2", "key3": "val3"})
volume_types.create(self.ctxt, "type3", {"key1": "val1", "key3": "val3", "key4": "val4"})
vol_types = volume_types.get_all_types(self.ctxt, search_opts={"extra_specs": {"key1": "val1", "key3": "val3"}})
LOG.info("vol_types: %s" % vol_types)
self.assertEqual(len(vol_types), 2)
self.assertIn("type1", vol_types.keys())
self.assertIn("type3", vol_types.keys())
self.assertEqual(vol_types["type1"]["extra_specs"], {"key1": "val1", "key2": "val2", "key3": "val3"})
self.assertEqual(vol_types["type3"]["extra_specs"], {"key1": "val1", "key3": "val3", "key4": "val4"})
def test_volume_type_create_then_destroy_with_non_admin(self):
"""Ensure volume types can be created and deleted by non-admin user.
If a non-admn user is authorized at API, volume type operations
should be permitted.
"""
prev_all_vtypes = volume_types.get_all_types(self.ctxt)
self.ctxt = context.RequestContext('fake', 'fake', is_admin=False)
# create
type_ref = volume_types.create(self.ctxt,
self.vol_type1_name,
self.vol_type1_specs,
description=self.vol_type1_description)
new = volume_types.get_volume_type_by_name(self.ctxt,
self.vol_type1_name)
self.assertEqual(self.vol_type1_description, new['description'])
new_all_vtypes = volume_types.get_all_types(self.ctxt)
self.assertEqual(len(prev_all_vtypes) + 1,
len(new_all_vtypes),
'drive type was not created')
# update
new_type_name = self.vol_type1_name + '_updated'
new_type_desc = self.vol_type1_description + '_updated'
type_ref_updated = volume_types.update(self.ctxt,
type_ref.id,
new_type_name,
new_type_desc)
self.assertEqual(new_type_name, type_ref_updated['name'])
self.assertEqual(new_type_desc, type_ref_updated['description'])
# destroy
volume_types.destroy(self.ctxt, type_ref['id'])
new_all_vtypes = volume_types.get_all_types(self.ctxt)
self.assertEqual(prev_all_vtypes,
new_all_vtypes,
'drive type was not deleted')
def _get_volume_types(self, req):
"""Helper function that returns a list of type dicts."""
params = req.params.copy()
marker, limit, offset = common.get_pagination_params(params)
sort_keys, sort_dirs = common.get_sort_params(params)
filters = params
context = req.environ['cinder.context']
req_version = req.api_version_request
if req_version.matches(mv.SUPPORT_VOLUME_TYPE_FILTER):
self._process_volume_type_filtering(context=context,
filters=filters,
req_version=req_version)
else:
api_utils.remove_invalid_filter_options(
context, filters, self._get_vol_type_filter_options())
if context.is_admin:
# Only admin has query access to all volume types
filters['is_public'] = api_utils._parse_is_public(
req.params.get('is_public', None))
else:
filters['is_public'] = True
if 'extra_specs' in filters:
try:
filters['extra_specs'] = ast.literal_eval(
filters['extra_specs'])
except (ValueError, SyntaxError):
LOG.debug(
'Could not evaluate "extra_specs" %s, assuming '
'dictionary string.', filters['extra_specs'])
# Do not allow sensitive extra specs to be used in a filter if
# the context only allows access to user visible extra specs.
# Removing the filter would yield inaccurate results, so an
# empty result is returned because as far as an unauthorized
# user goes, the list of volume-types meeting their filtering
# criteria is empty.
if not context.authorize(extra_specs_policy.READ_SENSITIVE_POLICY,
fatal=False):
for k in filters['extra_specs'].keys():
if k not in extra_specs_policy.USER_VISIBLE_EXTRA_SPECS:
return []
limited_types = volume_types.get_all_types(context,
filters=filters,
marker=marker,
limit=limit,
sort_keys=sort_keys,
sort_dirs=sort_dirs,
offset=offset,
list_result=True)
return limited_types
def test_volume_type_search_by_extra_spec_multiple(self):
"""Ensure volume types get by extra spec returns correct type."""
volume_types.create(self.ctxt, "type1", {"key1": "val1",
"key2": "val2",
"key3": "val3"})
volume_types.create(self.ctxt, "type2", {"key2": "val2",
"key3": "val3"})
volume_types.create(self.ctxt, "type3", {"key1": "val1",
"key3": "val3",
"key4": "val4"})
vol_types = volume_types.get_all_types(
self.ctxt,
filters={'extra_specs': {"key1": "val1", "key3": "val3"}})
self.assertEqual(2, len(vol_types))
self.assertIn("type1", vol_types.keys())
self.assertIn("type3", vol_types.keys())
self.assertEqual({"key1": "val1", "key2": "val2", "key3": "val3"},
vol_types['type1']['extra_specs'])
self.assertEqual({"key1": "val1", "key3": "val3", "key4": "val4"},
vol_types['type3']['extra_specs'])
def _get_volume_types(self, req):
"""Helper function that returns a list of type dicts."""
params = req.params.copy()
marker, limit, offset = common.get_pagination_params(params)
sort_keys, sort_dirs = common.get_sort_params(params)
filters = params
context = req.environ['cinder.context']
req_version = req.api_version_request
if req_version.matches(mv.SUPPORT_VOLUME_TYPE_FILTER):
self._process_volume_type_filtering(context=context,
filters=filters,
req_version=req_version)
else:
api_utils.remove_invalid_filter_options(
context, filters, self._get_vol_type_filter_options())
if context.is_admin:
# Only admin has query access to all volume types
filters['is_public'] = api_utils._parse_is_public(
req.params.get('is_public', None))
else:
filters['is_public'] = True
if 'extra_specs' in filters:
try:
filters['extra_specs'] = ast.literal_eval(
filters['extra_specs'])
except (ValueError, SyntaxError):
LOG.debug(
'Could not evaluate "extra_specs" %s, assuming '
'dictionary string.', filters['extra_specs'])
limited_types = volume_types.get_all_types(context,
filters=filters,
marker=marker,
limit=limit,
sort_keys=sort_keys,
sort_dirs=sort_dirs,
offset=offset,
list_result=True)
return limited_types
def _get_volume_types(self, req):
"""Helper function that returns a list of type dicts."""
params = req.params.copy()
marker, limit, offset = common.get_pagination_params(params)
sort_keys, sort_dirs = common.get_sort_params(params)
filters = params
context = req.environ['cinder.context']
req_version = req.api_version_request
if req_version.matches(mv.SUPPORT_VOLUME_TYPE_FILTER):
self._process_volume_type_filtering(context=context,
filters=filters,
req_version=req_version)
else:
utils.remove_invalid_filter_options(
context, filters, self._get_vol_type_filter_options())
if context.is_admin:
# Only admin has query access to all volume types
filters['is_public'] = self._parse_is_public(
req.params.get('is_public', None))
else:
filters['is_public'] = True
if 'extra_specs' in filters:
try:
filters['extra_specs'] = ast.literal_eval(
filters['extra_specs'])
except (ValueError, SyntaxError):
LOG.debug('Could not evaluate "extra_specs" %s, assuming '
'dictionary string.', filters['extra_specs'])
limited_types = volume_types.get_all_types(context,
filters=filters,
marker=marker, limit=limit,
sort_keys=sort_keys,
sort_dirs=sort_dirs,
offset=offset,
list_result=True)
return limited_types
def backend_passes(self, backend_state, filter_properties):
# get the volume type from the filter properties or return None
volume_type = filter_properties.get('volume_type', None)
"""
if the user passed a volume type then this filter has nothing to do
so just return True with the assumption that the other mechanisms in
place will determine if this is possible or not
"""
if volume_type is not None:
return True
# get the request context object
r_context = filter_properties.get('context')
# we can't do anything without the request context
if r_context is None:
LOG.fatal("context not found in filter_properties")
return False
# get the project id from the request context
project_id = None
if hasattr(r_context, 'project_id'):
project_id = r_context.project_id
# we can't do anything without a project id
if project_id is None:
LOG.fatal("project id not found in the request context")
return False
# we need the admin context to fetch the list of backend types
# and access ids
admin_context = context.get_admin_context()
# get all backend types
backend_types = volume_types.get_all_types(admin_context)
# get the type name from the backend state
backend_type_name = backend_state.pool_name
# get backend state information
backend_type_info = backend_types.get(backend_type_name)
# we can't do anything without the backend type information
if backend_type_info is None:
LOG.info("no backend type information found for {}. "
"skipping".format(backend_type_name))
return False
# we're only looking for private backend types
if backend_type_info['is_public']:
LOG.info("backend type {} is not private. "
"skipping".format(backend_type_name))
return False
# get the backend type id
backend_type_id = backend_type_info['id']
# get list of access ids for current backend type
backend_type_access = db.volume_type_access_get_all(
admin_context, backend_type_id)
# look for project id in list of access ids
backend_type_found = [
access for access in backend_type_access
if access.project_id == project_id
]
if len(backend_type_found) > 0:
LOG.info("{} is a valid backend type".format(backend_type_name))
return True
LOG.info("could not find project id {} in the {} backend type. "
"skipping".format(project_id, backend_type_name))
return False
def index(self, req):
""" Returns the list of volume types """
context = req.environ['cinder.context']
return {'volume_types': volume_types.get_all_types(context).values()}
def test_get_all_volume_types(self):
"""Ensures that all volume types can be retrieved."""
session = db_api.get_session()
total_volume_types = session.query(models.VolumeTypes).count()
vol_types = volume_types.get_all_types(self.ctxt)
self.assertEqual(total_volume_types, len(vol_types))
def get_all(cls, context, inactive=0, search_opts=None):
types = volume_types.get_all_types(context, inactive, search_opts)
expected_attrs = ["extra_specs", "projects"]
return base.obj_make_list(
context, cls(context), objects.VolumeType, types.values(), expected_attrs=expected_attrs
)
def index(self, req):
"""Returns the list of volume types."""
context = req.environ['cinder.context']
vol_types = volume_types.get_all_types(context).values()
return self._view_builder.index(req, vol_types)
def test_get_all_volume_types(self):
"""Ensures that all volume types can be retrieved."""
session = db_api.get_session()
total_volume_types = session.query(models.VolumeTypes).count()
vol_types = volume_types.get_all_types(self.ctxt)
self.assertEqual(total_volume_types, len(vol_types))
def index(self, req):
"""Returns the list of volume types."""
context = req.environ['cinder.context']
vol_types = volume_types.get_all_types(context).values()
return self._view_builder.index(req, vol_types)
