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

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

如果转载，请保留作者信息。

博客地址：http://blog.csdn.net/gaoxingnengjisuan

邮箱地址：dong.liu@siat.ac.cn

这里就不写什么开头语了，直接继续上一篇博客！

2.构建并返回用于建立卷的flow（继续）

我们先来关注，这里是如何实现Flow类的初始化的，来看语句：

api_flow = linear_flow.Flow(flow_name)

来看看任务流基类中都定义了哪些方法，这也有助于我们理解任务流的整体概念；

class Flow(object):

"""

The base abstract class of all flow implementations.

Flow抽象类；

"""

def __init__(self, name, parents=None, uuid=None):

super(Flow, self).__init__(name, parents, uuid)

# 获取回滚方法累加器类的实例化对象；

self._accumulator = utils.RollbackAccumulator()

self.results = {}

self._leftoff_at = None

# 所有要运行的任务集合；

self._runners = []

self._connected = False

# 确定所要使用的恢复策略；

self.resumer = None


def name(self)flow可读的非唯一的名称；

def uuid(self)flow唯一的标识；

def state(self)为flow提供了一个只读的状态信息；

def _change_state(self, context, new_state)改变目前的flow状态为新的状态new_state，并执行通知操作；

def add(self, task)添加一个给定的task到工作流中；

def add_many(self, tasks)添加给定的若干的task到工作流中；

def interrupt(self)尝试中断当前的flow和当前没有在flow中执行的task；

def reset(self)完全重置flow的内部的状态，并允许flow再次运行；

def soft_reset(self)部分地重置flow的内部状态，并允许flow从中止的状态再次运行；

def run(self, context, *args, **kwargs)工作流（workflow）的执行操作；

def rollback(self, context, cause)执行workflow和其父workflow的回滚操作；

再来看一下这里是如何实现task的添加的，比如语句：

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

所以来看看方法add的源码实现：

@decorators.locked
    def add(self, task):
        """
      Adds a given task to this flow.
        添加一个给定的task到flow；
        """
        assert isinstance(task, collections.Callable)
        r = utils.Runner(task)
        r.runs_before = list(reversed(self._runners))
        self._runners.append(r)
        self._reset_internals()
        return r.uuid

所实现的功能就是添加一个给定的task到flow中，具体实现就是添加到self._runners中；其中每一个task都包装成了一个Runner类的对象；其中runs_before中存储了除了当前task的以前的task；这里的变量信息后面的flow运行实现过程中都要用到的；

我们继续来关注用于卷的建立的flow中都添加了哪些task？

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

这个类实现了注入字典信息create_what到flow中，create_what是建立卷所要遵守的规范信息（字典）；

来看类InjectTask的具体代码：

class InjectTask(CinderTask):
    """
    这个类实现了注入字典信息到flow中；
    """

    def __init__(self, inject_what, addons=None):
        super(InjectTask, self).__init__(addons=addons)
        self.provides.update(inject_what.keys())
        self._inject = inject_what

    def __call__(self, context):
        return dict(self._inject)

这个类以task的形式添加到flow中，从这个类的__call__方法我们可以看出，这个类实际上就是实现了对create_what的字典化处理；

在这个task类中并没有具体实现revert方法，因为这个task中不需要回滚操作；

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

这个task类所实现的功能就是对输入的请求信息中的相关参数进行验证，并将这些参数转换成有效的集合，并返回这些经过验证和转换的参数，这些参数会应用于后续的task的实现过程之中的；

来看类ExtractVolumeRequestTask的具体代码：

