【译】OpenStack 虚拟机创建的请求流程

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

def _build_and_run_instance:
    ...
    with self._build_resources(context, instance,
         requested_networks, security_groups, image_meta,
         block_device_mapping, provider_mapping,
         accel_uuids) as resources:
    instance.vm_state = vm_states.BUILDING
    instance.task_state = task_states.SPAWNING
    # NOTE(JoshNang) This also saves the changes to the
    # instance from _allocate_network_async, as they aren't
    # saved in that function to prevent races.
    instance.save(expected_task_state=
             task_states.BLOCK_DEVICE_MAPPING)
    block_device_info = resources['block_device_info']
    network_info = resources['network_info']
    accel_info = resources['accel_info']
    LOG.debug('Start spawning the instance on the hypervisor.',instance=instance)

1
2
3
4
5
6

LOG.debug('Start building networks asynchronously for instance.',
                      instance=instance)
network_info = self._build_networks_for_instance(context, instance,
                    requested_networks, security_groups,
                    resource_provider_mapping, network_arqs)
resources['network_info'] = network_info

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

# Verify that all the BDMs have a device_name set and assign a
# default to the ones missing it with the help of the driver.
self._default_block_device_names(instance, image_meta,
                                             block_device_mapping)

LOG.debug('Start building block device mappings for instance.',
                      instance=instance)
instance.vm_state = vm_states.BUILDING
instance.task_state = task_states.BLOCK_DEVICE_MAPPING
instance.save()

block_device_info = self._prep_block_device(context, instance,
                    block_device_mapping)
resources['block_device_info'] = block_device_info

1
2
3
4
5
6
7
8

self.driver.spawn(context, instance, image_meta,
                  injected_files, admin_password,
                  allocs, network_info=network_info,
 				  block_device_info=block_device_info,
                  accel_info=accel_info)
LOG.info('Took %0.2f seconds to spawn the instance on '
                             'the hypervisor.', timer.elapsed(),
                             instance=instance)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

    def spawn(self, context, instance, image_meta, injected_files,
              admin_password, allocations, network_info=None,
              block_device_info=None, power_on=True, accel_info=None):
        disk_info = blockinfo.get_disk_info(CONF.libvirt.virt_type,
                                            instance,
                                            image_meta,
                                            block_device_info)
        injection_info = InjectionInfo(network_info=network_info,
                                       files=injected_files,
                                       admin_pass=admin_password)
        gen_confdrive = functools.partial(self._create_configdrive,
                                          context, instance,
                                          injection_info)
        created_instance_dir, created_disks = self._create_image(
                context, instance, disk_info['mapping'],
                injection_info=injection_info,
                block_device_info=block_device_info)

        # Required by Quobyte CI
        self._ensure_console_log_for_instance(instance)

        # Does the guest need to be assigned some vGPU mediated devices ?
        mdevs = self._allocate_mdevs(allocations)

        # If the guest needs a vTPM, _get_guest_xml needs its secret to exist
        # and its uuid to be registered in the instance prior to _get_guest_xml
        if CONF.libvirt.swtpm_enabled and hardware.get_vtpm_constraint(
            instance.flavor, image_meta
        ):
            if not instance.system_metadata.get('vtpm_secret_uuid'):
                # Create the secret via the key manager service so that we have
                # it to hand when generating the XML. This is slightly wasteful
                # as we'll perform a redundant key manager API call later when
                # we create the domain but the alternative is an ugly mess
                crypto.ensure_vtpm_secret(context, instance)

        xml = self._get_guest_xml(context, instance, network_info,
                                  disk_info, image_meta,
                                  block_device_info=block_device_info,
                                  mdevs=mdevs, accel_info=accel_info)
        self._create_guest_with_network(
            context, xml, instance, network_info, block_device_info,
            post_xml_callback=gen_confdrive,
            power_on=power_on,
            cleanup_instance_dir=created_instance_dir,
            cleanup_instance_disks=created_disks)
        LOG.debug("Guest created on hypervisor", instance=instance)