Coverage for nova/api/openstack/compute/servers.py: 97%

1# Copyright 2010 OpenStack Foundation 

2# Copyright 2011 Piston Cloud Computing, Inc 

3# All Rights Reserved. 

4# 

5# Licensed under the Apache License, Version 2.0 (the "License"); you may 

6# not use this file except in compliance with the License. You may obtain 

7# a copy of the License at 

8# 

9# http://www.apache.org/licenses/LICENSE-2.0 

10# 

11# Unless required by applicable law or agreed to in writing, software 

12# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT 

13# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the 

14# License for the specific language governing permissions and limitations 

15# under the License. 

16 

17import copy 

18 

19from oslo_log import log as logging 

20import oslo_messaging as messaging 

21from oslo_utils import strutils 

22from oslo_utils import timeutils 

23from oslo_utils import uuidutils 

24import webob 

25from webob import exc 

26 

27from nova.api.openstack import api_version_request 

28from nova.api.openstack import common 

29from nova.api.openstack.compute import helpers 

30from nova.api.openstack.compute.schemas import servers as schema 

31from nova.api.openstack.compute.views import servers as views_servers 

32from nova.api.openstack import wsgi 

33from nova.api import validation 

34from nova import block_device 

35from nova.compute import api as compute 

36from nova.compute import flavors 

37from nova.compute import utils as compute_utils 

38import nova.conf 

39from nova import context as nova_context 

40from nova import exception 

41from nova.i18n import _ 

42from nova.image import glance 

43from nova import objects 

44from nova.policies import servers as server_policies 

45from nova import utils 

46 

47TAG_SEARCH_FILTERS = ('tags', 'tags-any', 'not-tags', 'not-tags-any') 

48PAGING_SORTING_PARAMS = ('sort_key', 'sort_dir', 'limit', 'marker') 

49 

50CONF = nova.conf.CONF 

51 

52LOG = logging.getLogger(__name__) 

53 

54INVALID_FLAVOR_IMAGE_EXCEPTIONS = ( 

55 exception.BadRequirementEmulatorThreadsPolicy, 

56 exception.CPUThreadPolicyConfigurationInvalid, 

57 exception.FlavorImageConflict, 

58 exception.FlavorDiskTooSmall, 

59 exception.FlavorMemoryTooSmall, 

60 exception.ImageCPUPinningForbidden, 

61 exception.ImageCPUThreadPolicyForbidden, 

62 exception.ImageNUMATopologyAsymmetric, 

63 exception.ImageNUMATopologyCPUDuplicates, 

64 exception.ImageNUMATopologyCPUOutOfRange, 

65 exception.ImageNUMATopologyCPUsUnassigned, 

66 exception.ImageNUMATopologyForbidden, 

67 exception.ImageNUMATopologyIncomplete, 

68 exception.ImageNUMATopologyMemoryOutOfRange, 

69 exception.ImageNUMATopologyRebuildConflict, 

70 exception.ImageSerialPortNumberExceedFlavorValue, 

71 exception.ImageSerialPortNumberInvalid, 

72 exception.ImageVCPULimitsRangeExceeded, 

73 exception.ImageVCPUTopologyRangeExceeded, 

74 exception.InvalidCPUAllocationPolicy, 

75 exception.InvalidCPUThreadAllocationPolicy, 

76 exception.InvalidEmulatorThreadsPolicy, 

77 exception.InvalidMachineType, 

78 exception.InvalidNUMANodesNumber, 

79 exception.InvalidRequest, 

80 exception.MemoryPageSizeForbidden, 

81 exception.MemoryPageSizeInvalid, 

82 exception.PciInvalidAlias, 

83 exception.PciRequestAliasNotDefined, 

84 exception.RealtimeConfigurationInvalid, 

85 exception.RealtimeMaskNotFoundOrInvalid, 

86 exception.RequiredMixedInstancePolicy, 

87 exception.RequiredMixedOrRealtimeCPUMask, 

88 exception.InvalidMixedInstanceDedicatedMask, 

89) 

90 

91 

92class ServersController(wsgi.Controller): 

93 """The Server API base controller class for the OpenStack API.""" 

94 

95 _view_builder_class = views_servers.ViewBuilder 

96 

97 @staticmethod 

98 def _add_location(robj): 

99 # Just in case... 

100 if 'server' not in robj.obj: 100 ↛ 101line 100 didn't jump to line 101 because the condition on line 100 was never true

101 return robj 

102 

103 link = [link for link in robj.obj['server'][ 

104 'links'] if link['rel'] == 'self'] 

105 if link: 105 ↛ 109line 105 didn't jump to line 109 because the condition on line 105 was always true