class ExtractVolumeRequestTask(base.CinderTask):
    """
    实现提取并验证处理卷的请求信息任务类；

    这个task的主要任务是提取和验证输入的值，这些输入的值将形成一个潜在的卷的请求信息；
    并且实现根据一组条件对这些输入值进行验证，并将这些输入值转换成有效的集合；
    并返回这些经过验证和转换的输入值，这些输入值将会应用于其他task中。
    """

    # image_service：获取默认的镜像服务类
    # az_check_functor：验证availability_zone是否是可用的（即是否包含在可用zone的列表中）；
    def __init__(self, image_service, az_check_functor=None):
        super(ExtractVolumeRequestTask, self).__init__(addons=[ACTION])
        self.provides.update(['availability_zone', 'size', 'snapshot_id',
                              'source_volid', 'volume_type', 'volume_type_id',
                              'encryption_key_id'])
        self.requires.update(['availability_zone', 'image_id', 'metadata',
                              'size', 'snapshot', 'source_volume',
                              'volume_type', 'key_manager',
                              'backup_source_volume'])
        self.image_service = image_service
        self.az_check_functor = az_check_functor
        if not self.az_check_functor:
            self.az_check_functor = lambda az: True

    def __call__(self, context, size, snapshot, image_id, source_volume,
                 availability_zone, volume_type, metadata,
                 key_manager, backup_source_volume):
        """
        这个task的主要任务是提取和验证输入的值，这些输入的值将形成一个潜在的卷的请求信息；
        并且实现根据一组条件对这些输入值进行验证，并将这些输入值转换成有效的集合；
        并返回这些经过验证和转换的输入值，这些输入值将会应用于其他task中。
        """

        # 实现对所提供的输入参数进行是否为空的验证操作；
        utils.check_exclusive_options(snapshot=snapshot,
                                      imageRef=image_id,
                                      source_volume=source_volume)
        # 验证在指定的上下文环境中ACTION是有效的；
        # ACTION = 'volume:create'；
        policy.enforce_action(context, ACTION)
        
        # 从给定的快照中提取快照的id信息；
        snapshot_id = self._extract_snapshot(snapshot)
        # 从给定的卷中提取卷的id信息；
        source_volid = self._extract_source_volume(source_volume)
        # 提取并验证卷的大小；
        size = self._extract_size(size, source_volume, snapshot)
        # 检测镜像的存在性，并验证镜像的元数据中镜像大小的属性信息；
        self._check_image_metadata(context, image_id, size)
        # 提取并返回一个经过验证的可用的zone；
        availability_zone = self._extract_availability_zone(availability_zone,
                                                            snapshot,
                                                            source_volume)
        
        # 如果没有定义volume_type，则获取默认的卷的类型；
        if not volume_type and not source_volume and not snapshot:
            # 获取默认的卷的类型；
            volume_type = volume_types.get_default_volume_type()

        # 获取卷类型信息的id值；
        volume_type_id = self._get_volume_type_id(volume_type,
                                                  source_volume, snapshot,
                                                  backup_source_volume)
        
        # 获取加密密钥信息的id值；
        encryption_key_id = self._get_encryption_key_id(key_manager,
                                                        context,
                                                        volume_type_id,
                                                        snapshot,
                                                        source_volume,
                                                        backup_source_volume)

        specs = {}
        # 根据给定的卷类型获取所有QOS功能相关的信息；
        if volume_type_id:
            qos_specs = volume_types.get_volume_type_qos_specs(volume_type_id)
            specs = qos_specs['qos_specs']
        if not specs:
            specs = None

        # 检测卷的元数据属性是有效的；
        self._check_metadata_properties(metadata)

        # 返回经过验证的参数信息；
        # 将会用于其他task的操作；
        return {
            'size': size,
            'snapshot_id': snapshot_id,
            'source_volid': source_volid,
            'availability_zone': availability_zone,
            'volume_type': volume_type,
            'volume_type_id': volume_type_id,
            'encryption_key_id': encryption_key_id,
            'qos_specs': specs,
        }

具体功能的实现过程可以看我在代码中的注释信息，这里不再赘述，这个task类中也是不需要回滚操作的；
2.3 api_flow.add(QuotaReserveTask())

在这个task类中主要实现了几个步骤的内容，也就是说：

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

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

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

来看类QuotaReserveTask的具体代码：

