openstack 创建快照(create snapshot)过程源码分析-凯发app官方网站

1. # note(melwitt): we don't check instance lock for snapshot because lock is
   
2.     # intended to prevent accidental change/delete of instances
   
3.     @wrap_check_policy
   
4.     @check_instance_cell
   
5.     @check_instance_state(vm_state=[vm_states.active, vm_states.stopped,
   
6.                                     vm_states.paused, vm_states.suspended])
   
7.     def snapshot(self, context, instance, name, extra_properties=none):
   
8.         """snapshot the given instance.
   
9. 
   
10.         :param instance: nova.db.sqlalchemy.models.instance
    
11.         :param name: name of the snapshot
    
12.         :param extra_properties: dict of extra image properties to include
    
13.                                  when creating the image.
    
14.         :returns: a dict containing image metadata
    
15.         """
16.        #调用glance api创建image entry，为后将snapshot上传为镜像做准备，虽然镜像和snapshot在可以上传到glance作为镜像启动虚拟机，
17.        #但是为了区分二者的不同，glance将镜像和snapshot标记卫不同的类型：type=image 和 type=snapshot
    
18.         image_meta = self._create_image(context, instance, name,
    
19.                                         'snapshot',
    
20.                                         extra_properties=extra_properties)
    
21. 
    
22.         # note(comstud): any changes to this method should also be made
    
23.         # to the snapshot_instance() method in nova/cells/messaging.py
24.         # 将任务状态(task state) 设置为:image_snapshot_pending
    
25.         instance.task_state = task_states.image_snapshot_pending
    
26.         instance.save(expected_task_state=[none])
    
27.         #通过rpc调用nova/compute/rpcapi.py的snapshot_instance函数
    
