diff options
35 files changed, 1774 insertions, 1254 deletions
diff --git a/doc/source/devref/distributed_scheduler.rst b/doc/source/devref/distributed_scheduler.rst index c63e62f7f..7a631d69f 100644 --- a/doc/source/devref/distributed_scheduler.rst +++ b/doc/source/devref/distributed_scheduler.rst @@ -77,6 +77,8 @@ The filtering (excluding compute nodes incapable of fulfilling the request) and Requesting a new instance ------------------------- +(Note: The information below is out of date, as the `nova.compute.api.create_all_at_once()` functionality has merged into `nova.compute.api.create()` and the non-zone aware schedulers have been updated.) + Prior to the `BaseScheduler`, to request a new instance, a call was made to `nova.compute.api.create()`. The type of instance created depended on the value of the `InstanceType` record being passed in. The `InstanceType` determined the amount of disk, CPU, RAM and network required for the instance. Administrators can add new `InstanceType` records to suit their needs. For more complicated instance requests we need to go beyond the default fields in the `InstanceType` table. `nova.compute.api.create()` performed the following actions: diff --git a/nova/api/ec2/cloud.py b/nova/api/ec2/cloud.py index 3c8cd513f..a71ab8cf0 100644 --- a/nova/api/ec2/cloud.py +++ b/nova/api/ec2/cloud.py @@ -1385,7 +1385,7 @@ class CloudController(object): if image_state != 'available': raise exception.ApiError(_('Image must be available')) - instances = self.compute_api.create(context, + (instances, resv_id) = self.compute_api.create(context, instance_type=instance_types.get_instance_type_by_name( kwargs.get('instance_type', None)), image_href=self._get_image(context, kwargs['image_id'])['id'], @@ -1400,9 +1400,11 @@ class CloudController(object): security_group=kwargs.get('security_group'), availability_zone=kwargs.get('placement', {}).get( 'AvailabilityZone'), - block_device_mapping=kwargs.get('block_device_mapping', {})) - return self._format_run_instances(context, - reservation_id=instances[0]['reservation_id']) + block_device_mapping=kwargs.get('block_device_mapping', {}), + # NOTE(comstud): Unfortunately, EC2 requires that the + # instance DB entries have been created.. + wait_for_instances=True) + return self._format_run_instances(context, resv_id) def _do_instance(self, action, context, ec2_id): instance_id = ec2utils.ec2_id_to_id(ec2_id) diff --git a/nova/api/openstack/__init__.py b/nova/api/openstack/__init__.py index 3b74fefc9..b517eae2c 100644 --- a/nova/api/openstack/__init__.py +++ b/nova/api/openstack/__init__.py @@ -139,8 +139,7 @@ class APIRouter(base_wsgi.Router): controller=zones.create_resource(version), collection={'detail': 'GET', 'info': 'GET', - 'select': 'POST', - 'boot': 'POST'}) + 'select': 'POST'}) mapper.connect("versions", "/", controller=versions.create_resource(version), diff --git a/nova/api/openstack/contrib/createserverext.py b/nova/api/openstack/contrib/createserverext.py index af7f37f13..1e13e10d4 100644 --- a/nova/api/openstack/contrib/createserverext.py +++ b/nova/api/openstack/contrib/createserverext.py @@ -15,7 +15,6 @@ # under the License from nova import utils -from nova.api.openstack import create_instance_helper as helper from nova.api.openstack import extensions from nova.api.openstack import servers from nova.api.openstack import wsgi @@ -66,7 +65,7 @@ class Createserverext(extensions.ExtensionDescriptor): } body_deserializers = { - 'application/xml': helper.ServerXMLDeserializerV11(), + 'application/xml': servers.ServerXMLDeserializerV11(), } serializer = wsgi.ResponseSerializer(body_serializers, diff --git a/nova/api/openstack/contrib/volumes.py b/nova/api/openstack/contrib/volumes.py index 9d4254f1f..6c79a0538 100644 --- a/nova/api/openstack/contrib/volumes.py +++ b/nova/api/openstack/contrib/volumes.py @@ -334,47 +334,8 @@ class VolumeAttachmentController(object): class BootFromVolumeController(servers.ControllerV11): """The boot from volume API controller for the Openstack API.""" - def _create_instance(self, context, instance_type, image_href, **kwargs): - try: - return self.compute_api.create(context, instance_type, - image_href, **kwargs) - except quota.QuotaError as error: - self.helper._handle_quota_error(error) - except exception.ImageNotFound as error: - msg = _("Can not find requested image") - raise faults.Fault(exc.HTTPBadRequest(explanation=msg)) - - def create(self, req, body): - """ Creates a new server for a given user """ - extra_values = None - try: - - def get_kwargs(context, instance_type, image_href, **kwargs): - kwargs['context'] = context - kwargs['instance_type'] = instance_type - kwargs['image_href'] = image_href - return kwargs - - extra_values, kwargs = self.helper.create_instance(req, body, - get_kwargs) - - block_device_mapping = body['server'].get('block_device_mapping') - kwargs['block_device_mapping'] = block_device_mapping - - instances = self._create_instance(**kwargs) - except faults.Fault, f: - return f - - # We can only return 1 instance via the API, if we happen to - # build more than one... instances is a list, so we'll just - # use the first one.. - inst = instances[0] - for key in ['instance_type', 'image_ref']: - inst[key] = extra_values[key] - - server = self._build_view(req, inst, is_detail=True) - server['server']['adminPass'] = extra_values['password'] - return server + def _get_block_device_mapping(self, data): + return data.get('block_device_mapping') class Volumes(extensions.ExtensionDescriptor): diff --git a/nova/api/openstack/contrib/zones.py b/nova/api/openstack/contrib/zones.py new file mode 100644 index 000000000..5901e321e --- /dev/null +++ b/nova/api/openstack/contrib/zones.py @@ -0,0 +1,50 @@ +# vim: tabstop=4 shiftwidth=4 softtabstop=4 + +# Copyright 2011 OpenStack LLC. +# All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. + +"""The zones extension.""" + + +from nova import flags +from nova import log as logging +from nova.api.openstack import extensions + + +LOG = logging.getLogger("nova.api.zones") +FLAGS = flags.FLAGS + + +class Zones(extensions.ExtensionDescriptor): + def get_name(self): + return "Zones" + + def get_alias(self): + return "os-zones" + + def get_description(self): + return """Enables zones-related functionality such as adding +child zones, listing child zones, getting the capabilities of the +local zone, and returning build plans to parent zones' schedulers""" + + def get_namespace(self): + return "http://docs.openstack.org/ext/zones/api/v1.1" + + def get_updated(self): + return "2011-09-21T00:00:00+00:00" + + def get_resources(self): + # Nothing yet. + return [] diff --git a/nova/api/openstack/create_instance_helper.py b/nova/api/openstack/create_instance_helper.py deleted file mode 100644 index dde9187cd..000000000 --- a/nova/api/openstack/create_instance_helper.py +++ /dev/null @@ -1,606 +0,0 @@ -# Copyright 2011 OpenStack LLC. -# Copyright 2011 Piston Cloud Computing, Inc. -# All Rights Reserved. -# -# Licensed under the Apache License, Version 2.0 (the "License"); you may -# not use this file except in compliance with the License. You may obtain -# a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations -# under the License. - -import base64 - -from webob import exc -from xml.dom import minidom - -from nova import exception -from nova import flags -from nova import log as logging -import nova.image -from nova import quota -from nova import utils - -from nova.compute import instance_types -from nova.api.openstack import common -from nova.api.openstack import wsgi -from nova.rpc.common import RemoteError - -LOG = logging.getLogger('nova.api.openstack.create_instance_helper') -FLAGS = flags.FLAGS - - -class CreateFault(exception.NovaException): - message = _("Invalid parameters given to create_instance.") - - def __init__(self, fault): - self.fault = fault - super(CreateFault, self).__init__() - - -class CreateInstanceHelper(object): - """This is the base class for OS API Controllers that - are capable of creating instances (currently Servers and Zones). - - Once we stabilize the Zones portion of the API we may be able - to move this code back into servers.py - """ - - def __init__(self, controller): - """We need the image service to create an instance.""" - self.controller = controller - self._image_service = utils.import_object(FLAGS.image_service) - super(CreateInstanceHelper, self).__init__() - - def create_instance(self, req, body, create_method): - """Creates a new server for the given user. The approach - used depends on the create_method. For example, the standard - POST /server call uses compute.api.create(), while - POST /zones/server uses compute.api.create_all_at_once(). - - The problem is, both approaches return different values (i.e. - [instance dicts] vs. reservation_id). So the handling of the - return type from this method is left to the caller. - """ - if not body: - raise exc.HTTPUnprocessableEntity() - - if not 'server' in body: - raise exc.HTTPUnprocessableEntity() - - context = req.environ['nova.context'] - server_dict = body['server'] - password = self.controller._get_server_admin_password(server_dict) - - if not 'name' in server_dict: - msg = _("Server name is not defined") - raise exc.HTTPBadRequest(explanation=msg) - - name = server_dict['name'] - self._validate_server_name(name) - name = name.strip() - - image_href = self.controller._image_ref_from_req_data(body) - # If the image href was generated by nova api, strip image_href - # down to an id and use the default glance connection params - - if str(image_href).startswith(req.application_url): - image_href = image_href.split('/').pop() - try: - image_service, image_id = nova.image.get_image_service(context, - image_href) - kernel_id, ramdisk_id = self._get_kernel_ramdisk_from_image( - req, image_service, image_id) - images = set([str(x['id']) for x in image_service.index(context)]) - assert str(image_id) in images - except Exception, e: - msg = _("Cannot find requested image %(image_href)s: %(e)s" % - locals()) - raise exc.HTTPBadRequest(explanation=msg) - - personality = server_dict.get('personality') - config_drive = server_dict.get('config_drive') - - injected_files = [] - if personality: - injected_files = self._get_injected_files(personality) - - sg_names = [] - security_groups = server_dict.get('security_groups') - if security_groups is not None: - sg_names = [sg['name'] for sg in security_groups if sg.get('name')] - if not sg_names: - sg_names.append('default') - - sg_names = list(set(sg_names)) - - requested_networks = server_dict.get('networks') - if requested_networks is not None: - requested_networks = self._get_requested_networks( - requested_networks) - - try: - flavor_id = self.controller._flavor_id_from_req_data(body) - except ValueError as error: - msg = _("Invalid flavorRef provided.") - raise exc.HTTPBadRequest(explanation=msg) - - zone_blob = server_dict.get('blob') - - # optional openstack extensions: - key_name = server_dict.get('key_name') - user_data = server_dict.get('user_data') - self._validate_user_data(user_data) - - availability_zone = server_dict.get('availability_zone') - name = server_dict['name'] - self._validate_server_name(name) - name = name.strip() - - reservation_id = server_dict.get('reservation_id') - min_count = server_dict.get('min_count') - max_count = server_dict.get('max_count') - # min_count and max_count are optional. If they exist, they come - # in as strings. We want to default 'min_count' to 1, and default - # 'max_count' to be 'min_count'. - min_count = int(min_count) if min_count else 1 - max_count = int(max_count) if max_count else min_count - if min_count > max_count: - min_count = max_count - - try: - inst_type = \ - instance_types.get_instance_type_by_flavor_id(flavor_id) - extra_values = { - 'instance_type': inst_type, - 'image_ref': image_href, - 'config_drive': config_drive, - 'password': password} - - return (extra_values, - create_method(context, - inst_type, - image_id, - kernel_id=kernel_id, - ramdisk_id=ramdisk_id, - display_name=name, - display_description=name, - key_name=key_name, - metadata=server_dict.get('metadata', {}), - access_ip_v4=server_dict.get('accessIPv4'), - access_ip_v6=server_dict.get('accessIPv6'), - injected_files=injected_files, - admin_password=password, - zone_blob=zone_blob, - reservation_id=reservation_id, - min_count=min_count, - max_count=max_count, - requested_networks=requested_networks, - security_group=sg_names, - user_data=user_data, - availability_zone=availability_zone, - config_drive=config_drive,)) - except quota.QuotaError as error: - self._handle_quota_error(error) - except exception.InstanceTypeMemoryTooSmall as error: - raise exc.HTTPBadRequest(explanation=unicode(error)) - except exception.InstanceTypeDiskTooSmall as error: - raise exc.HTTPBadRequest(explanation=unicode(error)) - except exception.ImageNotFound as error: - msg = _("Can not find requested image") - raise exc.HTTPBadRequest(explanation=msg) - except exception.FlavorNotFound as error: - msg = _("Invalid flavorRef provided.") - raise exc.HTTPBadRequest(explanation=msg) - except exception.KeypairNotFound as error: - msg = _("Invalid key_name provided.") - raise exc.HTTPBadRequest(explanation=msg) - except exception.SecurityGroupNotFound as error: - raise exc.HTTPBadRequest(explanation=unicode(error)) - except RemoteError as err: - msg = "%(err_type)s: %(err_msg)s" % \ - {'err_type': err.exc_type, 'err_msg': err.value} - raise exc.HTTPBadRequest(explanation=msg) - # Let the caller deal with unhandled exceptions. - - def _handle_quota_error(self, error): - """ - Reraise quota errors as api-specific http exceptions - """ - if error.code == "OnsetFileLimitExceeded": - expl = _("Personality file limit exceeded") - raise exc.HTTPRequestEntityTooLarge(explanation=error.message, - headers={'Retry-After': 0}) - if error.code == "OnsetFilePathLimitExceeded": - expl = _("Personality file path too long") - raise exc.HTTPRequestEntityTooLarge(explanation=error.message, - headers={'Retry-After': 0}) - if error.code == "OnsetFileContentLimitExceeded": - expl = _("Personality file content too long") - raise exc.HTTPRequestEntityTooLarge(explanation=error.message, - headers={'Retry-After': 0}) - if error.code == "InstanceLimitExceeded": - expl = _("Instance quotas have been exceeded") - raise exc.HTTPRequestEntityTooLarge(explanation=error.message, - headers={'Retry-After': 0}) - # if the original error is okay, just reraise it - raise error - - def _deserialize_create(self, request): - """ - Deserialize a create request - - Overrides normal behavior in the case of xml content - """ - if request.content_type == "application/xml": - deserializer = ServerXMLDeserializer() - return deserializer.deserialize(request.body) - else: - return self._deserialize(request.body, request.get_content_type()) - - def _validate_server_name(self, value): - if not isinstance(value, basestring): - msg = _("Server name is not a string or unicode") - raise exc.HTTPBadRequest(explanation=msg) - - if value.strip() == '': - msg = _("Server name is an empty string") - raise exc.HTTPBadRequest(explanation=msg) - - def _get_kernel_ramdisk_from_image(self, req, image_service, image_id): - """Fetch an image from the ImageService, then if present, return the - associated kernel and ramdisk image IDs. - """ - context = req.environ['nova.context'] - image_meta = image_service.show(context, image_id) - # NOTE(sirp): extracted to a separate method to aid unit-testing, the - # new method doesn't need a request obj or an ImageService stub - kernel_id, ramdisk_id = self._do_get_kernel_ramdisk_from_image( - image_meta) - return kernel_id, ramdisk_id - - @staticmethod - def _do_get_kernel_ramdisk_from_image(image_meta): - """Given an ImageService image_meta, return kernel and ramdisk image - ids if present. - - This is only valid for `ami` style images. - """ - image_id = image_meta['id'] - if image_meta['status'] != 'active': - raise exception.ImageUnacceptable(image_id=image_id, - reason=_("status is not active")) - - if image_meta.get('container_format') != 'ami': - return None, None - - try: - kernel_id = image_meta['properties']['kernel_id'] - except KeyError: - raise exception.KernelNotFoundForImage(image_id=image_id) - - try: - ramdisk_id = image_meta['properties']['ramdisk_id'] - except KeyError: - ramdisk_id = None - - return kernel_id, ramdisk_id - - def _get_injected_files(self, personality): - """ - Create a list of injected files from the personality attribute - - At this time, injected_files must be formatted as a list of - (file_path, file_content) pairs for compatibility with the - underlying compute service. - """ - injected_files = [] - - for item in personality: - try: - path = item['path'] - contents = item['contents'] - except KeyError as key: - expl = _('Bad personality format: missing %s') % key - raise exc.HTTPBadRequest(explanation=expl) - except TypeError: - expl = _('Bad personality format') - raise exc.HTTPBadRequest(explanation=expl) - try: - contents = base64.b64decode(contents) - except TypeError: - expl = _('Personality content for %s cannot be decoded') % path - raise exc.HTTPBadRequest(explanation=expl) - injected_files.append((path, contents)) - return injected_files - - def _get_server_admin_password_old_style(self, server): - """ Determine the admin password for a server on creation """ - return utils.generate_password(FLAGS.password_length) - - def _get_server_admin_password_new_style(self, server): - """ Determine the admin password for a server on creation """ - password = server.get('adminPass') - - if password is None: - return utils.generate_password(FLAGS.password_length) - if not isinstance(password, basestring) or password == '': - msg = _("Invalid adminPass") - raise exc.HTTPBadRequest(explanation=msg) - return password - - def _get_requested_networks(self, requested_networks): - """ - Create a list of requested networks from the networks attribute - """ - networks = [] - for network in requested_networks: - try: - network_uuid = network['uuid'] - - if not utils.is_uuid_like(network_uuid): - msg = _("Bad networks format: network uuid is not in" - " proper format (%s)") % network_uuid - raise exc.HTTPBadRequest(explanation=msg) - - #fixed IP address is optional - #if the fixed IP address is not provided then - #it will use one of the available IP address from the network - address = network.get('fixed_ip', None) - if address is not None and not utils.is_valid_ipv4(address): - msg = _("Invalid fixed IP address (%s)") % address - raise exc.HTTPBadRequest(explanation=msg) - # check if the network id is already present in the list, - # we don't want duplicate networks to be passed - # at the boot time - for id, ip in networks: - if id == network_uuid: - expl = _("Duplicate networks (%s) are not allowed")\ - % network_uuid - raise exc.HTTPBadRequest(explanation=expl) - - networks.append((network_uuid, address)) - except KeyError as key: - expl = _('Bad network format: missing %s') % key - raise exc.HTTPBadRequest(explanation=expl) - except TypeError: - expl = _('Bad networks format') - raise exc.HTTPBadRequest(explanation=expl) - - return networks - - def _validate_user_data(self, user_data): - """Check if the user_data is encoded properly""" - if not user_data: - return - try: - user_data = base64.b64decode(user_data) - except TypeError: - expl = _('Userdata content cannot be decoded') - raise exc.HTTPBadRequest(explanation=expl) - - -class ServerXMLDeserializer(wsgi.XMLDeserializer): - """ - Deserializer to handle xml-formatted server create requests. - - Handles standard server attributes as well as optional metadata - and personality attributes - """ - - metadata_deserializer = common.MetadataXMLDeserializer() - - def create(self, string): - """Deserialize an xml-formatted server create request""" - dom = minidom.parseString(string) - server = self._extract_server(dom) - return {'body': {'server': server}} - - def _extract_server(self, node): - """Marshal the server attribute of a parsed request""" - server = {} - server_node = self.find_first_child_named(node, 'server') - - attributes = ["name", "imageId", "flavorId", "adminPass"] - for attr in attributes: - if server_node.getAttribute(attr): - server[attr] = server_node.getAttribute(attr) - - metadata_node = self.find_first_child_named(server_node, "metadata") - server["metadata"] = self.metadata_deserializer.extract_metadata( - metadata_node) - - server["personality"] = self._extract_personality(server_node) - - return server - - def _extract_personality(self, server_node): - """Marshal the personality attribute of a parsed request""" - node = self.find_first_child_named(server_node, "personality") - personality = [] - if node is not None: - for file_node in self.find_children_named(node, "file"): - item = {} - if file_node.hasAttribute("path"): - item["path"] = file_node.getAttribute("path") - item["contents"] = self.extract_text(file_node) - personality.append(item) - return personality - - -class ServerXMLDeserializerV11(wsgi.MetadataXMLDeserializer): - """ - Deserializer to handle xml-formatted server create requests. - - Handles standard server attributes as well as optional metadata - and personality attributes - """ - - metadata_deserializer = common.MetadataXMLDeserializer() - - def action(self, string): - dom = minidom.parseString(string) - action_node = dom.childNodes[0] - action_name = action_node.tagName - - action_deserializer = { - 'createImage': self._action_create_image, - 'createBackup': self._action_create_backup, - 'changePassword': self._action_change_password, - 'reboot': self._action_reboot, - 'rebuild': self._action_rebuild, - 'resize': self._action_resize, - 'confirmResize': self._action_confirm_resize, - 'revertResize': self._action_revert_resize, - }.get(action_name, self.default) - - action_data = action_deserializer(action_node) - - return {'body': {action_name: action_data}} - - def _action_create_image(self, node): - return self._deserialize_image_action(node, ('name',)) - - def _action_create_backup(self, node): - attributes = ('name', 'backup_type', 'rotation') - return self._deserialize_image_action(node, attributes) - - def _action_change_password(self, node): - if not node.hasAttribute("adminPass"): - raise AttributeError("No adminPass was specified in request") - return {"adminPass": node.getAttribute("adminPass")} - - def _action_reboot(self, node): - if not node.hasAttribute("type"): - raise AttributeError("No reboot type was specified in request") - return {"type": node.getAttribute("type")} - - def _action_rebuild(self, node): - rebuild = {} - if node.hasAttribute("name"): - rebuild['name'] = node.getAttribute("name") - - metadata_node = self.find_first_child_named(node, "metadata") - if metadata_node is not None: - rebuild["metadata"] = self.extract_metadata(metadata_node) - - personality = self._extract_personality(node) - if personality is not None: - rebuild["personality"] = personality - - if not node.hasAttribute("imageRef"): - raise AttributeError("No imageRef was specified in request") - rebuild["imageRef"] = node.getAttribute("imageRef") - - return rebuild - - def _action_resize(self, node): - if not node.hasAttribute("flavorRef"): - raise AttributeError("No flavorRef was specified in request") - return {"flavorRef": node.getAttribute("flavorRef")} - - def _action_confirm_resize(self, node): - return None - - def _action_revert_resize(self, node): - return None - - def _deserialize_image_action(self, node, allowed_attributes): - data = {} - for attribute in allowed_attributes: - value = node.getAttribute(attribute) - if value: - data[attribute] = value - metadata_node = self.find_first_child_named(node, 'metadata') - if metadata_node is not None: - metadata = self.metadata_deserializer.extract_metadata( - metadata_node) - data['metadata'] = metadata - return data - - def create(self, string): - """Deserialize an xml-formatted server create request""" - dom = minidom.parseString(string) - server = self._extract_server(dom) - return {'body': {'server': server}} - - def _extract_server(self, node): - """Marshal the server attribute of a parsed request""" - server = {} - server_node = self.find_first_child_named(node, 'server') - - attributes = ["name", "imageRef", "flavorRef", "adminPass", - "accessIPv4", "accessIPv6"] - for attr in attributes: - if server_node.getAttribute(attr): - server[attr] = server_node.getAttribute(attr) - - metadata_node = self.find_first_child_named(server_node, "metadata") - if metadata_node is not None: - server["metadata"] = self.extract_metadata(metadata_node) - - personality = self._extract_personality(server_node) - if personality is not None: - server["personality"] = personality - - networks = self._extract_networks(server_node) - if networks is not None: - server["networks"] = networks - - security_groups = self._extract_security_groups(server_node) - if security_groups is not None: - server["security_groups"] = security_groups - - return server - - def _extract_personality(self, server_node): - """Marshal the personality attribute of a parsed request""" - node = self.find_first_child_named(server_node, "personality") - if node is not None: - personality = [] - for file_node in self.find_children_named(node, "file"): - item = {} - if file_node.hasAttribute("path"): - item["path"] = file_node.getAttribute("path") - item["contents"] = self.extract_text(file_node) - personality.append(item) - return personality - else: - return None - - def _extract_networks(self, server_node): - """Marshal the networks attribute of a parsed request""" - node = self.find_first_child_named(server_node, "networks") - if node is not None: - networks = [] - for network_node in self.find_children_named(node, - "network"): - item = {} - if network_node.hasAttribute("uuid"): - item["uuid"] = network_node.getAttribute("uuid") - if network_node.hasAttribute("fixed_ip"): - item["fixed_ip"] = network_node.getAttribute("fixed_ip") - networks.append(item) - return networks - else: - return None - - def _extract_security_groups(self, server_node): - """Marshal the security_groups attribute of a parsed request""" - node = self.find_first_child_named(server_node, "security_groups") - if node is not None: - security_groups = [] - for sg_node in self.find_children_named(node, "security_group"): - item = {} - name_node = self.find_first_child_named(sg_node, "name") - if name_node: - item["name"] = self.extract_text(name_node) - security_groups.append(item) - return security_groups - else: - return None diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py index e92ab9bda..4a2d0bcbc 100644 --- a/nova/api/openstack/servers.py +++ b/nova/api/openstack/servers.py @@ -1,4 +1,5 @@ # Copyright 2010 OpenStack LLC. +# Copyright 2011 Piston Cloud Computing, Inc # All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); you may @@ -21,18 +22,21 @@ from novaclient import exceptions as novaclient_exceptions from lxml import etree from webob import exc import webob +from xml.dom import minidom from nova import compute from nova import network from nova import db from nova import exception from nova import flags +from nova import image from nova import log as logging from nova import utils +from nova import quota from nova.api.openstack import common -from nova.api.openstack import create_instance_helper as helper from nova.api.openstack import ips from nova.api.openstack import wsgi +from nova.compute import instance_types from nova.scheduler import api as scheduler_api import nova.api.openstack import nova.api.openstack.views.addresses @@ -40,6 +44,7 @@ import nova.api.openstack.views.flavors import nova.api.openstack.views.images import nova.api.openstack.views.servers from nova.api.openstack import xmlutil +from nova.rpc import common as rpc_common LOG = logging.getLogger('nova.api.openstack.servers') @@ -73,7 +78,6 @@ class Controller(object): def __init__(self): self.compute_api = compute.API() self.network_api = network.API() - self.helper = helper.CreateInstanceHelper(self) def index(self, req): """ Returns a list of server names and ids for a given user """ @@ -107,11 +111,23 @@ class Controller(object): def _action_rebuild(self, info, request, instance_id): raise NotImplementedError() + def _get_block_device_mapping(self, data): + """Get block_device_mapping from 'server' dictionary. + Overidden by volumes controller. + """ + return None + def _get_networks_for_instance(self, req, instance): return ips._get_networks_for_instance(req.environ['nova.context'], self.network_api, instance) + def _get_block_device_mapping(self, data): + """Get block_device_mapping from 'server' dictionary. + Overidden by volumes controller. + """ + return None + def _get_servers(self, req, is_detail): """Returns a list of servers, taking into account any search options specified. @@ -163,6 +179,181 @@ class Controller(object): limited_list = self._limit_items(instance_list, req) return self._build_list(req, limited_list, is_detail=is_detail) + def _handle_quota_error(self, error): + """ + Reraise quota errors as api-specific http exceptions + """ + + code_mappings = { + "OnsetFileLimitExceeded": + _("Personality file limit exceeded"), + "OnsetFilePathLimitExceeded": + _("Personality file path too long"), + "OnsetFileContentLimitExceeded": + _("Personality file content too long"), + "InstanceLimitExceeded": + _("Instance quotas have been exceeded")} + + expl = code_mappings.get(error.code) + if expl: + raise exc.HTTPRequestEntityTooLarge(explanation=expl, + headers={'Retry-After': 0}) + # if the original error is okay, just reraise it + raise error + + def _deserialize_create(self, request): + """ + Deserialize a create request + + Overrides normal behavior in the case of xml content + """ + if request.content_type == "application/xml": + deserializer = ServerXMLDeserializer() + return deserializer.deserialize(request.body) + else: + return self._deserialize(request.body, request.get_content_type()) + + def _validate_server_name(self, value): + if not isinstance(value, basestring): + msg = _("Server name is not a string or unicode") + raise exc.HTTPBadRequest(explanation=msg) + + if value.strip() == '': + msg = _("Server name is an empty string") + raise exc.HTTPBadRequest(explanation=msg) + + def _get_kernel_ramdisk_from_image(self, req, image_service, image_id): + """Fetch an image from the ImageService, then if present, return the + associated kernel and ramdisk image IDs. + """ + context = req.environ['nova.context'] + image_meta = image_service.show(context, image_id) + # NOTE(sirp): extracted to a separate method to aid unit-testing, the + # new method doesn't need a request obj or an ImageService stub + kernel_id, ramdisk_id = self._do_get_kernel_ramdisk_from_image( + image_meta) + return kernel_id, ramdisk_id + + @staticmethod + def _do_get_kernel_ramdisk_from_image(image_meta): + """Given an ImageService image_meta, return kernel and ramdisk image + ids if present. + + This is only valid for `ami` style images. + """ + image_id = image_meta['id'] + if image_meta['status'] != 'active': + raise exception.ImageUnacceptable(image_id=image_id, + reason=_("status is not active")) + + if image_meta.get('container_format') != 'ami': + return None, None + + try: + kernel_id = image_meta['properties']['kernel_id'] + except KeyError: + raise exception.KernelNotFoundForImage(image_id=image_id) + + try: + ramdisk_id = image_meta['properties']['ramdisk_id'] + except KeyError: + ramdisk_id = None + + return kernel_id, ramdisk_id + + def _get_injected_files(self, personality): + """ + Create a list of injected files from the personality attribute + + At this time, injected_files must be formatted as a list of + (file_path, file_content) pairs for compatibility with the + underlying compute service. + """ + injected_files = [] + + for item in personality: + try: + path = item['path'] + contents = item['contents'] + except KeyError as key: + expl = _('Bad personality format: missing %s') % key + raise exc.HTTPBadRequest(explanation=expl) + except TypeError: + expl = _('Bad personality format') + raise exc.HTTPBadRequest(explanation=expl) + try: + contents = base64.b64decode(contents) + except TypeError: + expl = _('Personality content for %s cannot be decoded') % path + raise exc.HTTPBadRequest(explanation=expl) + injected_files.append((path, contents)) + return injected_files + + def _get_server_admin_password_old_style(self, server): + """ Determine the admin password for a server on creation """ + return utils.generate_password(FLAGS.password_length) + + def _get_server_admin_password_new_style(self, server): + """ Determine the admin password for a server on creation """ + password = server.get('adminPass') + + if password is None: + return utils.generate_password(FLAGS.password_length) + if not isinstance(password, basestring) or password == '': + msg = _("Invalid adminPass") + raise exc.HTTPBadRequest(explanation=msg) + return password + + def _get_requested_networks(self, requested_networks): + """ + Create a list of requested networks from the networks attribute + """ + networks = [] + for network in requested_networks: + try: + network_uuid = network['uuid'] + + if not utils.is_uuid_like(network_uuid): + msg = _("Bad networks format: network uuid is not in" + " proper format (%s)") % network_uuid + raise exc.HTTPBadRequest(explanation=msg) + + #fixed IP address is optional + #if the fixed IP address is not provided then + #it will use one of the available IP address from the network + address = network.get('fixed_ip', None) + if address is not None and not utils.is_valid_ipv4(address): + msg = _("Invalid fixed IP address (%s)") % address + raise exc.HTTPBadRequest(explanation=msg) + # check if the network id is already present in the list, + # we don't want duplicate networks to be passed + # at the boot time + for id, ip in networks: + if id == network_uuid: + expl = _("Duplicate networks (%s) are not allowed")\ + % network_uuid + raise exc.HTTPBadRequest(explanation=expl) + + networks.append((network_uuid, address)) + except KeyError as key: + expl = _('Bad network format: missing %s') % key + raise exc.HTTPBadRequest(explanation=expl) + except TypeError: + expl = _('Bad networks format') + raise exc.HTTPBadRequest(explanation=expl) + + return networks + + def _validate_user_data(self, user_data): + """Check if the user_data is encoded properly""" + if not user_data: + return + try: + user_data = base64.b64decode(user_data) + except TypeError: + expl = _('Userdata content cannot be decoded') + raise exc.HTTPBadRequest(explanation=expl) + @novaclient_exception_converter @scheduler_api.redirect_handler def show(self, req, id): @@ -180,22 +371,172 @@ class Controller(object): def create(self, req, body): """ Creates a new server for a given user """ - if 'server' in body: - body['server']['key_name'] = self._get_key_name(req, body) - extra_values = None - extra_values, instances = self.helper.create_instance( - req, body, self.compute_api.create) + if not body: + raise exc.HTTPUnprocessableEntity() + + if not 'server' in body: + raise exc.HTTPUnprocessableEntity() + + body['server']['key_name'] = self._get_key_name(req, body) + + context = req.environ['nova.context'] + server_dict = body['server'] + password = self._get_server_admin_password(server_dict) + + if not 'name' in server_dict: + msg = _("Server name is not defined") + raise exc.HTTPBadRequest(explanation=msg) + + name = server_dict['name'] + self._validate_server_name(name) + name = name.strip() - # We can only return 1 instance via the API, if we happen to - # build more than one... instances is a list, so we'll just - # use the first one.. - inst = instances[0] - for key in ['instance_type', 'image_ref']: - inst[key] = extra_values[key] + image_href = self._image_ref_from_req_data(body) + # If the image href was generated by nova api, strip image_href + # down to an id and use the default glance connection params - server = self._build_view(req, inst, is_detail=True) - server['server']['adminPass'] = extra_values['password'] + if str(image_href).startswith(req.application_url): + image_href = image_href.split('/').pop() + try: + image_service, image_id = image.get_image_service(context, + image_href) + kernel_id, ramdisk_id = self._get_kernel_ramdisk_from_image( + req, image_service, image_id) + images = set([str(x['id']) for x in image_service.index(context)]) + assert str(image_id) in images + except Exception, e: + msg = _("Cannot find requested image %(image_href)s: %(e)s" % + locals()) + raise exc.HTTPBadRequest(explanation=msg) + + personality = server_dict.get('personality') + config_drive = server_dict.get('config_drive') + + injected_files = [] + if personality: + injected_files = self._get_injected_files(personality) + + sg_names = [] + security_groups = server_dict.get('security_groups') + if security_groups is not None: + sg_names = [sg['name'] for sg in security_groups if sg.get('name')] + if not sg_names: + sg_names.append('default') + + sg_names = list(set(sg_names)) + + requested_networks = server_dict.get('networks') + if requested_networks is not None: + requested_networks = self._get_requested_networks( + requested_networks) + + try: + flavor_id = self._flavor_id_from_req_data(body) + except ValueError as error: + msg = _("Invalid flavorRef provided.") + raise exc.HTTPBadRequest(explanation=msg) + + zone_blob = server_dict.get('blob') + + # optional openstack extensions: + key_name = server_dict.get('key_name') + user_data = server_dict.get('user_data') + self._validate_user_data(user_data) + + availability_zone = server_dict.get('availability_zone') + name = server_dict['name'] + self._validate_server_name(name) + name = name.strip() + + block_device_mapping = self._get_block_device_mapping(server_dict) + + # Only allow admins to specify their own reservation_ids + # This is really meant to allow zones to work. + reservation_id = server_dict.get('reservation_id') + if all([reservation_id is not None, + reservation_id != '', + not context.is_admin]): + reservation_id = None + + ret_resv_id = server_dict.get('return_reservation_id', False) + + min_count = server_dict.get('min_count') + max_count = server_dict.get('max_count') + # min_count and max_count are optional. If they exist, they come + # in as strings. We want to default 'min_count' to 1, and default + # 'max_count' to be 'min_count'. + min_count = int(min_count) if min_count else 1 + max_count = int(max_count) if max_count else min_count + if min_count > max_count: + min_count = max_count + + try: + inst_type = \ + instance_types.get_instance_type_by_flavor_id(flavor_id) + + (instances, resv_id) = self.compute_api.create(context, + inst_type, + image_id, + kernel_id=kernel_id, + ramdisk_id=ramdisk_id, + display_name=name, + display_description=name, + key_name=key_name, + metadata=server_dict.get('metadata', {}), + access_ip_v4=server_dict.get('accessIPv4'), + access_ip_v6=server_dict.get('accessIPv6'), + injected_files=injected_files, + admin_password=password, + zone_blob=zone_blob, + reservation_id=reservation_id, + min_count=min_count, + max_count=max_count, + requested_networks=requested_networks, + security_group=sg_names, + user_data=user_data, + availability_zone=availability_zone, + config_drive=config_drive, + block_device_mapping=block_device_mapping, + wait_for_instances=not ret_resv_id) + except quota.QuotaError as error: + self._handle_quota_error(error) + except exception.InstanceTypeMemoryTooSmall as error: + raise exc.HTTPBadRequest(explanation=unicode(error)) + except exception.InstanceTypeDiskTooSmall as error: + raise exc.HTTPBadRequest(explanation=unicode(error)) + except exception.ImageNotFound as error: + msg = _("Can not find requested image") + raise exc.HTTPBadRequest(explanation=msg) + except exception.FlavorNotFound as error: + msg = _("Invalid flavorRef provided.") + raise exc.HTTPBadRequest(explanation=msg) + except exception.KeypairNotFound as error: + msg = _("Invalid key_name provided.") + raise exc.HTTPBadRequest(explanation=msg) + except exception.SecurityGroupNotFound as error: + raise exc.HTTPBadRequest(explanation=unicode(error)) + except rpc_common.RemoteError as err: + msg = "%(err_type)s: %(err_msg)s" % \ + {'err_type': err.exc_type, 'err_msg': err.value} + raise exc.HTTPBadRequest(explanation=msg) + # Let the caller deal with unhandled exceptions. + + # If the caller wanted a reservation_id, return it + if ret_resv_id: + return {'reservation_id': resv_id} + + # Instances is a list + instance = instances[0] + if not instance.get('_is_precooked', False): + instance['instance_type'] = inst_type + instance['image_ref'] = image_href + + server = self._build_view(req, instance, is_detail=True) + if '_is_precooked' in server['server']: + del server['server']['_is_precooked'] + else: + server['server']['adminPass'] = password return server def _delete(self, context, id): @@ -218,7 +559,7 @@ class Controller(object): if 'name' in body['server']: name = body['server']['name'] - self.helper._validate_server_name(name) + self._validate_server_name(name) update_dict['display_name'] = name.strip() if 'accessIPv4' in body['server']: @@ -290,17 +631,17 @@ class Controller(object): except KeyError as missing_key: msg = _("createBackup entity requires %s attribute") % missing_key - raise webob.exc.HTTPBadRequest(explanation=msg) + raise exc.HTTPBadRequest(explanation=msg) except TypeError: msg = _("Malformed createBackup entity") - raise webob.exc.HTTPBadRequest(explanation=msg) + raise exc.HTTPBadRequest(explanation=msg) try: rotation = int(rotation) except ValueError: msg = _("createBackup attribute 'rotation' must be an integer") - raise webob.exc.HTTPBadRequest(explanation=msg) + raise exc.HTTPBadRequest(explanation=msg) # preserve link to server in image properties server_ref = os.path.join(req.application_url, @@ -315,7 +656,7 @@ class Controller(object): props.update(metadata) except ValueError: msg = _("Invalid metadata") - raise webob.exc.HTTPBadRequest(explanation=msg) + raise exc.HTTPBadRequest(explanation=msg) image = self.compute_api.backup(context, instance_id, @@ -696,7 +1037,7 @@ class ControllerV10(Controller): def _get_server_admin_password(self, server): """ Determine the admin password for a server on creation """ - return self.helper._get_server_admin_password_old_style(server) + return self._get_server_admin_password_old_style(server) def _get_server_search_options(self): """Return server search options allowed by non-admin""" @@ -884,11 +1225,11 @@ class ControllerV11(Controller): except KeyError: msg = _("createImage entity requires name attribute") - raise webob.exc.HTTPBadRequest(explanation=msg) + raise exc.HTTPBadRequest(explanation=msg) except TypeError: msg = _("Malformed createImage entity") - raise webob.exc.HTTPBadRequest(explanation=msg) + raise exc.HTTPBadRequest(explanation=msg) # preserve link to server in image properties server_ref = os.path.join(req.application_url, @@ -903,7 +1244,7 @@ class ControllerV11(Controller): props.update(metadata) except ValueError: msg = _("Invalid metadata") - raise webob.exc.HTTPBadRequest(explanation=msg) + raise exc.HTTPBadRequest(explanation=msg) image = self.compute_api.snapshot(context, instance_id, @@ -923,7 +1264,7 @@ class ControllerV11(Controller): def _get_server_admin_password(self, server): """ Determine the admin password for a server on creation """ - return self.helper._get_server_admin_password_new_style(server) + return self._get_server_admin_password_new_style(server) def _get_server_search_options(self): """Return server search options allowed by non-admin""" @@ -1068,6 +1409,227 @@ class ServerXMLSerializer(wsgi.XMLDictSerializer): return self._to_xml(server) +class ServerXMLDeserializer(wsgi.XMLDeserializer): + """ + Deserializer to handle xml-formatted server create requests. + + Handles standard server attributes as well as optional metadata + and personality attributes + """ + + metadata_deserializer = common.MetadataXMLDeserializer() + + def create(self, string): + """Deserialize an xml-formatted server create request""" + dom = minidom.parseString(string) + server = self._extract_server(dom) + return {'body': {'server': server}} + + def _extract_server(self, node): + """Marshal the server attribute of a parsed request""" + server = {} + server_node = self.find_first_child_named(node, 'server') + + attributes = ["name", "imageId", "flavorId", "adminPass"] + for attr in attributes: + if server_node.getAttribute(attr): + server[attr] = server_node.getAttribute(attr) + + metadata_node = self.find_first_child_named(server_node, "metadata") + server["metadata"] = self.metadata_deserializer.extract_metadata( + metadata_node) + + server["personality"] = self._extract_personality(server_node) + + return server + + def _extract_personality(self, server_node): + """Marshal the personality attribute of a parsed request""" + node = self.find_first_child_named(server_node, "personality") + personality = [] + if node is not None: + for file_node in self.find_children_named(node, "file"): + item = {} + if file_node.hasAttribute("path"): + item["path"] = file_node.getAttribute("path") + item["contents"] = self.extract_text(file_node) + personality.append(item) + return personality + + +class ServerXMLDeserializerV11(wsgi.MetadataXMLDeserializer): + """ + Deserializer to handle xml-formatted server create requests. + + Handles standard server attributes as well as optional metadata + and personality attributes + """ + + metadata_deserializer = common.MetadataXMLDeserializer() + + def action(self, string): + dom = minidom.parseString(string) + action_node = dom.childNodes[0] + action_name = action_node.tagName + + action_deserializer = { + 'createImage': self._action_create_image, + 'createBackup': self._action_create_backup, + 'changePassword': self._action_change_password, + 'reboot': self._action_reboot, + 'rebuild': self._action_rebuild, + 'resize': self._action_resize, + 'confirmResize': self._action_confirm_resize, + 'revertResize': self._action_revert_resize, + }.get(action_name, self.default) + + action_data = action_deserializer(action_node) + + return {'body': {action_name: action_data}} + + def _action_create_image(self, node): + return self._deserialize_image_action(node, ('name',)) + + def _action_create_backup(self, node): + attributes = ('name', 'backup_type', 'rotation') + return self._deserialize_image_action(node, attributes) + + def _action_change_password(self, node): + if not node.hasAttribute("adminPass"): + raise AttributeError("No adminPass was specified in request") + return {"adminPass": node.getAttribute("adminPass")} + + def _action_reboot(self, node): + if not node.hasAttribute("type"): + raise AttributeError("No reboot type was specified in request") + return {"type": node.getAttribute("type")} + + def _action_rebuild(self, node): + rebuild = {} + if node.hasAttribute("name"): + rebuild['name'] = node.getAttribute("name") + + metadata_node = self.find_first_child_named(node, "metadata") + if metadata_node is not None: + rebuild["metadata"] = self.extract_metadata(metadata_node) + + personality = self._extract_personality(node) + if personality is not None: + rebuild["personality"] = personality + + if not node.hasAttribute("imageRef"): + raise AttributeError("No imageRef was specified in request") + rebuild["imageRef"] = node.getAttribute("imageRef") + + return rebuild + + def _action_resize(self, node): + if not node.hasAttribute("flavorRef"): + raise AttributeError("No flavorRef was specified in request") + return {"flavorRef": node.getAttribute("flavorRef")} + + def _action_confirm_resize(self, node): + return None + + def _action_revert_resize(self, node): + return None + + def _deserialize_image_action(self, node, allowed_attributes): + data = {} + for attribute in allowed_attributes: + value = node.getAttribute(attribute) + if value: + data[attribute] = value + metadata_node = self.find_first_child_named(node, 'metadata') + if metadata_node is not None: + metadata = self.metadata_deserializer.extract_metadata( + metadata_node) + data['metadata'] = metadata + return data + + def create(self, string): + """Deserialize an xml-formatted server create request""" + dom = minidom.parseString(string) + server = self._extract_server(dom) + return {'body': {'server': server}} + + def _extract_server(self, node): + """Marshal the server attribute of a parsed request""" + server = {} + server_node = self.find_first_child_named(node, 'server') + + attributes = ["name", "imageRef", "flavorRef", "adminPass", + "accessIPv4", "accessIPv6"] + for attr in attributes: + if server_node.getAttribute(attr): + server[attr] = server_node.getAttribute(attr) + + metadata_node = self.find_first_child_named(server_node, "metadata") + if metadata_node is not None: + server["metadata"] = self.extract_metadata(metadata_node) + + personality = self._extract_personality(server_node) + if personality is not None: + server["personality"] = personality + + networks = self._extract_networks(server_node) + if networks is not None: + server["networks"] = networks + + security_groups = self._extract_security_groups(server_node) + if security_groups is not None: + server["security_groups"] = security_groups + + return server + + def _extract_personality(self, server_node): + """Marshal the personality attribute of a parsed request""" + node = self.find_first_child_named(server_node, "personality") + if node is not None: + personality = [] + for file_node in self.find_children_named(node, "file"): + item = {} + if file_node.hasAttribute("path"): + item["path"] = file_node.getAttribute("path") + item["contents"] = self.extract_text(file_node) + personality.append(item) + return personality + else: + return None + + def _extract_networks(self, server_node): + """Marshal the networks attribute of a parsed request""" + node = self.find_first_child_named(server_node, "networks") + if node is not None: + networks = [] + for network_node in self.find_children_named(node, + "network"): + item = {} + if network_node.hasAttribute("uuid"): + item["uuid"] = network_node.getAttribute("uuid") + if network_node.hasAttribute("fixed_ip"): + item["fixed_ip"] = network_node.getAttribute("fixed_ip") + networks.append(item) + return networks + else: + return None + + def _extract_security_groups(self, server_node): + """Marshal the security_groups attribute of a parsed request""" + node = self.find_first_child_named(server_node, "security_groups") + if node is not None: + security_groups = [] + for sg_node in self.find_children_named(node, "security_group"): + item = {} + name_node = self.find_first_child_named(sg_node, "name") + if name_node: + item["name"] = self.extract_text(name_node) + security_groups.append(item) + return security_groups + else: + return None + + def create_resource(version='1.0'): controller = { '1.0': ControllerV10, @@ -1107,8 +1669,8 @@ def create_resource(version='1.0'): } xml_deserializer = { - '1.0': helper.ServerXMLDeserializer(), - '1.1': helper.ServerXMLDeserializerV11(), + '1.0': ServerXMLDeserializer(), + '1.1': ServerXMLDeserializerV11(), }[version] body_deserializers = { diff --git a/nova/api/openstack/zones.py b/nova/api/openstack/zones.py index 998498e82..95e9eaa51 100644 --- a/nova/api/openstack/zones.py +++ b/nova/api/openstack/zones.py @@ -25,8 +25,8 @@ from nova import log as logging from nova.compute import api as compute from nova.scheduler import api -from nova.api.openstack import create_instance_helper as helper from nova.api.openstack import common +from nova.api.openstack import servers from nova.api.openstack import wsgi @@ -67,7 +67,6 @@ class Controller(object): def __init__(self): self.compute_api = compute.API() - self.helper = helper.CreateInstanceHelper(self) def index(self, req): """Return all zones in brief""" @@ -120,18 +119,6 @@ class Controller(object): zone = api.zone_update(context, zone_id, body["zone"]) return dict(zone=_scrub_zone(zone)) - def boot(self, req, body): - """Creates a new server for a given user while being Zone aware. - - Returns a reservation ID (a UUID). - """ - result = None - extra_values, result = self.helper.create_instance(req, body, - self.compute_api.create_all_at_once) - - reservation_id = result - return {'reservation_id': reservation_id} - @check_encryption_key def select(self, req, body): """Returns a weighted list of costs to create instances @@ -155,37 +142,8 @@ class Controller(object): blob=cipher_text)) return cooked - def _image_ref_from_req_data(self, data): - return data['server']['imageId'] - - def _flavor_id_from_req_data(self, data): - return data['server']['flavorId'] - - def _get_server_admin_password(self, server): - """ Determine the admin password for a server on creation """ - return self.helper._get_server_admin_password_old_style(server) - - -class ControllerV11(Controller): - """Controller for 1.1 Zone resources.""" - - def _get_server_admin_password(self, server): - """ Determine the admin password for a server on creation """ - return self.helper._get_server_admin_password_new_style(server) - - def _image_ref_from_req_data(self, data): - return data['server']['imageRef'] - - def _flavor_id_from_req_data(self, data): - return data['server']['flavorRef'] - def create_resource(version): - controller = { - '1.0': Controller, - '1.1': ControllerV11, - }[version]() - metadata = { "attributes": { "zone": ["id", "api_url", "name", "capabilities"], @@ -199,8 +157,8 @@ def create_resource(version): serializer = wsgi.ResponseSerializer(body_serializers) body_deserializers = { - 'application/xml': helper.ServerXMLDeserializer(), + 'application/xml': servers.ServerXMLDeserializer(), } deserializer = wsgi.RequestDeserializer(body_deserializers) - return wsgi.Resource(controller, deserializer, serializer) + return wsgi.Resource(Controller(), deserializer, serializer) diff --git a/nova/compute/api.py b/nova/compute/api.py index 5f5e980c3..3900e8a40 100644 --- a/nova/compute/api.py +++ b/nova/compute/api.py @@ -75,6 +75,11 @@ def generate_default_hostname(instance): return display_name.translate(table, deletions) +def generate_default_display_name(instance): + """Generate a default display name""" + return 'Server %s' % instance['id'] + + def _is_able_to_shutdown(instance, instance_id): vm_state = instance["vm_state"] task_state = instance["task_state"] @@ -177,17 +182,27 @@ class API(base.Base): self.network_api.validate_networks(context, requested_networks) - def _check_create_parameters(self, context, instance_type, - image_href, kernel_id=None, ramdisk_id=None, - min_count=None, max_count=None, - display_name='', display_description='', - key_name=None, key_data=None, security_group='default', - availability_zone=None, user_data=None, metadata=None, - injected_files=None, admin_password=None, zone_blob=None, - reservation_id=None, access_ip_v4=None, access_ip_v6=None, - requested_networks=None, config_drive=None,): + def _create_instance(self, context, instance_type, + image_href, kernel_id, ramdisk_id, + min_count, max_count, + display_name, display_description, + key_name, key_data, security_group, + availability_zone, user_data, metadata, + injected_files, admin_password, zone_blob, + reservation_id, access_ip_v4, access_ip_v6, + requested_networks, config_drive, + block_device_mapping, + wait_for_instances): """Verify all the input parameters regardless of the provisioning - strategy being performed.""" + strategy being performed and schedule the instance(s) for + creation.""" + + if not metadata: + metadata = {} + if not display_description: + display_description = '' + if not security_group: + security_group = 'default' if not instance_type: instance_type = instance_types.get_default_instance_type() @@ -198,6 +213,8 @@ class API(base.Base): if not metadata: metadata = {} + block_device_mapping = block_device_mapping or [] + num_instances = quota.allowed_instances(context, max_count, instance_type) if num_instances < min_count: @@ -303,7 +320,28 @@ class API(base.Base): 'vm_mode': vm_mode, 'root_device_name': root_device_name} - return (num_instances, base_options, image) + LOG.debug(_("Going to run %s instances...") % num_instances) + + if wait_for_instances: + rpc_method = rpc.call + else: + rpc_method = rpc.cast + + # TODO(comstud): We should use rpc.multicall when we can + # retrieve the full instance dictionary from the scheduler. + # Otherwise, we could exceed the AMQP max message size limit. + # This would require the schedulers' schedule_run_instances + # methods to return an iterator vs a list. + instances = self._schedule_run_instance( + rpc_method, + context, base_options, + instance_type, zone_blob, + availability_zone, injected_files, + admin_password, image, + num_instances, requested_networks, + block_device_mapping, security_group) + + return (instances, reservation_id) @staticmethod def _volume_size(instance_type, virtual_name): @@ -399,10 +437,8 @@ class API(base.Base): including any related table updates (such as security group, etc). - This will called by create() in the majority of situations, - but create_all_at_once() style Schedulers may initiate the call. - If you are changing this method, be sure to update both - call paths. + This is called by the scheduler after a location for the + instance has been determined. """ elevated = context.elevated() if security_group is None: @@ -439,7 +475,7 @@ class API(base.Base): updates = {} if (not hasattr(instance, 'display_name') or instance.display_name is None): - updates['display_name'] = "Server %s" % instance_id + updates['display_name'] = generate_default_display_name(instance) instance['display_name'] = updates['display_name'] updates['hostname'] = self.hostname_factory(instance) updates['vm_state'] = vm_states.BUILDING @@ -448,21 +484,23 @@ class API(base.Base): instance = self.update(context, instance_id, **updates) return instance - def _ask_scheduler_to_create_instance(self, context, base_options, - instance_type, zone_blob, - availability_zone, injected_files, - admin_password, image, - instance_id=None, num_instances=1, - requested_networks=None): - """Send the run_instance request to the schedulers for processing.""" + def _schedule_run_instance(self, + rpc_method, + context, base_options, + instance_type, zone_blob, + availability_zone, injected_files, + admin_password, image, + num_instances, + requested_networks, + block_device_mapping, + security_group): + """Send a run_instance request to the schedulers for processing.""" + pid = context.project_id uid = context.user_id - if instance_id: - LOG.debug(_("Casting to scheduler for %(pid)s/%(uid)s's" - " instance %(instance_id)s (single-shot)") % locals()) - else: - LOG.debug(_("Casting to scheduler for %(pid)s/%(uid)s's" - " (all-at-once)") % locals()) + + LOG.debug(_("Sending create to scheduler for %(pid)s/%(uid)s's") % + locals()) request_spec = { 'image': image, @@ -471,82 +509,41 @@ class API(base.Base): 'filter': None, 'blob': zone_blob, 'num_instances': num_instances, + 'block_device_mapping': block_device_mapping, + 'security_group': security_group, } - rpc.cast(context, - FLAGS.scheduler_topic, - {"method": "run_instance", - "args": {"topic": FLAGS.compute_topic, - "instance_id": instance_id, - "request_spec": request_spec, - "availability_zone": availability_zone, - "admin_password": admin_password, - "injected_files": injected_files, - "requested_networks": requested_networks}}) - - def create_all_at_once(self, context, instance_type, - image_href, kernel_id=None, ramdisk_id=None, - min_count=None, max_count=None, - display_name='', display_description='', - key_name=None, key_data=None, security_group='default', - availability_zone=None, user_data=None, metadata=None, - injected_files=None, admin_password=None, zone_blob=None, - reservation_id=None, block_device_mapping=None, - access_ip_v4=None, access_ip_v6=None, - requested_networks=None, config_drive=None): - """Provision the instances by passing the whole request to - the Scheduler for execution. Returns a Reservation ID - related to the creation of all of these instances.""" - - if not metadata: - metadata = {} - - num_instances, base_options, image = self._check_create_parameters( - context, instance_type, - image_href, kernel_id, ramdisk_id, - min_count, max_count, - display_name, display_description, - key_name, key_data, security_group, - availability_zone, user_data, metadata, - injected_files, admin_password, zone_blob, - reservation_id, access_ip_v4, access_ip_v6, - requested_networks, config_drive) - - self._ask_scheduler_to_create_instance(context, base_options, - instance_type, zone_blob, - availability_zone, injected_files, - admin_password, image, - num_instances=num_instances, - requested_networks=requested_networks) - - return base_options['reservation_id'] + return rpc_method(context, + FLAGS.scheduler_topic, + {"method": "run_instance", + "args": {"topic": FLAGS.compute_topic, + "request_spec": request_spec, + "admin_password": admin_password, + "injected_files": injected_files, + "requested_networks": requested_networks}}) def create(self, context, instance_type, image_href, kernel_id=None, ramdisk_id=None, min_count=None, max_count=None, - display_name='', display_description='', - key_name=None, key_data=None, security_group='default', + display_name=None, display_description=None, + key_name=None, key_data=None, security_group=None, availability_zone=None, user_data=None, metadata=None, injected_files=None, admin_password=None, zone_blob=None, reservation_id=None, block_device_mapping=None, access_ip_v4=None, access_ip_v6=None, - requested_networks=None, config_drive=None,): + requested_networks=None, config_drive=None, + wait_for_instances=True): """ - Provision the instances by sending off a series of single - instance requests to the Schedulers. This is fine for trival - Scheduler drivers, but may remove the effectiveness of the - more complicated drivers. + Provision instances, sending instance information to the + scheduler. The scheduler will determine where the instance(s) + go and will handle creating the DB entries. - NOTE: If you change this method, be sure to change - create_all_at_once() at the same time! - - Returns a list of instance dicts. + Returns a tuple of (instances, reservation_id) where instances + could be 'None' or a list of instance dicts depending on if + we waited for information from the scheduler or not. """ - if not metadata: - metadata = {} - - num_instances, base_options, image = self._check_create_parameters( + (instances, reservation_id) = self._create_instance( context, instance_type, image_href, kernel_id, ramdisk_id, min_count, max_count, @@ -555,27 +552,25 @@ class API(base.Base): availability_zone, user_data, metadata, injected_files, admin_password, zone_blob, reservation_id, access_ip_v4, access_ip_v6, - requested_networks, config_drive) + requested_networks, config_drive, + block_device_mapping, + wait_for_instances) - block_device_mapping = block_device_mapping or [] - instances = [] - LOG.debug(_("Going to run %s instances..."), num_instances) - for num in range(num_instances): - instance = self.create_db_entry_for_new_instance(context, - instance_type, image, - base_options, security_group, - block_device_mapping, num=num) - instances.append(instance) - instance_id = instance['id'] - - self._ask_scheduler_to_create_instance(context, base_options, - instance_type, zone_blob, - availability_zone, injected_files, - admin_password, image, - instance_id=instance_id, - requested_networks=requested_networks) - - return [dict(x.iteritems()) for x in instances] + if instances is None: + # wait_for_instances must have been False + return (instances, reservation_id) + + inst_ret_list = [] + for instance in instances: + if instance.get('_is_precooked', False): + inst_ret_list.append(instance) + else: + # Scheduler only gives us the 'id'. We need to pull + # in the created instances from the DB + instance = self.db.instance_get(context, instance['id']) + inst_ret_list.append(dict(instance.iteritems())) + + return (inst_ret_list, reservation_id) def has_finished_migration(self, context, instance_uuid): """Returns true if an instance has a finished migration.""" diff --git a/nova/compute/manager.py b/nova/compute/manager.py index 0d504ab78..878a70add 100644 --- a/nova/compute/manager.py +++ b/nova/compute/manager.py @@ -69,8 +69,6 @@ flags.DEFINE_string('instances_path', '$state_path/instances', 'where instances are stored on disk') flags.DEFINE_string('compute_driver', 'nova.virt.connection.get_connection', 'Driver to use for controlling virtualization') -flags.DEFINE_string('stub_network', False, - 'Stub network related code') flags.DEFINE_string('console_host', socket.gethostname(), 'Console proxy host to use to connect to instances on' 'this host.') diff --git a/nova/flags.py b/nova/flags.py index 5dde02adf..1050f0347 100644 --- a/nova/flags.py +++ b/nova/flags.py @@ -432,3 +432,6 @@ DEFINE_list('monkey_patch_modules', DEFINE_bool('allow_resize_to_same_host', False, 'Allow destination machine to match source for resize. Useful' ' when testing in environments with only one host machine.') + +DEFINE_string('stub_network', False, + 'Stub network related code') diff --git a/nova/scheduler/abstract_scheduler.py b/nova/scheduler/abstract_scheduler.py index b121444f2..e8712e5df 100644 --- a/nova/scheduler/abstract_scheduler.py +++ b/nova/scheduler/abstract_scheduler.py @@ -60,24 +60,10 @@ class AbstractScheduler(driver.Scheduler): request_spec, kwargs): """Create the requested resource in this Zone.""" host = build_plan_item['hostname'] - base_options = request_spec['instance_properties'] - image = request_spec['image'] - instance_type = request_spec.get('instance_type') - - # TODO(sandy): I guess someone needs to add block_device_mapping - # support at some point? Also, OS API has no concept of security - # groups. - instance = compute_api.API().create_db_entry_for_new_instance(context, - instance_type, image, base_options, None, []) - - instance_id = instance['id'] - kwargs['instance_id'] = instance_id - - queue = db.queue_get_for(context, "compute", host) - params = {"method": "run_instance", "args": kwargs} - rpc.cast(context, queue, params) - LOG.debug(_("Provisioning locally via compute node %(host)s") - % locals()) + instance = self.create_instance_db_entry(context, request_spec) + driver.cast_to_compute_host(context, host, + 'run_instance', instance_id=instance['id'], **kwargs) + return driver.encode_instance(instance, local=True) def _decrypt_blob(self, blob): """Returns the decrypted blob or None if invalid. Broken out @@ -112,7 +98,7 @@ class AbstractScheduler(driver.Scheduler): files = kwargs['injected_files'] child_zone = zone_info['child_zone'] child_blob = zone_info['child_blob'] - zone = db.zone_get(context, child_zone) + zone = db.zone_get(context.elevated(), child_zone) url = zone.api_url LOG.debug(_("Forwarding instance create call to child zone %(url)s" ". ReservationID=%(reservation_id)s") % locals()) @@ -132,12 +118,13 @@ class AbstractScheduler(driver.Scheduler): # arguments are passed as keyword arguments # (there's a reasonable default for ipgroups in the # novaclient call). - nova.servers.create(name, image_ref, flavor_id, + instance = nova.servers.create(name, image_ref, flavor_id, meta=meta, files=files, zone_blob=child_blob, reservation_id=reservation_id) + return driver.encode_instance(instance._info, local=False) def _provision_resource_from_blob(self, context, build_plan_item, - instance_id, request_spec, kwargs): + request_spec, kwargs): """Create the requested resource locally or in a child zone based on what is stored in the zone blob info. @@ -165,21 +152,21 @@ class AbstractScheduler(driver.Scheduler): # Valid data ... is it for us? if 'child_zone' in host_info and 'child_blob' in host_info: - self._ask_child_zone_to_create_instance(context, host_info, - request_spec, kwargs) + instance = self._ask_child_zone_to_create_instance(context, + host_info, request_spec, kwargs) else: - self._provision_resource_locally(context, host_info, request_spec, - kwargs) + instance = self._provision_resource_locally(context, + host_info, request_spec, kwargs) + return instance - def _provision_resource(self, context, build_plan_item, instance_id, + def _provision_resource(self, context, build_plan_item, request_spec, kwargs): """Create the requested resource in this Zone or a child zone.""" if "hostname" in build_plan_item: - self._provision_resource_locally(context, build_plan_item, - request_spec, kwargs) - return - self._provision_resource_from_blob(context, build_plan_item, - instance_id, request_spec, kwargs) + return self._provision_resource_locally(context, + build_plan_item, request_spec, kwargs) + return self._provision_resource_from_blob(context, + build_plan_item, request_spec, kwargs) def _adjust_child_weights(self, child_results, zones): """Apply the Scale and Offset values from the Zone definition @@ -205,8 +192,7 @@ class AbstractScheduler(driver.Scheduler): LOG.exception(_("Bad child zone scaling values " "for Zone: %(zone_id)s") % locals()) - def schedule_run_instance(self, context, instance_id, request_spec, - *args, **kwargs): + def schedule_run_instance(self, context, request_spec, *args, **kwargs): """This method is called from nova.compute.api to provision an instance. However we need to look at the parameters being passed in to see if this is a request to: @@ -214,13 +200,16 @@ class AbstractScheduler(driver.Scheduler): 2. Use the Build Plan information in the request parameters to simply create the instance (either in this zone or a child zone). + + returns list of instances created. """ # TODO(sandy): We'll have to look for richer specs at some point. blob = request_spec.get('blob') if blob: - self._provision_resource(context, request_spec, instance_id, - request_spec, kwargs) - return None + instance = self._provision_resource(context, + request_spec, request_spec, kwargs) + # Caller expects a list of instances + return [instance] num_instances = request_spec.get('num_instances', 1) LOG.debug(_("Attempting to build %(num_instances)d instance(s)") % @@ -231,16 +220,16 @@ class AbstractScheduler(driver.Scheduler): if not build_plan: raise driver.NoValidHost(_('No hosts were available')) + instances = [] for num in xrange(num_instances): if not build_plan: break build_plan_item = build_plan.pop(0) - self._provision_resource(context, build_plan_item, instance_id, - request_spec, kwargs) + instance = self._provision_resource(context, + build_plan_item, request_spec, kwargs) + instances.append(instance) - # Returning None short-circuits the routing to Compute (since - # we've already done it here) - return None + return instances def select(self, context, request_spec, *args, **kwargs): """Select returns a list of weights and zone/host information @@ -251,7 +240,7 @@ class AbstractScheduler(driver.Scheduler): return self._schedule(context, "compute", request_spec, *args, **kwargs) - def schedule(self, context, topic, request_spec, *args, **kwargs): + def schedule(self, context, topic, method, *args, **kwargs): """The schedule() contract requires we return the one best-suited host for this request. """ @@ -285,7 +274,7 @@ class AbstractScheduler(driver.Scheduler): weighted_hosts = self.weigh_hosts(topic, request_spec, filtered_hosts) # Next, tack on the host weights from the child zones json_spec = json.dumps(request_spec) - all_zones = db.zone_get_all(context) + all_zones = db.zone_get_all(context.elevated()) child_results = self._call_zone_method(context, "select", specs=json_spec, zones=all_zones) self._adjust_child_weights(child_results, all_zones) diff --git a/nova/scheduler/api.py b/nova/scheduler/api.py index 44e01aa0c..0b91edccc 100644 --- a/nova/scheduler/api.py +++ b/nova/scheduler/api.py @@ -65,7 +65,7 @@ def get_zone_list(context): for item in items: item['api_url'] = item['api_url'].replace('\\/', '/') if not items: - items = db.zone_get_all(context) + items = db.zone_get_all(context.elevated()) return items @@ -116,7 +116,7 @@ def call_zone_method(context, method_name, errors_to_ignore=None, pool = greenpool.GreenPool() results = [] if zones is None: - zones = db.zone_get_all(context) + zones = db.zone_get_all(context.elevated()) for zone in zones: try: # Do this on behalf of the user ... diff --git a/nova/scheduler/chance.py b/nova/scheduler/chance.py index f4461cee2..8a69f2d0f 100644 --- a/nova/scheduler/chance.py +++ b/nova/scheduler/chance.py @@ -29,12 +29,33 @@ from nova.scheduler import driver class ChanceScheduler(driver.Scheduler): """Implements Scheduler as a random node selector.""" - def schedule(self, context, topic, *_args, **_kwargs): + def _schedule(self, context, topic, **kwargs): """Picks a host that is up at random.""" - hosts = self.hosts_up(context, topic) + elevated = context.elevated() + hosts = self.hosts_up(elevated, topic) if not hosts: raise driver.NoValidHost(_("Scheduler was unable to locate a host" " for this request. Is the appropriate" " service running?")) return hosts[int(random.random() * len(hosts))] + + def schedule(self, context, topic, method, *_args, **kwargs): + """Picks a host that is up at random.""" + + host = self._schedule(context, topic, **kwargs) + driver.cast_to_host(context, topic, host, method, **kwargs) + + def schedule_run_instance(self, context, request_spec, *_args, **kwargs): + """Create and run an instance or instances""" + elevated = context.elevated() + num_instances = request_spec.get('num_instances', 1) + instances = [] + for num in xrange(num_instances): + host = self._schedule(context, 'compute', **kwargs) + instance = self.create_instance_db_entry(elevated, request_spec) + driver.cast_to_compute_host(context, host, + 'run_instance', instance_id=instance['id'], **kwargs) + instances.append(driver.encode_instance(instance)) + + return instances diff --git a/nova/scheduler/driver.py b/nova/scheduler/driver.py index 22f4e14f9..7bf26cfdf 100644 --- a/nova/scheduler/driver.py +++ b/nova/scheduler/driver.py @@ -29,17 +29,94 @@ from nova import flags from nova import log as logging from nova import rpc from nova import utils +from nova.compute import api as compute_api from nova.compute import power_state from nova.compute import vm_states from nova.api.ec2 import ec2utils FLAGS = flags.FLAGS +LOG = logging.getLogger('nova.scheduler.driver') flags.DEFINE_integer('service_down_time', 60, 'maximum time since last checkin for up service') flags.DECLARE('instances_path', 'nova.compute.manager') +def cast_to_volume_host(context, host, method, update_db=True, **kwargs): + """Cast request to a volume host queue""" + + if update_db: + volume_id = kwargs.get('volume_id', None) + if volume_id is not None: + now = utils.utcnow() + db.volume_update(context, volume_id, + {'host': host, 'scheduled_at': now}) + rpc.cast(context, + db.queue_get_for(context, 'volume', host), + {"method": method, "args": kwargs}) + LOG.debug(_("Casted '%(method)s' to volume '%(host)s'") % locals()) + + +def cast_to_compute_host(context, host, method, update_db=True, **kwargs): + """Cast request to a compute host queue""" + + if update_db: + instance_id = kwargs.get('instance_id', None) + if instance_id is not None: + now = utils.utcnow() + db.instance_update(context, instance_id, + {'host': host, 'scheduled_at': now}) + rpc.cast(context, + db.queue_get_for(context, 'compute', host), + {"method": method, "args": kwargs}) + LOG.debug(_("Casted '%(method)s' to compute '%(host)s'") % locals()) + + +def cast_to_network_host(context, host, method, update_db=False, **kwargs): + """Cast request to a network host queue""" + + rpc.cast(context, + db.queue_get_for(context, 'network', host), + {"method": method, "args": kwargs}) + LOG.debug(_("Casted '%(method)s' to network '%(host)s'") % locals()) + + +def cast_to_host(context, topic, host, method, update_db=True, **kwargs): + """Generic cast to host""" + + topic_mapping = { + "compute": cast_to_compute_host, + "volume": cast_to_volume_host, + 'network': cast_to_network_host} + + func = topic_mapping.get(topic) + if func: + func(context, host, method, update_db=update_db, **kwargs) + else: + rpc.cast(context, + db.queue_get_for(context, topic, host), + {"method": method, "args": kwargs}) + LOG.debug(_("Casted '%(method)s' to %(topic)s '%(host)s'") + % locals()) + + +def encode_instance(instance, local=True): + """Encode locally created instance for return via RPC""" + # TODO(comstud): I would love to be able to return the full + # instance information here, but we'll need some modifications + # to the RPC code to handle datetime conversions with the + # json encoding/decoding. We should be able to set a default + # json handler somehow to do it. + # + # For now, I'll just return the instance ID and let the caller + # do a DB lookup :-/ + if local: + return dict(id=instance['id'], _is_precooked=False) + else: + instance['_is_precooked'] = True + return instance + + class NoValidHost(exception.Error): """There is no valid host for the command.""" pass @@ -55,6 +132,7 @@ class Scheduler(object): def __init__(self): self.zone_manager = None + self.compute_api = compute_api.API() def set_zone_manager(self, zone_manager): """Called by the Scheduler Service to supply a ZoneManager.""" @@ -76,7 +154,20 @@ class Scheduler(object): for service in services if self.service_is_up(service)] - def schedule(self, context, topic, *_args, **_kwargs): + def create_instance_db_entry(self, context, request_spec): + """Create instance DB entry based on request_spec""" + base_options = request_spec['instance_properties'] + image = request_spec['image'] + instance_type = request_spec.get('instance_type') + security_group = request_spec.get('security_group', 'default') + block_device_mapping = request_spec.get('block_device_mapping', []) + + instance = self.compute_api.create_db_entry_for_new_instance( + context, instance_type, image, base_options, + security_group, block_device_mapping) + return instance + + def schedule(self, context, topic, method, *_args, **_kwargs): """Must override at least this method for scheduler to work.""" raise NotImplementedError(_("Must implement a fallback schedule")) @@ -114,10 +205,12 @@ class Scheduler(object): volume_ref['id'], {'status': 'migrating'}) - # Return value is necessary to send request to src - # Check _schedule() in detail. src = instance_ref['host'] - return src + cast_to_compute_host(context, src, 'live_migration', + update_db=False, + instance_id=instance_id, + dest=dest, + block_migration=block_migration) def _live_migration_src_check(self, context, instance_ref): """Live migration check routine (for src host). @@ -205,7 +298,7 @@ class Scheduler(object): if not block_migration: src = instance_ref['host'] ipath = FLAGS.instances_path - logging.error(_("Cannot confirm tmpfile at %(ipath)s is on " + LOG.error(_("Cannot confirm tmpfile at %(ipath)s is on " "same shared storage between %(src)s " "and %(dest)s.") % locals()) raise @@ -243,7 +336,7 @@ class Scheduler(object): except rpc.RemoteError: src = instance_ref['host'] - logging.exception(_("host %(dest)s is not compatible with " + LOG.exception(_("host %(dest)s is not compatible with " "original host %(src)s.") % locals()) raise @@ -354,6 +447,8 @@ class Scheduler(object): dst_t = db.queue_get_for(context, FLAGS.compute_topic, dest) src_t = db.queue_get_for(context, FLAGS.compute_topic, src) + filename = None + try: # create tmpfile at dest host filename = rpc.call(context, dst_t, @@ -370,6 +465,8 @@ class Scheduler(object): raise finally: - rpc.call(context, dst_t, - {"method": 'cleanup_shared_storage_test_file', - "args": {'filename': filename}}) + # Should only be None for tests? + if filename is not None: + rpc.call(context, dst_t, + {"method": 'cleanup_shared_storage_test_file', + "args": {'filename': filename}}) diff --git a/nova/scheduler/least_cost.py b/nova/scheduler/least_cost.py index 903d786cd..1a6ef990c 100644 --- a/nova/scheduler/least_cost.py +++ b/nova/scheduler/least_cost.py @@ -160,8 +160,7 @@ class LeastCostScheduler(base_scheduler.BaseScheduler): weighted = [] weight_log = [] - for cost, (hostname, service) in zip(costs, hosts): - caps = service[topic] + for cost, (hostname, caps) in zip(costs, hosts): weight_log.append("%s: %s" % (hostname, "%.2f" % cost)) weight_dict = dict(weight=cost, hostname=hostname, capabilities=caps) diff --git a/nova/scheduler/manager.py b/nova/scheduler/manager.py index bf18abc6c..f5a268adb 100644 --- a/nova/scheduler/manager.py +++ b/nova/scheduler/manager.py @@ -81,37 +81,23 @@ class SchedulerManager(manager.Manager): """Select a list of hosts best matching the provided specs.""" return self.driver.select(context, *args, **kwargs) - def get_scheduler_rules(self, context=None, *args, **kwargs): - """Ask the driver how requests should be made of it.""" - return self.driver.get_scheduler_rules(context, *args, **kwargs) - def _schedule(self, method, context, topic, *args, **kwargs): """Tries to call schedule_* method on the driver to retrieve host. Falls back to schedule(context, topic) if method doesn't exist. """ driver_method = 'schedule_%s' % method - elevated = context.elevated() try: real_meth = getattr(self.driver, driver_method) - args = (elevated,) + args + args = (context,) + args except AttributeError, e: LOG.warning(_("Driver Method %(driver_method)s missing: %(e)s." "Reverting to schedule()") % locals()) real_meth = self.driver.schedule - args = (elevated, topic) + args - host = real_meth(*args, **kwargs) - - if not host: - LOG.debug(_("%(topic)s %(method)s handled in Scheduler") - % locals()) - return - - rpc.cast(context, - db.queue_get_for(context, topic, host), - {"method": method, - "args": kwargs}) - LOG.debug(_("Casted to %(topic)s %(host)s for %(method)s") % locals()) + args = (context, topic, method) + args + + # Scheduler methods are responsible for casting. + return real_meth(*args, **kwargs) # NOTE (masumotok) : This method should be moved to nova.api.ec2.admin. # Based on bexar design summit discussion, diff --git a/nova/scheduler/multi.py b/nova/scheduler/multi.py index b1578033c..126dbe60e 100644 --- a/nova/scheduler/multi.py +++ b/nova/scheduler/multi.py @@ -38,7 +38,8 @@ flags.DEFINE_string('volume_scheduler_driver', # A mapping of methods to topics so we can figure out which driver to use. _METHOD_MAP = {'run_instance': 'compute', 'start_instance': 'compute', - 'create_volume': 'volume'} + 'create_volume': 'volume', + 'create_volumes': 'volume'} class MultiScheduler(driver.Scheduler): @@ -69,5 +70,6 @@ class MultiScheduler(driver.Scheduler): for k, v in self.drivers.iteritems(): v.set_zone_manager(zone_manager) - def schedule(self, context, topic, *_args, **_kwargs): - return self.drivers[topic].schedule(context, topic, *_args, **_kwargs) + def schedule(self, context, topic, method, *_args, **_kwargs): + return self.drivers[topic].schedule(context, topic, + method, *_args, **_kwargs) diff --git a/nova/scheduler/simple.py b/nova/scheduler/simple.py index fc1b3142a..cce1509b8 100644 --- a/nova/scheduler/simple.py +++ b/nova/scheduler/simple.py @@ -39,47 +39,50 @@ flags.DEFINE_integer("max_networks", 1000, class SimpleScheduler(chance.ChanceScheduler): """Implements Naive Scheduler that tries to find least loaded host.""" - def _schedule_instance(self, context, instance_id, *_args, **_kwargs): + def _schedule_instance(self, context, instance_opts, *_args, **_kwargs): """Picks a host that is up and has the fewest running instances.""" - instance_ref = db.instance_get(context, instance_id) - if (instance_ref['availability_zone'] - and ':' in instance_ref['availability_zone'] - and context.is_admin): - zone, _x, host = instance_ref['availability_zone'].partition(':') + + availability_zone = instance_opts.get('availability_zone') + + if availability_zone and context.is_admin and \ + (':' in availability_zone): + zone, host = availability_zone.split(':', 1) service = db.service_get_by_args(context.elevated(), host, 'nova-compute') if not self.service_is_up(service): raise driver.WillNotSchedule(_("Host %s is not alive") % host) - - # TODO(vish): this probably belongs in the manager, if we - # can generalize this somehow - now = utils.utcnow() - db.instance_update(context, instance_id, {'host': host, - 'scheduled_at': now}) return host + results = db.service_get_all_compute_sorted(context) for result in results: (service, instance_cores) = result - if instance_cores + instance_ref['vcpus'] > FLAGS.max_cores: + if instance_cores + instance_opts['vcpus'] > FLAGS.max_cores: raise driver.NoValidHost(_("All hosts have too many cores")) if self.service_is_up(service): - # NOTE(vish): this probably belongs in the manager, if we - # can generalize this somehow - now = utils.utcnow() - db.instance_update(context, - instance_id, - {'host': service['host'], - 'scheduled_at': now}) return service['host'] raise driver.NoValidHost(_("Scheduler was unable to locate a host" " for this request. Is the appropriate" " service running?")) - def schedule_run_instance(self, context, instance_id, *_args, **_kwargs): - return self._schedule_instance(context, instance_id, *_args, **_kwargs) + def schedule_run_instance(self, context, request_spec, *_args, **_kwargs): + num_instances = request_spec.get('num_instances', 1) + instances = [] + for num in xrange(num_instances): + host = self._schedule_instance(context, + request_spec['instance_properties'], *_args, **_kwargs) + instance_ref = self.create_instance_db_entry(context, + request_spec) + driver.cast_to_compute_host(context, host, 'run_instance', + instance_id=instance_ref['id'], **_kwargs) + instances.append(driver.encode_instance(instance_ref)) + return instances def schedule_start_instance(self, context, instance_id, *_args, **_kwargs): - return self._schedule_instance(context, instance_id, *_args, **_kwargs) + instance_ref = db.instance_get(context, instance_id) + host = self._schedule_instance(context, instance_ref, + *_args, **_kwargs) + driver.cast_to_compute_host(context, host, 'start_instance', + instance_id=intance_id, **_kwargs) def schedule_create_volume(self, context, volume_id, *_args, **_kwargs): """Picks a host that is up and has the fewest volumes.""" @@ -92,13 +95,9 @@ class SimpleScheduler(chance.ChanceScheduler): 'nova-volume') if not self.service_is_up(service): raise driver.WillNotSchedule(_("Host %s not available") % host) - - # TODO(vish): this probably belongs in the manager, if we - # can generalize this somehow - now = utils.utcnow() - db.volume_update(context, volume_id, {'host': host, - 'scheduled_at': now}) - return host + driver.cast_to_volume_host(context, host, 'create_volume', + volume_id=volume_id, **_kwargs) + return None results = db.service_get_all_volume_sorted(context) for result in results: (service, volume_gigabytes) = result @@ -106,14 +105,9 @@ class SimpleScheduler(chance.ChanceScheduler): raise driver.NoValidHost(_("All hosts have too many " "gigabytes")) if self.service_is_up(service): - # NOTE(vish): this probably belongs in the manager, if we - # can generalize this somehow - now = utils.utcnow() - db.volume_update(context, - volume_id, - {'host': service['host'], - 'scheduled_at': now}) - return service['host'] + driver.cast_to_volume_host(context, service['host'], + 'create_volume', volume_id=volume_id, **_kwargs) + return None raise driver.NoValidHost(_("Scheduler was unable to locate a host" " for this request. Is the appropriate" " service running?")) @@ -127,7 +121,9 @@ class SimpleScheduler(chance.ChanceScheduler): if instance_count >= FLAGS.max_networks: raise driver.NoValidHost(_("All hosts have too many networks")) if self.service_is_up(service): - return service['host'] + driver.cast_to_network_host(context, service['host'], + 'set_network_host', **_kwargs) + return None raise driver.NoValidHost(_("Scheduler was unable to locate a host" " for this request. Is the appropriate" " service running?")) diff --git a/nova/scheduler/vsa.py b/nova/scheduler/vsa.py index 6962dd86b..da4475004 100644 --- a/nova/scheduler/vsa.py +++ b/nova/scheduler/vsa.py @@ -195,8 +195,6 @@ class VsaScheduler(simple.SimpleScheduler): 'display_description': vol['description'], 'volume_type_id': vol['volume_type_id'], 'metadata': dict(to_vsa_id=vsa_id), - 'host': vol['host'], - 'scheduled_at': now } size = vol['size'] @@ -205,12 +203,10 @@ class VsaScheduler(simple.SimpleScheduler): LOG.debug(_("Provision volume %(name)s of size %(size)s GB on "\ "host %(host)s"), locals()) - volume_ref = db.volume_create(context, options) - rpc.cast(context, - db.queue_get_for(context, "volume", vol['host']), - {"method": "create_volume", - "args": {"volume_id": volume_ref['id'], - "snapshot_id": None}}) + volume_ref = db.volume_create(context.elevated(), options) + driver.cast_to_volume_host(context, vol['host'], + 'create_volume', volume_id=volume_ref['id'], + snapshot_id=None) def _check_host_enforcement(self, context, availability_zone): if (availability_zone @@ -274,7 +270,6 @@ class VsaScheduler(simple.SimpleScheduler): def schedule_create_volumes(self, context, request_spec, availability_zone=None, *_args, **_kwargs): """Picks hosts for hosting multiple volumes.""" - num_volumes = request_spec.get('num_volumes') LOG.debug(_("Attempting to spawn %(num_volumes)d volume(s)") % locals()) @@ -291,7 +286,8 @@ class VsaScheduler(simple.SimpleScheduler): for vol in volume_params: self._provision_volume(context, vol, vsa_id, availability_zone) - except: + except Exception: + LOG.exception(_("Error creating volumes")) if vsa_id: db.vsa_update(context, vsa_id, dict(status=VsaState.FAILED)) @@ -310,10 +306,9 @@ class VsaScheduler(simple.SimpleScheduler): host = self._check_host_enforcement(context, volume_ref['availability_zone']) if host: - now = utils.utcnow() - db.volume_update(context, volume_id, {'host': host, - 'scheduled_at': now}) - return host + driver.cast_to_volume_host(context, host, 'create_volume', + volume_id=volume_id, **_kwargs) + return None volume_type_id = volume_ref['volume_type_id'] if volume_type_id: @@ -344,18 +339,16 @@ class VsaScheduler(simple.SimpleScheduler): try: (host, qos_cap) = self._select_hosts(request_spec, all_hosts=hosts) - except: + except Exception: + LOG.exception(_("Error creating volume")) if volume_ref['to_vsa_id']: db.vsa_update(context, volume_ref['to_vsa_id'], dict(status=VsaState.FAILED)) raise if host: - now = utils.utcnow() - db.volume_update(context, volume_id, {'host': host, - 'scheduled_at': now}) - self._consume_resource(qos_cap, volume_ref['size'], -1) - return host + driver.cast_to_volume_host(context, host, 'create_volume', + volume_id=volume_id, **_kwargs) def _consume_full_drive(self, qos_values, direction): qos_values['FullDrive']['NumFreeDrives'] += direction diff --git a/nova/scheduler/zone.py b/nova/scheduler/zone.py index 44d5a166f..c369477f8 100644 --- a/nova/scheduler/zone.py +++ b/nova/scheduler/zone.py @@ -35,7 +35,7 @@ class ZoneScheduler(driver.Scheduler): for topic and availability zone (if defined). """ - if zone is None: + if not zone: return self.hosts_up(context, topic) services = db.service_get_all_by_topic(context, topic) @@ -44,16 +44,34 @@ class ZoneScheduler(driver.Scheduler): if self.service_is_up(service) and service.availability_zone == zone] - def schedule(self, context, topic, *_args, **_kwargs): + def _schedule(self, context, topic, request_spec, **kwargs): """Picks a host that is up at random in selected availability zone (if defined). """ - zone = _kwargs.get('availability_zone') - hosts = self.hosts_up_with_zone(context, topic, zone) + zone = kwargs.get('availability_zone') + if not zone and request_spec: + zone = request_spec['instance_properties'].get( + 'availability_zone') + hosts = self.hosts_up_with_zone(context.elevated(), topic, zone) if not hosts: raise driver.NoValidHost(_("Scheduler was unable to locate a host" " for this request. Is the appropriate" " service running?")) - return hosts[int(random.random() * len(hosts))] + + def schedule(self, context, topic, method, *_args, **kwargs): + host = self._schedule(context, topic, None, **kwargs) + driver.cast_to_host(context, topic, host, method, **kwargs) + + def schedule_run_instance(self, context, request_spec, *_args, **kwargs): + """Builds and starts instances on selected hosts""" + num_instances = request_spec.get('num_instances', 1) + instances = [] + for num in xrange(num_instances): + host = self._schedule(context, 'compute', request_spec, **kwargs) + instance = self.create_instance_db_entry(context, request_spec) + driver.cast_to_compute_host(context, host, + 'run_instance', instance_id=instance['id'], **kwargs) + instances.append(driver.encode_instance(instance)) + return instances diff --git a/nova/tests/api/openstack/contrib/test_createserverext.py b/nova/tests/api/openstack/contrib/test_createserverext.py index d2fac26c7..9921b54a3 100644 --- a/nova/tests/api/openstack/contrib/test_createserverext.py +++ b/nova/tests/api/openstack/contrib/test_createserverext.py @@ -25,6 +25,7 @@ import webob from nova import db from nova import exception from nova import flags +from nova import rpc from nova import test import nova.api.openstack from nova.tests.api.openstack import fakes @@ -118,13 +119,15 @@ class CreateserverextTest(test.TestCase): if 'user_data' in kwargs: self.user_data = kwargs['user_data'] - return [{'id': '1234', 'display_name': 'fakeinstance', + resv_id = None + + return ([{'id': '1234', 'display_name': 'fakeinstance', 'uuid': FAKE_UUID, 'user_id': 'fake', 'project_id': 'fake', 'created_at': "", 'updated_at': "", - 'progress': 0}] + 'progress': 0}], resv_id) def set_admin_password(self, *args, **kwargs): pass @@ -133,10 +136,9 @@ class CreateserverextTest(test.TestCase): self.stubs.Set(nova.compute, 'API', self._make_stub_method(compute_api)) self.stubs.Set( - nova.api.openstack.create_instance_helper.CreateInstanceHelper, + nova.api.openstack.servers.Controller, '_get_kernel_ramdisk_from_image', self._make_stub_method((1, 1))) - return compute_api def _setup_mock_network_api(self): @@ -399,7 +401,8 @@ class CreateserverextTest(test.TestCase): self._setup_mock_network_api() body_dict = self._create_security_group_request_dict(security_groups) request = self._get_create_request_json(body_dict) - response = request.get_response(fakes.wsgi_app()) + compute_api, response = \ + self._run_create_instance_with_mock_compute_api(request) self.assertEquals(response.status_int, 202) def test_get_server_by_id_verify_security_groups_json(self): diff --git a/nova/tests/api/openstack/contrib/test_volumes.py b/nova/tests/api/openstack/contrib/test_volumes.py index f61e25d12..9a24b9a54 100644 --- a/nova/tests/api/openstack/contrib/test_volumes.py +++ b/nova/tests/api/openstack/contrib/test_volumes.py @@ -29,8 +29,12 @@ FLAGS = flags.FLAGS def fake_compute_api_create(cls, context, instance_type, image_href, **kwargs): + global _block_device_mapping_seen + _block_device_mapping_seen = kwargs.get('block_device_mapping') + inst_type = instance_types.get_instance_type_by_flavor_id(2) - return [{'id': 1, + resv_id = None + return ([{'id': 1, 'display_name': 'test_server', 'uuid': fake_gen_uuid(), 'instance_type': dict(inst_type), @@ -42,7 +46,7 @@ def fake_compute_api_create(cls, context, instance_type, image_href, **kwargs): 'created_at': datetime.datetime(2010, 10, 10, 12, 0, 0), 'updated_at': datetime.datetime(2010, 11, 11, 11, 0, 0), 'progress': 0 - }] + }], resv_id) def fake_get_instance_nw_info(cls, context, instance): @@ -73,6 +77,8 @@ class BootFromVolumeTest(test.TestCase): delete_on_termination=False, )] )) + global _block_device_mapping_seen + _block_device_mapping_seen = None req = webob.Request.blank('/v1.1/fake/os-volumes_boot') req.method = 'POST' req.body = json.dumps(body) @@ -85,3 +91,7 @@ class BootFromVolumeTest(test.TestCase): self.assertEqual(u'test_server', server['name']) self.assertEqual(3, int(server['image']['id'])) self.assertEqual(FLAGS.password_length, len(server['adminPass'])) + self.assertEqual(len(_block_device_mapping_seen), 1) + self.assertEqual(_block_device_mapping_seen[0]['volume_id'], 1) + self.assertEqual(_block_device_mapping_seen[0]['device_name'], + '/dev/vda') diff --git a/nova/tests/api/openstack/test_extensions.py b/nova/tests/api/openstack/test_extensions.py index a5c6fe65a..4f66f5405 100644 --- a/nova/tests/api/openstack/test_extensions.py +++ b/nova/tests/api/openstack/test_extensions.py @@ -87,6 +87,7 @@ class ExtensionControllerTest(test.TestCase): self.ext_list = [ "Createserverext", "DeferredDelete", + "DiskConfig", "FlavorExtraSpecs", "FlavorExtraData", "Floating_ips", @@ -102,7 +103,7 @@ class ExtensionControllerTest(test.TestCase): "VirtualInterfaces", "Volumes", "VolumeTypes", - "DiskConfig", + "Zones", ] self.ext_list.sort() diff --git a/nova/tests/api/openstack/test_server_actions.py b/nova/tests/api/openstack/test_server_actions.py index 3811fcf0f..04b603237 100644 --- a/nova/tests/api/openstack/test_server_actions.py +++ b/nova/tests/api/openstack/test_server_actions.py @@ -9,7 +9,7 @@ from nova import context from nova import utils from nova import exception from nova import flags -from nova.api.openstack import create_instance_helper +from nova.api.openstack import servers from nova.compute import vm_states from nova.compute import instance_types import nova.db.api @@ -971,7 +971,7 @@ class ServerActionsTestV11(test.TestCase): class TestServerActionXMLDeserializerV11(test.TestCase): def setUp(self): - self.deserializer = create_instance_helper.ServerXMLDeserializerV11() + self.deserializer = servers.ServerXMLDeserializerV11() def tearDown(self): pass diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py index 29be7a812..fa67db688 100644 --- a/nova/tests/api/openstack/test_servers.py +++ b/nova/tests/api/openstack/test_servers.py @@ -33,7 +33,6 @@ from nova import flags from nova import test from nova import utils import nova.api.openstack -from nova.api.openstack import create_instance_helper from nova.api.openstack import servers from nova.api.openstack import xmlutil import nova.compute.api @@ -1562,10 +1561,15 @@ class ServersTest(test.TestCase): def _setup_for_create_instance(self): """Shared implementation for tests below that create instance""" + + self.instance_cache_num = 0 + self.instance_cache = {} + def instance_create(context, inst): inst_type = instance_types.get_instance_type_by_flavor_id(3) image_ref = 'http://localhost/images/2' - return {'id': 1, + self.instance_cache_num += 1 + instance = {'id': self.instance_cache_num, 'display_name': 'server_test', 'uuid': FAKE_UUID, 'instance_type': dict(inst_type), @@ -1574,11 +1578,32 @@ class ServersTest(test.TestCase): 'image_ref': image_ref, 'user_id': 'fake', 'project_id': 'fake', + 'reservation_id': inst['reservation_id'], "created_at": datetime.datetime(2010, 10, 10, 12, 0, 0), "updated_at": datetime.datetime(2010, 11, 11, 11, 0, 0), "config_drive": self.config_drive, "progress": 0 } + self.instance_cache[instance['id']] = instance + return instance + + def instance_get(context, instance_id): + """Stub for compute/api create() pulling in instance after + scheduling + """ + return self.instance_cache[instance_id] + + def rpc_call_wrapper(context, topic, msg): + """Stub out the scheduler creating the instance entry""" + if topic == FLAGS.scheduler_topic and \ + msg['method'] == 'run_instance': + request_spec = msg['args']['request_spec'] + num_instances = request_spec.get('num_instances', 1) + instances = [] + for x in xrange(num_instances): + instances.append(instance_create(context, + request_spec['instance_properties'])) + return instances def server_update(context, id, params): return instance_create(context, id) @@ -1601,18 +1626,20 @@ class ServersTest(test.TestCase): self.stubs.Set(nova.db.api, 'project_get_networks', project_get_networks) self.stubs.Set(nova.db.api, 'instance_create', instance_create) + self.stubs.Set(nova.db.api, 'instance_get', instance_get) self.stubs.Set(nova.rpc, 'cast', fake_method) - self.stubs.Set(nova.rpc, 'call', fake_method) + self.stubs.Set(nova.rpc, 'call', rpc_call_wrapper) self.stubs.Set(nova.db.api, 'instance_update', server_update) self.stubs.Set(nova.db.api, 'queue_get_for', queue_get_for) self.stubs.Set(nova.network.manager.VlanManager, 'allocate_fixed_ip', fake_method) self.stubs.Set( - nova.api.openstack.create_instance_helper.CreateInstanceHelper, - "_get_kernel_ramdisk_from_image", kernel_ramdisk_mapping) + servers.Controller, + "_get_kernel_ramdisk_from_image", + kernel_ramdisk_mapping) self.stubs.Set(nova.compute.api.API, "_find_host", find_host) - def _test_create_instance_helper(self): + def _test_create_instance(self): self._setup_for_create_instance() body = dict(server=dict( @@ -1636,7 +1663,7 @@ class ServersTest(test.TestCase): self.assertEqual(FAKE_UUID, server['uuid']) def test_create_instance(self): - self._test_create_instance_helper() + self._test_create_instance() def test_create_instance_has_uuid(self): """Tests at the db-layer instead of API layer since that's where the @@ -1648,51 +1675,134 @@ class ServersTest(test.TestCase): expected = FAKE_UUID self.assertEqual(instance['uuid'], expected) - def test_create_instance_via_zones(self): - """Server generated ReservationID""" + def test_create_multiple_instances(self): + """Test creating multiple instances but not asking for + reservation_id + """ self._setup_for_create_instance() - self.flags(allow_admin_api=True) - body = dict(server=dict( - name='server_test', imageId=3, flavorId=2, - metadata={'hello': 'world', 'open': 'stack'}, - personality={})) - req = webob.Request.blank('/v1.0/zones/boot') + image_href = 'http://localhost/v1.1/123/images/2' + flavor_ref = 'http://localhost/123/flavors/3' + body = { + 'server': { + 'min_count': 2, + 'name': 'server_test', + 'imageRef': image_href, + 'flavorRef': flavor_ref, + 'metadata': {'hello': 'world', + 'open': 'stack'}, + 'personality': [] + } + } + + req = webob.Request.blank('/v1.1/123/servers') req.method = 'POST' req.body = json.dumps(body) req.headers["content-type"] = "application/json" res = req.get_response(fakes.wsgi_app()) + self.assertEqual(res.status_int, 202) + body = json.loads(res.body) + self.assertIn('server', body) - reservation_id = json.loads(res.body)['reservation_id'] - self.assertEqual(res.status_int, 200) + def test_create_multiple_instances_resv_id_return(self): + """Test creating multiple instances with asking for + reservation_id + """ + self._setup_for_create_instance() + + image_href = 'http://localhost/v1.1/123/images/2' + flavor_ref = 'http://localhost/123/flavors/3' + body = { + 'server': { + 'min_count': 2, + 'name': 'server_test', + 'imageRef': image_href, + 'flavorRef': flavor_ref, + 'metadata': {'hello': 'world', + 'open': 'stack'}, + 'personality': [], + 'return_reservation_id': True + } + } + + req = webob.Request.blank('/v1.1/123/servers') + req.method = 'POST' + req.body = json.dumps(body) + req.headers["content-type"] = "application/json" + + res = req.get_response(fakes.wsgi_app()) + self.assertEqual(res.status_int, 202) + body = json.loads(res.body) + reservation_id = body.get('reservation_id') self.assertNotEqual(reservation_id, "") self.assertNotEqual(reservation_id, None) self.assertTrue(len(reservation_id) > 1) - def test_create_instance_via_zones_with_resid(self): - """User supplied ReservationID""" + def test_create_instance_with_user_supplied_reservation_id(self): + """Non-admin supplied reservation_id should be ignored.""" self._setup_for_create_instance() - self.flags(allow_admin_api=True) - body = dict(server=dict( - name='server_test', imageId=3, flavorId=2, - metadata={'hello': 'world', 'open': 'stack'}, - personality={}, reservation_id='myresid')) - req = webob.Request.blank('/v1.0/zones/boot') + image_href = 'http://localhost/v1.1/123/images/2' + flavor_ref = 'http://localhost/123/flavors/3' + body = { + 'server': { + 'name': 'server_test', + 'imageRef': image_href, + 'flavorRef': flavor_ref, + 'metadata': {'hello': 'world', + 'open': 'stack'}, + 'personality': [], + 'reservation_id': 'myresid', + 'return_reservation_id': True + } + } + + req = webob.Request.blank('/v1.1/123/servers') req.method = 'POST' req.body = json.dumps(body) req.headers["content-type"] = "application/json" res = req.get_response(fakes.wsgi_app()) + self.assertEqual(res.status_int, 202) + res_body = json.loads(res.body) + self.assertIn('reservation_id', res_body) + self.assertNotEqual(res_body['reservation_id'], 'myresid') + def test_create_instance_with_admin_supplied_reservation_id(self): + """Admin supplied reservation_id should be honored.""" + self._setup_for_create_instance() + + image_href = 'http://localhost/v1.1/123/images/2' + flavor_ref = 'http://localhost/123/flavors/3' + body = { + 'server': { + 'name': 'server_test', + 'imageRef': image_href, + 'flavorRef': flavor_ref, + 'metadata': {'hello': 'world', + 'open': 'stack'}, + 'personality': [], + 'reservation_id': 'myresid', + 'return_reservation_id': True + } + } + + req = webob.Request.blank('/v1.1/123/servers') + req.method = 'POST' + req.body = json.dumps(body) + req.headers["content-type"] = "application/json" + + context = nova.context.RequestContext('testuser', 'testproject', + is_admin=True) + res = req.get_response(fakes.wsgi_app(fake_auth_context=context)) + self.assertEqual(res.status_int, 202) reservation_id = json.loads(res.body)['reservation_id'] - self.assertEqual(res.status_int, 200) self.assertEqual(reservation_id, "myresid") def test_create_instance_no_key_pair(self): fakes.stub_out_key_pair_funcs(self.stubs, have_key_pair=False) - self._test_create_instance_helper() + self._test_create_instance() def test_create_instance_no_name(self): self._setup_for_create_instance() @@ -2782,7 +2892,7 @@ class TestServerStatus(test.TestCase): class TestServerCreateRequestXMLDeserializerV10(unittest.TestCase): def setUp(self): - self.deserializer = create_instance_helper.ServerXMLDeserializer() + self.deserializer = servers.ServerXMLDeserializer() def test_minimal_request(self): serial_request = """ @@ -3068,7 +3178,7 @@ class TestServerCreateRequestXMLDeserializerV11(test.TestCase): def setUp(self): super(TestServerCreateRequestXMLDeserializerV11, self).setUp() - self.deserializer = create_instance_helper.ServerXMLDeserializerV11() + self.deserializer = servers.ServerXMLDeserializerV11() def test_minimal_request(self): serial_request = """ @@ -3543,10 +3653,12 @@ class TestServerInstanceCreation(test.TestCase): else: self.injected_files = None - return [{'id': '1234', 'display_name': 'fakeinstance', + resv_id = None + + return ([{'id': '1234', 'display_name': 'fakeinstance', 'user_id': 'fake', 'project_id': 'fake', - 'uuid': FAKE_UUID}] + 'uuid': FAKE_UUID}], resv_id) def set_admin_password(self, *args, **kwargs): pass @@ -3559,8 +3671,9 @@ class TestServerInstanceCreation(test.TestCase): compute_api = MockComputeAPI() self.stubs.Set(nova.compute, 'API', make_stub_method(compute_api)) self.stubs.Set( - nova.api.openstack.create_instance_helper.CreateInstanceHelper, - '_get_kernel_ramdisk_from_image', make_stub_method((1, 1))) + servers.Controller, + '_get_kernel_ramdisk_from_image', + make_stub_method((1, 1))) return compute_api def _create_personality_request_dict(self, personality_files): @@ -3821,8 +3934,8 @@ class TestGetKernelRamdiskFromImage(test.TestCase): @staticmethod def _get_k_r(image_meta): """Rebinding function to a shorter name for convenience""" - kernel_id, ramdisk_id = create_instance_helper.CreateInstanceHelper. \ - _do_get_kernel_ramdisk_from_image(image_meta) + kernel_id, ramdisk_id = servers.Controller.\ + _do_get_kernel_ramdisk_from_image(image_meta) return kernel_id, ramdisk_id diff --git a/nova/tests/integrated/api/client.py b/nova/tests/integrated/api/client.py index 67c35fe6b..c942b0108 100644 --- a/nova/tests/integrated/api/client.py +++ b/nova/tests/integrated/api/client.py @@ -16,6 +16,7 @@ import json import httplib +import urllib import urlparse from nova import log as logging @@ -100,7 +101,7 @@ class TestOpenStackClient(object): relative_url = parsed_url.path if parsed_url.query: - relative_url = relative_url + parsed_url.query + relative_url = relative_url + "?" + parsed_url.query LOG.info(_("Doing %(method)s on %(relative_url)s") % locals()) if body: LOG.info(_("Body: %s") % body) @@ -205,12 +206,24 @@ class TestOpenStackClient(object): def get_server(self, server_id): return self.api_get('/servers/%s' % server_id)['server'] - def get_servers(self, detail=True): + def get_servers(self, detail=True, search_opts=None): rel_url = '/servers/detail' if detail else '/servers' + + if search_opts is not None: + qparams = {} + for opt, val in search_opts.iteritems(): + qparams[opt] = val + if qparams: + query_string = "?%s" % urllib.urlencode(qparams) + rel_url += query_string return self.api_get(rel_url)['servers'] def post_server(self, server): - return self.api_post('/servers', server)['server'] + response = self.api_post('/servers', server) + if 'reservation_id' in response: + return response + else: + return response['server'] def put_server(self, server_id, server): return self.api_put('/servers/%s' % server_id, server) diff --git a/nova/tests/integrated/test_servers.py b/nova/tests/integrated/test_servers.py index ca3eb7340..4bfad93b1 100644 --- a/nova/tests/integrated/test_servers.py +++ b/nova/tests/integrated/test_servers.py @@ -438,6 +438,42 @@ class ServersTest(integrated_helpers._IntegratedTestBase): # Cleanup self._delete_server(server_id) + def test_create_multiple_servers(self): + """Creates multiple servers and checks for reservation_id""" + + # Create 2 servers, setting 'return_reservation_id, which should + # return a reservation_id + server = self._build_minimal_create_server_request() + server['min_count'] = 2 + server['return_reservation_id'] = True + post = {'server': server} + response = self.api.post_server(post) + self.assertIn('reservation_id', response) + reservation_id = response['reservation_id'] + self.assertNotIn(reservation_id, ['', None]) + + # Create 1 more server, which should not return a reservation_id + server = self._build_minimal_create_server_request() + post = {'server': server} + created_server = self.api.post_server(post) + self.assertTrue(created_server['id']) + created_server_id = created_server['id'] + + # lookup servers created by the first request. + servers = self.api.get_servers(detail=True, + search_opts={'reservation_id': reservation_id}) + server_map = dict((server['id'], server) for server in servers) + found_server = server_map.get(created_server_id) + # The server from the 2nd request should not be there. + self.assertEqual(found_server, None) + # Should have found 2 servers. + self.assertEqual(len(server_map), 2) + + # Cleanup + self._delete_server(created_server_id) + for server_id in server_map.iterkeys(): + self._delete_server(server_id) + if __name__ == "__main__": unittest.main() diff --git a/nova/tests/scheduler/test_abstract_scheduler.py b/nova/tests/scheduler/test_abstract_scheduler.py index 5549ea453..da25f1544 100644 --- a/nova/tests/scheduler/test_abstract_scheduler.py +++ b/nova/tests/scheduler/test_abstract_scheduler.py @@ -20,6 +20,7 @@ import json import nova.db +from nova import context from nova import exception from nova import rpc from nova import test @@ -102,7 +103,7 @@ def fake_empty_call_zone_method(context, method, specs, zones): was_called = False -def fake_provision_resource(context, item, instance_id, request_spec, kwargs): +def fake_provision_resource(context, item, request_spec, kwargs): global was_called was_called = True @@ -118,8 +119,7 @@ def fake_provision_resource_locally(context, build_plan, request_spec, kwargs): was_called = True -def fake_provision_resource_from_blob(context, item, instance_id, - request_spec, kwargs): +def fake_provision_resource_from_blob(context, item, request_spec, kwargs): global was_called was_called = True @@ -185,7 +185,7 @@ class AbstractSchedulerTestCase(test.TestCase): zm = FakeZoneManager() sched.set_zone_manager(zm) - fake_context = {} + fake_context = context.RequestContext('user', 'project') build_plan = sched.select(fake_context, {'instance_type': {'memory_mb': 512}, 'num_instances': 4}) @@ -229,9 +229,10 @@ class AbstractSchedulerTestCase(test.TestCase): zm = FakeEmptyZoneManager() sched.set_zone_manager(zm) - fake_context = {} + fake_context = context.RequestContext('user', 'project') + request_spec = {} self.assertRaises(driver.NoValidHost, sched.schedule_run_instance, - fake_context, 1, + fake_context, request_spec, dict(host_filter=None, instance_type={})) def test_schedule_do_not_schedule_with_hint(self): @@ -250,8 +251,8 @@ class AbstractSchedulerTestCase(test.TestCase): 'blob': "Non-None blob data", } - result = sched.schedule_run_instance(None, 1, request_spec) - self.assertEquals(None, result) + instances = sched.schedule_run_instance(None, request_spec) + self.assertTrue(instances) self.assertTrue(was_called) def test_provision_resource_local(self): @@ -263,7 +264,7 @@ class AbstractSchedulerTestCase(test.TestCase): fake_provision_resource_locally) request_spec = {'hostname': "foo"} - sched._provision_resource(None, request_spec, 1, request_spec, {}) + sched._provision_resource(None, request_spec, request_spec, {}) self.assertTrue(was_called) def test_provision_resource_remote(self): @@ -275,7 +276,7 @@ class AbstractSchedulerTestCase(test.TestCase): fake_provision_resource_from_blob) request_spec = {} - sched._provision_resource(None, request_spec, 1, request_spec, {}) + sched._provision_resource(None, request_spec, request_spec, {}) self.assertTrue(was_called) def test_provision_resource_from_blob_empty(self): @@ -285,7 +286,7 @@ class AbstractSchedulerTestCase(test.TestCase): request_spec = {} self.assertRaises(abstract_scheduler.InvalidBlob, sched._provision_resource_from_blob, - None, {}, 1, {}, {}) + None, {}, {}, {}) def test_provision_resource_from_blob_with_local_blob(self): """ @@ -303,20 +304,21 @@ class AbstractSchedulerTestCase(test.TestCase): # return fake instances return {'id': 1, 'uuid': 'f874093c-7b17-49c0-89c3-22a5348497f9'} - def fake_rpc_cast(*args, **kwargs): + def fake_cast_to_compute_host(*args, **kwargs): pass self.stubs.Set(sched, '_decrypt_blob', fake_decrypt_blob_returns_local_info) + self.stubs.Set(driver, 'cast_to_compute_host', + fake_cast_to_compute_host) self.stubs.Set(compute_api.API, 'create_db_entry_for_new_instance', fake_create_db_entry_for_new_instance) - self.stubs.Set(rpc, 'cast', fake_rpc_cast) build_plan_item = {'blob': "Non-None blob data"} request_spec = {'image': {}, 'instance_properties': {}} - sched._provision_resource_from_blob(None, build_plan_item, 1, + sched._provision_resource_from_blob(None, build_plan_item, request_spec, {}) self.assertTrue(was_called) @@ -335,7 +337,7 @@ class AbstractSchedulerTestCase(test.TestCase): request_spec = {'blob': "Non-None blob data"} - sched._provision_resource_from_blob(None, request_spec, 1, + sched._provision_resource_from_blob(None, request_spec, request_spec, {}) self.assertTrue(was_called) @@ -352,7 +354,7 @@ class AbstractSchedulerTestCase(test.TestCase): request_spec = {'child_blob': True, 'child_zone': True} - sched._provision_resource_from_blob(None, request_spec, 1, + sched._provision_resource_from_blob(None, request_spec, request_spec, {}) self.assertTrue(was_called) @@ -386,7 +388,7 @@ class AbstractSchedulerTestCase(test.TestCase): zm.service_states = {} sched.set_zone_manager(zm) - fake_context = {} + fake_context = context.RequestContext('user', 'project') build_plan = sched.select(fake_context, {'instance_type': {'memory_mb': 512}, 'num_instances': 4}) @@ -394,6 +396,45 @@ class AbstractSchedulerTestCase(test.TestCase): # 0 from local zones, 12 from remotes self.assertEqual(12, len(build_plan)) + def test_run_instance_non_admin(self): + """Test creating an instance locally using run_instance, passing + a non-admin context. DB actions should work.""" + sched = FakeAbstractScheduler() + + def fake_cast_to_compute_host(*args, **kwargs): + pass + + def fake_zone_get_all_zero(context): + # make sure this is called with admin context, even though + # we're using user context below + self.assertTrue(context.is_admin) + return [] + + self.stubs.Set(driver, 'cast_to_compute_host', + fake_cast_to_compute_host) + self.stubs.Set(sched, '_call_zone_method', fake_call_zone_method) + self.stubs.Set(nova.db, 'zone_get_all', fake_zone_get_all_zero) + + zm = FakeZoneManager() + sched.set_zone_manager(zm) + + fake_context = context.RequestContext('user', 'project') + + request_spec = { + 'image': {'properties': {}}, + 'security_group': [], + 'instance_properties': { + 'project_id': fake_context.project_id, + 'user_id': fake_context.user_id}, + 'instance_type': {'memory_mb': 256}, + 'filter_driver': 'nova.scheduler.host_filter.AllHostsFilter' + } + + instances = sched.schedule_run_instance(fake_context, request_spec) + self.assertEqual(len(instances), 1) + self.assertFalse(instances[0].get('_is_precooked', False)) + nova.db.instance_destroy(fake_context, instances[0]['id']) + class BaseSchedulerTestCase(test.TestCase): """Test case for Base Scheduler.""" diff --git a/nova/tests/scheduler/test_least_cost_scheduler.py b/nova/tests/scheduler/test_least_cost_scheduler.py index af58de527..b8847a2bf 100644 --- a/nova/tests/scheduler/test_least_cost_scheduler.py +++ b/nova/tests/scheduler/test_least_cost_scheduler.py @@ -134,7 +134,7 @@ class LeastCostSchedulerTestCase(test.TestCase): expected = [] for idx, (hostname, services) in enumerate(hosts): - caps = copy.deepcopy(services["compute"]) + caps = copy.deepcopy(services) # Costs are normalized so over 10 hosts, each host with increasing # free ram will cost 1/N more. Since the lowest cost host has some # free ram, we add in the 1/N for the base_cost diff --git a/nova/tests/scheduler/test_scheduler.py b/nova/tests/scheduler/test_scheduler.py index 3a10e9287..77db3520b 100644 --- a/nova/tests/scheduler/test_scheduler.py +++ b/nova/tests/scheduler/test_scheduler.py @@ -35,10 +35,13 @@ from nova import service from nova import test from nova import rpc from nova import utils +from nova.db.sqlalchemy import models from nova.scheduler import api from nova.scheduler import driver from nova.scheduler import manager from nova.scheduler import multi +from nova.scheduler.simple import SimpleScheduler +from nova.scheduler.zone import ZoneScheduler from nova.compute import power_state from nova.compute import vm_states @@ -53,17 +56,86 @@ FAKE_UUID_NOT_FOUND = 'ffffffff-ffff-ffff-ffff-ffffffffffff' FAKE_UUID = 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa' -class FakeContext(object): - auth_token = None +def _create_instance_dict(**kwargs): + """Create a dictionary for a test instance""" + inst = {} + # NOTE(jk0): If an integer is passed as the image_ref, the image + # service will use the default image service (in this case, the fake). + inst['image_ref'] = '1' + inst['reservation_id'] = 'r-fakeres' + inst['user_id'] = kwargs.get('user_id', 'admin') + inst['project_id'] = kwargs.get('project_id', 'fake') + inst['instance_type_id'] = '1' + if 'host' in kwargs: + inst['host'] = kwargs.get('host') + inst['vcpus'] = kwargs.get('vcpus', 1) + inst['memory_mb'] = kwargs.get('memory_mb', 20) + inst['local_gb'] = kwargs.get('local_gb', 30) + inst['vm_state'] = kwargs.get('vm_state', vm_states.ACTIVE) + inst['power_state'] = kwargs.get('power_state', power_state.RUNNING) + inst['task_state'] = kwargs.get('task_state', None) + inst['availability_zone'] = kwargs.get('availability_zone', None) + inst['ami_launch_index'] = 0 + inst['launched_on'] = kwargs.get('launched_on', 'dummy') + return inst + + +def _create_volume(): + """Create a test volume""" + vol = {} + vol['size'] = 1 + vol['availability_zone'] = 'test' + ctxt = context.get_admin_context() + return db.volume_create(ctxt, vol)['id'] + + +def _create_instance(**kwargs): + """Create a test instance""" + ctxt = context.get_admin_context() + return db.instance_create(ctxt, _create_instance_dict(**kwargs)) + + +def _create_instance_from_spec(spec): + return _create_instance(**spec['instance_properties']) + + +def _create_request_spec(**kwargs): + return dict(instance_properties=_create_instance_dict(**kwargs)) + + +def _fake_cast_to_compute_host(context, host, method, **kwargs): + global _picked_host + _picked_host = host + + +def _fake_cast_to_volume_host(context, host, method, **kwargs): + global _picked_host + _picked_host = host + + +def _fake_create_instance_db_entry(simple_self, context, request_spec): + instance = _create_instance_from_spec(request_spec) + global instance_ids + instance_ids.append(instance['id']) + return instance + + +class FakeContext(context.RequestContext): + def __init__(self, *args, **kwargs): + super(FakeContext, self).__init__('user', 'project', **kwargs) class TestDriver(driver.Scheduler): """Scheduler Driver for Tests""" - def schedule(context, topic, *args, **kwargs): - return 'fallback_host' + def schedule(self, context, topic, method, *args, **kwargs): + host = 'fallback_host' + driver.cast_to_host(context, topic, host, method, **kwargs) - def schedule_named_method(context, topic, num): - return 'named_host' + def schedule_named_method(self, context, num=None): + topic = 'topic' + host = 'named_host' + method = 'named_method' + driver.cast_to_host(context, topic, host, method, num=num) class SchedulerTestCase(test.TestCase): @@ -89,31 +161,16 @@ class SchedulerTestCase(test.TestCase): return db.service_get(ctxt, s_ref['id']) - def _create_instance(self, **kwargs): - """Create a test instance""" - ctxt = context.get_admin_context() - inst = {} - inst['user_id'] = 'admin' - inst['project_id'] = kwargs.get('project_id', 'fake') - inst['host'] = kwargs.get('host', 'dummy') - inst['vcpus'] = kwargs.get('vcpus', 1) - inst['memory_mb'] = kwargs.get('memory_mb', 10) - inst['local_gb'] = kwargs.get('local_gb', 20) - inst['vm_state'] = kwargs.get('vm_state', vm_states.ACTIVE) - inst['power_state'] = kwargs.get('power_state', power_state.RUNNING) - inst['task_state'] = kwargs.get('task_state', None) - return db.instance_create(ctxt, inst) - def test_fallback(self): scheduler = manager.SchedulerManager() self.mox.StubOutWithMock(rpc, 'cast', use_mock_anything=True) ctxt = context.get_admin_context() rpc.cast(ctxt, - 'topic.fallback_host', + 'fake_topic.fallback_host', {'method': 'noexist', 'args': {'num': 7}}) self.mox.ReplayAll() - scheduler.noexist(ctxt, 'topic', num=7) + scheduler.noexist(ctxt, 'fake_topic', num=7) def test_named_method(self): scheduler = manager.SchedulerManager() @@ -173,8 +230,8 @@ class SchedulerTestCase(test.TestCase): scheduler = manager.SchedulerManager() ctxt = context.get_admin_context() s_ref = self._create_compute_service() - i_ref1 = self._create_instance(project_id='p-01', host=s_ref['host']) - i_ref2 = self._create_instance(project_id='p-02', vcpus=3, + i_ref1 = _create_instance(project_id='p-01', host=s_ref['host']) + i_ref2 = _create_instance(project_id='p-02', vcpus=3, host=s_ref['host']) result = scheduler.show_host_resources(ctxt, s_ref['host']) @@ -197,7 +254,10 @@ class ZoneSchedulerTestCase(test.TestCase): """Test case for zone scheduler""" def setUp(self): super(ZoneSchedulerTestCase, self).setUp() - self.flags(scheduler_driver='nova.scheduler.zone.ZoneScheduler') + self.flags( + scheduler_driver='nova.scheduler.multi.MultiScheduler', + compute_scheduler_driver='nova.scheduler.zone.ZoneScheduler', + volume_scheduler_driver='nova.scheduler.zone.ZoneScheduler') def _create_service_model(self, **kwargs): service = db.sqlalchemy.models.Service() @@ -214,7 +274,7 @@ class ZoneSchedulerTestCase(test.TestCase): def test_with_two_zones(self): scheduler = manager.SchedulerManager() - ctxt = context.get_admin_context() + ctxt = context.RequestContext('user', 'project') service_list = [self._create_service_model(id=1, host='host1', zone='zone1'), @@ -230,66 +290,53 @@ class ZoneSchedulerTestCase(test.TestCase): self._create_service_model(id=5, host='host5', zone='zone2')] + + request_spec = _create_request_spec(availability_zone='zone1') + + fake_instance = _create_instance_dict( + **request_spec['instance_properties']) + fake_instance['id'] = 100 + fake_instance['uuid'] = FAKE_UUID + self.mox.StubOutWithMock(db, 'service_get_all_by_topic') + self.mox.StubOutWithMock(db, 'instance_update') + # Assumes we're testing with MultiScheduler + compute_sched_driver = scheduler.driver.drivers['compute'] + self.mox.StubOutWithMock(compute_sched_driver, + 'create_instance_db_entry') + self.mox.StubOutWithMock(rpc, 'cast', use_mock_anything=True) + arg = IgnoreArg() db.service_get_all_by_topic(arg, arg).AndReturn(service_list) - self.mox.StubOutWithMock(rpc, 'cast', use_mock_anything=True) - rpc.cast(ctxt, + compute_sched_driver.create_instance_db_entry(arg, + request_spec).AndReturn(fake_instance) + db.instance_update(arg, 100, {'host': 'host1', 'scheduled_at': arg}) + rpc.cast(arg, 'compute.host1', {'method': 'run_instance', - 'args': {'instance_id': 'i-ffffffff', - 'availability_zone': 'zone1'}}) + 'args': {'instance_id': 100}}) self.mox.ReplayAll() scheduler.run_instance(ctxt, 'compute', - instance_id='i-ffffffff', - availability_zone='zone1') + request_spec=request_spec) class SimpleDriverTestCase(test.TestCase): """Test case for simple driver""" def setUp(self): super(SimpleDriverTestCase, self).setUp() + simple_scheduler = 'nova.scheduler.simple.SimpleScheduler' self.flags(connection_type='fake', - stub_network=True, - max_cores=4, - max_gigabytes=4, - network_manager='nova.network.manager.FlatManager', - volume_driver='nova.volume.driver.FakeISCSIDriver', - scheduler_driver='nova.scheduler.simple.SimpleScheduler') + stub_network=True, + max_cores=4, + max_gigabytes=4, + network_manager='nova.network.manager.FlatManager', + volume_driver='nova.volume.driver.FakeISCSIDriver', + scheduler_driver='nova.scheduler.multi.MultiScheduler', + compute_scheduler_driver=simple_scheduler, + volume_scheduler_driver=simple_scheduler) self.scheduler = manager.SchedulerManager() self.context = context.get_admin_context() - self.user_id = 'fake' - self.project_id = 'fake' - - def _create_instance(self, **kwargs): - """Create a test instance""" - inst = {} - # NOTE(jk0): If an integer is passed as the image_ref, the image - # service will use the default image service (in this case, the fake). - inst['image_ref'] = '1' - inst['reservation_id'] = 'r-fakeres' - inst['user_id'] = self.user_id - inst['project_id'] = self.project_id - inst['instance_type_id'] = '1' - inst['vcpus'] = kwargs.get('vcpus', 1) - inst['ami_launch_index'] = 0 - inst['availability_zone'] = kwargs.get('availability_zone', None) - inst['host'] = kwargs.get('host', 'dummy') - inst['memory_mb'] = kwargs.get('memory_mb', 20) - inst['local_gb'] = kwargs.get('local_gb', 30) - inst['launched_on'] = kwargs.get('launghed_on', 'dummy') - inst['vm_state'] = kwargs.get('vm_state', vm_states.ACTIVE) - inst['task_state'] = kwargs.get('task_state', None) - inst['power_state'] = kwargs.get('power_state', power_state.RUNNING) - return db.instance_create(self.context, inst)['id'] - - def _create_volume(self): - """Create a test volume""" - vol = {} - vol['size'] = 1 - vol['availability_zone'] = 'test' - return db.volume_create(self.context, vol)['id'] def _create_compute_service(self, **kwargs): """Create a compute service.""" @@ -369,14 +416,30 @@ class SimpleDriverTestCase(test.TestCase): 'compute', FLAGS.compute_manager) compute2.start() - instance_id1 = self._create_instance() - compute1.run_instance(self.context, instance_id1) - instance_id2 = self._create_instance() - host = self.scheduler.driver.schedule_run_instance(self.context, - instance_id2) - self.assertEqual(host, 'host2') - compute1.terminate_instance(self.context, instance_id1) - db.instance_destroy(self.context, instance_id2) + + global instance_ids + instance_ids = [] + instance_ids.append(_create_instance()['id']) + compute1.run_instance(self.context, instance_ids[0]) + + self.stubs.Set(SimpleScheduler, + 'create_instance_db_entry', _fake_create_instance_db_entry) + global _picked_host + _picked_host = None + self.stubs.Set(driver, + 'cast_to_compute_host', _fake_cast_to_compute_host) + + request_spec = _create_request_spec() + instances = self.scheduler.driver.schedule_run_instance( + self.context, request_spec) + + self.assertEqual(_picked_host, 'host2') + self.assertEqual(len(instance_ids), 2) + self.assertEqual(len(instances), 1) + self.assertEqual(instances[0].get('_is_precooked', False), False) + + compute1.terminate_instance(self.context, instance_ids[0]) + compute2.terminate_instance(self.context, instance_ids[1]) compute1.kill() compute2.kill() @@ -392,14 +455,27 @@ class SimpleDriverTestCase(test.TestCase): 'compute', FLAGS.compute_manager) compute2.start() - instance_id1 = self._create_instance() - compute1.run_instance(self.context, instance_id1) - instance_id2 = self._create_instance(availability_zone='nova:host1') - host = self.scheduler.driver.schedule_run_instance(self.context, - instance_id2) - self.assertEqual('host1', host) - compute1.terminate_instance(self.context, instance_id1) - db.instance_destroy(self.context, instance_id2) + + global instance_ids + instance_ids = [] + instance_ids.append(_create_instance()['id']) + compute1.run_instance(self.context, instance_ids[0]) + + self.stubs.Set(SimpleScheduler, + 'create_instance_db_entry', _fake_create_instance_db_entry) + global _picked_host + _picked_host = None + self.stubs.Set(driver, + 'cast_to_compute_host', _fake_cast_to_compute_host) + + request_spec = _create_request_spec(availability_zone='nova:host1') + instances = self.scheduler.driver.schedule_run_instance( + self.context, request_spec) + self.assertEqual(_picked_host, 'host1') + self.assertEqual(len(instance_ids), 2) + + compute1.terminate_instance(self.context, instance_ids[0]) + compute1.terminate_instance(self.context, instance_ids[1]) compute1.kill() compute2.kill() @@ -414,12 +490,21 @@ class SimpleDriverTestCase(test.TestCase): delta = datetime.timedelta(seconds=FLAGS.service_down_time * 2) past = now - delta db.service_update(self.context, s1['id'], {'updated_at': past}) - instance_id2 = self._create_instance(availability_zone='nova:host1') + + global instance_ids + instance_ids = [] + self.stubs.Set(SimpleScheduler, + 'create_instance_db_entry', _fake_create_instance_db_entry) + global _picked_host + _picked_host = None + self.stubs.Set(driver, + 'cast_to_compute_host', _fake_cast_to_compute_host) + + request_spec = _create_request_spec(availability_zone='nova:host1') self.assertRaises(driver.WillNotSchedule, self.scheduler.driver.schedule_run_instance, self.context, - instance_id2) - db.instance_destroy(self.context, instance_id2) + request_spec) compute1.kill() def test_will_schedule_on_disabled_host_if_specified_no_queue(self): @@ -430,11 +515,22 @@ class SimpleDriverTestCase(test.TestCase): compute1.start() s1 = db.service_get_by_args(self.context, 'host1', 'nova-compute') db.service_update(self.context, s1['id'], {'disabled': True}) - instance_id2 = self._create_instance(availability_zone='nova:host1') - host = self.scheduler.driver.schedule_run_instance(self.context, - instance_id2) - self.assertEqual('host1', host) - db.instance_destroy(self.context, instance_id2) + + global instance_ids + instance_ids = [] + self.stubs.Set(SimpleScheduler, + 'create_instance_db_entry', _fake_create_instance_db_entry) + global _picked_host + _picked_host = None + self.stubs.Set(driver, + 'cast_to_compute_host', _fake_cast_to_compute_host) + + request_spec = _create_request_spec(availability_zone='nova:host1') + instances = self.scheduler.driver.schedule_run_instance( + self.context, request_spec) + self.assertEqual(_picked_host, 'host1') + self.assertEqual(len(instance_ids), 1) + compute1.terminate_instance(self.context, instance_ids[0]) compute1.kill() def test_too_many_cores_no_queue(self): @@ -452,17 +548,17 @@ class SimpleDriverTestCase(test.TestCase): instance_ids1 = [] instance_ids2 = [] for index in xrange(FLAGS.max_cores): - instance_id = self._create_instance() + instance_id = _create_instance()['id'] compute1.run_instance(self.context, instance_id) instance_ids1.append(instance_id) - instance_id = self._create_instance() + instance_id = _create_instance()['id'] compute2.run_instance(self.context, instance_id) instance_ids2.append(instance_id) - instance_id = self._create_instance() + request_spec = _create_request_spec() self.assertRaises(driver.NoValidHost, self.scheduler.driver.schedule_run_instance, self.context, - instance_id) + request_spec) for instance_id in instance_ids1: compute1.terminate_instance(self.context, instance_id) for instance_id in instance_ids2: @@ -481,13 +577,19 @@ class SimpleDriverTestCase(test.TestCase): 'nova-volume', 'volume', FLAGS.volume_manager) + + global _picked_host + _picked_host = None + self.stubs.Set(driver, + 'cast_to_volume_host', _fake_cast_to_volume_host) + volume2.start() - volume_id1 = self._create_volume() + volume_id1 = _create_volume() volume1.create_volume(self.context, volume_id1) - volume_id2 = self._create_volume() - host = self.scheduler.driver.schedule_create_volume(self.context, - volume_id2) - self.assertEqual(host, 'host2') + volume_id2 = _create_volume() + self.scheduler.driver.schedule_create_volume(self.context, + volume_id2) + self.assertEqual(_picked_host, 'host2') volume1.delete_volume(self.context, volume_id1) db.volume_destroy(self.context, volume_id2) @@ -514,17 +616,30 @@ class SimpleDriverTestCase(test.TestCase): compute2.kill() def test_least_busy_host_gets_instance(self): - """Ensures the host with less cores gets the next one""" + """Ensures the host with less cores gets the next one w/ Simple""" compute1 = self.start_service('compute', host='host1') compute2 = self.start_service('compute', host='host2') - instance_id1 = self._create_instance() - compute1.run_instance(self.context, instance_id1) - instance_id2 = self._create_instance() - host = self.scheduler.driver.schedule_run_instance(self.context, - instance_id2) - self.assertEqual(host, 'host2') - compute1.terminate_instance(self.context, instance_id1) - db.instance_destroy(self.context, instance_id2) + + global instance_ids + instance_ids = [] + instance_ids.append(_create_instance()['id']) + compute1.run_instance(self.context, instance_ids[0]) + + self.stubs.Set(SimpleScheduler, + 'create_instance_db_entry', _fake_create_instance_db_entry) + global _picked_host + _picked_host = None + self.stubs.Set(driver, + 'cast_to_compute_host', _fake_cast_to_compute_host) + + request_spec = _create_request_spec() + instances = self.scheduler.driver.schedule_run_instance( + self.context, request_spec) + self.assertEqual(_picked_host, 'host2') + self.assertEqual(len(instance_ids), 2) + + compute1.terminate_instance(self.context, instance_ids[0]) + compute2.terminate_instance(self.context, instance_ids[1]) compute1.kill() compute2.kill() @@ -532,41 +647,64 @@ class SimpleDriverTestCase(test.TestCase): """Ensures if you set availability_zone it launches on that zone""" compute1 = self.start_service('compute', host='host1') compute2 = self.start_service('compute', host='host2') - instance_id1 = self._create_instance() - compute1.run_instance(self.context, instance_id1) - instance_id2 = self._create_instance(availability_zone='nova:host1') - host = self.scheduler.driver.schedule_run_instance(self.context, - instance_id2) - self.assertEqual('host1', host) - compute1.terminate_instance(self.context, instance_id1) - db.instance_destroy(self.context, instance_id2) + + global instance_ids + instance_ids = [] + instance_ids.append(_create_instance()['id']) + compute1.run_instance(self.context, instance_ids[0]) + + self.stubs.Set(SimpleScheduler, + 'create_instance_db_entry', _fake_create_instance_db_entry) + global _picked_host + _picked_host = None + self.stubs.Set(driver, + 'cast_to_compute_host', _fake_cast_to_compute_host) + + request_spec = _create_request_spec(availability_zone='nova:host1') + instances = self.scheduler.driver.schedule_run_instance( + self.context, request_spec) + self.assertEqual(_picked_host, 'host1') + self.assertEqual(len(instance_ids), 2) + + compute1.terminate_instance(self.context, instance_ids[0]) + compute1.terminate_instance(self.context, instance_ids[1]) compute1.kill() compute2.kill() - def test_wont_sechedule_if_specified_host_is_down(self): + def test_wont_schedule_if_specified_host_is_down(self): compute1 = self.start_service('compute', host='host1') s1 = db.service_get_by_args(self.context, 'host1', 'nova-compute') now = utils.utcnow() delta = datetime.timedelta(seconds=FLAGS.service_down_time * 2) past = now - delta db.service_update(self.context, s1['id'], {'updated_at': past}) - instance_id2 = self._create_instance(availability_zone='nova:host1') + request_spec = _create_request_spec(availability_zone='nova:host1') self.assertRaises(driver.WillNotSchedule, self.scheduler.driver.schedule_run_instance, self.context, - instance_id2) - db.instance_destroy(self.context, instance_id2) + request_spec) compute1.kill() def test_will_schedule_on_disabled_host_if_specified(self): compute1 = self.start_service('compute', host='host1') s1 = db.service_get_by_args(self.context, 'host1', 'nova-compute') db.service_update(self.context, s1['id'], {'disabled': True}) - instance_id2 = self._create_instance(availability_zone='nova:host1') - host = self.scheduler.driver.schedule_run_instance(self.context, - instance_id2) - self.assertEqual('host1', host) - db.instance_destroy(self.context, instance_id2) + + global instance_ids + instance_ids = [] + self.stubs.Set(SimpleScheduler, + 'create_instance_db_entry', _fake_create_instance_db_entry) + global _picked_host + _picked_host = None + self.stubs.Set(driver, + 'cast_to_compute_host', _fake_cast_to_compute_host) + + request_spec = _create_request_spec(availability_zone='nova:host1') + instances = self.scheduler.driver.schedule_run_instance( + self.context, request_spec) + self.assertEqual(_picked_host, 'host1') + self.assertEqual(len(instance_ids), 1) + compute1.terminate_instance(self.context, instance_ids[0]) compute1.kill() def test_too_many_cores(self): @@ -576,18 +714,30 @@ class SimpleDriverTestCase(test.TestCase): instance_ids1 = [] instance_ids2 = [] for index in xrange(FLAGS.max_cores): - instance_id = self._create_instance() + instance_id = _create_instance()['id'] compute1.run_instance(self.context, instance_id) instance_ids1.append(instance_id) - instance_id = self._create_instance() + instance_id = _create_instance()['id'] compute2.run_instance(self.context, instance_id) instance_ids2.append(instance_id) - instance_id = self._create_instance() + + def _create_instance_db_entry(simple_self, context, request_spec): + self.fail(_("Shouldn't try to create DB entry when at " + "max cores")) + self.stubs.Set(SimpleScheduler, + 'create_instance_db_entry', _create_instance_db_entry) + + global _picked_host + _picked_host = None + self.stubs.Set(driver, + 'cast_to_compute_host', _fake_cast_to_compute_host) + + request_spec = _create_request_spec() + self.assertRaises(driver.NoValidHost, self.scheduler.driver.schedule_run_instance, self.context, - instance_id) - db.instance_destroy(self.context, instance_id) + request_spec) for instance_id in instance_ids1: compute1.terminate_instance(self.context, instance_id) for instance_id in instance_ids2: @@ -599,12 +749,18 @@ class SimpleDriverTestCase(test.TestCase): """Ensures the host with less gigabytes gets the next one""" volume1 = self.start_service('volume', host='host1') volume2 = self.start_service('volume', host='host2') - volume_id1 = self._create_volume() + + global _picked_host + _picked_host = None + self.stubs.Set(driver, + 'cast_to_volume_host', _fake_cast_to_volume_host) + + volume_id1 = _create_volume() volume1.create_volume(self.context, volume_id1) - volume_id2 = self._create_volume() - host = self.scheduler.driver.schedule_create_volume(self.context, - volume_id2) - self.assertEqual(host, 'host2') + volume_id2 = _create_volume() + self.scheduler.driver.schedule_create_volume(self.context, + volume_id2) + self.assertEqual(_picked_host, 'host2') volume1.delete_volume(self.context, volume_id1) db.volume_destroy(self.context, volume_id2) volume1.kill() @@ -617,13 +773,13 @@ class SimpleDriverTestCase(test.TestCase): volume_ids1 = [] volume_ids2 = [] for index in xrange(FLAGS.max_gigabytes): - volume_id = self._create_volume() + volume_id = _create_volume() volume1.create_volume(self.context, volume_id) volume_ids1.append(volume_id) - volume_id = self._create_volume() + volume_id = _create_volume() volume2.create_volume(self.context, volume_id) volume_ids2.append(volume_id) - volume_id = self._create_volume() + volume_id = _create_volume() self.assertRaises(driver.NoValidHost, self.scheduler.driver.schedule_create_volume, self.context, @@ -636,13 +792,13 @@ class SimpleDriverTestCase(test.TestCase): volume2.kill() def test_scheduler_live_migration_with_volume(self): - """scheduler_live_migration() works correctly as expected. + """schedule_live_migration() works correctly as expected. Also, checks instance state is changed from 'running' -> 'migrating'. """ - instance_id = self._create_instance() + instance_id = _create_instance(host='dummy')['id'] i_ref = db.instance_get(self.context, instance_id) dic = {'instance_id': instance_id, 'size': 1} v_ref = db.volume_create(self.context, dic) @@ -680,7 +836,8 @@ class SimpleDriverTestCase(test.TestCase): def test_live_migration_src_check_instance_not_running(self): """The instance given by instance_id is not running.""" - instance_id = self._create_instance(power_state=power_state.NOSTATE) + instance_id = _create_instance( + power_state=power_state.NOSTATE)['id'] i_ref = db.instance_get(self.context, instance_id) try: @@ -695,7 +852,7 @@ class SimpleDriverTestCase(test.TestCase): def test_live_migration_src_check_volume_node_not_alive(self): """Raise exception when volume node is not alive.""" - instance_id = self._create_instance() + instance_id = _create_instance()['id'] i_ref = db.instance_get(self.context, instance_id) dic = {'instance_id': instance_id, 'size': 1} v_ref = db.volume_create(self.context, {'instance_id': instance_id, @@ -715,7 +872,7 @@ class SimpleDriverTestCase(test.TestCase): def test_live_migration_src_check_compute_node_not_alive(self): """Confirms src-compute node is alive.""" - instance_id = self._create_instance() + instance_id = _create_instance()['id'] i_ref = db.instance_get(self.context, instance_id) t = utils.utcnow() - datetime.timedelta(10) s_ref = self._create_compute_service(created_at=t, updated_at=t, @@ -730,7 +887,7 @@ class SimpleDriverTestCase(test.TestCase): def test_live_migration_src_check_works_correctly(self): """Confirms this method finishes with no error.""" - instance_id = self._create_instance() + instance_id = _create_instance()['id'] i_ref = db.instance_get(self.context, instance_id) s_ref = self._create_compute_service(host=i_ref['host']) @@ -743,7 +900,7 @@ class SimpleDriverTestCase(test.TestCase): def test_live_migration_dest_check_not_alive(self): """Confirms exception raises in case dest host does not exist.""" - instance_id = self._create_instance() + instance_id = _create_instance()['id'] i_ref = db.instance_get(self.context, instance_id) t = utils.utcnow() - datetime.timedelta(10) s_ref = self._create_compute_service(created_at=t, updated_at=t, @@ -758,7 +915,7 @@ class SimpleDriverTestCase(test.TestCase): def test_live_migration_dest_check_service_same_host(self): """Confirms exceptioin raises in case dest and src is same host.""" - instance_id = self._create_instance() + instance_id = _create_instance()['id'] i_ref = db.instance_get(self.context, instance_id) s_ref = self._create_compute_service(host=i_ref['host']) @@ -771,9 +928,9 @@ class SimpleDriverTestCase(test.TestCase): def test_live_migration_dest_check_service_lack_memory(self): """Confirms exception raises when dest doesn't have enough memory.""" - instance_id = self._create_instance() - instance_id2 = self._create_instance(host='somewhere', - memory_mb=12) + instance_id = _create_instance()['id'] + instance_id2 = _create_instance(host='somewhere', + memory_mb=12)['id'] i_ref = db.instance_get(self.context, instance_id) s_ref = self._create_compute_service(host='somewhere') @@ -787,9 +944,9 @@ class SimpleDriverTestCase(test.TestCase): def test_block_migration_dest_check_service_lack_disk(self): """Confirms exception raises when dest doesn't have enough disk.""" - instance_id = self._create_instance() - instance_id2 = self._create_instance(host='somewhere', - local_gb=70) + instance_id = _create_instance()['id'] + instance_id2 = _create_instance(host='somewhere', + local_gb=70)['id'] i_ref = db.instance_get(self.context, instance_id) s_ref = self._create_compute_service(host='somewhere') @@ -803,7 +960,7 @@ class SimpleDriverTestCase(test.TestCase): def test_live_migration_dest_check_service_works_correctly(self): """Confirms method finishes with no error.""" - instance_id = self._create_instance() + instance_id = _create_instance()['id'] i_ref = db.instance_get(self.context, instance_id) s_ref = self._create_compute_service(host='somewhere', memory_mb_used=5) @@ -821,7 +978,7 @@ class SimpleDriverTestCase(test.TestCase): dest = 'dummydest' # mocks for live_migration_common_check() - instance_id = self._create_instance() + instance_id = _create_instance()['id'] i_ref = db.instance_get(self.context, instance_id) t1 = utils.utcnow() - datetime.timedelta(10) s_ref = self._create_compute_service(created_at=t1, updated_at=t1, @@ -855,7 +1012,7 @@ class SimpleDriverTestCase(test.TestCase): def test_live_migration_common_check_service_different_hypervisor(self): """Original host and dest host has different hypervisor type.""" dest = 'dummydest' - instance_id = self._create_instance() + instance_id = _create_instance(host='dummy')['id'] i_ref = db.instance_get(self.context, instance_id) # compute service for destination @@ -880,7 +1037,7 @@ class SimpleDriverTestCase(test.TestCase): def test_live_migration_common_check_service_different_version(self): """Original host and dest host has different hypervisor version.""" dest = 'dummydest' - instance_id = self._create_instance() + instance_id = _create_instance(host='dummy')['id'] i_ref = db.instance_get(self.context, instance_id) # compute service for destination @@ -904,10 +1061,10 @@ class SimpleDriverTestCase(test.TestCase): db.service_destroy(self.context, s_ref2['id']) def test_live_migration_common_check_checking_cpuinfo_fail(self): - """Raise excetion when original host doen't have compatible cpu.""" + """Raise exception when original host doesn't have compatible cpu.""" dest = 'dummydest' - instance_id = self._create_instance() + instance_id = _create_instance(host='dummy')['id'] i_ref = db.instance_get(self.context, instance_id) # compute service for destination @@ -927,7 +1084,7 @@ class SimpleDriverTestCase(test.TestCase): self.mox.ReplayAll() try: - self.scheduler.driver._live_migration_common_check(self.context, + driver._live_migration_common_check(self.context, i_ref, dest, False) @@ -1021,7 +1178,6 @@ class FakeResource(object): class ZoneRedirectTest(test.TestCase): def setUp(self): super(ZoneRedirectTest, self).setUp() - self.stubs = stubout.StubOutForTesting() self.stubs.Set(db, 'zone_get_all', zone_get_all) self.stubs.Set(db, 'instance_get_by_uuid', @@ -1029,7 +1185,6 @@ class ZoneRedirectTest(test.TestCase): self.flags(enable_zone_routing=True) def tearDown(self): - self.stubs.UnsetAll() super(ZoneRedirectTest, self).tearDown() def test_trap_found_locally(self): @@ -1257,12 +1412,10 @@ class FakeNovaClientZones(object): class CallZoneMethodTest(test.TestCase): def setUp(self): super(CallZoneMethodTest, self).setUp() - self.stubs = stubout.StubOutForTesting() self.stubs.Set(db, 'zone_get_all', zone_get_all) self.stubs.Set(novaclient, 'Client', FakeNovaClientZones) def tearDown(self): - self.stubs.UnsetAll() super(CallZoneMethodTest, self).tearDown() def test_call_zone_method(self): diff --git a/nova/tests/scheduler/test_vsa_scheduler.py b/nova/tests/scheduler/test_vsa_scheduler.py index 37964f00d..802946e1b 100644 --- a/nova/tests/scheduler/test_vsa_scheduler.py +++ b/nova/tests/scheduler/test_vsa_scheduler.py @@ -22,6 +22,7 @@ from nova import db from nova import exception from nova import flags from nova import log as logging +from nova import rpc from nova import test from nova import utils from nova.volume import volume_types @@ -37,6 +38,10 @@ scheduled_volume = {} global_volume = {} +def fake_rpc_cast(*args, **kwargs): + pass + + class FakeVsaLeastUsedScheduler( vsa_sched.VsaSchedulerLeastUsedHost): # No need to stub anything at the moment @@ -170,12 +175,10 @@ class VsaSchedulerTestCase(test.TestCase): LOG.debug(_("Test: provision vol %(name)s on host %(host)s"), locals()) LOG.debug(_("\t vol=%(vol)s"), locals()) - pass def _fake_vsa_update(self, context, vsa_id, values): LOG.debug(_("Test: VSA update request: vsa_id=%(vsa_id)s "\ "values=%(values)s"), locals()) - pass def _fake_volume_create(self, context, options): LOG.debug(_("Test: Volume create: %s"), options) @@ -196,7 +199,6 @@ class VsaSchedulerTestCase(test.TestCase): "values=%(values)s"), locals()) global scheduled_volume scheduled_volume = {'id': volume_id, 'host': values['host']} - pass def _fake_service_get_by_args(self, context, host, binary): return "service" @@ -209,7 +211,6 @@ class VsaSchedulerTestCase(test.TestCase): def setUp(self, sched_class=None): super(VsaSchedulerTestCase, self).setUp() - self.stubs = stubout.StubOutForTesting() self.context = context.get_admin_context() if sched_class is None: @@ -220,6 +221,7 @@ class VsaSchedulerTestCase(test.TestCase): self.host_num = 10 self.drive_type_num = 5 + self.stubs.Set(rpc, 'cast', fake_rpc_cast) self.stubs.Set(self.sched, '_get_service_states', self._fake_get_service_states) self.stubs.Set(self.sched, @@ -234,8 +236,6 @@ class VsaSchedulerTestCase(test.TestCase): def tearDown(self): for name in self.created_types_lst: volume_types.purge(self.context, name) - - self.stubs.UnsetAll() super(VsaSchedulerTestCase, self).tearDown() def test_vsa_sched_create_volumes_simple(self): @@ -333,6 +333,8 @@ class VsaSchedulerTestCase(test.TestCase): self.stubs.Set(self.sched, '_get_service_states', self._fake_get_service_states) self.stubs.Set(nova.db, 'volume_create', self._fake_volume_create) + self.stubs.Set(nova.db, 'volume_update', self._fake_volume_update) + self.stubs.Set(rpc, 'cast', fake_rpc_cast) self.sched.schedule_create_volumes(self.context, request_spec, @@ -467,10 +469,9 @@ class VsaSchedulerTestCase(test.TestCase): self.stubs.Set(self.sched, 'service_is_up', self._fake_service_is_up_True) - host = self.sched.schedule_create_volume(self.context, - 123, availability_zone=None) + self.sched.schedule_create_volume(self.context, + 123, availability_zone=None) - self.assertEqual(host, 'host_3') self.assertEqual(scheduled_volume['id'], 123) self.assertEqual(scheduled_volume['host'], 'host_3') @@ -514,10 +515,9 @@ class VsaSchedulerTestCase(test.TestCase): global_volume['volume_type_id'] = volume_type['id'] global_volume['size'] = 0 - host = self.sched.schedule_create_volume(self.context, - 123, availability_zone=None) + self.sched.schedule_create_volume(self.context, + 123, availability_zone=None) - self.assertEqual(host, 'host_2') self.assertEqual(scheduled_volume['id'], 123) self.assertEqual(scheduled_volume['host'], 'host_2') @@ -529,7 +529,6 @@ class VsaSchedulerTestCaseMostAvail(VsaSchedulerTestCase): FakeVsaMostAvailCapacityScheduler()) def tearDown(self): - self.stubs.UnsetAll() super(VsaSchedulerTestCaseMostAvail, self).tearDown() def test_vsa_sched_create_single_volume(self): @@ -558,10 +557,9 @@ class VsaSchedulerTestCaseMostAvail(VsaSchedulerTestCase): global_volume['volume_type_id'] = volume_type['id'] global_volume['size'] = 0 - host = self.sched.schedule_create_volume(self.context, - 123, availability_zone=None) + self.sched.schedule_create_volume(self.context, + 123, availability_zone=None) - self.assertEqual(host, 'host_9') self.assertEqual(scheduled_volume['id'], 123) self.assertEqual(scheduled_volume['host'], 'host_9') diff --git a/nova/tests/test_compute.py b/nova/tests/test_compute.py index 86ffc18a6..4da551c93 100644 --- a/nova/tests/test_compute.py +++ b/nova/tests/test_compute.py @@ -28,6 +28,7 @@ from nova import db from nova import exception from nova import flags from nova import log as logging +from nova.scheduler import driver as scheduler_driver from nova import rpc from nova import test from nova import utils @@ -56,6 +57,38 @@ class FakeTime(object): self.counter += t +orig_rpc_call = rpc.call +orig_rpc_cast = rpc.cast + + +def rpc_call_wrapper(context, topic, msg, do_cast=True): + """Stub out the scheduler creating the instance entry""" + if topic == FLAGS.scheduler_topic and \ + msg['method'] == 'run_instance': + request_spec = msg['args']['request_spec'] + scheduler = scheduler_driver.Scheduler + num_instances = request_spec.get('num_instances', 1) + instances = [] + for x in xrange(num_instances): + instance = scheduler().create_instance_db_entry( + context, request_spec) + encoded = scheduler_driver.encode_instance(instance) + instances.append(encoded) + return instances + else: + if do_cast: + orig_rpc_cast(context, topic, msg) + else: + return orig_rpc_call(context, topic, msg) + + +def rpc_cast_wrapper(context, topic, msg): + """Stub out the scheduler creating the instance entry in + the reservation_id case. + """ + rpc_call_wrapper(context, topic, msg, do_cast=True) + + def nop_report_driver_status(self): pass @@ -80,6 +113,8 @@ class ComputeTestCase(test.TestCase): 'properties': {'kernel_id': 1, 'ramdisk_id': 1}} self.stubs.Set(fake_image._FakeImageService, 'show', fake_show) + self.stubs.Set(rpc, 'call', rpc_call_wrapper) + self.stubs.Set(rpc, 'cast', rpc_cast_wrapper) def _create_instance(self, params=None): """Create a test instance""" @@ -142,7 +177,7 @@ class ComputeTestCase(test.TestCase): """Verify that an instance cannot be created without a display_name.""" cases = [dict(), dict(display_name=None)] for instance in cases: - ref = self.compute_api.create(self.context, + (ref, resv_id) = self.compute_api.create(self.context, instance_types.get_default_instance_type(), None, **instance) try: self.assertNotEqual(ref[0]['display_name'], None) @@ -152,7 +187,7 @@ class ComputeTestCase(test.TestCase): def test_create_instance_associates_security_groups(self): """Make sure create associates security groups""" group = self._create_group() - ref = self.compute_api.create( + (ref, resv_id) = self.compute_api.create( self.context, instance_type=instance_types.get_default_instance_type(), image_href=None, @@ -212,7 +247,7 @@ class ComputeTestCase(test.TestCase): ('<}\x1fh\x10e\x08l\x02l\x05o\x12!{>', 'hello'), ('hello_server', 'hello-server')] for display_name, hostname in cases: - ref = self.compute_api.create(self.context, + (ref, resv_id) = self.compute_api.create(self.context, instance_types.get_default_instance_type(), None, display_name=display_name) try: @@ -224,7 +259,7 @@ class ComputeTestCase(test.TestCase): """Make sure destroying disassociates security groups""" group = self._create_group() - ref = self.compute_api.create( + (ref, resv_id) = self.compute_api.create( self.context, instance_type=instance_types.get_default_instance_type(), image_href=None, @@ -240,7 +275,7 @@ class ComputeTestCase(test.TestCase): """Make sure destroying security groups disassociates instances""" group = self._create_group() - ref = self.compute_api.create( + (ref, resv_id) = self.compute_api.create( self.context, instance_type=instance_types.get_default_instance_type(), image_href=None, @@ -1398,6 +1433,84 @@ class ComputeTestCase(test.TestCase): 'swap'), swap_size) + def test_reservation_id_one_instance(self): + """Verify building an instance has a reservation_id that + matches return value from create""" + (refs, resv_id) = self.compute_api.create(self.context, + instance_types.get_default_instance_type(), None) + try: + self.assertEqual(len(refs), 1) + self.assertEqual(refs[0]['reservation_id'], resv_id) + finally: + db.instance_destroy(self.context, refs[0]['id']) + + def test_reservation_ids_two_instances(self): + """Verify building 2 instances at once results in a + reservation_id being returned equal to reservation id set + in both instances + """ + (refs, resv_id) = self.compute_api.create(self.context, + instance_types.get_default_instance_type(), None, + min_count=2, max_count=2) + try: + self.assertEqual(len(refs), 2) + self.assertNotEqual(resv_id, None) + finally: + for instance in refs: + self.assertEqual(instance['reservation_id'], resv_id) + db.instance_destroy(self.context, instance['id']) + + def test_reservation_ids_two_instances_no_wait(self): + """Verify building 2 instances at once without waiting for + instance IDs results in a reservation_id being returned equal + to reservation id set in both instances + """ + (refs, resv_id) = self.compute_api.create(self.context, + instance_types.get_default_instance_type(), None, + min_count=2, max_count=2, wait_for_instances=False) + try: + self.assertEqual(refs, None) + self.assertNotEqual(resv_id, None) + finally: + instances = self.compute_api.get_all(self.context, + search_opts={'reservation_id': resv_id}) + self.assertEqual(len(instances), 2) + for instance in instances: + self.assertEqual(instance['reservation_id'], resv_id) + db.instance_destroy(self.context, instance['id']) + + def test_create_with_specified_reservation_id(self): + """Verify building instances with a specified + reservation_id results in the correct reservation_id + being set + """ + + # We need admin context to be able to specify our own + # reservation_ids. + context = self.context.elevated() + # 1 instance + (refs, resv_id) = self.compute_api.create(context, + instance_types.get_default_instance_type(), None, + min_count=1, max_count=1, reservation_id='meow') + try: + self.assertEqual(len(refs), 1) + self.assertEqual(resv_id, 'meow') + finally: + self.assertEqual(refs[0]['reservation_id'], resv_id) + db.instance_destroy(self.context, refs[0]['id']) + + # 2 instances + (refs, resv_id) = self.compute_api.create(context, + instance_types.get_default_instance_type(), None, + min_count=2, max_count=2, reservation_id='woof') + try: + self.assertEqual(len(refs), 2) + self.assertEqual(resv_id, 'woof') + finally: + for instance in refs: + self.assertEqual(instance['reservation_id'], resv_id) + db.instance_destroy(self.context, instance['id']) + class ComputeTestMinRamMinDisk(test.TestCase): def setUp(self): @@ -1405,6 +1518,8 @@ class ComputeTestMinRamMinDisk(test.TestCase): self.compute = utils.import_object(FLAGS.compute_manager) self.compute_api = compute.API() self.context = context.RequestContext('fake', 'fake') + self.stubs.Set(rpc, 'call', rpc_call_wrapper) + self.stubs.Set(rpc, 'cast', rpc_cast_wrapper) self.fake_image = { 'id': 1, 'properties': {'kernel_id': 1, 'ramdisk_id': 1}} @@ -1425,10 +1540,9 @@ class ComputeTestMinRamMinDisk(test.TestCase): # Now increase the inst_type memory and make sure all is fine. inst_type['memory_mb'] = 2 - ref = self.compute_api.create(self.context, inst_type, None) - self.assertTrue(ref) - - db.instance_destroy(self.context, ref[0]['id']) + (refs, resv_id) = self.compute_api.create(self.context, + inst_type, None) + db.instance_destroy(self.context, refs[0]['id']) def test_create_with_too_little_disk(self): """Test an instance type with too little disk space""" @@ -1447,10 +1561,9 @@ class ComputeTestMinRamMinDisk(test.TestCase): # Now increase the inst_type disk space and make sure all is fine. inst_type['local_gb'] = 2 - ref = self.compute_api.create(self.context, inst_type, None) - self.assertTrue(ref) - - db.instance_destroy(self.context, ref[0]['id']) + (refs, resv_id) = self.compute_api.create(self.context, + inst_type, None) + db.instance_destroy(self.context, refs[0]['id']) def test_create_just_enough_ram_and_disk(self): """Test an instance type with just enough ram and disk space""" @@ -1466,10 +1579,9 @@ class ComputeTestMinRamMinDisk(test.TestCase): return img self.stubs.Set(fake_image._FakeImageService, 'show', fake_show) - ref = self.compute_api.create(self.context, inst_type, None) - self.assertTrue(ref) - - db.instance_destroy(self.context, ref[0]['id']) + (refs, resv_id) = self.compute_api.create(self.context, + inst_type, None) + db.instance_destroy(self.context, refs[0]['id']) def test_create_with_no_ram_and_disk_reqs(self): """Test an instance type with no min_ram or min_disk""" @@ -1482,7 +1594,6 @@ class ComputeTestMinRamMinDisk(test.TestCase): return copy(self.fake_image) self.stubs.Set(fake_image._FakeImageService, 'show', fake_show) - ref = self.compute_api.create(self.context, inst_type, None) - self.assertTrue(ref) - - db.instance_destroy(self.context, ref[0]['id']) + (refs, resv_id) = self.compute_api.create(self.context, + inst_type, None) + db.instance_destroy(self.context, refs[0]['id']) diff --git a/nova/tests/test_quota.py b/nova/tests/test_quota.py index f4b481ebe..35d48dd62 100644 --- a/nova/tests/test_quota.py +++ b/nova/tests/test_quota.py @@ -21,9 +21,11 @@ from nova import context from nova import db from nova import flags from nova import quota +from nova import rpc from nova import test from nova import volume from nova.compute import instance_types +from nova.scheduler import driver as scheduler_driver FLAGS = flags.FLAGS @@ -51,6 +53,21 @@ class QuotaTestCase(test.TestCase): self.context = context.RequestContext(self.user_id, self.project_id, True) + orig_rpc_call = rpc.call + + def rpc_call_wrapper(context, topic, msg): + """Stub out the scheduler creating the instance entry""" + if topic == FLAGS.scheduler_topic and \ + msg['method'] == 'run_instance': + scheduler = scheduler_driver.Scheduler + instance = scheduler().create_instance_db_entry( + context, + msg['args']['request_spec']) + return [scheduler_driver.encode_instance(instance)] + else: + return orig_rpc_call(context, topic, msg) + + self.stubs.Set(rpc, 'call', rpc_call_wrapper) def _create_instance(self, cores=2): """Create a test instance""" |