感謝朋友支援本部落格，歡迎共同探討交流，由於能力和時間有限，錯誤之處在所難免，歡迎指正！
如果轉載，請保留作者資訊。
部落格地址：http://blog.csdn.net/gaoxingnengjisuan
郵箱地址：[email protected]

我們在上一篇部落格中可以看到，在建立新卷之前，需要獲取建立卷的目標主機，經過分析原始碼我們可以知道，如果沒有指定建立新卷的目標主機，需要通過排程器演算法實現目標主機的確定，如果指定了建立新卷的目標主機，則直接獲取目標主機，無論是哪種情況，都需要呼叫方法self.volume_rpcapi.create_volume來實現在目標主機上新卷的建立。在這篇部落格中，我們就具體來分析這個方法的實現過程。

我們先來看方法create_volume的原始碼實現：

    def create_volume(self, ctxt, volume, host,
                      request_spec, filter_properties,
                      allow_reschedule=True,
                      snapshot_id=None, image_id=None,
                      source_volid=None):
        """
        遠端呼叫實現建立並匯出卷；
        """

        request_spec_p = jsonutils.to_primitive(request_spec)
        self.cast(ctxt,
                  self.make_msg('create_volume',
                                volume_id=volume['id'],
                                request_spec=request_spec_p,
                                filter_properties=filter_properties,
                                allow_reschedule=allow_reschedule,
                                snapshot_id=snapshot_id,
                                image_id=image_id,
                                source_volid=source_volid),
                  # queue_get_for：根據給定的topic和host獲取對應的佇列名稱；
                  topic=rpc.queue_get_for(ctxt,
                                          self.topic,
                                          host),
                  version='1.4')
 

    @utils.require_driver_initialized
    def create_volume(self, context, volume_id, request_spec=None,
                      filter_properties=None, allow_reschedule=True,
                      snapshot_id=None, image_id=None, source_volid=None):
        """
        Creates and exports the volume.
        建立並匯出卷；
        """

        # 構建並返回用於通過管理器建立卷的flow；
        flow = create_volume.get_manager_flow(
            self.db,
            self.driver,
            self.scheduler_rpcapi,
            self.host,
            volume_id,
            request_spec=request_spec,
            filter_properties=filter_properties,
            allow_reschedule=allow_reschedule,
            snapshot_id=snapshot_id,
            image_id=image_id,
            source_volid=source_volid,
            reschedule_context=context.deepcopy())

        assert flow, _('Manager volume flow not retrieved')

        # 進行flow的執行操作；
        flow.run(context.elevated())
        if flow.state != states.SUCCESS:
            raise exception.CinderException(_("Failed to successfully complete"
                                              " manager volume workflow"))

        self._reset_stats()
        return volume_id
 

def get_manager_flow(db, driver, scheduler_rpcapi, host, volume_id,
                     request_spec=None, filter_properties=None,
                     allow_reschedule=True,
                     snapshot_id=None, image_id=None, source_volid=None,
                     reschedule_context=None):
    """
    Constructs and returns the manager entrypoint flow.
    構建並返回用於通過管理器建立卷的flow；

    flow將會做以下的事情：
    1. 首先要確定我們是否允許進行重新排程，因為這影響了我們如何對出現錯誤的情況進行處理；
    2. 為相關的task注入keys和values；
    3. 對於出錯的task進行處理，傳送錯誤通知，記錄錯誤資訊等；
    4. 實現了從輸入的引數中提取建立卷的規範資訊的操作；
    5. 通知已經開始進行卷的建立操作；
    6. 根據所獲取的建立卷的規範資訊實現卷的建立操作；
    7. 當成功的建立卷之後，完成卷建立之後的通知操作；
    """

    # flow_name：volume_create_manager；
    flow_name = ACTION.replace(":", "_") + "_manager"
    # 獲取類Flow的例項化物件；
    volume_flow = linear_flow.Flow(flow_name)

    # Determine if we are allowed to reschedule since this affects how
    # failures will be handled.
    # 首先要確定我們是否允許進行重新排程，因為這影響了我們如何對出現錯誤的情況進行處理；
    if not filter_properties:
        filter_properties = {}
    if not request_spec and allow_reschedule:
        LOG.debug(_("No request spec, will not reschedule"))
        allow_reschedule = False
    if not filter_properties.get('retry', None) and allow_reschedule:
        LOG.debug(_("No retry filter property or associated "
                    "retry info, will not reschedule"))
        allow_reschedule = False

    # 新增一個給定的task到flow；
    # 這個類實現了注入字典資訊到flow中；
    volume_flow.add(base.InjectTask({
        'filter_properties': filter_properties,
        'image_id': image_id,
        'request_spec': request_spec,
        'snapshot_id': snapshot_id,
        'source_volid': source_volid,
        'volume_id': volume_id,
    }, addons=[ACTION]))

    # 如果不允許進行重新排程的操作；
    if not allow_reschedule:
        # On failure ensure that we just set the volume status to error.
        LOG.debug(_("Retry info not present, will not reschedule"))
        # 新增一個給定的task到flow；
        # 這個task實現了當出現錯誤時，設定指定id的卷的狀態為ERROR；
        volume_flow.add(OnFailureChangeStatusTask(db))
    # 如果允許進行重新排程的操作；
    else:
        # 新增一個給定的task到flow；
        # 觸發一個傳送進行重新排程的請求，當進行task恢復回滾操作的時候；
        volume_flow.add(OnFailureRescheduleTask(reschedule_context, db, scheduler_rpcapi))

    # 新增一個給定的task到flow；
    # 提取一個用於建立卷的通用結構規範；
    volume_flow.add(ExtractVolumeSpecTask(db))
    # 新增一個給定的task到flow；
    # 執行關於給定卷的相關通知操作，獲取指定卷的使用率資訊，並進行通知操作；
    volume_flow.add(NotifyVolumeActionTask(db, host, "create.start"))
    # 新增一個給定的task到flow；
    # 根據所提供的規範要求實現卷的建立操作；
    volume_flow.add(CreateVolumeFromSpecTask(db, host, driver))
    # 新增一個給定的task到flow；
    # 當成功的建立卷之後，完成卷建立之後的通知操作；
    volume_flow.add(CreateVolumeOnFinishTask(db, host, "create.end"))

    # 獲取flow的除錯資訊；
    return flow_utils.attach_debug_listeners(volume_flow)