106 robj['Location'] = link[0]['href'] 

107 

108 # Convenience return 

109 return robj 

110 

111 def __init__(self): 

112 super(ServersController, self).__init__() 

113 self.compute_api = compute.API() 

114 

115 @wsgi.expected_errors((400, 403)) 

116 @validation.query_schema(schema.query_params_v275, '2.75') 

117 @validation.query_schema(schema.query_params_v273, '2.73', '2.74') 

118 @validation.query_schema(schema.query_params_v266, '2.66', '2.72') 

119 @validation.query_schema(schema.query_params_v226, '2.26', '2.65') 

120 @validation.query_schema(schema.query_params_v21, '2.1', '2.25') 

121 def index(self, req): 

122 """Returns a list of server names and ids for a given user.""" 

123 context = req.environ['nova.context'] 

124 context.can(server_policies.SERVERS % 'index') 

125 try: 

126 servers = self._get_servers(req, is_detail=False) 

127 except exception.Invalid as err: 

128 raise exc.HTTPBadRequest(explanation=err.format_message()) 

129 return servers 

130 

131 @wsgi.expected_errors((400, 403)) 

132 @validation.query_schema(schema.query_params_v275, '2.75') 

133 @validation.query_schema(schema.query_params_v273, '2.73', '2.74') 

134 @validation.query_schema(schema.query_params_v266, '2.66', '2.72') 

135 @validation.query_schema(schema.query_params_v226, '2.26', '2.65') 

136 @validation.query_schema(schema.query_params_v21, '2.1', '2.25') 

137 def detail(self, req): 

138 """Returns a list of server details for a given user.""" 

139 context = req.environ['nova.context'] 

140 context.can(server_policies.SERVERS % 'detail') 

141 try: 

142 servers = self._get_servers(req, is_detail=True) 

143 except exception.Invalid as err: 

144 raise exc.HTTPBadRequest(explanation=err.format_message()) 

145 return servers 

146 

147 @staticmethod 

148 def _is_cell_down_supported(req, search_opts): 

149 cell_down_support = api_version_request.is_supported( 

150 req, min_version='2.69') 

151 

152 if cell_down_support: 

153 # NOTE(tssurya): Minimal constructs would be returned from the down 

154 # cells if cell_down_support is True, however if filtering, sorting 

155 # or paging is requested by the user, then cell_down_support should 

156 # be made False and the down cells should be skipped (depending on 

157 # CONF.api.list_records_by_skipping_down_cells) as there is no 

158 # way to return correct results for the down cells in those 

159 # situations due to missing keys/information. 

160 # NOTE(tssurya): Since there is a chance that 

161 # remove_invalid_options function could have removed the paging and 

162 # sorting parameters, we add the additional check for that from the 

163 # request. 

164 pag_sort = any( 

165 ps in req.GET.keys() for ps in PAGING_SORTING_PARAMS) 

166 # NOTE(tssurya): ``nova list --all_tenants`` is the only 

167 # allowed filter exception when handling down cells. 

168 filters = list(search_opts.keys()) not in ([u'all_tenants'], []) 

169 if pag_sort or filters: 

170 cell_down_support = False 

171 return cell_down_support 

172 

173 def _get_servers(self, req, is_detail): 

174 """Returns a list of servers, based on any search options specified.""" 

175 

176 search_opts = {} 

177 search_opts.update(req.GET) 

178 

179 context = req.environ['nova.context'] 

180 remove_invalid_options(context, search_opts, 

181 self._get_server_search_options(req)) 

182 

183 cell_down_support = self._is_cell_down_supported(req, search_opts) 

184 

185 for search_opt in search_opts: 

186 if (search_opt in 

187 schema.JOINED_TABLE_QUERY_PARAMS_SERVERS.keys() or 

188 search_opt.startswith('_')): 

189 msg = _("Invalid filter field: %s.") % search_opt 

190 raise exc.HTTPBadRequest(explanation=msg) 

191 

192 # Verify search by 'status' contains a valid status. 

193 # Convert it to filter by vm_state or task_state for compute_api. 

194 # For non-admin user, vm_state and task_state are filtered through 

195 # remove_invalid_options function, based on value of status field. 

196 # Set value to vm_state and task_state to make search simple. 

197 search_opts.pop('status', None) 

198 if 'status' in req.GET.keys(): 

199 statuses = req.GET.getall('status') 

200 states = common.task_and_vm_state_from_status(statuses) 

201 vm_state, task_state = states 

202 if not vm_state and not task_state: 

203 if api_version_request.is_supported(req, min_version='2.38'): 

204 msg = _('Invalid status value') 

205 raise exc.HTTPBadRequest(explanation=msg) 

