def get_by_values(self,
container_id,
name,
URL,
suppress_exception=False,
show_deleted=False,
session=None):
session = self.get_session(session)
try:
query = session.query(models.ContainerConsumerMetadatum)
query = query.filter_by(container_id=container_id,
name=name,
URL=URL)
if not show_deleted:
query.filter_by(deleted=False)
consumer = query.one()
except sa_orm.exc.NoResultFound:
if not suppress_exception:
raise exception.NotFound(
u._("Could not find {entity_name}").format(
entity_name=self._do_entity_name()))
return consumer
def get_by_create_date(self,
keystone_id,
offset_arg=None,
limit_arg=None,
name=None,
alg=None,
mode=None,
bits=0,
suppress_exception=False,
session=None):
"""Returns a list of secrets, ordered by the date they were created at
and paged based on the offset and limit fields. The keystone_id is
external-to-Barbican value assigned to the tenant by Keystone.
"""
offset, limit = clean_paging_values(offset_arg, limit_arg)
session = self.get_session(session)
utcnow = timeutils.utcnow()
try:
query = session.query(models.Secret) \
.order_by(models.Secret.created_at) \
.filter_by(deleted=False)
# Note: Must use '== None' below, not 'is None'.
query = query.filter(
or_(models.Secret.expiration == None,
models.Secret.expiration > utcnow))
if name:
query = query.filter(models.Secret.name.like(name))
if alg:
query = query.filter(models.Secret.algorithm.like(alg))
if mode:
query = query.filter(models.Secret.mode.like(mode))
if bits > 0:
query = query.filter(models.Secret.bit_length == bits)
query = query.join(models.TenantSecret,
models.Secret.tenant_assocs) \
.join(models.Tenant, models.TenantSecret.tenants) \
.filter(models.Tenant.keystone_id == keystone_id)
start = offset
end = offset + limit
LOG.debug('Retrieving from {0} to {1}'.format(start, end))
total = query.count()
entities = query[start:end]
LOG.debug('Number entities retrieved: {0} out of {1}'.format(
len(entities), total))
except sa_orm.exc.NoResultFound:
entities = None
total = 0
if not suppress_exception:
raise exception.NotFound("No %s's found" %
(self._do_entity_name()))
return entities, offset, limit, total
def get(self,
entity_id,
keystone_id=None,
force_show_deleted=False,
suppress_exception=False,
session=None):
"""Get an entity or raise if it does not exist."""
session = self.get_session(session)
try:
query = self._do_build_get_query(entity_id, keystone_id, session)
# filter out deleted entities if requested
if not force_show_deleted:
query = query.filter_by(deleted=False)
entity = query.one()
except sa_orm.exc.NoResultFound:
LOG.exception("Not found for {0}".format(entity_id))
entity = None
if not suppress_exception:
raise exception.NotFound("No %s found with ID %s" %
(self._do_entity_name(), entity_id))
return entity
def test_should_throw_exception_for_delete_when_trans_key_not_found(self):
self.repo.delete_entity_by_id.side_effect = excep.NotFound(
"Test not found exception")
resp = self.app.delete('/%s/transport_keys/%s/' %
(self.tenant_keystone_id, self.tkey.id),
expect_errors=True)
self.assertEqual(resp.status_int, 404)
def test_should_404_consumer_bad_container_id(self):
self.container_repo.get.side_effect = excep.NotFound()
resp = self.app.post_json(
'/containers/{0}/consumers/'.format('bad_id'),
self.consumer_ref,
expect_errors=True)
self.container_repo.get.side_effect = None
self.assertEqual(404, resp.status_int)
def test_should_404_on_delete_when_consumer_not_found_later(self):
self.consumer_repo.delete_entity_by_id.side_effect = excep.NotFound()
resp = self.app.delete_json('/containers/{0}/consumers/'.format(
self.container.id
), self.consumer_ref, expect_errors=True)
self.consumer_repo.delete_entity_by_id.side_effect = None
self.assertEqual(404, resp.status_int)
# Error response should have json content type
self.assertEqual("application/json", resp.content_type)
def test_should_throw_exception_for_delete_when_order_not_found(self):
self.order_repo.delete_entity_by_id.side_effect = excep.NotFound(
"Test not found exception")
with self.assertRaises(falcon.HTTPError) as cm:
self.resource.on_delete(self.req, self.resp,
self.tenant_keystone_id, self.order.id)
exception = cm.exception
self.assertEqual(falcon.HTTP_404, exception.status)
def delete_entity_by_id(self, entity_id, keystone_id):
"""Remove the entity by its ID"""
session = get_session()
with session.begin():
entity = self.get(entity_id=entity_id,
keystone_id=keystone_id,
session=session)
try:
entity.delete(session=session)
except sqlalchemy.exc.IntegrityError:
LOG.exception('Problem finding entity to delete')
raise exception.NotFound("Entity ID %s not found" % entity_id)
def get_by_create_date(self,
keystone_id,
offset_arg=None,
limit_arg=None,
suppress_exception=False,
session=None):
"""
Returns a list of orders, ordered by the date they were created at
and paged based on the offset and limit fields.
:param keystone_id: The keystone id for the tenant.
:param offset_arg: The entity number where the query result should
start.
:param limit_arg: The maximum amount of entities in the result set.
:param suppress_exception: Whether NoResultFound exceptions should be
suppressed.
:param session: SQLAlchemy session object.
:returns: Tuple consisting of (list_of_entities, offset, limit, total).
"""
offset, limit = clean_paging_values(offset_arg, limit_arg)
session = self.get_session(session)
try:
query = session.query(models.Order) \
.order_by(models.Order.created_at)
query = query.filter_by(deleted=False) \
.join(models.Tenant, models.Order.tenant) \
.filter(models.Tenant.keystone_id == keystone_id)
start = offset
end = offset + limit
LOG.debug('Retrieving from {0} to {1}'.format(start, end))
total = query.count()
entities = query[start:end]
LOG.debug('Number entities retrieved: {0} out of {1}'.format(
len(entities), total))
except sa_orm.exc.NoResultFound:
entities = None
total = 0
if not suppress_exception:
raise exception.NotFound("No %s's found" %
(self._do_entity_name()))
return entities, offset, limit, total
def _update(self, entity_id, values, purge_props=False):
"""
Used internally by update()
:param values: A dict of attributes to set
:param entity_id: If None, create the entity, otherwise,
find and update it
"""
session = get_session()
with session.begin():
if entity_id:
entity_ref = self.get(entity_id, session=session)
values['updated_at'] = timeutils.utcnow()
else:
self._do_convert_values(values)
entity_ref = self._do_create_instance()
# Need to canonicalize ownership
if 'owner' in values and not values['owner']:
values['owner'] = None
entity_ref.update(values)
# Validate the attributes before we go any further. From my
# (unknown Glance developer) investigation, the @validates
# decorator does not validate
# on new records, only on existing records, which is, well,
# idiotic.
self._do_validate(entity_ref.to_dict())
self._update_values(entity_ref, values)
try:
entity_ref.save(session=session)
except sqlalchemy.exc.IntegrityError:
LOG.exception('Problem saving entity for _update')
if entity_id:
raise exception.NotFound("Entity ID %s not found" %
entity_id)
else:
raise exception.Duplicate("Entity ID %s already exists!" %
values['id'])
return self.get(entity_ref.id)
def find_by_keystone_id(self,
keystone_id,
suppress_exception=False,
session=None):
session = self.get_session(session)
try:
query = session.query(
models.Tenant).filter_by(keystone_id=keystone_id)
entity = query.one()
except sa_orm.exc.NoResultFound:
LOG.exception("Problem getting Tenant {0}".format(keystone_id))
entity = None
if not suppress_exception:
raise exception.NotFound("No %s found with keystone-ID %s" %
(self._do_entity_name(), keystone_id))
return entity
def save(self, entity):
"""Saves the state of the entity.
:raises NotFound if entity does not exist.
"""
session = get_session()
with session.begin():
entity.updated_at = timeutils.utcnow()
# Validate the attributes before we go any further. From my
# (unknown Glance developer) investigation, the @validates
# decorator does not validate
# on new records, only on existing records, which is, well,
# idiotic.
self._do_validate(entity.to_dict())
try:
entity.save(session=session)
except sqlalchemy.exc.IntegrityError:
LOG.exception('Problem saving entity for update')
raise exception.NotFound("Entity ID %s not found" % entity.id)
def get_by_create_date(self,
keystone_id,
offset_arg=None,
limit_arg=None,
suppress_exception=False,
session=None):
"""
Returns a list of containers, ordered by the date they were
created at and paged based on the offset and limit fields. The
keystone_id is external-to-Barbican value assigned to the tenant
by Keystone.
"""
offset, limit = clean_paging_values(offset_arg, limit_arg)
session = self.get_session(session)
try:
query = session.query(models.Container) \
.order_by(models.Container.created_at)
query = query.filter_by(deleted=False) \
.join(models.Tenant, models.Container.tenant) \
.filter(models.Tenant.keystone_id == keystone_id)
start = offset
end = offset + limit
LOG.debug('Retrieving from {0} to {1}'.format(start, end))
total = query.count()
entities = query[start:end]
LOG.debug('Number entities retrieved: {0} out of {1}'.format(
len(entities), total))
except sa_orm.exc.NoResultFound:
entities = None
total = 0
if not suppress_exception:
raise exception.NotFound("No %s's found" %
(self._do_entity_name()))
return entities, offset, limit, total
def get_by_create_date(self,
plugin_name=None,
offset_arg=None,
limit_arg=None,
suppress_exception=False,
session=None):
"""Returns a list of transport keys, ordered from latest created first.
The search accepts plugin_id as an optional parameter for the search.
"""
offset, limit = clean_paging_values(offset_arg, limit_arg)
session = self.get_session(session)
try:
query = session.query(models.TransportKey) \
.order_by(models.TransportKey.created_at)
if plugin_name is not None:
query = session.query(models.TransportKey).\
filter_by(deleted=False, plugin_name=plugin_name)
else:
query = query.filter_by(deleted=False)
start = offset
end = offset + limit
LOG.debug('Retrieving from {0} to {1}'.format(start, end))
total = query.count()
entities = query[start:end]
LOG.debug('Number of entities retrieved: {0} out of {1}'.format(
len(entities), total))
except sa_orm.exc.NoResultFound:
entities = None
total = 0
if not suppress_exception:
raise exception.NotFound("No {0}'s found".format(
self._do_entity_name()))
return entities, offset, limit, total
def find_by_external_project_id(self,
external_project_id,
suppress_exception=False,
session=None):
session = self.get_session(session)
try:
query = session.query(models.Project)
query = query.filter_by(external_id=external_project_id)
entity = query.one()
except sa_orm.exc.NoResultFound:
entity = None
if not suppress_exception:
LOG.exception(u._LE("Problem getting Project %s"),
external_project_id)
raise exception.NotFound(
u._("No {entity_name} found with keystone-ID {id}").format(
entity_name=self._do_entity_name(),
id=external_project_id))
return entity
def _raise_no_entities_found(entity_name):
raise exception.NotFound(
u._("No entities of type {entity_name} found").format(
entity_name=entity_name))
def _raise_entity_id_not_found(entity_id):
raise exception.NotFound(
u._("Entity ID {entity_id} not "
"found").format(entity_id=entity_id))
def _raise_entity_not_found(entity_name, entity_id):
raise exception.NotFound(
u._("No {entity} found with ID {id}").format(entity=entity_name,
id=entity_id))
