OpenStack之Glance源码简析

　　Glance简介

　　OpenStack镜像服务器是一套虚拟机镜像发现、注册、检索。

　　glance架构图：

　　

　　Glance源码结构：

　　

　　glance/api：主要负责接收响应镜像管理命令的Restful请求，分析消息请求信息并分发其所带的命令（如新增，删除，更新等）。默认绑定端口是9292。

　　glance/registry：主要负责接收响应镜像元数据命令的Restful请求。分析消息请求信息并分发其所带的命令（如获取元数据，更新元数据等）。默认绑定的端口是9191。

　　glance/db:主要负责与数据库Mysql的交互

　　glance/store:主要负责存储适配

　　本次主要从简单的查询来简析glance源码，看一下glance代码是如何执行的。

　　查询的API：/v1/images/detail，method:GET,有兴趣的朋友可以用火狐浏览器自带的RESTClient来进行REST服务的测试。

　　好了，废话不多说，源码走起。

　　源码分析

　　　 图为glance/api/v1中的源码目录树。

　　　此次就从glance的查询来分析glance的源码，从horizon的传过来的HTTP请求首先来到glance/api/v1/router.py中，查找匹配的HTTP请求：

　　　　代码如下：　　　

 mapper.connect("/images/detail",
                        controller=images_resource,
                        action='detail',
                        conditions={'method': ['GET']})

　　　　可以看到，这与Glance的API文档是相符的，GET请求，然后是/v1/images/detail。

　　　　而后，找到匹配的请求之后，就会进入glance/api/v1/images.py文件中，下面是有关的代码：　　

 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)

　　　26行是根据获取查询条件，在此不深入谈，想了解的朋友可以留言，主要查询语句在try里面，也就是第28行：　

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

　　从这里，查询就跳入了glance/registry/client/v1/api.py文件中。

　

　　图为glance/registry的目录树，glance/registry/client/v1/api.py中相关代码如下：　

 def get_images_detail(context, **kwargs):
     c = get_registry_client(context)
     return c.get_images_detailed(**kwargs)

　　首先，会在glance/registry/client/v1/api.py文件进行registry端口的认证连接，　

 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)

　　然后第三行返回查询，进入glance/registry/client/v1/client.py中：　

 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

　　在12行再次发出请求，然后在glance/registry/api/v1/__init__.py中查找匹配的请求：　　

 mapper.connect("/images/detail",
                        controller=images_resource,
                        action="detail",
                        conditions={'method': ['GET']})

　　在glance/registry/api/v1/images.py中找到相应的方法进行查询：

 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)

　　第14行又调用glance/registry/api/v1/images.py的_get_images(req.context, **params)方法：

 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

　　在第10行中，进入glance/db/sqlalchemy/api.py中：

　　图为glance/db的目录树。下面是调用的glance/db/sqlalchemy/api.py中的image_get_all方法，

　　

 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()]

　　此方法最后将查询结果返回字典，至此，glance查询方法就此结束。

　　如果有不对的地方，欢迎各位大神指出。

PS:本博客欢迎转发，但请注明博客地址及作者~

　　博客地址：http://www.cnblogs.com/voidy/

　　<。)#)))≦