206 

207 return {'servers': []} 

208 search_opts['vm_state'] = vm_state 

209 # When we search by vm state, task state will return 'default'. 

210 # So we don't need task_state search_opt. 

211 if 'default' not in task_state: 

212 search_opts['task_state'] = task_state 

213 

214 if 'changes-since' in search_opts: 

215 try: 

216 search_opts['changes-since'] = timeutils.parse_isotime( 

217 search_opts['changes-since']) 

218 except ValueError: 

219 # NOTE: This error handling is for V2.0 API to pass the 

220 # experimental jobs at the gate. V2.1 API covers this case 

221 # with JSON-Schema and it is a hard burden to apply it to 

222 # v2.0 API at this time. 

223 msg = _("Invalid filter field: changes-since.") 

224 raise exc.HTTPBadRequest(explanation=msg) 

225 

226 if 'changes-before' in search_opts: 

227 try: 

228 search_opts['changes-before'] = timeutils.parse_isotime( 

229 search_opts['changes-before']) 

230 changes_since = search_opts.get('changes-since') 

231 if changes_since and search_opts['changes-before'] < \ 

232 search_opts['changes-since']: 

233 msg = _('The value of changes-since must be' 

234 ' less than or equal to changes-before.') 

235 raise exc.HTTPBadRequest(explanation=msg) 

236 except ValueError: 

237 msg = _("Invalid filter field: changes-before.") 

238 raise exc.HTTPBadRequest(explanation=msg) 

239 

240 # By default, compute's get_all() will return deleted instances. 

241 # If an admin hasn't specified a 'deleted' search option, we need 

242 # to filter out deleted instances by setting the filter ourselves. 

243 # ... Unless 'changes-since' or 'changes-before' is specified, 

244 # because those will return recently deleted instances according to 

245 # the API spec. 

246 

247 if 'deleted' not in search_opts: 

248 if 'changes-since' not in search_opts and \ 

249 'changes-before' not in search_opts: 

250 # No 'changes-since' or 'changes-before', so we only 

251 # want non-deleted servers 

252 search_opts['deleted'] = False 

253 else: 

254 # Convert deleted filter value to a valid boolean. 

255 # Return non-deleted servers if an invalid value 

256 # is passed with deleted filter. 

257 search_opts['deleted'] = strutils.bool_from_string( 

258 search_opts['deleted'], default=False) 

259 

260 if search_opts.get("vm_state") == ['deleted']: 

261 if context.is_admin: 

262 search_opts['deleted'] = True 

263 else: 

264 msg = _("Only administrators may list deleted instances") 

265 raise exc.HTTPForbidden(explanation=msg) 

266 

267 if api_version_request.is_supported(req, min_version='2.26'): 

268 for tag_filter in TAG_SEARCH_FILTERS: 

269 if tag_filter in search_opts: 

270 search_opts[tag_filter] = search_opts[ 

271 tag_filter].split(',') 

272 

273 all_tenants = common.is_all_tenants(search_opts) 

274 # use the boolean from here on out so remove the entry from search_opts 

275 # if it's present. 

276 # NOTE(tssurya): In case we support handling down cells 

277 # we need to know further down the stack whether the 'all_tenants' 

278 # filter was passed with the true value or not, so we pass the flag 

279 # further down the stack. 

280 search_opts.pop('all_tenants', None) 

281 

282 if 'locked' in search_opts: 

283 search_opts['locked'] = common.is_locked(search_opts) 

284 

285 elevated = None 

286 if all_tenants: 

287 if is_detail: 

288 context.can(server_policies.SERVERS % 'detail:get_all_tenants') 

289 else: 

290 context.can(server_policies.SERVERS % 'index:get_all_tenants') 

291 elevated = context.elevated() 

292 else: 

293 # As explained in lp:#1185290, if `all_tenants` is not passed 

294 # we must ignore the `tenant_id` search option. 

295 search_opts.pop('tenant_id', None) 

296 if context.project_id: 

297 search_opts['project_id'] = context.project_id 

298 else: 

299 search_opts['user_id'] = context.user_id 

300 

301 limit, marker = common.get_limit_and_marker(req) 

302 sort_keys, sort_dirs = common.get_sort_params(req.params) 

303 blacklist = schema.SERVER_LIST_IGNORE_SORT_KEY 

304 if api_version_request.is_supported(req, min_version='2.73'): 

305 blacklist = schema.SERVER_LIST_IGNORE_SORT_KEY_V273 

306 sort_keys, sort_dirs = remove_invalid_sort_keys( 

307 context, sort_keys, sort_dirs, blacklist, ('host', 'node')) 

308 

309 expected_attrs = [] 

310 if is_detail: 

