图文精华

About云-梭伦科技»专题 › 技术学习(版主发帖区) › 云技术学习 › Cinder › Openstack Cinder中建立volume过程的源码解析（4）---- ...
分享

Openstack Cinder中建立volume过程的源码解析（4）----以及taskflow相关解析

shihailong123 发表于 2014-11-22 13:29:14 [显示全部楼层] 回帖奖励 阅读模式 关闭右栏 0 16617
About云VIP帮助找工作和提升
阅读导读：
1.简述cinder是如何实现卷的建立的？
2.简述taskflow库来实现卷的简历过程？
3.如何根据给定id来检索获取单个的卷的类型？
4.如何构建并返回用于建立卷的flow？
5.如何声明flow是否是真的？
6.简述建立卷的flow的步骤？



感谢朋友支持本博客，欢迎共同探讨交流，由于能力和时间有限，错误之处在所难免，欢迎指正！

在上一篇博客中，在cinder模块中实现客户端发送过来的请求信息操作的主要的步骤已经全部解析完成。在本篇博客中，我将解析方法cinder.api.v1.volumes.VolumeController.create，来进一步解析cinder是如何实现卷的建立的。而且在这部分内容中，应用了taskflow库（或者可以理解成一种设计模式）来实现卷的建立过程。
目前openstack的源代码随着模块和功能的增加和完善，代码量快速增长，功能的实现复杂度也随之增加，引进taskflow库能够实现方便的代码管理，并且增加功能实现的安全性。简单来说，当实现一个功能时，应用taskflow模式能够实现对flow执行的管理，能够开始、中止、重新开始以及逆转回滚等操作，比如当执行某个flow操作出现异常时，可以视具体情况尝试进行flow的逆转回滚操作，实现回溯到flow执行之前的状态。
在本篇博客中，我会依据卷的建立为例，具体解析taskflow在cinder模块中卷建立过程中的应用情况。

