1.nova/api/openstack/compute/servers.py create()
在create函数前面包含三种装饰器,分别为:@wsgi.response、@wsgi.expected_errors、@validation.schema
(1)@wsgi.response属于限制装饰器,限制请求完成后的成功状态码202
(2)@wsgi.expected_errors属于限制装饰器,限制请求完成后的失败状态码400、403、409
(3)@validation.schema属于验证装饰器,在请求create函数开始前拦截http请求,对http请求中的参数进行校验,若校验成功则进入create,若失败则返回失败状态码,此装饰器主要功能是进行版本兼容
create函数中主要分为两个功能
(1)收集并校验参数,为后续创建虚拟机做准备
(2)调用nova/compute/api.py中的create()函数,此函数的主要功能是提供实例并将实例信息发送给调度器
1 @wsgi.response(202)
2 @wsgi.expected_errors((400, 403, 409))
3 @validation.schema(schema_servers.base_create_v20, '2.0', '2.0')
4 @validation.schema(schema_servers.base_create, '2.1', '2.18')
5 @validation.schema(schema_servers.base_create_v219, '2.19', '2.31')
6 @validation.schema(schema_servers.base_create_v232, '2.32', '2.32')
7 @validation.schema(schema_servers.base_create_v233, '2.33', '2.36')
8 @validation.schema(schema_servers.base_create_v237, '2.37', '2.41')
9 @validation.schema(schema_servers.base_create_v242, '2.42', '2.51')
10 @validation.schema(schema_servers.base_create_v252, '2.52', '2.56')
11 @validation.schema(schema_servers.base_create_v257, '2.57', '2.62')
12 @validation.schema(schema_servers.base_create_v263, '2.63', '2.66')
13 @validation.schema(schema_servers.base_create_v267, '2.67', '2.73')
14 @validation.schema(schema_servers.base_create_v274, '2.74')
15 def create(self, req, body):
16 """Creates a new server for a given user."""
17 context = req.environ['nova.context']
18 server_dict = body['server']
19 password = self._get_server_admin_password(server_dict)
20 name = common.normalize_name(server_dict['name'])
21 description = name
22 if api_version_request.is_supported(req, min_version='2.19'):
23 description = server_dict.get('description')
24
25 # Arguments to be passed to instance create function
26 create_kwargs = {}
27
28 create_kwargs['user_data'] = server_dict.get('user_data')
29 # NOTE(alex_xu): The v2.1 API compat mode, we strip the spaces for
30 # keypair create. But we didn't strip spaces at here for
31 # backward-compatible some users already created keypair and name with
32 # leading/trailing spaces by legacy v2 API.
33 create_kwargs['key_name'] = server_dict.get('key_name')
34 create_kwargs['config_drive'] = server_dict.get('config_drive')
35 security_groups = server_dict.get('security_groups')
36 if security_groups is not None:
37 create_kwargs['security_groups'] = [
38 sg['name'] for sg in security_groups if sg.get('name')]
39 create_kwargs['security_groups'] = list(
40 set(create_kwargs['security_groups']))
41
42 scheduler_hints = {}
43 if 'os:scheduler_hints' in body:
44 scheduler_hints = body['os:scheduler_hints']
45 elif 'OS-SCH-HNT:scheduler_hints' in body:
46 scheduler_hints = body['OS-SCH-HNT:scheduler_hints']
47 create_kwargs['scheduler_hints'] = scheduler_hints
48
49 # min_count and max_count are optional. If they exist, they may come
50 # in as strings. Verify that they are valid integers and > 0.
51 # Also, we want to default 'min_count' to 1, and default
52 # 'max_count' to be 'min_count'.
53 min_count = int(server_dict.get('min_count', 1))
54 max_count = int(server_dict.get('max_count', min_count))
55 if min_count > max_count:
56 msg = _('min_count must be <= max_count')
57 raise exc.HTTPBadRequest(explanation=msg)
58 create_kwargs['min_count'] = min_count
59 create_kwargs['max_count'] = max_count
60
61 availability_zone = server_dict.pop("availability_zone", None)
62
63 if api_version_request.is_supported(req, min_version='2.52'):
64 create_kwargs['tags'] = server_dict.get('tags')
65
66 helpers.translate_attributes(helpers.CREATE,
67 server_dict, create_kwargs)
68
69 target = {
70 'project_id': context.project_id,
71 'user_id': context.user_id,
72 'availability_zone': availability_zone}
73 context.can(server_policies.SERVERS % 'create', target)
74
75 # Skip policy check for 'create:trusted_certs' if no trusted
76 # certificate IDs were provided.
77 trusted_certs = server_dict.get('trusted_image_certificates', None)
78 if trusted_certs:
79 create_kwargs['trusted_certs'] = trusted_certs
80 context.can(server_policies.SERVERS % 'create:trusted_certs',
81 target=target)
82
83 parse_az = self.compute_api.parse_availability_zone
84 try:
85 availability_zone, host, node = parse_az(context,
86 availability_zone)
87 except exception.InvalidInput as err:
88 raise exc.HTTPBadRequest(explanation=six.text_type(err))
89 if host or node:
90 context.can(server_policies.SERVERS % 'create:forced_host', {})
91
92 if api_version_request.is_supported(req, min_version='2.74'):
93 self._process_hosts_for_create(context, target, server_dict,
94 create_kwargs, host, node)
95
96 self._process_bdms_for_create(
97 context, target, server_dict, create_kwargs)
98
99 image_uuid = self._image_from_req_data(server_dict, create_kwargs)
100
101 self._process_networks_for_create(
102 context, target, server_dict, create_kwargs)
103
104 flavor_id = self._flavor_id_from_req_data(body)
105 try:
106 inst_type = flavors.get_flavor_by_flavor_id(
107 flavor_id, ctxt=context, read_deleted="no")
108
109 supports_multiattach = common.supports_multiattach_volume(req)
110 supports_port_resource_request = \
111 common.supports_port_resource_request(req)
112 (instances, resv_id) = self.compute_api.create(context,
113 inst_type,
114 image_uuid,
115 display_name=name,
116 display_description=description,
117 availability_zone=availability_zone,
118 forced_host=host, forced_node=node,
119 metadata=server_dict.get('metadata', {}),
120 admin_password=password,
121 check_server_group_quota=True,
122 supports_multiattach=supports_multiattach,
123 supports_port_resource_request=supports_port_resource_request,
124 **create_kwargs)
125 except (exception.QuotaError,
126 exception.PortLimitExceeded) as error:
127 raise exc.HTTPForbidden(
128 explanation=error.format_message())
129 except exception.ImageNotFound:
130 msg = _("Can not find requested image")
131 raise exc.HTTPBadRequest(explanation=msg)
132 except exception.KeypairNotFound:
133 msg = _("Invalid key_name provided.")
134 raise exc.HTTPBadRequest(explanation=msg)
135 except exception.ConfigDriveInvalidValue:
136 msg = _("Invalid config_drive provided.")
137 raise exc.HTTPBadRequest(explanation=msg)
138 except (exception.BootFromVolumeRequiredForZeroDiskFlavor,
139 exception.ExternalNetworkAttachForbidden) as error:
140 raise exc.HTTPForbidden(explanation=error.format_message())
141 except messaging.RemoteError as err:
142 msg = "%(err_type)s: %(err_msg)s" % {'err_type': err.exc_type,
143 'err_msg': err.value}
144 raise exc.HTTPBadRequest(explanation=msg)
145 except UnicodeDecodeError as error:
146 msg = "UnicodeError: %s" % error
147 raise exc.HTTPBadRequest(explanation=msg)
148 except (exception.ImageNotActive,
149 exception.ImageBadRequest,
150 exception.ImageNotAuthorized,
151 exception.FixedIpNotFoundForAddress,
152 exception.FlavorNotFound,
153 exception.FlavorDiskTooSmall,
154 exception.FlavorMemoryTooSmall,
155 exception.InvalidMetadata,
156 exception.InvalidVolume,
157 exception.MultiplePortsNotApplicable,
158 exception.InvalidFixedIpAndMaxCountRequest,
159 exception.InstanceUserDataMalformed,
160 exception.PortNotFound,
161 exception.FixedIpAlreadyInUse,
162 exception.SecurityGroupNotFound,
163 exception.PortRequiresFixedIP,
164 exception.NetworkRequiresSubnet,
165 exception.NetworkNotFound,
166 exception.InvalidBDM,
167 exception.InvalidBDMSnapshot,
168 exception.InvalidBDMVolume,
169 exception.InvalidBDMImage,
170 exception.InvalidBDMBootSequence,
171 exception.InvalidBDMLocalsLimit,
172 exception.InvalidBDMVolumeNotBootable,
173 exception.InvalidBDMEphemeralSize,
174 exception.InvalidBDMFormat,
175 exception.InvalidBDMSwapSize,
176 exception.VolumeTypeNotFound,
177 exception.AutoDiskConfigDisabledByImage,
178 exception.InstanceGroupNotFound,
179 exception.SnapshotNotFound,
180 exception.UnableToAutoAllocateNetwork,
181 exception.MultiattachNotSupportedOldMicroversion,
182 exception.CertificateValidationFailed,
183 exception.CreateWithPortResourceRequestOldVersion,
184 exception.ComputeHostNotFound) as error:
185 raise exc.HTTPBadRequest(explanation=error.format_message())
186 except INVALID_FLAVOR_IMAGE_EXCEPTIONS as error:
187 raise exc.HTTPBadRequest(explanation=error.format_message())
188 except (exception.PortInUse,
189 exception.InstanceExists,
190 exception.NetworkAmbiguous,
191 exception.NoUniqueMatch,
192 exception.VolumeTypeSupportNotYetAvailable) as error:
193 raise exc.HTTPConflict(explanation=error.format_message())
194
195 # If the caller wanted a reservation_id, return it
196 if server_dict.get('return_reservation_id', False):
197 return wsgi.ResponseObject({'reservation_id': resv_id})
198
199 server = self._view_builder.create(req, instances[0])
200
201 if CONF.api.enable_instance_password:
202 server['server']['adminPass'] = password
203
204 robj = wsgi.ResponseObject(server)
205
206 return self._add_location(robj)
第17行~第111行的功能为收集数据、校验数据将数据打包
第80行
context.can(server_policies.SERVERS % 'create', target)
最终调用nova/policy.py中authorize()
1 def authorize(context, action, target=None, do_raise=True, exc=None):
2 """Verifies that the action is valid on the target in this context.
3
4 :param context: nova context
5 :param action: string representing the action to be checked
6 this should be colon separated for clarity.
7 i.e. ``compute:create_instance``,
8 ``compute:attach_volume``,
9 ``volume:attach_volume``
10 :param target: dictionary representing the object of the action
11 for object creation this should be a dictionary representing the
12 location of the object e.g. ``{'project_id': instance.project_id}``
13 If None, then this default target will be considered:
14 {'project_id': self.project_id, 'user_id': self.user_id}
15 :param do_raise: if True (the default), raises PolicyNotAuthorized;
16 if False, returns False
17 :param exc: Class of the exception to raise if the check fails.
18 Any remaining arguments passed to :meth:`authorize` (both
19 positional and keyword arguments) will be passed to
20 the exception class. If not specified,
21 :class:`PolicyNotAuthorized` will be used.
22
23 :raises nova.exception.PolicyNotAuthorized: if verification fails
24 and do_raise is True. Or if 'exc' is specified it will raise an
25 exception of that type.
26
27 :return: returns a non-False value (not necessarily "True") if
28 authorized, and the exact value False if not authorized and
29 do_raise is False.
30 """
31 init()
32 credentials = context.to_policy_values()
33 if not exc:
34 exc = exception.PolicyNotAuthorized
35
36 # Legacy fallback for emtpy target from context.can()
37 # should be removed once we improve testing and scope checks
38 if target is None:
39 target = default_target(context)
40
41 try:
42 result = _ENFORCER.authorize(action, target, credentials,
43 do_raise=do_raise, exc=exc, action=action)
44 except policy.PolicyNotRegistered:
45 with excutils.save_and_reraise_exception():
46 LOG.exception(_LE('Policy not registered'))
47 except Exception:
48 with excutils.save_and_reraise_exception():
49 LOG.debug('Policy check for %(action)s failed with credentials '
50 '%(credentials)s',
51 {'action': action, 'credentials': credentials})
52 return result
第30行init()为一个初始化函数,主要功能是加载路由和配置文件
1 def init(policy_file=None, rules=None, default_rule=None, use_conf=True):
2 """Init an Enforcer class.
3
4 :param policy_file: Custom policy file to use, if none is specified,
5 `CONF.policy_file` will be used.
6 :param rules: Default dictionary / Rules to use. It will be
7 considered just in the first instantiation.
8 :param default_rule: Default rule to use, CONF.default_rule will
9 be used if none is specified.
10 :param use_conf: Whether to load rules from config file.
11 """
12
13 global _ENFORCER
14 global saved_file_rules
15
16 if not _ENFORCER:
17 _ENFORCER = policy.Enforcer(CONF,
18 policy_file=policy_file,
19 rules=rules,
20 default_rule=default_rule,
21 use_conf=use_conf)
22 register_rules(_ENFORCER)
23 _ENFORCER.load_rules()
24
25 # Only the rules which are loaded from file may be changed.
26 current_file_rules = _ENFORCER.file_rules
27 current_file_rules = _serialize_rules(current_file_rules)
28
29 # Checks whether the rules are updated in the runtime
30 if saved_file_rules != current_file_rules:
31 _warning_for_deprecated_user_based_rules(current_file_rules)
32 saved_file_rules = copy.deepcopy(current_file_rules)
第22行为注册路由功能(详情可参考源码)
跳转至nova/compute/api.py中create()方法
1 @hooks.add_hook("create_instance")
2 def create(self, context, instance_type,
3 image_href, kernel_id=None, ramdisk_id=None,
4 min_count=None, max_count=None,
5 display_name=None, display_description=None,
6 key_name=None, key_data=None, security_groups=None,
7 availability_zone=None, forced_host=None, forced_node=None,
8 user_data=None, metadata=None, injected_files=None,
9 admin_password=None, block_device_mapping=None,
10 access_ip_v4=None, access_ip_v6=None, requested_networks=None,
11 config_drive=None, auto_disk_config=None, scheduler_hints=None,
12 legacy_bdm=True, shutdown_terminate=False,
13 check_server_group_quota=False, tags=None,
14 supports_multiattach=False, trusted_certs=None,
15 supports_port_resource_request=False,
16 requested_host=None, requested_hypervisor_hostname=None):
17 """Provision instances, sending instance information to the
18 scheduler. The scheduler will determine where the instance(s)
19 go and will handle creating the DB entries.
20
21 Returns a tuple of (instances, reservation_id)
22 """
23 if requested_networks and max_count is not None and max_count > 1:
24 self._check_multiple_instances_with_specified_ip(
25 requested_networks)
26 if utils.is_neutron():
27 self._check_multiple_instances_with_neutron_ports(
28 requested_networks)
29
30 if availability_zone:
31 available_zones = availability_zones. \
32 get_availability_zones(context.elevated(), self.host_api,
33 get_only_available=True)
34 if forced_host is None and availability_zone not in \
35 available_zones:
36 msg = _('The requested availability zone is not available')
37 raise exception.InvalidRequest(msg)
38
39 filter_properties = scheduler_utils.build_filter_properties(
40 scheduler_hints, forced_host, forced_node, instance_type)
41
42 return self._create_instance(
43 context, instance_type,
44 image_href, kernel_id, ramdisk_id,
45 min_count, max_count,
46 display_name, display_description,
47 key_name, key_data, security_groups,
48 availability_zone, user_data, metadata,
49 injected_files, admin_password,
50 access_ip_v4, access_ip_v6,
51 requested_networks, config_drive,
52 block_device_mapping, auto_disk_config,
53 filter_properties=filter_properties,
54 legacy_bdm=legacy_bdm,
55 shutdown_terminate=shutdown_terminate,
56 check_server_group_quota=check_server_group_quota,
57 tags=tags, supports_multiattach=supports_multiattach,
58 trusted_certs=trusted_certs,
59 supports_port_resource_request=supports_port_resource_request,
60 requested_host=requested_host,
61 requested_hypervisor_hostname=requested_hypervisor_hostname)
整段代码主要对网络ip、端口进行校验,获取可用区列表检验可用区是否属于此列表,并根据条件筛选符合创建虚机所需的主机的条件,最后调用nova/compute/api.py中的_create_instance()方法
1 def _create_instance(self, context, instance_type,
2 image_href, kernel_id, ramdisk_id,
3 min_count, max_count,
4 display_name, display_description,
5 key_name, key_data, security_groups,
6 availability_zone, user_data, metadata, injected_files,
7 admin_password, access_ip_v4, access_ip_v6,
8 requested_networks, config_drive,
9 block_device_mapping, auto_disk_config, filter_properties,
10 reservation_id=None, legacy_bdm=True, shutdown_terminate=False,
11 check_server_group_quota=False, tags=None,
12 supports_multiattach=False, trusted_certs=None,
13 supports_port_resource_request=False,
14 requested_host=None, requested_hypervisor_hostname=None):
15 """Verify all the input parameters regardless of the provisioning
16 strategy being performed and schedule the instance(s) for
17 creation.
18 """
19
20 # Normalize and setup some parameters
21 if reservation_id is None:
22 reservation_id = utils.generate_uid('r')
23 security_groups = security_groups or ['default']
24 min_count = min_count or 1
25 max_count = max_count or min_count
26 block_device_mapping = block_device_mapping or []
27 tags = tags or []
28
29 if image_href:
30 image_id, boot_meta = self._get_image(context, image_href)
31 else:
32 # This is similar to the logic in _retrieve_trusted_certs_object.
33 if (trusted_certs or
34 (CONF.glance.verify_glance_signatures and
35 CONF.glance.enable_certificate_validation and
36 CONF.glance.default_trusted_certificate_ids)):
37 msg = _("Image certificate validation is not supported "
38 "when booting from volume")
39 raise exception.CertificateValidationFailed(message=msg)
40 image_id = None
41 boot_meta = self._get_bdm_image_metadata(
42 context, block_device_mapping, legacy_bdm)
43
44 self._check_auto_disk_config(image=boot_meta,
45 auto_disk_config=auto_disk_config)
46
47 base_options, max_net_count, key_pair, security_groups, \
48 network_metadata = self._validate_and_build_base_options(
49 context, instance_type, boot_meta, image_href, image_id,
50 kernel_id, ramdisk_id, display_name, display_description,
51 key_name, key_data, security_groups, availability_zone,
52 user_data, metadata, access_ip_v4, access_ip_v6,
53 requested_networks, config_drive, auto_disk_config,
54 reservation_id, max_count, supports_port_resource_request)
55
56 # max_net_count is the maximum number of instances requested by the
57 # user adjusted for any network quota constraints, including
58 # consideration of connections to each requested network
59 if max_net_count < min_count:
60 raise exception.PortLimitExceeded()
61 elif max_net_count < max_count:
62 LOG.info("max count reduced from %(max_count)d to "
63 "%(max_net_count)d due to network port quota",
64 {'max_count': max_count,
65 'max_net_count': max_net_count})
66 max_count = max_net_count
67
68 block_device_mapping = self._check_and_transform_bdm(context,
69 base_options, instance_type, boot_meta, min_count,
70 max_count,
71 block_device_mapping, legacy_bdm)
72
73 # We can't do this check earlier because we need bdms from all sources
74 # to have been merged in order to get the root bdm.
75 # Set validate_numa=False since numa validation is already done by
76 # _validate_and_build_base_options().
77 self._checks_for_create_and_rebuild(context, image_id, boot_meta,
78 instance_type, metadata, injected_files,
79 block_device_mapping.root_bdm(), validate_numa=False)
80
81 instance_group = self._get_requested_instance_group(context,
82 filter_properties)
83
84 tags = self._create_tag_list_obj(context, tags)
85
86 instances_to_build = self._provision_instances(
87 context, instance_type, min_count, max_count, base_options,
88 boot_meta, security_groups, block_device_mapping,
89 shutdown_terminate, instance_group, check_server_group_quota,
90 filter_properties, key_pair, tags, trusted_certs,
91 supports_multiattach, network_metadata,
92 requested_host, requested_hypervisor_hostname)
93
94 instances = []
95 request_specs = []
96 build_requests = []
97 for rs, build_request, im in instances_to_build:
98 build_requests.append(build_request)
99 instance = build_request.get_new_instance(context)
100 instances.append(instance)
101 request_specs.append(rs)
102
103 self.compute_task_api.schedule_and_build_instances(
104 context,
105 build_requests=build_requests,
106 request_spec=request_specs,
107 image=boot_meta,
108 admin_password=admin_password,
109 injected_files=injected_files,
110 requested_networks=requested_networks,
111 block_device_mapping=block_device_mapping,
112 tags=tags)
113
114 return instances, reservation_id
整段代码的作用为收集创建虚机所需的disk,image信息,保证创建顺利创建,最后调用nova/conductor/api.py中schedule_and_build_instances()方法
1 def schedule_and_build_instances(self, context, build_requests,
2 request_spec, image,
3 admin_password, injected_files,
4 requested_networks, block_device_mapping,
5 tags=None):
6 self.conductor_compute_rpcapi.schedule_and_build_instances(
7 context, build_requests, request_spec, image,
8 admin_password, injected_files, requested_networks,
9 block_device_mapping, tags)
整段代码只起到缓冲作用,立刻调用nova/conductor/rpcapi.py中schedule_and_build_instances()方法
1 def schedule_and_build_instances(self, context, build_requests,
2 request_specs,
3 image, admin_password, injected_files,
4 requested_networks,
5 block_device_mapping,
6 tags=None):
7 version = '1.17'
8 kw = {'build_requests': build_requests,
9 'request_specs': request_specs,
10 'image': jsonutils.to_primitive(image),
11 'admin_password': admin_password,
12 'injected_files': injected_files,
13 'requested_networks': requested_networks,
14 'block_device_mapping': block_device_mapping,
15 'tags': tags}
16
17 if not self.client.can_send_version(version):
18 version = '1.16'
19 del kw['tags']
20
21 cctxt = self.client.prepare(version=version)
22 cctxt.cast(context, 'schedule_and_build_instances', **kw)
整段代码有两个作用,一是进行版本判断,根据版本调整参数,二是使用rpc调用nova/conductor/manager.py中schedule_and_build_instances()方法
1 def schedule_and_build_instances(self, context, build_requests,
2 request_specs, image,
3 admin_password, injected_files,
4 requested_networks, block_device_mapping,
5 tags=None):
6 # Add all the UUIDs for the instances
7 instance_uuids = [spec.instance_uuid for spec in request_specs]
8 try:
9 host_lists = self._schedule_instances(context, request_specs[0],
10 instance_uuids, return_alternates=True)
11 except Exception as exc:
12 LOG.exception('Failed to schedule instances')
13 self._bury_in_cell0(context, request_specs[0], exc,
14 build_requests=build_requests,
15 block_device_mapping=block_device_mapping,
16 tags=tags)
17 return
18
19 host_mapping_cache = {}
20 cell_mapping_cache = {}
21 instances = []
22 host_az = {} # host=az cache to optimize multi-create
23
24 for (build_request, request_spec, host_list) in six.moves.zip(
25 build_requests, request_specs, host_lists):
26 instance = build_request.get_new_instance(context)
27 # host_list is a list of one or more Selection objects, the first
28 # of which has been selected and its resources claimed.
29 host = host_list[0]
30 # Convert host from the scheduler into a cell record
31 if host.service_host not in host_mapping_cache:
32 try:
33 host_mapping = objects.HostMapping.get_by_host(
34 context, host.service_host)
35 host_mapping_cache[host.service_host] = host_mapping
36 except exception.HostMappingNotFound as exc:
37 LOG.error('No host-to-cell mapping found for selected '
38 'host %(host)s. Setup is incomplete.',
39 {'host': host.service_host})
40 self._bury_in_cell0(
41 context, request_spec, exc,
42 build_requests=[build_request], instances=[instance],
43 block_device_mapping=block_device_mapping,
44 tags=tags)
45 # This is a placeholder in case the quota recheck fails.
46 instances.append(None)
47 continue
48 else:
49 host_mapping = host_mapping_cache[host.service_host]
50
51 cell = host_mapping.cell_mapping
52
53 # Before we create the instance, let's make one final check that
54 # the build request is still around and wasn't deleted by the user
55 # already.
56 try:
57 objects.BuildRequest.get_by_instance_uuid(
58 context, instance.uuid)
59 except exception.BuildRequestNotFound:
60 # the build request is gone so we're done for this instance
61 LOG.debug('While scheduling instance, the build request '
62 'was already deleted.', instance=instance)
63 # This is a placeholder in case the quota recheck fails.
64 instances.append(None)
65 # If the build request was deleted and the instance is not
66 # going to be created, there is on point in leaving an orphan
67 # instance mapping so delete it.
68 try:
69 im = objects.InstanceMapping.get_by_instance_uuid(
70 context, instance.uuid)
71 im.destroy()
72 except exception.InstanceMappingNotFound:
73 pass
74 self.report_client.delete_allocation_for_instance(
75 context, instance.uuid)
76 continue
77 else:
78 if host.service_host not in host_az:
79 host_az[host.service_host] = (
80 availability_zones.get_host_availability_zone(
81 context, host.service_host))
82 instance.availability_zone = host_az[host.service_host]
83 with obj_target_cell(instance, cell):
84 instance.create()
85 instances.append(instance)
86 cell_mapping_cache[instance.uuid] = cell
87
88 # NOTE(melwitt): We recheck the quota after creating the
89 # objects to prevent users from allocating more resources
90 # than their allowed quota in the event of a race. This is
91 # configurable because it can be expensive if strict quota
92 # limits are not required in a deployment.
93 if CONF.quota.recheck_quota:
94 try:
95 compute_utils.check_num_instances_quota(
96 context, instance.flavor, 0, 0,
97 orig_num_req=len(build_requests))
98 except exception.TooManyInstances as exc:
99 with excutils.save_and_reraise_exception():
100 self._cleanup_build_artifacts(context, exc, instances,
101 build_requests,
102 request_specs,
103 block_device_mapping, tags,
104 cell_mapping_cache)
105
106 zipped = six.moves.zip(build_requests, request_specs, host_lists,
107 instances)
108 for (build_request, request_spec, host_list, instance) in zipped:
109 if instance is None:
110 # Skip placeholders that were buried in cell0 or had their
111 # build requests deleted by the user before instance create.
112 continue
113 cell = cell_mapping_cache[instance.uuid]
114 # host_list is a list of one or more Selection objects, the first
115 # of which has been selected and its resources claimed.
116 host = host_list.pop(0)
117 alts = [(alt.service_host, alt.nodename) for alt in host_list]
118 LOG.debug("Selected host: %s; Selected node: %s; Alternates: %s",
119 host.service_host, host.nodename, alts, instance=instance)
120 filter_props = request_spec.to_legacy_filter_properties_dict()
121 scheduler_utils.populate_retry(filter_props, instance.uuid)
122 scheduler_utils.populate_filter_properties(filter_props,
123 host)
124
125 # Now that we have a selected host (which has claimed resource
126 # allocations in the scheduler) for this instance, we may need to
127 # map allocations to resource providers in the request spec.
128 try:
129 scheduler_utils.fill_provider_mapping(
130 context, self.report_client, request_spec, host)
131 except Exception as exc:
132 # If anything failed here we need to cleanup and bail out.
133 with excutils.save_and_reraise_exception():
134 self._cleanup_build_artifacts(
135 context, exc, instances, build_requests, request_specs,
136 block_device_mapping, tags, cell_mapping_cache)
137
138 # TODO(melwitt): Maybe we should set_target_cell on the contexts
139 # once we map to a cell, and remove these separate with statements.
140 with obj_target_cell(instance, cell) as cctxt:
141 # send a state update notification for the initial create to
142 # show it going from non-existent to BUILDING
143 # This can lazy-load attributes on instance.
144 notifications.send_update_with_states(cctxt, instance, None,
145 vm_states.BUILDING, None, None, service="conductor")
146 objects.InstanceAction.action_start(
147 cctxt, instance.uuid, instance_actions.CREATE,
148 want_result=False)
149 instance_bdms = self._create_block_device_mapping(
150 cell, instance.flavor, instance.uuid, block_device_mapping)
151 instance_tags = self._create_tags(cctxt, instance.uuid, tags)
152
153 # TODO(Kevin Zheng): clean this up once instance.create() handles
154 # tags; we do this so the instance.create notification in
155 # build_and_run_instance in nova-compute doesn't lazy-load tags
156 instance.tags = instance_tags if instance_tags \
157 else objects.TagList()
158
159 # Update mapping for instance. Normally this check is guarded by
160 # a try/except but if we're here we know that a newer nova-api
161 # handled the build process and would have created the mapping
162 inst_mapping = objects.InstanceMapping.get_by_instance_uuid(
163 context, instance.uuid)
164 inst_mapping.cell_mapping = cell
165 inst_mapping.save()
166
167 if not self._delete_build_request(
168 context, build_request, instance, cell, instance_bdms,
169 instance_tags):
170 # The build request was deleted before/during scheduling so
171 # the instance is gone and we don't have anything to build for
172 # this one.
173 continue
174
175 # NOTE(danms): Compute RPC expects security group names or ids
176 # not objects, so convert this to a list of names until we can
177 # pass the objects.
178 legacy_secgroups = [s.identifier
179 for s in request_spec.security_groups]
180 with obj_target_cell(instance, cell) as cctxt:
181 self.compute_rpcapi.build_and_run_instance(
182 cctxt, instance=instance, image=image,
183 request_spec=request_spec,
184 filter_properties=filter_props,
185 admin_password=admin_password,
186 injected_files=injected_files,
187 requested_networks=requested_networks,
188 security_groups=legacy_secgroups,
189 block_device_mapping=instance_bdms,
190 host=host.service_host, node=host.nodename,
191 limits=host.limits, host_list=host_list)
此方法比较复杂,第9行调用_schedule_instances()获取符合创建虚机的主机
1 def _schedule_instances(self, context, request_spec,
2 instance_uuids=None, return_alternates=False):
3 scheduler_utils.setup_instance_group(context, request_spec)
4 with timeutils.StopWatch() as timer:
5 host_lists = self.query_client.select_destinations(
6 context, request_spec, instance_uuids, return_objects=True,
7 return_alternates=return_alternates)
8 LOG.debug('Took %0.2f seconds to select destinations for %s '
9 'instance(s).', timer.elapsed(), len(instance_uuids))
10 return host_lists
第5行调用select_destinations()方法,此方法调用shceduler_rpcapi中的select_destinations()方法进行rpc调用
1 def select_destinations(self, context, spec_obj, instance_uuids,
2 return_objects=False, return_alternates=False):
3 """Returns destinations(s) best suited for this request_spec and
4 filter_properties.
5
6 When return_objects is False, the result will be the "old-style" list
7 of dicts with 'host', 'nodename' and 'limits' as keys. The value of
8 return_alternates is ignored.
9
10 When return_objects is True, the result will be a list of lists of
11 Selection objects, with one list per instance. Each instance's list
12 will contain a Selection representing the selected (and claimed) host,
13 and, if return_alternates is True, zero or more Selection objects that
14 represent alternate hosts. The number of alternates returned depends on
15 the configuration setting `CONF.scheduler.max_attempts`.
16 """
17 return self.scheduler_rpcapi.select_destinations(context, spec_obj,
18 instance_uuids, return_objects, return_alternates)
1 def select_destinations(self, ctxt, spec_obj, instance_uuids,
2 return_objects=False, return_alternates=False):
3 # Modify the parameters if an older version is requested
4 version = '4.5'
5 msg_args = {'instance_uuids': instance_uuids,
6 'spec_obj': spec_obj,
7 'return_objects': return_objects,
8 'return_alternates': return_alternates}
9 if not self.client.can_send_version(version):
10 if msg_args['return_objects'] or msg_args['return_alternates']:
11 # The client is requesting an RPC version we can't support.
12 raise exc.SelectionObjectsWithOldRPCVersionNotSupported(
13 version=self.client.version_cap)
14 del msg_args['return_objects']
15 del msg_args['return_alternates']
16 version = '4.4'
17 if not self.client.can_send_version(version):
18 del msg_args['instance_uuids']
19 version = '4.3'
20 if not self.client.can_send_version(version):
21 del msg_args['spec_obj']
22 msg_args['request_spec'] = spec_obj.to_legacy_request_spec_dict()
23 msg_args['filter_properties'
24 ] = spec_obj.to_legacy_filter_properties_dict()
25 version = '4.0'
26 cctxt = self.client.prepare(
27 version=version, call_monitor_timeout=CONF.rpc_response_timeout,
28 timeout=CONF.long_rpc_timeout)
29 return cctxt.call(ctxt, 'select_destinations', **msg_args)
注:精力有限,后续方法可自行阅读源码,方法如上
回归正题
此方法多为操作数据库,进行数据查询并判断,最后遍历host_list进行虚机创建,此处由于是for循环,所以每创建一个虚机都会调用一次build_and_run_instance()方法
1 def build_and_run_instance(self, ctxt, instance, host, image, request_spec,
2 filter_properties, admin_password=None, injected_files=None,
3 requested_networks=None, security_groups=None,
4 block_device_mapping=None, node=None, limits=None,
5 host_list=None):
6 # NOTE(edleafe): compute nodes can only use the dict form of limits.
7 if isinstance(limits, objects.SchedulerLimits):
8 limits = limits.to_dict()
9 kwargs = {"instance": instance,
10 "image": image,
11 "request_spec": request_spec,
12 "filter_properties": filter_properties,
13 "admin_password": admin_password,
14 "injected_files": injected_files,
15 "requested_networks": requested_networks,
16 "security_groups": security_groups,
17 "block_device_mapping": block_device_mapping,
18 "node": node,
19 "limits": limits,
20 "host_list": host_list,
21 }
22 client = self.router.client(ctxt)
23 version = '5.0'
24 cctxt = client.prepare(server=host, version=version)
25 cctxt.cast(ctxt, 'build_and_run_instance', **kwargs)
此方法主要功能是用rpc调用nova/compute/manager.py中build_and_run_instances()方法
1 @wrap_exception()
2 @reverts_task_state
3 @wrap_instance_fault
4 def build_and_run_instance(self, context, instance, image, request_spec,
5 filter_properties, admin_password=None,
6 injected_files=None, requested_networks=None,
7 security_groups=None, block_device_mapping=None,
8 node=None, limits=None, host_list=None):
9
10 @utils.synchronized(instance.uuid)
11 def _locked_do_build_and_run_instance(*args, **kwargs):
12 # NOTE(danms): We grab the semaphore with the instance uuid
13 # locked because we could wait in line to build this instance
14 # for a while and we want to make sure that nothing else tries
15 # to do anything with this instance while we wait.
16 with self._build_semaphore:
17 try:
18 result = self._do_build_and_run_instance(*args, **kwargs)
19 except Exception:
20 # NOTE(mriedem): This should really only happen if
21 # _decode_files in _do_build_and_run_instance fails, and
22 # that's before a guest is spawned so it's OK to remove
23 # allocations for the instance for this node from Placement
24 # below as there is no guest consuming resources anyway.
25 # The _decode_files case could be handled more specifically
26 # but that's left for another day.
27 result = build_results.FAILED
28 raise
29 finally:
30 if result == build_results.FAILED:
31 # Remove the allocation records from Placement for the
32 # instance if the build failed. The instance.host is
33 # likely set to None in _do_build_and_run_instance
34 # which means if the user deletes the instance, it
35 # will be deleted in the API, not the compute service.
36 # Setting the instance.host to None in
37 # _do_build_and_run_instance means that the
38 # ResourceTracker will no longer consider this instance
39 # to be claiming resources against it, so we want to
40 # reflect that same thing in Placement. No need to
41 # call this for a reschedule, as the allocations will
42 # have already been removed in
43 # self._do_build_and_run_instance().
44 self.reportclient.delete_allocation_for_instance(
45 context, instance.uuid)
46
47 if result in (build_results.FAILED,
48 build_results.RESCHEDULED):
49 self._build_failed(node)
50 else:
51 self._build_succeeded(node)
52
53 # NOTE(danms): We spawn here to return the RPC worker thread back to
54 # the pool. Since what follows could take a really long time, we don't
55 # want to tie up RPC workers.
56 utils.spawn_n(_locked_do_build_and_run_instance,
57 context, instance, image, request_spec,
58 filter_properties, admin_password, injected_files,
59 requested_networks, security_groups,
60 block_device_mapping, node, limits, host_list)
1 def spawn_n(func, *args, **kwargs):
2 """Passthrough method for eventlet.spawn_n.
3
4 This utility exists so that it can be stubbed for testing without
5 interfering with the service spawns.
6
7 It will also grab the context from the threadlocal store and add it to
8 the store on the new thread. This allows for continuity in logging the
9 context when using this method to spawn a new thread.
10 """
11 _context = common_context.get_current()
12 profiler_info = _serialize_profile_info()
13
14 @functools.wraps(func)
15 def context_wrapper(*args, **kwargs):
16 # NOTE: If update_store is not called after spawn_n it won't be
17 # available for the logger to pull from threadlocal storage.
18 if _context is not None:
19 _context.update_store()
20 if profiler_info and profiler:
21 profiler.init(**profiler_info)
22 func(*args, **kwargs)
23
24 eventlet.spawn_n(context_wrapper, *args, **kwargs)
此方法使用协程进行创建虚机(为保证数据一致性,创建前需要加锁)