311 if api_version_request.is_supported(req, '2.16'): 

312 expected_attrs.append('services') 

313 if api_version_request.is_supported(req, '2.26'): 

314 expected_attrs.append("tags") 

315 if api_version_request.is_supported(req, '2.63'): 315 ↛ 316line 315 didn't jump to line 316 because the condition on line 315 was never true

316 expected_attrs.append("trusted_certs") 

317 if api_version_request.is_supported(req, '2.73'): 317 ↛ 318line 317 didn't jump to line 318 because the condition on line 317 was never true

318 expected_attrs.append("system_metadata") 

319 

320 # merge our expected attrs with what the view builder needs for 

321 # showing details 

322 expected_attrs = self._view_builder.get_show_expected_attrs( 

323 expected_attrs) 

324 

325 try: 

326 instance_list = self.compute_api.get_all(elevated or context, 

327 search_opts=search_opts, limit=limit, marker=marker, 

328 expected_attrs=expected_attrs, sort_keys=sort_keys, 

329 sort_dirs=sort_dirs, cell_down_support=cell_down_support, 

330 all_tenants=all_tenants) 

331 except exception.MarkerNotFound: 

332 msg = _('marker [%s] not found') % marker 

333 raise exc.HTTPBadRequest(explanation=msg) 

334 except exception.FlavorNotFound: 

335 LOG.debug("Flavor '%s' could not be found ", 

336 search_opts['flavor']) 

337 instance_list = objects.InstanceList() 

338 

339 if is_detail: 

340 instance_list._context = context 

341 instance_list.fill_faults() 

342 response = self._view_builder.detail( 

343 req, instance_list, cell_down_support=cell_down_support) 

344 else: 

345 response = self._view_builder.index( 

346 req, instance_list, cell_down_support=cell_down_support) 

347 return response 

348 

349 def _get_server(self, context, req, instance_uuid, is_detail=False, 

350 cell_down_support=False, columns_to_join=None): 

351 """Utility function for looking up an instance by uuid. 

352 

353 :param context: request context for auth 

354 :param req: HTTP request. 

355 :param instance_uuid: UUID of the server instance to get 

356 :param is_detail: True if you plan on showing the details of the 

357 instance in the response, False otherwise. 

358 :param cell_down_support: True if the API (and caller) support 

359 returning a minimal instance 

360 construct if the relevant cell is 

361 down. 

362 :param columns_to_join: optional list of extra fields to join on the 

363 Instance object 

364 """ 

365 expected_attrs = ['flavor', 'numa_topology'] 

366 if is_detail: 

367 if api_version_request.is_supported(req, '2.26'): 

368 expected_attrs.append("tags") 

369 if api_version_request.is_supported(req, '2.63'): 

370 expected_attrs.append("trusted_certs") 

371 expected_attrs = self._view_builder.get_show_expected_attrs( 

372 expected_attrs) 

373 if columns_to_join: 

374 expected_attrs.extend(columns_to_join) 

375 instance = common.get_instance(self.compute_api, context, 

376 instance_uuid, 

377 expected_attrs=expected_attrs, 

378 cell_down_support=cell_down_support) 

379 return instance 

380 

381 @staticmethod 

382 def _validate_network_id(net_id, network_uuids): 

383 """Validates that a requested network id. 

384 

385 This method checks that the network id is in the proper UUID format. 

386 

387 :param net_id: The network id to validate. 

388 :param network_uuids: A running list of requested network IDs that have 

389 passed validation already. 

390 :raises: webob.exc.HTTPBadRequest if validation fails 

391 """ 

392 if not uuidutils.is_uuid_like(net_id): 

393 msg = _("Bad networks format: network uuid is " 

394 "not in proper format (%s)") % net_id 

395 raise exc.HTTPBadRequest(explanation=msg) 

396 

397 def _get_requested_networks(self, requested_networks): 

398 """Create a list of requested networks from the networks attribute.""" 

399 

400 # Starting in the 2.37 microversion, requested_networks is either a 

401 # list or a string enum with value 'auto' or 'none'. The auto/none 

402 # values are verified via jsonschema so we don't check them again here. 

403 if isinstance(requested_networks, str): 

404 return objects.NetworkRequestList( 

405 objects=[objects.NetworkRequest( 

406 network_id=requested_networks)]) 

407 

408 networks = [] 

409 network_uuids = [] 

410 port_uuids = [] 

411 for network in requested_networks: 

412 request = objects.NetworkRequest() 

413 try: 

414 # fixed IP address is optional 

415 # if the fixed IP address is not provided then 

416 # it will use one of the available IP address from the network 

417 request.address = network.get('fixed_ip', None) 