class QuotaReserveTask(base.CinderTask):
    """
    根据给定的大小值和给定的卷类型信息实现保存单一的卷；
    """

    def __init__(self):
        super(QuotaReserveTask, self).__init__(addons=[ACTION])
        self.requires.update(['size', 'volume_type_id'])
        self.provides.update(['reservations'])

    def __call__(self, context, size, volume_type_id):
        """
        根据给定的大小值和给定的卷类型信息实现保存单一的卷；
        根据给定的建立新卷的大小和类型，对资源配额信息进行检测，检测建立卷的可行性；
        根据给定的建立新卷的大小和类型，实现对数据库中资源配额信息的更新；
        保留建立新卷之前的相关资源配额信息，用于一旦卷建立的执行出现异常时，调用逆转回滚方法实现资源配额信息的恢复；
        """
        try:
            reserve_opts = {'volumes': 1, 'gigabytes': size}
            # 添加卷的类型信息到reserve_opts，reserve_opts表示保留选项信息；
            QUOTAS.add_volume_type_opts(context, reserve_opts, volume_type_id)
            # 检测配额信息和并建立相应的资源配额预留资源；
            reservations = QUOTAS.reserve(context, **reserve_opts)
            return {
                'reservations': reservations,
            }
        except exception.OverQuota as e:
            overs = e.kwargs['overs']
            quotas = e.kwargs['quotas']
            usages = e.kwargs['usages']

            def _consumed(name):
                return (usages[name]['reserved'] + usages[name]['in_use'])

            def _is_over(name):
                for over in overs:
                    if name in over:
                        return True
                return False

            if _is_over('gigabytes'):
                msg = _("Quota exceeded for %(s_pid)s, tried to create "
                        "%(s_size)sG volume (%(d_consu：med)dG "
                        "of %(d_quota)dG already consumed)")
                LOG.warn(msg % {'s_pid': context.project_id,
                                's_size': size,
                                'd_consumed': _consumed('gigabytes'),
                                'd_quota': quotas['gigabytes']})
                raise exception.VolumeSizeExceedsAvailableQuota()
            elif _is_over('volumes'):
                msg = _("Quota exceeded for %(s_pid)s, tried to create "
                        "volume (%(d_consumed)d volumes "
                        "already consumed)")
                LOG.warn(msg % {'s_pid': context.project_id,
                                'd_consumed': _consumed('volumes')})
                allowed = quotas['volumes']
                raise exception.VolumeLimitExceeded(allowed=quotas['volumes'])
            else:
                # If nothing was reraised, ensure we reraise the initial error
                raise

    def revert(self, context, result, cause):
        """
        根据result中的reservations保留的信息，恢复数据库中卷的配额信息到建立新卷之前的状态；
        """
        if not result:
            return
        if context.quota_committed:
            return

        reservations = result['reservations']
        
        # 根据reservations保留的信息，恢复数据库中卷的配额信息到建立新卷之前的状态；
        try:
            QUOTAS.rollback(context, reservations)
        except exception.CinderException:
            LOG.exception(_("Failed rolling back quota for"
                            " %s reservations"), reservations)

具体功能的实现过程可以看我在代码中的注释信息，这里不再赘述；在这个类中实现了revert方法，用于当建立卷的过程中出现异常时，实现根据result中的reservations保留的信息，恢复数据库中卷的配额信息到建立新卷之前的状态；在方法revert中，具体调用了方法QUOTAS.rollback，我们简单来看一下代码的实现过程：

def rollback(self, context, reservations, project_id=None):
        """
        回调配额预留资源；
        根据reservations保留的信息，恢复数据库中卷的配额信息到建立新卷之前的状态；
        """

        # 回调配额预留资源；
        # 根据reservations保留的信息，恢复数据库中卷的配额信息到建立新卷之前的状态；
        try:
            self._driver.rollback(context, reservations, project_id=project_id)
        except Exception:
            LOG.exception(_("Failed to roll back reservations "
                            "%s") % reservations)

    def rollback(self, context, reservations, project_id=None):
        """
        回调配额预留资源；
        根据reservations保留的信息，恢复数据库中卷的配额信息到建立新卷之前的状态；
        """
        if project_id is None:
            project_id = context.project_id

        db.reservation_rollback(context, reservations, project_id=project_id)

    def reservation_rollback(context, reservations, project_id=None):
        """
        回调配额预留资源；
        根据reservations保留的信息，恢复数据库中卷的配额信息到建立新卷之前的状态；
        """
        return IMPL.reservation_rollback(context, reservations,
                                         project_id=project_id)

    @require_context
    def reservation_rollback(context, reservations, project_id=None):
        """
        回调配额预留资源；
        根据reservations保留的信息，恢复数据库中卷的配额信息到建立新卷之前的状态；
        """
        session = get_session()
        with session.begin():
            usages = _get_quota_usages(context, session, project_id)

            for reservation in _quota_reservations(session, context, reservations):
                usage = usages[reservation.resource]
                if reservation.delta >= 0:
                    usage.reserved -= reservation.delta

                reservation.delete(session=session)

            for usage in usages.values():
                usage.save(session=session)

    def _quota_reservations(session, context, reservations):
        """Return the relevant reservations."""

        # Get the listed reservations
        return model_query(context, models.Reservation,
                           read_deleted="no",
                           session=session).\
            filter(models.Reservation.uuid.in_(reservations)).\
            with_lockmode('update').\
            all()

