调用/glance/api/v2/images.py文件中ImagesController类下的create方法

# 获取对应后端对镜像的操作对象
image_factory = self.gateway.get_image_factory(req.context)
    ->  # `glance.location.ImageFactoryProxy`：存储位置处理。
  ->    # `glance.quota.ImageFactoryProxy`：存储配额处理。
  ->    # `policy.ImageFactoryProxy`：存储策略处理。
  ->    # `glance.notifier.ImageFactoryProxy`：存储消息通知处理。
  ->    # `glance.*.ImageFactoryProxy`四个类均继承自工厂类`/glance/domain/proxy.py`文件中的`ImageFactory`类，
        # 工厂类是用来创建封装镜像对象的，子类实现权限检查、消息通知、策略检查、配额检查等功能。
  ->    # `glance.*.ImageFactoryProxy`四个类依赖`glance.*.ImageProxy`类，`glance.*.ImageProxy`均继承
        # 自`/glance/domain/proxy.py`文件中的`Image`类，而`Image`类描述了镜像的基本属性信息，`glance.*.Image
        # Proxy`类是对`Image`类的扩展。
# get_image_factory实现
def get_image_factory(self, context):
        image_factory = glance.domain.ImageFactory()
    store_image_factory = glance.location.ImageFactoryProxy(image_factory, context, ....)
    quota_image_factory = glance.quota.ImageFactoryProxy(store_image_factory, context, ...)
    policy_image_factory = policy.ImageFactoryProxy(quota_image_factory, context, ...)
    notifier_image_factory = glance.notifier.ImageFactoryProxy(policy_image_factory, context, ...)
    if property_utils.is_property_protection_enabled():
            property_rules = property_utils.PropertyRules(self.policy)
            pif = property_protections.ProtectedImageFactoryProxy(notifier_image_factory, context, ...)
            authorized_image_factory = authorization.ImageFactoryProxy(pif, context)
    else:
        authorized_image_factory = authorization.ImageFactoryProxy(notifier_image_factory, context) 
    return authorized_image_factory
# 创建新的镜像-调用入口
image = image_factory.new_image(extra_properties=extra_properties, tags=tags, **image)
    ->  # 以下文件均是在glance目录下。该过程采用的是责任链调用模式。
    ->  # image_factory.new_image(...)首先调用`api.authorization.ImageFactoryProxy.new_image`。
  ->    # `api.authorization.ImageFactoryProxy.new_image(...)`调用`domain.proxy.ImageFactory.new_image`。
  ->    # `domain.proxy.ImageFactory.new_image(...)`调用`notifier.ImageFactoryProxy.new_image`。
  ->    # `notifier.ImageFactoryProxy.new_image(...)`调用`domain.proxy.ImageFactory.new_image`。
  ->    #   `domain.proxy.ImageFactory.new_image(...)`调用`api.policy.ImageFactoryProxy.new_image`。
  ->    #   `api.policy.ImageFactoryProxy.new_image(...)`调用`domain.proxy.ImageFactory.new_image`。
  ->    #   `domain.proxy.ImageFactory.new_image(...)`调用`quota.ImageFactoryProxy.new_image`。
  ->    #   `quota.ImageFactoryProxy.new_image(...)`调用`domain.proxy.ImageFactory.new_image`。
  ->    #   `domain.proxy.ImageFactory.new_image(...)`调用`location.ImageFactoryProxy.new_image`。
  ->    #   `location.ImageFactoryProxy.new_image(...)`调用`domain.proxy.ImageFactory.new_image`。
  ->    #   `domain.proxy.ImageFactory.new_image(...)`调用`domain.ImageFactory.new_image`。
  ->    # 通过`domain.ImageFactory.new_image(...)`生成Image对象并返回。
# 数据库操作对象，image_repo流程和image_factory类似
image_repo = self.gateway.get_repo(req.context)
# 镜像数据库操作
image_repo.add(image)

调用/glance/api/v2/image_data.py文件中ImageDataController类下的upload方法

# 获取存储后端类型，例如：CONF.glance_store.default_backend配置为rbd
backend = req.headers.get('x-image-meta-store', CONF.glance_store.default_backend)
# 更新数据库内容
image_repo.save(image, from_state='queued')
# 调用存储
image.set_data(data, size, backend=backend)
# 只对存储操作进行说明，数据库操作不做说明，具体和调用存储的逻辑一致
    -> # 以下文件均是在glance目录下。该过程采用的是责任链调用模式。
  -> # 调用的都是`glance.*.ImageProxy`下的`set_data(...)`方法。
  -> # 最后调用的是`location.ImageProxy`下的`set_data`方法。
  -> # 在模块下分别处理权限，通知，策略，配额，存储等处理。

调用/glance/location.py文件中ImageProxy类下的set_data方法

# 主要调用下面的方法
(location, size, checksum, multihash, loc_meta) = self.store_api.add_with_multihash(CONF, ...)
# 方法指向
self.store_api = store_api or glance_store   # store_api=None，即self.store_api=glance_store

调用/glance_store/multi_backend.py文件中的add_with_multihash方法

# 获取存储后端类型，配置的为rbd类型
if not backend:
        backend = conf.glance_store.default_backend
# 加载存储驱动并获取
store = get_store_from_store_identifier(backend)    # store即为`glance_store._drivers.rbd.Store`实例化对象
# 然后执行并返回
store_add_to_backend_with_multihash(..., store, ...)
    -> # 执行`store.add(...)`进行存储镜像

调用/glance_store/_drivers/rbd.py文件中Store类下的add方法

# 获取rados连接
with self.get_connection(conffile=self.conf_file, rados_id=self.user) as conn:
# 存储主要是下面的方法
with rbd.Image(ioctx, image_name) as image:
    bytes_written = 0
    offset = 0
    chunks = utils.chunkreadable(image_file, self.WRITE_CHUNKSIZE)
    for chunk in chunks:
            chunk_length = len(chunk)
            self.size = self._resize_on_write(image, image_size, bytes_written, chunk_length)
            bytes_written += chunk_length
            if not (self.thin_provisioning and not any(chunk)):
                image.write(chunk, offset)
        offset += chunk_length
        os_hash_value.update(chunk)
        checksum.update(chunk)
        if verifier:
                verifier.update(chunk)
        if image_size == 0:
            image.resize(bytes_written)
        if loc.snapshot:
            image.create_snap(loc.snapshot)
            image.protect_snap(loc.snapshot)
# 其中向后端存储设备写入数据的是通过`image.write(chunk, offset)`方法写入, 其中`image`为`rbd.c`的对象。