我们来看代码/cinder/api/v1/volumes.py----class VolumeController----def create的具体源码实现：
  1.  @wsgi.serializers(xml=VolumeTemplate)

  2.     @wsgi.deserializers(xml=CreateDeserializer)

  3.     def create(self, req, body):

  4.         """

  5.         Creates a new volume.

  6.         建立新卷的API；

  7.         

  8.         req = POST /v1/ecf0109bda814fa1a548af63f9ada370/volumes HTTP/1.0

  9.               Accept: application/json

  10.               Accept-Encoding: gzip, deflate, compress

  11.               Content-Length: 294

  12.               Content-Type: application/json

  13.               Host: 172.21.5.164:8776

  14.               User-Agent: python-cinderclient

  15.               X-Auth-Project-Id: admin

  16.               X-Auth-Token: MIIQKQYJKoZI......TBvg==

  17.               X-Domain-Id: None

  18.               X-Domain-Name: None

  19.               X-Identity-Status: Confirmed

  20.               X-Project-Domain-Id: None

  21.               X-Project-Domain-Name: None

  22.               X-Project-Id: ecf0109bda814fa1a548af63f9ada370

  23.               X-Project-Name: admin

  24.               X-Role: _member_,admin

  25.               X-Roles: _member_,admin

  26.               X-Service-Catalog: 

  27.               [{"endpoints_links": [], "endpoints": [....], "type": "compute", "name": "nova"}, 

  28.                {"endpoints_links": [], "endpoints": [....], "type": "network", "name": "neutron"}, 

  29.                {"endpoints_links": [], "endpoints": [....], "type": "volumev2", "name": "cinder_v2"}, 

  30.                {"endpoints_links": [], "endpoints": [....], "type": "s3", "name": "swift_s3"}, 

  31.                {"endpoints_links": [], "endpoints": [....], "type": "image", "name": "glance"}, 

  32.                {"endpoints_links": [], "endpoints": [....], "type": "metering", "name": "ceilometer"}, 

  33.                {"endpoints_links": [], "endpoints": [....], "type": "volume", "name": "cinder"}, 

  34.                {"endpoints_links": [], "endpoints": [....], "type": "ec2", "name": "nova_ec2"}, 

  35.                {"endpoints_links": [], "endpoints": [....], "type": "object-store", "name": "swift"}, 

  36.                {"endpoints_links": [], "endpoints": [....], "type": "identity", "name": "keystone"}]

  37.               X-Tenant: admin

  38.               X-Tenant-Id: ecf0109bda814fa1a548af63f9ada370

  39.               X-Tenant-Name: admin

  40.               X-User: admin

  41.               X-User-Domain-Id: None

  42.               X-User-Domain-Name: None

  43.               X-User-Id: d2ee2dd06c9e49098a3d2a278c650b6c

  44.               X-User-Name: admin

  45.               {"volume": {"status": "creating", 

  46.                           "availability_zone": null, 

  47.                           "source_volid": null, 

  48.                           "display_description": null, 

  49.                           "snapshot_id": null, 

  50.                           "user_id": null, 

  51.                           "size": 1, 

  52.                           "display_name": "shinian01", 

  53.                           "imageRef": null, 

  54.                           "attach_status": "detached", 

  55.                           "volume_type": null, 

  56.                           "project_id": null, 

  57.                           "metadata": {}}}

  58.         

  59.         body = {u'volume': {u'status': u'creating', 

  60.                             u'user_id': None, 

  61.                             u'imageRef': None, 

  62.                             u'availability_zone': None, 

  63.                             'scheduler_hints': {}, 

  64.                             u'attach_status': u'detached', 

  65.                             u'display_description': None, 

  66.                             u'metadata': {}, 

  67.                             u'source_volid': None, 

  68.                             u'snapshot_id': None, 

  69.                             u'display_name': u'shinian01', 

  70.                             u'project_id': None, 

  71.                             u'volume_type': None, 

  72.                             u'size': 1}}

  73.         """        

  74.         if not self.is_valid_body(body, 'volume'):

  75.             raise exc.HTTPUnprocessableEntity()

  76.         LOG.debug('Create volume request body: %s', body)

  77.         

  78.         # 获取cinder的上下文信息；

  79.         context = req.environ['cinder.context']

  80.         volume = body['volume']

  81.         kwargs = {}

  82.         # 获取请求信息中的volume_type信息；

  83.         req_volume_type = volume.get('volume_type', None)

  84.         #req_volume_type = None

  85.         

  86.         # 通过名称或给定id获取单个的卷的类型；

  87.         if req_volume_type:

  88.             try:

  89.                 if not uuidutils.is_uuid_like(req_volume_type):

  90.                     # 根据名称获取单个卷的类型；

  91.                     kwargs['volume_type'] = volume_types.get_volume_type_by_name(context, req_volume_type)

  92.                 else:

  93.                     # 根据给定id来检索获取单个的卷的类型；

  94.                     kwargs['volume_type'] = volume_types.get_volume_type(context, req_volume_type)

  95.             except exception.VolumeTypeNotFound:

  96.                 explanation = 'Volume type not found.'

  97.                 raise exc.HTTPNotFound(explanation=explanation)

  98.         # 从请求信息的body部分获取元数据信息；

  99.         kwargs['metadata'] = volume.get('metadata', None)

  100.         # kwargs['metadata'] = {}

  101.         # 从请求信息的body部分获取快照id信息；

  102.         snapshot_id = volume.get('snapshot_id')

  103.         # snapshot_id = None

  104.         

  105.         # 如果给定快照id信息，则根据snapshot_id获取指定的卷的快照。如果没有给定快照id信息，则赋值为None；

  106.         if snapshot_id is not None:

  107.             # get_snapshot：获取snapshot_id指定卷的快照；

  108.             kwargs['snapshot'] = self.volume_api.get_snapshot(context, snapshot_id)

  109.         else:

  110.             kwargs['snapshot'] = None

  111.         # 从请求信息的body部分获取source_volid信息；

  112.         source_volid = volume.get('source_volid')

  113.         # source_volid = None

  114.         

  115.         # 如果给定原卷的id信息，则根据source_volid获取指定的原卷。如果没有给定原卷的id信息，则赋值为None；

  116.         if source_volid is not None:

  117.             # 根据volume_id获取volume；

  118.             kwargs['source_volume'] = self.volume_api.get_volume(context, source_volid)

  119.         else:

  120.             kwargs['source_volume'] = None

  121.         # 从请求信息的body部分获取size信息；

  122.         size = volume.get('size', None)

  123.         # size = 1

  124.         

  125.         # 如果size为None，则从kwargs['snapshot']中或者kwargs['source_volume']中获取卷的大小值；

  126.         if size is None and kwargs['snapshot'] is not None:

  127.             size = kwargs['snapshot']['volume_size']

  128.         elif size is None and kwargs['source_volume'] is not None:

  129.             size = kwargs['source_volume']['size']

  130.         LOG.audit(_("Create volume of %s GB"), size, context=context)

  131.         image_href = None

  132.         image_uuid = None

  133.         

  134.         # 检测self.extensions中是否包含'os-image-create'；

  135.         if self.ext_mgr.is_loaded('os-image-create'):

  136.             # NOTE(jdg): misleading name "imageRef" as it's an image-id

  137.             image_href = volume.get('imageRef')

  138.             

  139.             if image_href:

  140.                 # 从image_href获取uuid；

  141.                 image_uuid = self._image_uuid_from_href(image_href)

  142.                 kwargs['image_id'] = image_uuid

  143.         # 从请求信息的body部分获取availability_zone信息；

  144.         kwargs['availability_zone'] = volume.get('availability_zone', None)

  145.         # kwargs['availability_zone'] = None

  146.         new_volume = self.volume_api.create(context,

  147.                                             size,

  148.                                             volume.get('display_name'), # 要建立卷的名称；

  149.                                             volume.get('display_description'),

  150.                                             **kwargs)

  151.         # TODO(vish): Instance should be None at db layer instead of

  152.         #             trying to lazy load, but for now we turn it into

  153.         #             a dict to avoid an error.

  154.         # 转换new_volume格式；

  155.         new_volume = dict(new_volume.iteritems())

  156.         self._add_visible_admin_metadata(context, new_volume)

  157.         # _translate_volume_detail_view：获取指定卷详细的重要属性信息；

  158.         retval = _translate_volume_detail_view(context, new_volume, image_uuid)

  159.         return {'volume': retval}