28.         self.compute_rpcapi.snapshot_instance(context, instance,
    
29.                                               image_meta['id

1. #梳理下流程： （1）用户发起create snapshot的请求; （2）nova-api服务接收到这个请求并进行前期处理，即3.1中代码的处理流程;
2.                             （3）真正的snapshot操作是需要在nova-compute节点上执行的，所以nova-api需要向nova-compute发送message
3. #由于openstack环境中会有很多个nova-compute,所以需要通过server=_compute_host(none, instance)来获取虚拟机所在的host，并向其发送message。
4. def snapshot_instance(self, ctxt, instance, image_id):
   
5.         version = '3.0'
   
6.         cctxt = self.client.prepare(server=_compute_host(none, instance),
   
7.                 version=version)
   
8.         cctxt.cast(ctxt, 'snapshot_instance',
   
9.                    instance=instance,
   
10.                    image_id=image_id)

2.  def snapshot(self, context, instance, image_id, update_task_state):
   
3.         """create snapshot from a running vm instance.
   
4. 
   
5.         this command only works with qemu 0.14
   
6.         """
   
7.         try:
   
8.             virt_dom = self._get_domain(instance)
   
9.         except exception.instancenotfound:
   
10.             raise exception.instancenotrunning(instance_id=instance['uuid'])
    
11. 
    
12.         base_image_ref = instance['image_ref']
    
13. 
    
14.         base = compute_utils.get_image_metadata(
    
15.             context, self._image_api, base_image_ref, instance)
    
16. 
    
17.         snapshot = self._image_api.get(context, image_id)
    
18. 
    
19.         disk_path = libvirt_utils.find_disk(virt_dom)
    
20.         source_format = libvirt_utils.get_disk_type(disk_path)
    
21. 
    
22.         image_format = conf.libvirt.snapshot_image_format or source_format
    
23. 
    
24.         # note(bfilippov): save lvm and rbd as raw
    
25.         if image_format == 'lvm' or image_format == 'rbd':
    
26.             image_format = 'raw'
    
27. 
    
28.         metadata = self._create_snapshot_metadata(base,
    
29.                                                   instance,
    
30.                                                   image_format,
    
31.                                                   snapshot['name'])
    
32. 
    
33.         snapshot_name = uuid.uuid4().hex
    
34. 
    
35.         state = libvirt_power_state[virt_dom.info()[0]]
    
36. 
    
37.         # note(rmk): live snapshots require qemu 1.3 and libvirt 1.0.0.
    
38.         # these restrictions can be relaxed as other configurations
    
39.         # can be validated.
    
40.         # note(dgenin): instances with lvm encrypted ephemeral storage require
    
41.         # cold snapshots. currently, checking for encryption is
    
42.         # redundant because lvm supports only cold snapshots.
    
43.         # it is necessary in case this situation changes in the
    
44.         # future.
45.         #这里需要注意，解释了为啥现在是cold snapshot而不是live snapshot:
46.         # 有人提过live snapshot的bug，社区认为live snapshot目前不稳定，所以默认条件下采用cold snapshot，并且是通过硬编码来实现的
47.         # 看下面这个判断条件，成立的时候将live_snapshot = true,其中min_libvirt_livesnapshot_version=1.3.0, 其实现在libvirt的最新版本
    
48.         # 才到1.2.11， 所以这个live_snapshot的条件不满足，就变成了cold_snapshot
    
49.         if (self._host.has_min_version(min_libvirt_livesnapshot_version,
    
50.                                        min_qemu_livesnapshot_version,
    
51.                                        req_hypervisor_livesnapshot)
    
52.              and source_format not in ('lvm', 'rbd')
    
53.              and not conf.ephemeral_storage_encryption.enabled):
    
54.             live_snapshot = true
    
55.             # abort is an idempotent operation, so make sure any block
    
56.             # jobs which may have failed are ended. this operation also
    
57.             # confirms the running instance, as opposed to the system as a
    
58.             # whole, has a new enough version of the hypervisor (bug 1193146).
    
59.             try:
    
60.                 virt_dom.blockjobabort(disk_path, 0)
    
61.             except libvirt.libvirterror as ex:
    
62.                 error_code = ex.get_error_code()
    
63.                 if error_code == libvirt.vir_err_config_unsupported:
    
64.                     live_snapshot = false
    
65.                 else:
    
66.                     pass
    
67.         else:
    
68.             live_snapshot = false
    
69. 
    
70.         # note(rmk): we cannot perform live snapshots when a managedsave
    
71.         # file is present, so we will use the cold/legacy method
    
72.         # for instances which are shutdown.
    
73.         if state == power_state.shutdown:
    
74.             live_snapshot = false
    
75. 
    
76.         # note(dkang): managedsave does not work for lxc
77.         #注意这里，如果live_snashot目前是false,所以在做snapshot之前先要执行：
78.         #（1）_detach_pci_devices， 卸载虚拟机挂载的pci设备，比如数据盘
79.         #（2）  self._detach_sriov_ports， 卸载虚拟机挂载的sriov设备，比如支持sriov的网卡设备
    
80.         if conf.libvirt.virt_type != 'lxc' and not live_snapshot:
    
81.             if state == power_state.running or state == power_state.paused:
    
82.                 self._detach_pci_devices(virt_dom,
    
83.                     pci_manager.get_instance_pci_devs(instance))
    
84.                 self._detach_sriov_ports(instance, virt_dom)
    
85.                 virt_dom.managedsave(0)
    
86.         #判断虚拟机的后端存储是什么，不同的后端存储做snapshot是不同的，本地文件系统的化，默认qcow2
    
87.         snapshot_backend = self.image_backend.snapshot(instance,
    
88.                 disk_path,
    
89.                 image_type=source_format)
    
90. 
    
91.         if live_snapshot:
    
92.             log.info(_li("beginning live snapshot process"),
    
93.                      instance=instance)
    
94.         else:
    
95.             log.info(_li("beginning cold snapshot process"),
    
96.                      instance=instance)
    
97.         #更新任务的状态为：image_pending_upload, 大家都知道做完snapshot要上传
    
98.         update_task_state(task_state=task_states.image_pending_upload)
99.         #目前做快照的过程是：
100.         #（1）现在../data/nova/instance/snapshots目录下生成临时目录，比如nova/instances/snapshots/tmpthr585
101.         #（2）然后将快照生成到这个目录，具体参见snapshot_backend.snapshot_extract(out_path, image_format)这个函数
102.         #（3）生成完成后，通过glance api上传，具体参见 self._image_api.update
103.         snapshot_directory = conf.libvirt.snapshots_directory
     
104.         fileutils.ensure_tree(snapshot_directory)
     
105.         with utils.tempdir(dir=snapshot_directory) as tmpdir:
     
106.             try:
     
107.                 out_path = os.path.join(tmpdir, snapshot_name)
     
108.                 if live_snapshot:
     
109.                     # note(xqueralt): libvirt needs ox in the temp directory
     
110.                     os.chmod(tmpdir, 0o701)
     
111.                     self._live_snapshot(context, instance, virt_dom, disk_path,
     
112.                                         out_path, image_format, base)
     
113.                 else:
114.                     #这个函数实际执行了一条命令： qemu-img convert -f qcow2 -o qcow2  disk_path out_path,算是生成了快照
     
115.                     snapshot_backend.snapshot_extract(out_path, image_format)
     
116.             finally:
     
117.                 new_dom = none
     
118.                 # note(dkang): because previous managedsave is not called
     
119.                 # for lxc, _create_domain must not be called.
     
120.                 if conf.libvirt.virt_type != 'lxc' and not live_snapshot:
     
121.                     if state == power_state.running:
     
122.                         new_dom = self._create_domain(domain=virt_dom)   ##恢复做快照之前虚拟机的状态
     
123.                     elif state == power_state.paused:
     
124.                         new_dom = self._create_domain(domain=virt_dom,
     
125.                                 launch_flags=libvirt.vir_domain_start_paused)
     
126.                     if new_dom is not none:
     
127.                         self._attach_pci_devices(new_dom,
     
128.                             pci_manager.get_instance_pci_devs(instance))
     
129.                         self._attach_sriov_ports(context, instance, new_dom)
     
130.                 log.info(_li("snapshot extracted, beginning image upload"),
     
131.                          instance=instance)
     
132. 
     
133.             # upload that image to the image service
     
134. 
     
135.             update_task_state(task_state=task_states.image_uploading,
     
136.                      expected_state=task_states.image_pending_upload)
     
137.             with libvirt_utils.file_open(out_path) as image_file:       ###将生成的快照上传到glance
     
138.                 self._image_api.update(context,
     
139.                                        image_id,
     
140.                                        metadata,
     
141.                                        image_file)
     
142.                 log.info(_li("snapshot image upload complete"),
     
143.                          instance=instance)

------------------------------------------------------------
   email: ustc.dylan@gmail.com
   微博：@marshal-liu
------------------------------------------------------------