418 request.port_id = network.get('port', None) 

419 request.tag = network.get('tag', None) 

420 

421 if request.port_id: 

422 if request.port_id in port_uuids: 

423 msg = _( 

424 "Port ID '%(port)s' was specified twice: you " 

425 "cannot attach a port multiple times." 

426 ) % { 

427 "port": request.port_id, 

428 } 

429 raise exc.HTTPBadRequest(explanation=msg) 

430 

431 if request.address is not None: 

432 msg = _( 

433 "Specified Fixed IP '%(addr)s' cannot be used " 

434 "with port '%(port)s': the two cannot be " 

435 "specified together." 

436 ) % { 

437 "addr": request.address, 

438 "port": request.port_id, 

439 } 

440 raise exc.HTTPBadRequest(explanation=msg) 

441 

442 request.network_id = None 

443 port_uuids.append(request.port_id) 

444 else: 

445 request.network_id = network['uuid'] 

446 self._validate_network_id( 

447 request.network_id, network_uuids) 

448 network_uuids.append(request.network_id) 

449 

450 networks.append(request) 

451 except KeyError as key: 

452 expl = _('Bad network format: missing %s') % key 

453 raise exc.HTTPBadRequest(explanation=expl) 

454 except TypeError: 

455 expl = _('Bad networks format') 

456 raise exc.HTTPBadRequest(explanation=expl) 

457 

458 return objects.NetworkRequestList(objects=networks) 

459 

460 @wsgi.expected_errors(404) 

461 @validation.query_schema(schema.show_query) 

462 def show(self, req, id): 

463 """Returns server details by server id.""" 

464 context = req.environ['nova.context'] 

465 cell_down_support = api_version_request.is_supported( 

466 req, min_version='2.69') 

467 show_server_groups = api_version_request.is_supported( 

468 req, min_version='2.71') 

469 

470 instance = self._get_server( 

471 context, req, id, is_detail=True, 

472 columns_to_join=['services'], 

473 cell_down_support=cell_down_support) 

474 context.can(server_policies.SERVERS % 'show', 

475 target={'project_id': instance.project_id}) 

476 

477 return self._view_builder.show( 

478 req, instance, cell_down_support=cell_down_support, 

479 show_server_groups=show_server_groups) 

480 

481 @staticmethod 

482 def _process_bdms_for_create( 

483 context, target, server_dict, create_kwargs): 

484 """Processes block_device_mapping(_v2) req parameters for server create 

485 

486 :param context: The nova auth request context 

487 :param target: The target dict for ``context.can`` policy checks 

488 :param server_dict: The POST /servers request body "server" entry 

489 :param create_kwargs: dict that gets populated by this method and 

490 passed to nova.compute.api.API.create() 

491 :raises: webob.exc.HTTPBadRequest if the request parameters are invalid 

492 :raises: nova.exception.Forbidden if a policy check fails 

493 """ 

494 block_device_mapping_legacy = server_dict.get('block_device_mapping', 

495 []) 

496 block_device_mapping_v2 = server_dict.get('block_device_mapping_v2', 

497 []) 

498 

499 if block_device_mapping_legacy and block_device_mapping_v2: 

500 expl = _('Using different block_device_mapping syntaxes ' 

501 'is not allowed in the same request.') 

502 raise exc.HTTPBadRequest(explanation=expl) 

503 

504 if block_device_mapping_legacy: 

505 for bdm in block_device_mapping_legacy: 

506 if 'delete_on_termination' in bdm: 

507 bdm['delete_on_termination'] = strutils.bool_from_string( 

508 bdm['delete_on_termination']) 

509 create_kwargs[ 

510 'block_device_mapping'] = block_device_mapping_legacy 

511 # Sets the legacy_bdm flag if we got a legacy block device mapping. 

512 create_kwargs['legacy_bdm'] = True 

513 elif block_device_mapping_v2: 

514 # Have to check whether --image is given, see bug 1433609 

515 image_href = server_dict.get('imageRef') 

516 image_uuid_specified = image_href is not None 

517 try: 

518 block_device_mapping = [ 

519 block_device.BlockDeviceDict.from_api(bdm_dict, 

520 image_uuid_specified) 

521 for bdm_dict in block_device_mapping_v2] 

522 except exception.InvalidBDMFormat as e: 

523 raise exc.HTTPBadRequest(explanation=e.format_message()) 

524 create_kwargs['block_device_mapping'] = block_device_mapping 

525 # Unset the legacy_bdm flag if we got a block device mapping. 

526 create_kwargs['legacy_bdm'] = False 

527 

528 block_device_mapping = create_kwargs.get("block_device_mapping") 

529 if block_device_mapping: 