复制代码
这个方法很好理解，主要完成了三部分内容：
  • 1.通过req和body获取建立卷所需的相关参数，因为建立卷的方法有几种，后面会分析到，具体采用哪种卷的建立方法，是根据req和body中的相关参数决定的，而且卷的建立也许要确定一些参数，例如卷的大小等等；
  • 2.调用方法create实现卷的建立；
  • 3.获取建立卷后的反馈信息，实现格式转换，并获取其中重要的属性信息，以便上层调用生成卷的建立的响应信息；
我们再来看其中调用的方法create，实际上调用的是方法/cinder/volume/api.py----class API----def create，我们来看其具体的源码实现：
  1. def create(self, context, size, name, description, snapshot=None,

  2.                image_id=None, volume_type=None, metadata=None,

  3.                availability_zone=None, source_volume=None,

  4.                scheduler_hints=None, backup_source_volume=None):

  5.         """

  6.         实现建立卷的操作；

  7.         """

  8.         def check_volume_az_zone(availability_zone):

  9.             """

  10.             验证availability_zone是否是可用的（即是否包含在可用zone的列表中）；

  11.             """

  12.             try:

  13.                 # _valid_availabilty_zone：验证availability_zone是否是可用的（即是否包含在可用zone的列表中）；

  14.                 return self._valid_availabilty_zone(availability_zone)

  15.             except exception.CinderException:

  16.                 LOG.exception(_("Unable to query if %s is in the "

  17.                                 "availability zone set"), availability_zone)

  18.                 return False

  19.         # 所要建立卷的规格数据信息；

  20.         create_what = {

  21.             'size': size,

  22.             'name': name,

  23.             'description': description,

  24.             'snapshot': snapshot,

  25.             'image_id': image_id,

  26.             'volume_type': volume_type,

  27.             'metadata': metadata,

  28.             'availability_zone': availability_zone,

  29.             'source_volume': source_volume,

  30.             'scheduler_hints': scheduler_hints,

  31.             'key_manager': self.key_manager,

  32.             'backup_source_volume': backup_source_volume,

  33.         }

  34.         

  35.         # 构建并返回用于建立卷的flow；

  36.         # self.scheduler_rpcapi = scheduler_rpcapi.SchedulerAPI()；

  37.         # self.volume_rpcapi = volume_rpcapi.VolumeAPI()；

  38.         # self.image_service = (image_service or glance.get_default_image_service())

  39.         # check_volume_az_zone：验证availability_zone是否是可用的（即是否包含在可用zone的列表中）；

  40.         # create_what：所要建立卷的规格数据信息；

  41.         (flow, uuid) = create_volume.get_api_flow(self.scheduler_rpcapi,

  42.                                                   self.volume_rpcapi,

  43.                                                   self.db,

  44.                                                   self.image_service,

  45.                                                   check_volume_az_zone,

  46.                                                   create_what)

  47.         # 应用assert关键字来声明flow是真的；

  48.         assert flow, _('Create volume flow not retrieved')

  49.         

  50.         

  51.         # 运行用于建立卷的flow；

  52.         flow.run(context)

  53.         

  54.         # 如果flow的运行状态不为states.SUCCESS，则引发异常；

  55.         if flow.state != states.SUCCESS:

  56.             raise exception.CinderException(_("Failed to successfully complete"

  57.                                               " create volume workflow"))

  58.         # Extract the volume information from the task uuid that was specified

  59.         # to produce said information.

  60.         # 通过task的uuid值获取建立卷的信息；

  61.         volume = None

  62.         try:

  63.             volume = flow.results[uuid]['volume']

  64.         except KeyError:

  65.             pass

  66.         # Raise an error, nobody provided it??

  67.         # 应用assert关键字来声明volume是真的；

  68.         assert volume, _('Expected volume result not found')

  69.         

  70.         return volume