class CreateVolumeFromSpecTask(base.CinderTask):
    """
    根據所提供的規範要求實現卷的建立操作；
    """

    def __init__(self, db, host, driver):
        super(CreateVolumeFromSpecTask, self).__init__(addons=[ACTION])
        self.db = db
        self.driver = driver
        self.requires.update(['volume_spec', 'volume_ref'])
        self._create_func_mapping = {
            'raw': self._create_raw_volume,
            'snap': self._create_from_snapshot,
            'source_vol': self._create_from_source_volume,
            'image': self._create_from_image,
        }
        self.host = host

    def __call__(self, context, volume_ref, volume_spec):
        """
        根據所提供的規範要求實現卷的建立操作；
        """
        if not self.driver.initialized:
            LOG.error(_("Unable to create volume, driver not initialized"))
            driver_name = self.driver.__class__.__name__
            raise exception.DriverNotInitialized(driver=driver_name)

        # 獲取建立卷的型別資訊；
        create_type = volume_spec.pop('type', None)
        
        # 根據具體的建立卷的型別，獲取對應的建立卷的方法；
        # self._create_func_mapping = {
        #    'raw': self._create_raw_volume,
        #    'snap': self._create_from_snapshot,
        #    'source_vol': self._create_from_source_volume,
        #    'image': self._create_from_image,
        # }
        create_functor = self._create_func_mapping.get(create_type)
        
        if not create_functor:
            raise exception.VolumeTypeNotFound(volume_type_id=create_type)

        volume_spec = dict(volume_spec)
        volume_id = volume_spec.pop('volume_id', None)
        if not volume_id:
            volume_id = volume_ref['id']
        LOG.info(_("Volume %(volume_id)s: being created using %(functor)s "
                   "with specification: %(volume_spec)s") %
                 {'volume_spec': volume_spec, 'volume_id': volume_id,
                  'functor': _make_pretty_name(create_functor)})

        volume_ref['host'] = self.host

        # 根據確定的要呼叫的建立卷的方法，呼叫這個方法實現指定型別的卷的建立操作；
        model_update = create_functor(context, volume_ref=volume_ref,
                                      **volume_spec)

        try:
            if model_update:
                volume_ref = self.db.volume_update(context, volume_ref['id'], model_update)
        except exception.CinderException as ex:
            if model_update:
                LOG.exception(_("Failed updating model of volume %(volume_id)s"
                                " with creation provided model %(model)s") %
                              {'volume_id': volume_id, 'model': model_update})
                raise exception.ExportFailure(reason=ex)

        model_update = None
        try:
            LOG.debug(_("Volume %s: creating export"), volume_ref['id'])
            # 為邏輯卷建立匯出介面；
            model_update = self.driver.create_export(context, volume_ref)
            if model_update:
                self.db.volume_update(context, volume_ref['id'], model_update)
        except exception.CinderException as ex:
            if model_update:
                LOG.exception(_("Failed updating model of volume %(volume_id)s"
                              " with driver provided model %(model)s") %
                              {'volume_id': volume_id, 'model': model_update})
                raise exception.ExportFailure(reason=ex)

        self._create_func_mapping = {
            'raw': self._create_raw_volume,
            'snap': self._create_from_snapshot,
            'source_vol': self._create_from_source_volume,
            'image': self._create_from_image,
        }

