mapper.connect("/images/detail",

                        controller=images_resource,

                        action='detail',

                        conditions={'method': ['GET']})

 def detail(self, req):

         """

         Returns detailed information for all available images

         :param req: The WSGI/Webob Request object

         :retval The response body is a mapping of the following form::

             {'images': [

                 {'id': <ID>,

                  'name': <NAME>,

                  'size': <SIZE>,

                  'disk_format': <DISK_FORMAT>,

                  'container_format': <CONTAINER_FORMAT>,

                  'checksum': <CHECKSUM>,

                  'min_disk': <MIN_DISK>,

                  'min_ram': <MIN_RAM>,

                  'store': <STORE>,

                  'status': <STATUS>,

                  'created_at': <TIMESTAMP>,

                  'updated_at': <TIMESTAMP>,

                  'deleted_at': <TIMESTAMP>|<NONE>,

                  'properties': {'distro': 'Ubuntu 10.04 LTS', ...}}, ...

             ]}

         """

         self._enforce(req, 'get_images')

         params = self._get_query_params(req)

         try:

             images = registry.get_images_detail(req.context, **params)

             # Strip out the Location attribute. Temporary fix for

             # LP Bug #755916. This information is still coming back

             # from the registry, since the API server still needs access

             # to it, however we do not return this potential security

             # information to the API end user...

             for image in images:

                 redact_loc(image, copy_dict=False)

                 self._enforce_read_protected_props(image, req)

         except exception.Invalid as e:

             raise HTTPBadRequest(explanation="%s" % e)

         return dict(images=images)

 images = registry.get_images_detail(req.context, **params)

 def get_images_detail(context, **kwargs):

     c = get_registry_client(context)

     return c.get_images_detailed(**kwargs)

 def get_registry_client(cxt):

     global _CLIENT_CREDS, _CLIENT_KWARGS, _CLIENT_HOST, _CLIENT_PORT

     global _METADATA_ENCRYPTION_KEY

     kwargs = _CLIENT_KWARGS.copy()

     if CONF.use_user_token:

         kwargs['auth_tok'] = cxt.auth_tok

     if _CLIENT_CREDS:

         kwargs['creds'] = _CLIENT_CREDS

     if CONF.send_identity_headers:

         identity_headers = {

             'X-User-Id': cxt.user,

             'X-Tenant-Id': cxt.tenant,

             'X-Roles': ','.join(cxt.roles),

             'X-Identity-Status': 'Confirmed',

             'X-Service-Catalog': jsonutils.dumps(cxt.service_catalog),

         }

         kwargs['identity_headers'] = identity_headers

     return client.RegistryClient(_CLIENT_HOST, _CLIENT_PORT,

                                  _METADATA_ENCRYPTION_KEY, **kwargs)

 def get_images_detailed(self, **kwargs):

         """

         Returns a list of detailed image data mappings from Registry

         :param filters: dict of keys & expected values to filter results

         :param marker: image id after which to start page

         :param limit: max number of images to return

         :param sort_key: results will be ordered by this image attribute

         :param sort_dir: direction in which to to order results (asc, desc)

         """

         params = self._extract_params(kwargs, images.SUPPORTED_PARAMS)

         res = self.do_request("GET", "/images/detail", params=params)

         image_list = jsonutils.loads(res.read())['images']

         for image in image_list:

             image = self.decrypt_metadata(image)

         return image_list

 mapper.connect("/images/detail",

                        controller=images_resource,

                        action="detail",

                        conditions={'method': ['GET']})

 def detail(self, req):

         """Return a filtered list of public, non-deleted images in detail

         :param req: the Request object coming from the wsgi layer

         :retval a mapping of the following form::

             dict(images=[image_list])

         Where image_list is a sequence of mappings containing

         all image model fields.

         """

         params = self._get_query_params(req)

         images = self._get_images(req.context, **params)

         image_dicts = [make_image_dict(i) for i in images]

         LOG.info(_("Returning detailed image list"))

         return dict(images=image_dicts)

 def _get_images(self, context, filters, **params):

         """Get images, wrapping in exception if necessary."""

         # NOTE(markwash): for backwards compatibility, is_public=True for

         # admins actually means "treat me as if I'm not an admin and show me

         # all my images"

         if context.is_admin and params.get('is_public') is True:

             params['admin_as_user'] = True

             del params['is_public']

         try:

             return self.db_api.image_get_all(context, filters=filters,

                                              **params)

         except exception.NotFound:

             LOG.info(_("Invalid marker. Image %(id)s could not be "

                        "found.") % {'id': params.get('marker')})

             msg = _("Invalid marker. Image could not be found.")

             raise exc.HTTPBadRequest(explanation=msg)

         except exception.Forbidden:

             LOG.info(_("Access denied to image %(id)s but returning "

                        "'not found'") % {'id': params.get('marker')})

             msg = _("Invalid marker. Image could not be found.")

             raise exc.HTTPBadRequest(explanation=msg)

         except Exception:

             LOG.exception(_("Unable to get images"))

             raise

 def image_get_all(context, filters=None, marker=None, limit=None,

                   sort_key='created_at', sort_dir='desc',

                   member_status='accepted', is_public=None,

                   admin_as_user=False):

     """

     Get all images that match zero or more filters.

     :param filters: dict of filter keys and values. If a 'properties'

                     key is present, it is treated as a dict of key/value

                     filters on the image properties attribute

     :param marker: image id after which to start page

     :param limit: maximum number of images to return

     :param sort_key: image attribute by which results should be sorted

     :param sort_dir: direction in which results should be sorted (asc, desc)

     :param member_status: only return shared images that have this membership

                           status

     :param is_public: If true, return only public images. If false, return

                       only private and shared images.

     :param admin_as_user: For backwards compatibility. If true, then return to

                       an admin the equivalent set of images which it would see

                       if it were a regular user

     """

     filters = filters or {}

     visibility = filters.pop('visibility', None)

     showing_deleted = 'changes-since' in filters or filters.get('deleted',

                                                                 False)

     img_conditions, prop_conditions, tag_conditions = \

         _make_conditions_from_filters(filters, is_public)

     query = _select_images_query(context,

                                  img_conditions,

                                  admin_as_user,

                                  member_status,

                                  visibility)

     if visibility is not None:

         if visibility == 'public':

             query = query.filter(models.Image.is_public == True)

         elif visibility == 'private':

             query = query.filter(models.Image.is_public == False)

     if prop_conditions:

         for prop_condition in prop_conditions:

             query = query.join(models.ImageProperty, aliased=True)\

                 .filter(sa_sql.and_(*prop_condition))

     if tag_conditions:

         for tag_condition in tag_conditions:

             query = query.join(models.ImageTag, aliased=True)\

                 .filter(sa_sql.and_(*tag_condition))

     marker_image = None

     if marker is not None:

         marker_image = _image_get(context,

                                   marker,

                                   force_show_deleted=showing_deleted)

     sort_keys = ['created_at', 'id']

     sort_keys.insert(0, sort_key) if sort_key not in sort_keys else sort_keys

     query = _paginate_query(query, models.Image, limit,

                             sort_keys,

                             marker=marker_image,

                             sort_dir=sort_dir)

     query = query.options(sa_orm.joinedload(models.Image.properties))\

                  .options(sa_orm.joinedload(models.Image.locations))

     return [_normalize_locations(image.to_dict()) for image in query.all()]