复制代码
  在这个方法中主要实完成了四部分内容：
  • 1.构建字典create_what，实现整合建立卷的具体参数；
  • 2.构建并返回用于建立卷的flow；
  • 3.执行构建的用于建立卷的flow；
  • 4.从flow中获取建立卷的反馈信息；
1.先来看一下语句变量create_what的输出实例：
  1. create_what = {'backup_source_volume': None,

  2.                    'description': None, 

  3.                    'availability_zone': None, 

  4.                    'image_id': None, 

  5.                    'scheduler_hints': None, 

  6.                    'name': u'shinian01', 

  7.                    'source_volume': None, 

  8.                    'volume_type': None, 

  9.                    'snapshot': None, 

  10.                    'size': 1, 

  11.                    'key_manager': ,

  12.                    'metadata': {}}
复制代码
2.构建并返回用于建立卷的flow
我们重点来看第2点，即如何构建用于建立卷的flow；
来看语句：
  1. (flow, uuid) = create_volume.get_api_flow(self.scheduler_rpcapi,

  2.                                           self.volume_rpcapi,

  3.                                           self.db,

  4.                                           self.image_service,

  5.                                           check_volume_az_zone,

  6.                                           create_what)
复制代码
我们先来简单分析一下传入方法get_api_flow中的几个变量信息：
  1. self.scheduler_rpcapi = scheduler_rpcapi.SchedulerAPI()；
复制代码
这个参数用于当请求信息中没有指定要建立卷的目标主机时，通过调度器API中的方法根据具体情况应用合适的调度算法实现选取目标主机并进行建立卷的操作；
  1. self.volume_rpcapi = volume_rpcapi.VolumeAPI()；
复制代码
这个参数指定了volume RPC API客户端，实现通过RPC对卷进行远程的相关操作的执行；
  1. self.image_service = (image_service or glance.get_default_image_service())；
复制代码
这个参数指定了镜像服务的接口API，主要用于当根据镜像实现卷的建立这种情况中；
  1. check_volume_az_zone：验证availability_zone是否是可用的（即是否包含在可用zone的列表中）；