我们可以看到，到最后方法根据reservations在数据表Reservation中查询到对应的保留的资源配额信息，来实现恢复数据库中卷的资源配额信息到建立新卷之前的状态。

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

这个task类所实现的功能是在数据库中为给定的要建立的卷来建立相关条目；

来看类EntryCreateTask的具体代码：

class EntryCreateTask(base.CinderTask):
    """
    在数据库中为给定的卷建立条目；
    逆转操作：从数据库中删除volume_id建立的条目；
    """

    def __init__(self, db):
        super(EntryCreateTask, self).__init__(addons=[ACTION])
        self.db = db
        self.requires.update(['availability_zone', 'description', 'metadata',
                              'name', 'reservations', 'size', 'snapshot_id',
                              'source_volid', 'volume_type_id',
                              'encryption_key_id'])
        self.provides.update(['volume_properties', 'volume_id'])

    def __call__(self, context, **kwargs):
        """
        为给定的输入在数据库中建立数据条目，并返回详细信息；
        从kwargs中获取卷的相关属性值，并根据卷的相关属性值在数据库中实现新卷的建立；
        """

        volume_properties = {
            'size': kwargs.pop('size'),
            'user_id': context.user_id,
            'project_id': context.project_id,
            'status': 'creating',
            'attach_status': 'detached',
            'encryption_key_id': kwargs.pop('encryption_key_id'),
            # Rename these to the internal name.
            'display_description': kwargs.pop('description'),
            'display_name': kwargs.pop('name'),
        }

        volume_properties.update(kwargs)
        # 根据卷的相关属性volume_properties的值来建立新卷；
        volume = self.db.volume_create(context, volume_properties)

        return {
            'volume_id': volume['id'],
            'volume_properties': volume_properties,
            'volume': volume,
        }

    def revert(self, context, result, cause):
        """
        删除指定的卷在数据库中的数据条目信息，实现逆转回滚操作；
        """
        
        # 如果result为none，说明从来没有产生任何结果，因此不能删除任何数据信息；
        if not result:
            return
        
        # quota_committed说明不能执行回滚操作，说明此时卷已经建立；
        if context.quota_committed:
            return
        vol_id = result['volume_id']
        
        # 删除指定的卷在数据库中的数据条目信息；
        try:
            self.db.volume_destroy(context.elevated(), vol_id)
        except exception.CinderException:
            LOG.exception(_("Failed destroying volume entry %s"), vol_id)

这个task类实现的功能很简单，就是在数据库中为新建立的卷添加相关的条目信息，如果建立卷的操作出现异常，可以调用方法revert来实现删除卷在数据库中新建立的数据条目信息，从而实现逆转回滚操作；
2.5 api_flow.add(QuotaCommitTask())

这个task类所实现的功能就是，暂时假设卷的建立是成功的，此时需要改变资源配额信息，这里就是提交新的资源配额信息到数据库中；如果卷的建立出现异常，这个task中也实现了revert方法，这个方法就是根据新建立的卷的大小等信息，从改变后的资源配额预留信息中减去新建立卷的大小等信息，就可以实现恢复卷的资源配额预留信息到新卷的建立之前的状态；

来看类QuotaCommitTask的具体代码：