530 context.can(server_policies.SERVERS % 'create:attach_volume', 

531 target) 

532 

533 def _process_networks_for_create( 

534 self, context, target, server_dict, create_kwargs): 

535 """Processes networks request parameter for server create 

536 

537 :param context: The nova auth request context 

538 :param target: The target dict for ``context.can`` policy checks 

539 :param server_dict: The POST /servers request body "server" entry 

540 :param create_kwargs: dict that gets populated by this method and 

541 passed to nova.compute.api.API.create() 

542 :raises: webob.exc.HTTPBadRequest if the request parameters are invalid 

543 :raises: nova.exception.Forbidden if a policy check fails 

544 """ 

545 requested_networks = server_dict.get('networks', None) 

546 

547 if requested_networks is not None: 

548 requested_networks = self._get_requested_networks( 

549 requested_networks) 

550 

551 # Skip policy check for 'create:attach_network' if there is no 

552 # network allocation request. 

553 if requested_networks and len(requested_networks) and \ 

554 not requested_networks.no_allocate: 

555 context.can(server_policies.SERVERS % 'create:attach_network', 

556 target) 

557 

558 create_kwargs['requested_networks'] = requested_networks 

559 

560 @staticmethod 

561 def _validate_host_availability_zone(context, availability_zone, host): 

562 """Ensure the host belongs in the availability zone. 

563 

564 This is slightly tricky and it's probably worth recapping how host 

565 aggregates and availability zones are related before reading. Hosts can 

566 belong to zero or more host aggregates, but they will always belong to 

567 exactly one availability zone. If the user has set the availability 

568 zone key on one of the host aggregates that the host is a member of 

569 then the host will belong to this availability zone. If the user has 

570 not set the availability zone key on any of the host aggregates that 

571 the host is a member of or the host is not a member of any host 

572 aggregates, then the host will belong to the default availability zone. 

573 Setting the availability zone key on more than one of host aggregates 

574 that the host is a member of is an error and will be rejected by the 

575 API. 

576 

577 Given the above, our host-availability zone check needs to vary 

578 behavior based on whether we're requesting the default availability 

579 zone or not. If we are not, then we simply ask "does this host belong 

580 to a host aggregate and, if so, do any of the host aggregates have the 

581 requested availability zone metadata set". By comparison, if we *are* 

582 requesting the default availability zone then we want to ask the 

583 inverse, or "does this host not belong to a host aggregate or, if it 

584 does, is the availability zone information unset (or, naughty naughty, 

585 set to the default) for each of the host aggregates". If both cases, if 

586 the answer is no then we warn about the mismatch and then use the 

587 actual availability zone of the host to avoid mismatches. 

588 

589 :param context: The nova auth request context 

590 :param availability_zone: The name of the requested availability zone 

591 :param host: The name of the requested host 

592 :returns: The availability zone that should actually be used for the 

593 request 

594 """ 

595 aggregates = objects.AggregateList.get_by_host(context, host=host) 

596 if not aggregates: 

597 # a host is assigned to the default availability zone if it is not 

598 # a member of any host aggregates 

599 if availability_zone == CONF.default_availability_zone: 

600 return availability_zone 

601 

602 LOG.warning( 

603 "Requested availability zone '%s' but forced host '%s' " 

604 "does not belong to any availability zones; ignoring " 

605 "requested availability zone to avoid bug #1934770", 

606 availability_zone, host, 

607 ) 

608 return None 

609 

610 # only one host aggregate will have the availability_zone field set so 

611 # use the first non-null value 

612 host_availability_zone = next( 

613 (a.availability_zone for a in aggregates if a.availability_zone), 

614 None, 

615 ) 

616 

617 if availability_zone == host_availability_zone: 

618 # if there's an exact match, use what the user requested 

619 return availability_zone 

620 

621 if ( 

622 availability_zone == CONF.default_availability_zone and 

623 host_availability_zone is None 

624 ): 

625 # special case the default availability zone since this won't (or 

626 # rather shouldn't) be explicitly stored on any host aggregate 

627 return availability_zone 

628 

629 # no match, so use the host's availability zone information, if any 

630 LOG.warning( 

631 "Requested availability zone '%s' but forced host '%s' " 

632 "does not belong to this availability zone; overwriting " 

633 "requested availability zone to avoid bug #1934770", 

634 availability_zone, host, 

635 ) 

636 return None 

637 

638 @staticmethod 

639 def _process_hosts_for_create( 

640 context, target, server_dict, create_kwargs, host, node): 