复制代码
create_what：所要建立卷的规格数据信息；
OK！我们来看方法get_api_flow，这个方法主要实现了构建并返回用于建立卷的flow，我们来看其源码实现：
  1. def get_api_flow(scheduler_rpcapi, volume_rpcapi, db,

  2.                  image_service,

  3.                  az_check_functor,

  4.                  create_what):

  5.     """

  6.     构建并返回用于建立卷的flow；

  7.     flow将会做如下的事情：

  8.     1.获取类Flow的初始化对象；

  9.     2.注入字典信息create_what到flow中；

  10.     3.验证用于后续操作的相关参数，返回经过验证的参数信息；

  11.     4.根据给定的建立卷的大小和类型信息，对资源配额信息进行检测，检测建立卷的可行性；

  12.       并实现对数据库中资源配额信息的更新，并且保留建立新卷之前的相关资源配额信息；

  13.     5.在数据库中为给定的卷建立相关条目；

  14.     6.提交新的资源配额的预留信息到数据库中；

  15.     7.远程调用实现卷的建立操作；

  16.     """

  17.     # 获取flow任务的名称；

  18.     # ACTION = 'volume:create'

  19.     # flow_name = 'volume_create_api'

  20.     flow_name = ACTION.replace(":", "_") + "_api"

  21.     

  22.     # 获取类Flow的初始化对象；

  23.     # Flow：线性工作流管理类；

  24.     api_flow = linear_flow.Flow(flow_name)

  25.     

  26.     # 添加一个给定的task到flow；

  27.     # InjectTask：这个类实现了注入字典信息create_what到flow中；

  28.     # create_what是建立卷所要遵守的规范信息（字典）；

  29.     api_flow.add(base.InjectTask(create_what, addons=[ACTION]))

  30.     

  31.     # 添加一个给定的task到flow；

  32.     # ExtractVolumeRequestTask：实现提取并验证输入的请求信息，并返回经过验证的参数信息，以便用于其他task当中；

  33.     # 这个task的主要任务是提取和验证输入的值，这些输入的值将形成一个潜在的卷的请求信息；

  34.     # 并且实现根据一组条件对这些输入值进行验证，并将这些输入值转换成有效的集合；

  35.     # 并返回这些经过验证和转换的输入值，这些输入值将会应用于其他task中。

  36.     # image_service：获取默认的镜像服务类

  37.     # az_check_functor：验证availability_zone是否是可用的（即是否包含在可用zone的列表中）；

  38.     api_flow.add(ExtractVolumeRequestTask(image_service, az_check_functor))

  39.     

  40.     # 添加一个给定的task到flow；

  41.     # QuotaReserveTask：根据给定的大小值和给定的卷类型信息实现保存单一的卷；

  42.     # 根据给定的建立新卷的大小和类型，对资源配额信息进行检测，检测建立卷的可行性；

  43.     # 根据给定的建立新卷的大小和类型，实现对数据库中资源配额信息的更新；

  44.     # 保留建立新卷之前的相关资源配额信息，用于一旦卷建立的执行出现异常时，调用逆转回滚方法实现资源配额信息的恢复；

  45.     # QuotaReserveTask：根据给定的大小值和给定的卷类型信息实现保存单一的卷；

  46.     api_flow.add(QuotaReserveTask())

  47.     

  48.     # 添加一个给定的task到flow；

  49.     # EntryCreateTask：在数据库中为给定的卷建立相关条目；

  50.     v_uuid = api_flow.add(EntryCreateTask(db))

  51.     

  52.     # 添加一个给定的task到flow；

  53.     # QuotaCommitTask：提交新的资源配额的预留信息到数据库中；

  54.     #（假设卷建立成功， 如果卷的建立出现异常，将会执行本flow中的回滚操作）；

  55.     api_flow.add(QuotaCommitTask())

  56.     # 添加一个给定的task到flow；

  57.     # 这个task实现了当出现错误时，设置指定id的卷的状态为ERROR；

  58.     api_flow.add(OnFailureChangeStatusTask(db))

  59.     # 添加一个给定的task到flow；

  60.     # 远程调用实现卷的建立操作；

  61.     api_flow.add(VolumeCastTask(scheduler_rpcapi, volume_rpcapi, db))

  62.     # Note(harlowja): this will return the flow as well as the uuid of the

  63.     # task which will produce the 'volume' database reference (since said

  64.     # reference is returned to other callers in the api for further usage).

  65.     # 返回相关状态的变化信息，并获取flow中task的uuid值；

  66.     return (flow_utils.attach_debug_listeners(api_flow), v_uuid)