class QuotaCommitTask(base.CinderTask):
    """
    提交新的资源配额的预留信息到数据库中；
    """

    def __init__(self):
        super(QuotaCommitTask, self).__init__(addons=[ACTION])
        self.requires.update(['reservations', 'volume_properties'])

    def __call__(self, context, reservations, volume_properties):
        # 提交新的资源配额的预留信息到数据库中；
        QUOTAS.commit(context, reservations)
        context.quota_committed = True
        return {'volume_properties': volume_properties}

    def revert(self, context, result, cause):
        """
        如果建立卷出现异常，则执行回滚操作，实现恢复数据库中原有的资源配额预留信息；
        """
        if not result:
            return
        volume = result['volume_properties']
        try:
            reserve_opts = {'volumes': -1, 'gigabytes': -volume['size']}
            # 添加卷的类型选项到reserve_opts；
            QUOTAS.add_volume_type_opts(context,
                                        reserve_opts,
                                        volume['volume_type_id'])
            # 检测配额信息和并建立相应的资源配额预留资源；
            reservations = QUOTAS.reserve(context,
                                          project_id=context.project_id,
                                          **reserve_opts)
            # 提交资源配额的预留信息到数据库中；
            if reservations:
                QUOTAS.commit(context, reservations,
                              project_id=context.project_id)
        except Exception:
            LOG.exception(_("Failed to update quota for deleting volume: %s"),
                          volume['id'])

上述功能的实现是很好理解的，也就是数据库相关的操作；
2.6 api_flow.add(OnFailureChangeStatusTask(db))

这个task类所实现的功能是当出现错误异常时，设置指定id的卷的状态为ERROR；

来看类OnFailureChangeStatusTask的具体代码：

class OnFailureChangeStatusTask(base.CinderTask):
    """
    这个task实现了当出现错误时，设置指定id的卷的状态为ERROR；
    """

    def __init__(self, db):
        super(OnFailureChangeStatusTask, self).__init__(addons=[ACTION])
        self.db = db
        self.requires.update(['volume_id'])
        self.optional.update(['volume_spec'])

    def __call__(self, context, volume_id, volume_spec=None):
        return {
            'volume_id': volume_id,
            'volume_spec': volume_spec,
        }

    def revert(self, context, result, cause):
        volume_spec = result.get('volume_spec')
        if not volume_spec:
            volume_spec = _find_result_spec(cause.flow)

        volume_id = result['volume_id']
        _restore_source_status(context, self.db, volume_spec)
        _error_out_volume(context, self.db, volume_id, reason=cause.exc)
        LOG.error(_("Volume %s: create failed"), volume_id)
        exc_info = False
        if all(cause.exc_info):
            exc_info = cause.exc_info
        LOG.error(_('Unexpected build error:'), exc_info=exc_info)

2.7
api_flow.add(VolumeCastTask(scheduler_rpcapi, volume_rpcapi, db))
这个task类所实现的功能就是根据具体需求调用相关的方法实现卷的建立。这里我先不做具体的分析，后面我会专门写一篇新的博客来对这里的实现进行详细的解析。当然，这个task类中就没有revert方法啦。

OK！上面我对添加到flow中的相关task进行了简单的解析，我们发现这些task类都继承自父类CinderTask，以及祖父类（哈哈哈）Task，我们来看看它们的相关实现：

class CinderTask(task.Task):
    """
    所有cinder任务的基类；
    """
    def __init__(self, addons=None):
        # _make_task_name：获取任务类的名称；
        super(CinderTask, self).__init__(_make_task_name(self.__class__, addons))

这里我们看一个输出实例，是添加第一个task之后进行测试输出的：

_make_task_name(self.__class__, addons) = cinder.volume.flows.base.InjectTask;volume:create

可见，实现的功能就是获取了当前任务类的类名和任务；

class Task(object):
    """
    这里定义了task的抽象的概念，可以用于恢复进程到没有执行操作的状态；
    """
    __metaclass__ = abc.ABCMeta

    def __init__(self, name):
        self.name = name
        self.requires = set()
        self.optional = set()
        self.provides = set()
        self.version = (1, 0)

    def __str__(self):
        return "%s==%s" % (self.name, utils.join(self.version, with_what="."))

    @abc.abstractmethod
    def __call__(self, context, *args, **kwargs):
        raise NotImplementedError()

    def revert(self, context, result, cause):
        pass

好了，具体如何实现用于建立新卷的flow的构建的过程已经简单的进行了解析，在下一篇博客中，我会进行如何执行构建好的flow的解析工作，也就是上一篇博客中的第3步骤！

好晚了啊，明天继续吧，加油！