glance上传镜像源码流程分析

1. 调用/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)
   

2. 调用/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`方法。
     -> # 在模块下分别处理权限，通知，策略，配额，存储等处理。
   

3. 调用/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
   

4. 调用/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(...)`进行存储镜像
   

5. 调用/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`的对象。