复制代码
我们可以看到关于taskflow的构建脉络很清晰的，这个方法中主要通过三部，实现了用于建立卷的flow的构建：
  • 1.初始化一个Flow类；
  • 2.按顺序添加相关的task到flow中；
  • 3.返回添加task后的flow给调用者；
OK！这篇博客先写到这里，在下一篇博客中，将会关注用于卷的建立的flow中都添加了哪些task，当然，taskflow的应用还没有分析完成，后面也会继续对其进行分析和总结。



相关文章：
Openstack Cinder中建立volume过程的源码解析（1）
http://www.aboutyun.com/thread-10217-1-1.html
1.cinder中卷的建立的过程中，客户端传递过来的request的执行过程是怎样的？
2.__call__方法都通过什么方法封装？
3.如何调用指定中间件的__call__方法？

Openstack Cinder中建立volume过程的源码解析（2）
http://www.aboutyun.com/thread-10216-1-1.html
1.如何获取要执行的action方法及其相关的扩展方法？
2.Resource类中的__call__(self,request)方法如何实现？
3.meth的作用？
4.如何从request.environ中获取要执行的action方法？
5.如何对body进行反序列化操作？

Openstack Cinder中建立volume过程的源码解析（3）
http://www.aboutyun.com/thread-10215-1-1.html
1.get_serializer的作用？
2.isgeneratorfunction是用来做什么的？
3.什么是特殊的generator方法？
4.进行响应信息的序列化操作的步骤？
5.简述在cinder模块中实现客户端发送过来的请求信息操作的主要的步骤？



Openstack Cinder中建立volume过程的源码解析（5）----以及taskflow相关解析
http://www.aboutyun.com/thread-10213-1-1.html
1.如何实现Flow类的初始化的？
2.用于卷的建立的flow中都添加了哪些task？
3.ExtractVolumeRequestTask类的作用是什么？
4.如何完全或部分的重置flow的内部的状态？
5.如何从给定的卷中提取卷的id信息？
6.OnFailureChangeStatusTask类的作用？

Openstack Cinder中建立volume过程的源码解析（6）----以及taskflow相关解析
http://www.aboutyun.com/thread-10212-1-1.html
1.如何来运行已经构建好的flow？
2.run的源码如何实现及实现过程是什么？
3.resume_it的实现过程是什么？
4.类Runner的初始化方法是什么？
5.run_it的源码如何实现？

Openstack Cinder中建立volume过程的源码解析（7）----以及taskflow相关解析
http://www.aboutyun.com/thread-10211-1-1.html
1.关于flow中task执行的重要语句的实现基本解析完成，如何实现？
2.如果卷的建立出现异常，则如何执行相关的逆转回滚操作？

Openstack Cinder中建立volume过程的源码解析（8）
http://www.aboutyun.com/thread-10219-1-1.html
1.VolumeCastTask的源码如何实现?
2.远程调用建立新卷的操作，有哪几个步骤？
3.task类VolumeCastTask具体是如何来实现根据请求信息进行卷的建立的？


Openstack Cinder中建立volume过程的源码解析（9）
http://www.aboutyun.com/thread-10210-1-1.html
1.如何实现create_volume的源码？
2.Cast如何实现远程调create_volume？
3.如何实现调用方法self.volume_rpcapi.create_volume来实现在目标主机上新卷的建立？



如果转载，请保留作者信息。
博客地址：http://blog.csdn.net/gaoxingnengjisuan
邮箱地址：dong.liu@siat.ac.cn




回复

使用道具 举报

自定义广告语

没找到任何评论，期待你打破沉寂

高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

发表新帖
shihailong123

中级会员

关注

  • 80

    主题

  • 157

    帖子

  • 4

    粉丝

TA的主题
关闭

推荐上一条 /2 下一条

关于我们· 联系我们· 加入我们· 小黑屋· 合作伙伴   

Copyright © 2001-2024 About云-梭伦科技 Powered by Discuz! X3.4 Licensed Discuz Team.

简书 / Smrz 京ICP备2020039040号 Wxb 简书网举报电话：021-34700000