641 """Processes hosts request parameter for server create 

642 

643 :param context: The nova auth request context 

644 :param target: The target dict for ``context.can`` policy checks 

645 :param server_dict: The POST /servers request body "server" entry 

646 :param create_kwargs: dict that gets populated by this method and 

647 passed to nova.compute.api.API.create() 

648 :param host: Forced host of availability_zone 

649 :param node: Forced node of availability_zone 

650 :raise: webob.exc.HTTPBadRequest if the request parameters are invalid 

651 :raise: nova.exception.Forbidden if a policy check fails 

652 """ 

653 requested_host = server_dict.get('host') 

654 requested_hypervisor_hostname = server_dict.get('hypervisor_hostname') 

655 if requested_host or requested_hypervisor_hostname: 

656 # If the policy check fails, this will raise Forbidden exception. 

657 context.can(server_policies.REQUESTED_DESTINATION, target=target) 

658 if host or node: 

659 msg = _("One mechanism with host and/or " 

660 "hypervisor_hostname and another mechanism " 

661 "with zone:host:node are mutually exclusive.") 

662 raise exc.HTTPBadRequest(explanation=msg) 

663 create_kwargs['requested_host'] = requested_host 

664 create_kwargs['requested_hypervisor_hostname'] = ( 

665 requested_hypervisor_hostname) 

666 

667 @wsgi.response(202) 

668 @wsgi.expected_errors((400, 403, 409)) 

669 @validation.schema(schema.create_v20, '2.0', '2.0') 

670 @validation.schema(schema.create, '2.1', '2.18') 

671 @validation.schema(schema.create_v219, '2.19', '2.31') 

672 @validation.schema(schema.create_v232, '2.32', '2.32') 

673 @validation.schema(schema.create_v233, '2.33', '2.36') 

674 @validation.schema(schema.create_v237, '2.37', '2.41') 

675 @validation.schema(schema.create_v242, '2.42', '2.51') 

676 @validation.schema(schema.create_v252, '2.52', '2.56') 

677 @validation.schema(schema.create_v257, '2.57', '2.62') 

678 @validation.schema(schema.create_v263, '2.63', '2.66') 

679 @validation.schema(schema.create_v267, '2.67', '2.73') 

680 @validation.schema(schema.create_v274, '2.74', '2.89') 

681 @validation.schema(schema.create_v290, '2.90', '2.93') 

682 @validation.schema(schema.create_v294, '2.94') 

683 def create(self, req, body): 

684 """Creates a new server for a given user.""" 

685 context = req.environ['nova.context'] 

686 server_dict = body['server'] 

687 password = self._get_server_admin_password(server_dict) 

688 name = common.normalize_name(server_dict['name']) 

689 description = name 

690 if api_version_request.is_supported(req, min_version='2.19'): 

691 description = server_dict.get('description') 

692 hostname = None 

693 if api_version_request.is_supported(req, min_version='2.90'): 

694 hostname = server_dict.get('hostname') 

695 

696 # Arguments to be passed to instance create function 

697 create_kwargs = {} 

698 

699 create_kwargs['user_data'] = server_dict.get('user_data') 

700 # NOTE(alex_xu): The v2.1 API compat mode, we strip the spaces for 

701 # keypair create. But we didn't strip spaces at here for 

702 # backward-compatible some users already created keypair and name with 

703 # leading/trailing spaces by legacy v2 API. 

704 create_kwargs['key_name'] = server_dict.get('key_name') 

705 create_kwargs['config_drive'] = server_dict.get('config_drive') 

706 security_groups = server_dict.get('security_groups') 

707 if security_groups is not None: 

708 create_kwargs['security_groups'] = [ 

709 sg['name'] for sg in security_groups if sg.get('name')] 

710 create_kwargs['security_groups'] = list( 

711 set(create_kwargs['security_groups'])) 

712 

713 scheduler_hints = {} 

714 if 'os:scheduler_hints' in body: 

715 scheduler_hints = body['os:scheduler_hints'] 

716 elif 'OS-SCH-HNT:scheduler_hints' in body: 

717 scheduler_hints = body['OS-SCH-HNT:scheduler_hints'] 

718 create_kwargs['scheduler_hints'] = scheduler_hints 

719 

720 # min_count and max_count are optional. If they exist, they may come 

721 # in as strings. Verify that they are valid integers and > 0. 

722 # Also, we want to default 'min_count' to 1, and default 

723 # 'max_count' to be 'min_count'. 

724 min_count = int(server_dict.get('min_count', 1)) 

725 max_count = int(server_dict.get('max_count', min_count)) 

726 if min_count > max_count: 

727 msg = _('min_count must be <= max_count') 

728 raise exc.HTTPBadRequest(explanation=msg) 

729 create_kwargs['min_count'] = min_count 

730 create_kwargs['max_count'] = max_count 