這裡就指明瞭建立新卷的四種途徑，即直接建立raw格式的新卷、從快照建立新卷、從已有的卷建立新卷和從映象建立新卷。在上述類的__call__方法中，根據具體情況分別呼叫了不用的方法實現了新卷的建立，我們來看看這幾個建立新卷的方法的原始碼：

    def _create_raw_volume(self, context, volume_ref, **kwargs):
        """
        實現raw格式卷的建立；
        """
        return self.driver.create_volume(volume_ref)

    def _create_from_snapshot(self, context, volume_ref, snapshot_id,
                              **kwargs):
        """
        實現從快照建立卷的操作，並根據具體情況實現對指定卷的glance元資料進行更新操作；
        """
        volume_id = volume_ref['id']
        # 獲取指定卷的快照；
        snapshot_ref = self.db.snapshot_get(context, snapshot_id)
        # 呼叫具體驅動中的create_volume_from_snapshot方法，實現從快照建立卷；
        model_update = self.driver.create_volume_from_snapshot(volume_ref,
                                                               snapshot_ref)
        make_bootable = False
        try:
            # 根據volume_id獲取volume；
            originating_vref = self.db.volume_get(context, snapshot_ref['volume_id'])
            make_bootable = originating_vref.bootable
        except exception.CinderException as ex:
            LOG.exception(_("Failed fetching snapshot %(snapshot_id)s bootable"
                            " flag using the provided glance snapshot "
                            "%(snapshot_ref_id)s volume reference") %
                          {'snapshot_id': snapshot_id,
                           'snapshot_ref_id': snapshot_ref['volume_id']})
            raise exception.MetadataUpdateFailure(reason=ex)
        if make_bootable:
            # 根據具體情況實現對指定卷的glance元資料進行更新操作；
            self._handle_bootable_volume_glance_meta(context, volume_id,
                                                     snapshot_id=snapshot_id)
        return model_update

    def _create_from_source_volume(self, context, volume_ref,
                                   source_volid, **kwargs):
        """
        實現從源卷建立（實際上就是直接拷貝）卷的操作；
        """        
        # 根據source_volid獲取卷的資訊；
        srcvol_ref = self.db.volume_get(context, source_volid)
        # 建立指定卷的克隆；
        model_update = self.driver.create_cloned_volume(volume_ref, srcvol_ref)
        
        # 根據具體情況實現對指定卷的glance元資料進行更新操作；
        if srcvol_ref.bootable:
            self._handle_bootable_volume_glance_meta(context, volume_ref['id'],
                                                     source_volid=source_volid)
        return model_update

    def _create_from_image(self, context, volume_ref,
                           image_location, image_id, image_meta,
                           image_service, **kwargs):
        """
        從映象實現卷的建立；
        """
        LOG.debug(_("Cloning %(volume_id)s from image %(image_id)s "
                    " at location %(image_location)s") %
                  {'volume_id': volume_ref['id'],
                   'image_location': image_location, 'image_id': image_id})
        
        # 從現有的映象有效的建立一個卷；
        model_update, cloned = self.driver.clone_image(volume_ref, image_location, image_id)
        
        # 如果沒有實現克隆，說明沒有指定的映象；
        # 實現建立卷，並下載映象資料到卷中；
        if not cloned:
            # 實現建立卷，並下載映象資料到卷中；
            model_update = self.driver.create_volume(volume_ref)
            updates = dict(model_update or dict(), status='downloading')
            # 更新卷的狀態；
            try:
                volume_ref = self.db.volume_update(context,
                                                   volume_ref['id'], updates)
            except exception.CinderException:
                LOG.exception(_("Failed updating volume %(volume_id)s with "
                                "%(updates)s") %
                              {'volume_id': volume_ref['id'],
                               'updates': updates})
            # 下載glance映象資料到指定的卷；
            self._copy_image_to_volume(context, volume_ref, image_id, image_location, image_service)

        # 根據具體情況實現對指定卷的glance元資料進行更新操作；
        self._handle_bootable_volume_glance_meta(context, volume_ref['id'],
                                                 image_id=image_id,
                                                 image_meta=image_meta)
        return model_update

OK！到此為止，cinder中建立新卷的整體流程的原始碼分析已經全部完成，其實我想說的一句話就是，如果真的把這個流程的實現過程搞清楚，那麼cinder模組的原始碼也就基本掌握了。

謝謝大家的支援！