731 

732 availability_zone = server_dict.pop("availability_zone", None) 

733 

734 if api_version_request.is_supported(req, min_version='2.52'): 

735 create_kwargs['tags'] = server_dict.get('tags') 

736 

737 helpers.translate_attributes(helpers.CREATE, 

738 server_dict, create_kwargs) 

739 

740 target = { 

741 'project_id': context.project_id, 

742 'user_id': context.user_id, 

743 'availability_zone': availability_zone} 

744 context.can(server_policies.SERVERS % 'create', target) 

745 

746 # Skip policy check for 'create:trusted_certs' if no trusted 

747 # certificate IDs were provided. 

748 trusted_certs = server_dict.get('trusted_image_certificates', None) 

749 if trusted_certs: 

750 create_kwargs['trusted_certs'] = trusted_certs 

751 context.can(server_policies.SERVERS % 'create:trusted_certs', 

752 target=target) 

753 

754 parse_az = self.compute_api.parse_availability_zone 

755 try: 

756 availability_zone, host, node = parse_az(context, 

757 availability_zone) 

758 except exception.InvalidInput as err: 

759 raise exc.HTTPBadRequest(explanation=str(err)) 

760 if host or node: 

761 context.can(server_policies.SERVERS % 'create:forced_host', 

762 target=target) 

763 availability_zone = self._validate_host_availability_zone( 

764 context, availability_zone, host) 

765 

766 if api_version_request.is_supported(req, min_version='2.74'): 

767 self._process_hosts_for_create(context, target, server_dict, 

768 create_kwargs, host, node) 

769 

770 self._process_bdms_for_create( 

771 context, target, server_dict, create_kwargs) 

772 

773 image_uuid = self._image_from_req_data(server_dict, create_kwargs) 

774 

775 self._process_networks_for_create( 

776 context, target, server_dict, create_kwargs) 

777 

778 flavor_id = self._flavor_id_from_req_data(body) 

779 try: 

780 flavor = flavors.get_flavor_by_flavor_id( 

781 flavor_id, ctxt=context, read_deleted="no") 

782 

783 supports_multiattach = common.supports_multiattach_volume(req) 

784 supports_port_resource_request = \ 

785 common.supports_port_resource_request(req) 

786 instances, resv_id = self.compute_api.create( 

787 context, 

788 flavor, 

789 image_uuid, 

790 display_name=name, 

791 display_description=description, 

792 hostname=hostname, 

793 availability_zone=availability_zone, 

794 forced_host=host, forced_node=node, 

795 metadata=server_dict.get('metadata', {}), 

796 admin_password=password, 

797 check_server_group_quota=True, 

798 supports_multiattach=supports_multiattach, 

799 supports_port_resource_request=supports_port_resource_request, 

800 **create_kwargs) 

801 except exception.OverQuota as error: 

802 raise exc.HTTPForbidden( 

803 explanation=error.format_message()) 

804 except exception.ImageNotFound: 

805 msg = _("Can not find requested image") 

806 raise exc.HTTPBadRequest(explanation=msg) 

807 except exception.KeypairNotFound: 

808 msg = _("Invalid key_name provided.") 

809 raise exc.HTTPBadRequest(explanation=msg) 

810 except exception.ConfigDriveInvalidValue: 

811 msg = _("Invalid config_drive provided.") 

812 raise exc.HTTPBadRequest(explanation=msg) 

813 except (exception.BootFromVolumeRequiredForZeroDiskFlavor, 

814 exception.ExternalNetworkAttachForbidden) as error: 

815 raise exc.HTTPForbidden(explanation=error.format_message()) 

816 except messaging.RemoteError as err: 

817 msg = "%(err_type)s: %(err_msg)s" % {'err_type': err.exc_type, 

818 'err_msg': err.value} 

819 raise exc.HTTPBadRequest(explanation=msg) 

820 except UnicodeDecodeError as error: 

821 msg = "UnicodeError: %s" % error 

822 raise exc.HTTPBadRequest(explanation=msg) 

823 except (exception.ImageNotActive, 

824 exception.ImageBadRequest, 

825 exception.ImageNotAuthorized, 

826 exception.ImageUnacceptable, 

827 exception.FixedIpNotFoundForAddress, 

828 exception.FlavorNotFound, 

829 exception.InvalidMetadata, 

830 exception.InvalidVolume, 

831 exception.VolumeNotFound, 

832 exception.MismatchVolumeAZException, 

833 exception.MultiplePortsNotApplicable, 

834 exception.InvalidFixedIpAndMaxCountRequest, 

835 exception.AmbiguousHostnameForMultipleInstances, 

836 exception.InstanceUserDataMalformed,