def resize_vm(uid, flavor_id, context): """ Resizes a VM up or down Update: libvirt now supports resize see: http://wiki.openstack.org/HypervisorSupportMatrix uid -- id of the instance flavor_id -- image reference. context -- the os context """ instance = get_vm(uid, context) kwargs = {} try: flavor = instance_types.get_instance_type_by_flavor_id(flavor_id) COMPUTE_API.resize(context, instance, flavor_id=flavor['flavorid'], **kwargs) ready = False i = 0 while not ready or i < 15: i += 1 state = get_vm(uid, context)['vm_state'] if state == 'resized': ready = True import time time.sleep(1) instance = get_vm(uid, context) COMPUTE_API.confirm_resize(context, instance) except Exception as e: raise AttributeError(e.message)
def resize_vm(uid, flavor_id, context): """ Resizes a VM up or down Update: libvirt now supports resize see: http://wiki.openstack.org/HypervisorSupportMatrix uid -- id of the instance flavor_id -- image reference. context -- the os context """ instance = get_vm(uid, context) kwargs = {} try: flavor = instance_types.get_instance_type_by_flavor_id(flavor_id) COMPUTE_API.resize(context, instance, flavor_id=flavor['flavorid'], **kwargs) ready = False i = 0 while not ready or i < 15: i += 1 state = get_vm(uid, context)['vm_state'] if state == 'resized': ready = True import time time.sleep(1) instance = get_vm(uid, context) COMPUTE_API.confirm_resize(context, instance) except Exception as e: raise AttributeError(e.message)
def resize_vm(uid, flavor_id, context): """ Resizes a VM up or down Update: libvirt now supports resize see: http://wiki.openstack.org/HypervisorSupportMatrix uid -- id of the instance flavor_id -- image reference. context -- the os context """ instance = get_vm(uid, context) kwargs = {} try: flavor = instance_types.get_instance_type_by_flavor_id(flavor_id) COMPUTE_API.resize(context, instance, flavor_id=flavor['flavorid'], **kwargs) ready = False i = 0 while not ready or i < 15: i += 1 state = get_vm(uid, context)['vm_state'] if state == 'resized': ready = True import time time.sleep(1) instance = get_vm(uid, context) COMPUTE_API.confirm_resize(context, instance) except exception.FlavorNotFound: raise AttributeError('Unable to locate requested flavor.') except exception.InstanceInvalidState as error: raise AttributeError('VM is in an invalid state: ' + str(error))
def resize_vm(uid, flavor_id, context): """ Resizes a VM up or down Update: libvirt now supports resize see: http://wiki.openstack.org/HypervisorSupportMatrix uid -- id of the instance flavor_id -- image reference. context -- the os context """ instance = get_vm(uid, context) kwargs = {} try: flavor = instance_types.get_instance_type_by_flavor_id(flavor_id) COMPUTE_API.resize(context, instance, flavor_id=flavor['flavorid'], **kwargs) ready = False i = 0 while not ready or i < 15: i += 1 state = get_vm(uid, context)['vm_state'] if state == 'resized': ready = True import time time.sleep(1) instance = get_vm(uid, context) COMPUTE_API.confirm_resize(context, instance) except exception.FlavorNotFound: raise AttributeError('Unable to locate requested flavor.') except exception.InstanceInvalidState as error: raise AttributeError('VM is in an invalid state: ' + str(error))
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) resv_id = None return ( [ { "id": 1, "display_name": "test_server", "uuid": FAKE_UUID, "instance_type": dict(inst_type), "access_ip_v4": "1.2.3.4", "access_ip_v6": "fead::1234", "image_ref": IMAGE_UUID, "user_id": "fake", "project_id": "fake", "created_at": datetime.datetime(2010, 10, 10, 12, 0, 0), "updated_at": datetime.datetime(2010, 11, 11, 11, 0, 0), "progress": 0, "fixed_ips": [], } ], resv_id, )
def stub_instance(id, metadata=None, image_ref="10", flavor_id="1", name=None, vm_state=None, task_state=None, uuid=None): if metadata is not None: metadata_items = [{'key':k, 'value':v} for k, v in metadata.items()] else: metadata_items = [{'key':'seq', 'value':id}] if uuid is None: uuid = FAKE_UUID inst_type = instance_types.get_instance_type_by_flavor_id(int(flavor_id)) instance = { "id": int(id), "name": str(id), "created_at": datetime.datetime(2010, 10, 10, 12, 0, 0), "updated_at": datetime.datetime(2010, 11, 11, 11, 0, 0), "admin_pass": "", "user_id": "fake", "project_id": "fake", "image_ref": image_ref, "kernel_id": "", "ramdisk_id": "", "launch_index": 0, "key_name": "", "key_data": "", "vm_state": vm_state or vm_states.ACTIVE, "task_state": task_state, "memory_mb": 0, "vcpus": 0, "local_gb": 0, "hostname": "", "host": "", "instance_type": dict(inst_type), "user_data": "", "reservation_id": "", "mac_address": "", "scheduled_at": utils.utcnow(), "launched_at": utils.utcnow(), "terminated_at": utils.utcnow(), "availability_zone": "", "display_name": name or "server%s" % id, "display_description": "", "locked": False, "metadata": metadata_items, "access_ip_v4": "", "access_ip_v6": "", "uuid": uuid, "virtual_interfaces": [], "progress": 0, } instance["fixed_ips"] = [{"address": '192.168.0.1', "network": {'label': 'public', 'cidr_v6': None}, "virtual_interface": {'address': 'aa:aa:aa:aa:aa:aa'}, "floating_ips": []}] return instance
def _delete(self, req, id): context = req.environ['nova.context'] authorize(context) try: flavor = instance_types.get_instance_type_by_flavor_id(id) except exception.NotFound, e: raise webob.exc.HTTPNotFound(explanation=str(e))
def show(self, req, id): """Return data about the given flavor id.""" try: flavor = instance_types.get_instance_type_by_flavor_id(id) except exception.NotFound: raise webob.exc.HTTPNotFound() return self._view_builder.show(req, flavor)
def show(self, req, id): """Return data about the given flavor id.""" try: flavor = instance_types.get_instance_type_by_flavor_id(id) except exception.NotFound: raise webob.exc.HTTPNotFound() return self._view_builder.show(req, flavor)
def _delete(self, req, id): context = req.environ['nova.context'] authorize(context) try: flavor = instance_types.get_instance_type_by_flavor_id(id) except exception.NotFound, e: raise webob.exc.HTTPNotFound(explanation=str(e))
def stub_instance(id, metadata=None, image_ref="10", flavor_id="1", name=None, vm_state=None, task_state=None): if metadata is not None: metadata_items = [{'key': k, 'value': v} for k, v in metadata.items()] else: metadata_items = [{'key': 'seq', 'value': id}] inst_type = instance_types.get_instance_type_by_flavor_id(int(flavor_id)) instance = { "id": int(id), "created_at": datetime.datetime(2010, 10, 10, 12, 0, 0), "updated_at": datetime.datetime(2010, 11, 11, 11, 0, 0), "admin_pass": "", "user_id": "fake", "project_id": "fake", "image_ref": image_ref, "kernel_id": "", "ramdisk_id": "", "launch_index": 0, "key_name": "", "key_data": "", "vm_state": vm_state or vm_states.ACTIVE, "task_state": task_state, "memory_mb": 0, "vcpus": 0, "local_gb": 0, "hostname": "", "host": "", "instance_type": dict(inst_type), "user_data": "", "reservation_id": "", "mac_address": "", "scheduled_at": utils.utcnow(), "launched_at": utils.utcnow(), "terminated_at": utils.utcnow(), "availability_zone": "", "display_name": name or "server%s" % id, "display_description": "", "locked": False, "metadata": metadata_items, "access_ip_v4": "", "access_ip_v6": "", "uuid": "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa", "virtual_interfaces": [], } instance["fixed_ips"] = { "address": '192.168.0.1', "floating_ips": [], } return instance
def _delete(self, req, id): context = req.environ['nova.context'] authorize(context) try: flavor = instance_types.get_instance_type_by_flavor_id( id, read_deleted="no") except exception.NotFound, e: raise webob.exc.HTTPNotFound(explanation=e.format_message())
def _delete(self, req, id): context = req.environ['nova.context'] authorize(context) try: flavor = instance_types.get_instance_type_by_flavor_id( id, read_deleted="no") except exception.NotFound, e: raise webob.exc.HTTPNotFound(explanation=e.format_message())
def _delete(self, req, id): context = req.environ['nova.context'] if not context.is_admin: return webob.Response(status_int=403) try: flavor = instance_types.get_instance_type_by_flavor_id(id) except exception.NotFound, e: raise webob.exc.HTTPNotFound(explanation=str(e))
def _delete(self, req, id): context = req.environ['nova.context'] if not context.is_admin: return webob.Response(status_int=403) try: flavor = instance_types.get_instance_type_by_flavor_id(id) except exception.NotFound, e: raise webob.exc.HTTPNotFound(explanation=str(e))
def show(self, req, id): """Return data about the given flavor id.""" try: context = req.environ['nova.context'] flavor = instance_types.get_instance_type_by_flavor_id( id, ctxt=context) req.cache_db_flavor(flavor) except exception.NotFound: raise webob.exc.HTTPNotFound() return self._view_builder.show(req, flavor)
def show(self, req, id): """Return data about the given flavor id.""" try: ctxt = req.environ['nova.context'] flavor = instance_types.get_instance_type_by_flavor_id(id) except exception.NotFound: raise webob.exc.HTTPNotFound() builder = self._get_view_builder(req) values = builder.build(flavor, is_detail=True) return dict(flavor=values)
def stub_instance(id, power_state=0, metadata=None, image_ref="10", flavor_id="1", name=None): if metadata is not None: metadata_items = [{'key':k, 'value':v} for k, v in metadata.items()] else: metadata_items = [{'key':'seq', 'value':id}] inst_type = instance_types.get_instance_type_by_flavor_id(int(flavor_id)) instance = { "id": int(id), "created_at": datetime.datetime(2010, 10, 10, 12, 0, 0), "updated_at": datetime.datetime(2010, 11, 11, 11, 0, 0), "admin_pass": "", "user_id": "fake", "project_id": "fake", "image_ref": image_ref, "kernel_id": "", "ramdisk_id": "", "launch_index": 0, "key_name": "", "key_data": "", "state": power_state, "state_description": "", "memory_mb": 0, "vcpus": 0, "local_gb": 0, "hostname": "", "host": "", "instance_type": dict(inst_type), "user_data": "", "reservation_id": "", "mac_address": "", "scheduled_at": utils.utcnow(), "launched_at": utils.utcnow(), "terminated_at": utils.utcnow(), "availability_zone": "", "display_name": name or "server%s" % id, "display_description": "", "locked": False, "metadata": metadata_items, "access_ip_v4": "", "access_ip_v6": "", "uuid": "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa", "virtual_interfaces": [], } instance["fixed_ips"] = { "address": '192.168.0.1', "floating_ips": [], } return instance
def test_read_deleted_false_converting_flavorid(self): """ Ensure deleted instance types are not returned when not needed (for example when creating a server and attempting to translate from flavorid to instance_type_id. """ instance_types.create("instance_type1", 256, 1, 120, 100, "test1") instance_types.destroy("instance_type1") instance_types.create("instance_type1_redo", 256, 1, 120, 100, "test1") instance_type = instance_types.get_instance_type_by_flavor_id("test1", read_deleted="no") self.assertEqual("instance_type1_redo", instance_type["name"])
def test_read_deleted_false_converting_flavorid(self): """ Ensure deleted instance types are not returned when not needed (for example when creating a server and attempting to translate from flavorid to instance_type_id. """ instance_types.create("instance_type1", 256, 1, 120, 100, "test1") instance_types.destroy("instance_type1") instance_types.create("instance_type1_redo", 256, 1, 120, 100, "test1") instance_type = instance_types.get_instance_type_by_flavor_id( "test1", read_deleted="no") self.assertEqual("instance_type1_redo", instance_type["name"])
def delete(self, req, id): qs = req.environ.get('QUERY_STRING', '') env = urlparse.parse_qs(qs) purge = env.get('purge', False) flavor = instance_types.get_instance_type_by_flavor_id(id) if purge: instance_types.purge(flavor['name']) else: instance_types.destroy(flavor['name']) return exc.HTTPAccepted()
def show(self, req, resp_obj, id): context = req.environ['nova.context'] if authorize(context): # Attach our slave template to the response object resp_obj.attach(xml=FlavorextradatumTemplate()) try: flavor_ref = instance_types.get_instance_type_by_flavor_id(id) except exception.FlavorNotFound: explanation = _("Flavor not found.") raise exception.HTTPNotFound(explanation=explanation) self._extend_flavor(resp_obj.obj['flavor'], flavor_ref)
def delete(self, req, id): qs = req.environ.get('QUERY_STRING', '') env = urlparse.parse_qs(qs) purge = env.get('purge', False) flavor = instance_types.get_instance_type_by_flavor_id(id) if purge: instance_types.purge(flavor['name']) else: instance_types.destroy(flavor['name']) return exc.HTTPAccepted()
def show(self, req, resp_obj, id): context = req.environ['nova.context'] if authorize(context): # Attach our slave template to the response object resp_obj.attach(xml=FlavorextradatumTemplate()) try: flavor_ref = instance_types.get_instance_type_by_flavor_id(id) except exception.FlavorNotFound: explanation = _("Flavor not found.") raise exception.HTTPNotFound(explanation=explanation) self._extend_flavor(resp_obj.obj['flavor'], flavor_ref)
def fake_compute_api_create(cls, context, instance_type, image_href, **kwargs): inst_type = instance_types.get_instance_type_by_flavor_id(2) return [{'id': 1, 'display_name': 'test_server', 'uuid': fake_gen_uuid(), 'instance_type': dict(inst_type), 'access_ip_v4': '1.2.3.4', 'access_ip_v6': 'fead::1234', 'image_ref': 3, 'user_id': 'fake', 'project_id': 'fake', 'created_at': datetime.datetime(2010, 10, 10, 12, 0, 0), 'updated_at': datetime.datetime(2010, 11, 11, 11, 0, 0), }]
def test_can_read_deleted_types_using_flavor_id(self): # Ensure deleted instance types can be read when querying flavor_id. inst_type_name = "test" inst_type_flavor_id = "test1" inst_type = instance_types.create(inst_type_name, 256, 1, 120, 100, inst_type_flavor_id) self.assertEqual(inst_type_name, inst_type["name"]) # NOTE(jk0): The deleted flavor will show up here because the context # in get_instance_type_by_flavor_id() is set to use read_deleted by # default. instance_types.destroy(inst_type["name"]) deleted_inst_type = instance_types.get_instance_type_by_flavor_id(inst_type_flavor_id) self.assertEqual(inst_type_name, deleted_inst_type["name"])
def test_can_read_deleted_types_using_flavor_id(self): """Ensure deleted instance types can be read when querying flavor_id""" inst_type_name = "test" inst_type_flavor_id = "test1" inst_type = instance_types.create(inst_type_name, 256, 1, 120, 100, inst_type_flavor_id) self.assertEqual(inst_type_name, inst_type["name"]) # NOTE(jk0): The deleted flavor will show up here because the context # in get_instance_type_by_flavor_id() is set to use read_deleted. instance_types.destroy(inst_type["name"]) deleted_inst_type = instance_types.get_instance_type_by_flavor_id( inst_type_flavor_id) self.assertEqual(inst_type_name, deleted_inst_type["name"])
def fake_compute_api_create(cls, context, instance_type, image_href, **kwargs): inst_type = instance_types.get_instance_type_by_flavor_id(2) return [{ 'id': 1, 'display_name': 'test_server', 'uuid': fake_gen_uuid(), 'instance_type': dict(inst_type), 'access_ip_v4': '1.2.3.4', 'access_ip_v6': 'fead::1234', 'image_ref': 3, 'user_id': 'fake', 'project_id': 'fake', 'created_at': datetime.datetime(2010, 10, 10, 12, 0, 0), 'updated_at': datetime.datetime(2010, 11, 11, 11, 0, 0), }]
def resize(self, context, instance, flavor_id=None, *args, **kwargs): """Resize (ie, migrate) a running instance. If flavor_id is None, the process is considered a migration, keeping the original flavor_id. If flavor_id is not None, the instance should be migrated to a new host and resized to the new flavor_id. """ super(ComputeCellsAPI, self).resize(context, instance, flavor_id=flavor_id, *args, **kwargs) # NOTE(johannes): If we get to this point, then we know the # specified flavor_id is valid and exists. We'll need to load # it again, but that should be safe. old_instance_type = instance_types.extract_instance_type(instance) if not flavor_id: new_instance_type = old_instance_type else: new_instance_type = instance_types.get_instance_type_by_flavor_id( flavor_id, read_deleted="no") # NOTE(johannes): Later, when the resize is confirmed or reverted, # the superclass implementations of those methods will need access # to a local migration record for quota reasons. We don't need # source and/or destination information, just the old and new # instance_types. Status is set to 'finished' since nothing else # will update the status along the way. self.db.migration_create( context.elevated(), { 'instance_uuid': instance['uuid'], 'old_instance_type_id': old_instance_type['id'], 'new_instance_type_id': new_instance_type['id'], 'status': 'finished' }) # FIXME(comstud): pass new instance_type object down to a method # that'll unfold it self._cast_to_cells(context, instance, 'resize', flavor_id=flavor_id, *args, **kwargs)
def index(self, req, flavor_id): context = req.environ['nova.context'] authorize(context) try: flavor = instance_types.get_instance_type_by_flavor_id(flavor_id) except exception.FlavorNotFound: explanation = _("Flavor not found.") raise webob.exc.HTTPNotFound(explanation=explanation) # public flavor to all projects if flavor['is_public']: explanation = _("Access list not available for public flavors.") raise webob.exc.HTTPNotFound(explanation=explanation) # private flavor to listed projects only return _marshall_flavor_access(flavor_id)
def index(self, req, flavor_id): context = req.environ['nova.context'] authorize(context) try: flavor = instance_types.get_instance_type_by_flavor_id(flavor_id) except exception.FlavorNotFound: explanation = _("Flavor not found.") raise webob.exc.HTTPNotFound(explanation=explanation) # public flavor to all projects if flavor['is_public']: explanation = _("Access list not available for public flavors.") raise webob.exc.HTTPNotFound(explanation=explanation) # private flavor to listed projects only return _marshall_flavor_access(flavor_id)
def _action_resize(self, input_dict, req, id): """ Resizes a given instance to the flavor size requested """ try: flavor_ref = input_dict["resize"]["flavorRef"] except (KeyError, TypeError): msg = _("Resize requests require 'flavorRef' attribute.") raise exc.HTTPBadRequest(explanation=msg) try: i_type = instance_types.get_instance_type_by_flavor_id(flavor_ref) except exception.FlavorNotFound: msg = _("Unable to locate requested flavor.") raise exc.HTTPBadRequest(explanation=msg) context = req.environ["nova.context"] self.compute_api.resize(context, id, i_type["id"]) return webob.Response(status_int=202)
def _action_resize(self, input_dict, req, id): """ Resizes a given instance to the flavor size requested """ try: flavor_ref = input_dict["resize"]["flavorRef"] except (KeyError, TypeError): msg = _("Resize requests require 'flavorRef' attribute.") raise exc.HTTPBadRequest(explanation=msg) try: i_type = instance_types.get_instance_type_by_flavor_id(flavor_ref) except exception.FlavorNotFound: msg = _("Unable to locate requested flavor.") raise exc.HTTPBadRequest(explanation=msg) context = req.environ["nova.context"] self.compute_api.resize(context, id, i_type["id"]) return webob.Response(status_int=202)
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) resv_id = None return ([{'id': 1, 'display_name': 'test_server', 'uuid': fake_gen_uuid(), 'instance_type': dict(inst_type), 'access_ip_v4': '1.2.3.4', 'access_ip_v6': 'fead::1234', 'image_ref': 3, 'user_id': 'fake', 'project_id': 'fake', '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_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) resv_id = None return ([{'id': 1, 'display_name': 'test_server', 'uuid': FAKE_UUID, 'instance_type': dict(inst_type), 'access_ip_v4': '1.2.3.4', 'access_ip_v6': 'fead::1234', 'image_ref': IMAGE_UUID, 'user_id': 'fake', 'project_id': 'fake', 'created_at': datetime.datetime(2010, 10, 10, 12, 0, 0), 'updated_at': datetime.datetime(2010, 11, 11, 11, 0, 0), 'progress': 0, 'fixed_ips': [] }], resv_id)
def resize(self, context, instance, *args, **kwargs): """Resize (ie, migrate) a running instance. If flavor_id is None, the process is considered a migration, keeping the original flavor_id. If flavor_id is not None, the instance should be migrated to a new host and resized to the new flavor_id. """ super(ComputeCellsAPI, self).resize(context, instance, *args, **kwargs) # NOTE(johannes): If we get to this point, then we know the # specified flavor_id is valid and exists. We'll need to load # it again, but that should be safe. old_instance_type_id = instance['instance_type_id'] old_instance_type = instance_types.get_instance_type( old_instance_type_id) flavor_id = kwargs.get('flavor_id') if not flavor_id: new_instance_type = old_instance_type else: new_instance_type = instance_types.get_instance_type_by_flavor_id( flavor_id) # NOTE(johannes): Later, when the resize is confirmed or reverted, # the superclass implementations of those methods will need access # to a local migration record for quota reasons. We don't need # source and/or destination information, just the old and new # instance_types. Status is set to 'finished' since nothing else # will update the status along the way. self.db.migration_create(context.elevated(), {'instance_uuid': instance['uuid'], 'old_instance_type_id': old_instance_type['id'], 'new_instance_type_id': new_instance_type['id'], 'status': 'finished'}) # FIXME(comstud): pass new instance_type object down to a method # that'll unfold it self._cast_to_cells(context, instance, 'resize', *args, **kwargs)
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() server_dict = body['server'] context = req.environ['nova.context'] password = self.controller._get_server_admin_password(server_dict) key_name = None key_data = None # TODO(vish): Key pair access should move into a common library # instead of being accessed directly from the db. key_pairs = db.key_pair_get_all_by_user(context.elevated(), context.user_id) if key_pairs: key_pair = key_pairs[0] key_name = key_pair['name'] key_data = key_pair['public_key'] image_href = self.controller._image_ref_from_req_data(body) try: image_service, image_id = nova.image.get_image_service(image_href) kernel_id, ramdisk_id = self._get_kernel_ramdisk_from_image( req, 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') injected_files = [] if personality: injected_files = self._get_injected_files(personality) try: flavor_id = self.controller._flavor_id_from_req_data(body) except ValueError as error: msg = _("Invalid flavorRef provided.") raise exc.HTTPBadRequest(explanation=msg) if not 'name' in server_dict: msg = _("Server name is not defined") raise exc.HTTPBadRequest(explanation=msg) zone_blob = server_dict.get('blob') 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, '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, key_data=key_data, metadata=server_dict.get('metadata', {}), injected_files=injected_files, admin_password=password, zone_blob=zone_blob, reservation_id=reservation_id, min_count=min_count, max_count=max_count)) except quota.QuotaError as error: self._handle_quota_error(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)
def stub_instance(id, user_id=None, project_id=None, host=None, vm_state=None, task_state=None, reservation_id="", uuid=FAKE_UUID, image_ref="10", flavor_id="1", name=None, key_name='', access_ipv4=None, access_ipv6=None, progress=0, auto_disk_config=False, display_name=None, include_fake_metadata=True, config_drive=None, power_state=None, nw_cache=None, metadata=None, security_groups=None, root_device_name=None, limit=None, marker=None): if user_id is None: user_id = 'fake_user' if project_id is None: project_id = 'fake_project' if metadata: metadata = [{'key':k, 'value':v} for k, v in metadata.items()] elif include_fake_metadata: metadata = [models.InstanceMetadata(key='seq', value=str(id))] else: metadata = [] inst_type = instance_types.get_instance_type_by_flavor_id(int(flavor_id)) if host is not None: host = str(host) if key_name: key_data = 'FAKE' else: key_data = '' if security_groups is None: security_groups = [{"id": 1, "name": "test"}] # ReservationID isn't sent back, hack it in there. server_name = name or "server%s" % id if reservation_id != "": server_name = "reservation_%s" % (reservation_id, ) info_cache = create_info_cache(nw_cache) instance = { "id": int(id), "created_at": datetime.datetime(2010, 10, 10, 12, 0, 0), "updated_at": datetime.datetime(2010, 11, 11, 11, 0, 0), "user_id": user_id, "project_id": project_id, "image_ref": image_ref, "kernel_id": "", "ramdisk_id": "", "launch_index": 0, "key_name": key_name, "key_data": key_data, "config_drive": config_drive, "vm_state": vm_state or vm_states.BUILDING, "task_state": task_state, "power_state": power_state, "memory_mb": 0, "vcpus": 0, "root_gb": 0, "ephemeral_gb": 0, "hostname": display_name or server_name, "host": host, "instance_type_id": 1, "instance_type": dict(inst_type), "user_data": "", "reservation_id": reservation_id, "mac_address": "", "scheduled_at": timeutils.utcnow(), "launched_at": timeutils.utcnow(), "terminated_at": timeutils.utcnow(), "availability_zone": "", "display_name": display_name or server_name, "display_description": "", "locked": False, "metadata": metadata, "access_ip_v4": access_ipv4, "access_ip_v6": access_ipv6, "uuid": uuid, "progress": progress, "auto_disk_config": auto_disk_config, "name": "instance-%s" % id, "shutdown_terminate": True, "disable_terminate": False, "security_groups": security_groups, "root_device_name": root_device_name} instance.update(info_cache) return instance
def stub_instance(id, user_id=None, project_id=None, host=None, vm_state=None, task_state=None, reservation_id="", uuid=FAKE_UUID, image_ref="10", flavor_id="1", name=None, key_name='', access_ipv4=None, access_ipv6=None, progress=0, auto_disk_config=False, display_name=None, include_fake_metadata=True, config_drive=None, power_state=None, nw_cache=None, metadata=None, security_groups=None, root_device_name=None, limit=None, marker=None): if user_id is None: user_id = 'fake_user' if project_id is None: project_id = 'fake_project' if metadata: metadata = [{'key': k, 'value': v} for k, v in metadata.items()] elif include_fake_metadata: metadata = [models.InstanceMetadata(key='seq', value=str(id))] else: metadata = [] inst_type = instance_types.get_instance_type_by_flavor_id(int(flavor_id)) if host is not None: host = str(host) if key_name: key_data = 'FAKE' else: key_data = '' if security_groups is None: security_groups = [{"id": 1, "name": "test"}] # ReservationID isn't sent back, hack it in there. server_name = name or "server%s" % id if reservation_id != "": server_name = "reservation_%s" % (reservation_id, ) info_cache = create_info_cache(nw_cache) instance = { "id": int(id), "created_at": datetime.datetime(2010, 10, 10, 12, 0, 0), "updated_at": datetime.datetime(2010, 11, 11, 11, 0, 0), "user_id": user_id, "project_id": project_id, "image_ref": image_ref, "kernel_id": "", "ramdisk_id": "", "launch_index": 0, "key_name": key_name, "key_data": key_data, "config_drive": config_drive, "vm_state": vm_state or vm_states.BUILDING, "task_state": task_state, "power_state": power_state, "memory_mb": 0, "vcpus": 0, "root_gb": 0, "ephemeral_gb": 0, "hostname": display_name or server_name, "host": host, "instance_type_id": 1, "instance_type": dict(inst_type), "user_data": "", "reservation_id": reservation_id, "mac_address": "", "scheduled_at": timeutils.utcnow(), "launched_at": timeutils.utcnow(), "terminated_at": timeutils.utcnow(), "availability_zone": "", "display_name": display_name or server_name, "display_description": "", "locked": False, "metadata": metadata, "access_ip_v4": access_ipv4, "access_ip_v6": access_ipv6, "uuid": uuid, "progress": progress, "auto_disk_config": auto_disk_config, "name": "instance-%s" % id, "shutdown_terminate": True, "disable_terminate": False, "security_groups": security_groups, "root_device_name": root_device_name } instance.update(info_cache) return instance
def create(self, req, body): """ Creates a new server for a given user """ 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() 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 if str(image_href).startswith(req.application_url): image_href = image_href.split("/").pop() 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) (access_ip_v4,) = (server_dict.get("accessIPv4"),) if access_ip_v4 is not None: self._validate_access_ipv4(access_ip_v4) (access_ip_v6,) = (server_dict.get("accessIPv6"),) if access_ip_v6 is not None: self._validate_access_ipv6(access_ip_v6) 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 auto_disk_config = server_dict.get("auto_disk_config") scheduler_hints = server_dict.get("scheduler_hints", {}) try: inst_type = instance_types.get_instance_type_by_flavor_id(flavor_id) (instances, resv_id) = self.compute_api.create( context, inst_type, image_href, display_name=name, display_description=name, key_name=key_name, metadata=server_dict.get("metadata", {}), access_ip_v4=access_ip_v4, access_ip_v6=access_ip_v6, 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, auto_disk_config=auto_disk_config, scheduler_hints=scheduler_hints, ) except exception.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} server = self._view_builder.create(req, instances[0]) if "_is_precooked" in server["server"].keys(): del server["server"]["_is_precooked"] else: server["server"]["adminPass"] = password robj = wsgi.ResponseObject(server) return self._add_location(robj)
def create(self, req, body): """ Creates a new server for a given user """ 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() 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 if str(image_href).startswith(req.application_url): image_href = image_href.split('/').pop() 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_href, 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) 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_create=True) if '_is_precooked' in server['server']: del server['server']['_is_precooked'] else: server['server']['adminPass'] = password return server
def test_get_by_flavor_id(self): type = instance_types.get_instance_type_by_flavor_id(1) self.assertEqual(type['name'], 'm1.tiny')
def create(self, req): """ Creates a new server for a given user """ env = self._deserialize_create(req) if not env: return faults.Fault(exc.HTTPUnprocessableEntity()) context = req.environ['nova.context'] password = self._get_server_admin_password(env['server']) key_name = env['server'].get('key_name') key_data = None if key_name: try: key_pair = db.key_pair_get(context, context.user_id, key_name) key_name = key_pair['name'] key_data = key_pair['public_key'] except: msg = _("Can not load the requested key %s" % key_name) return faults.Fault(exc.HTTPBadRequest(msg)) else: # backwards compatibility key_pairs = auth_manager.AuthManager.get_key_pairs(context) if key_pairs: key_pair = key_pairs[0] key_name = key_pair['name'] key_data = key_pair['public_key'] image_id = self._image_id_from_req_data(env) kernel_id, ramdisk_id = self._get_kernel_ramdisk_from_image( req, image_id) personality = env['server'].get('personality') injected_files = [] if personality: injected_files = self._get_injected_files(personality) flavor_id = self._flavor_id_from_req_data(env) if not 'name' in env['server']: msg = _("Server name is not defined") return exc.HTTPBadRequest(msg) print "4444" name = env['server']['name'] self._validate_server_name(name) name = name.strip() try: inst_type = \ instance_types.get_instance_type_by_flavor_id(flavor_id) (inst, ) = 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, key_data=key_data, user_data=env['server'].get('user_data'), metadata=env['server'].get('metadata', {}), injected_files=injected_files, admin_password=password) except quota.QuotaError as error: self._handle_quota_error(error) inst['instance_type'] = inst_type inst['image_id'] = image_id builder = self._get_view_builder(req) server = builder.build(inst, is_detail=True) server['server']['adminPass'] = password return server
def test_will_get_instance_by_flavor_id(self): default_instance_type = instance_types.get_default_instance_type() flavorid = default_instance_type['flavorid'] fetched = instance_types.get_instance_type_by_flavor_id(flavorid) self.assertEqual(default_instance_type, fetched)
def create(self, req, body): """ Creates a new server for a given user """ 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() 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 if str(image_href).startswith(req.application_url): image_href = image_href.split('/').pop() 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) (access_ip_v4, ) = server_dict.get('accessIPv4'), if access_ip_v4 is not None: self._validate_access_ipv4(access_ip_v4) (access_ip_v6, ) = server_dict.get('accessIPv6'), if access_ip_v6 is not None: self._validate_access_ipv6(access_ip_v6) 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 auto_disk_config = server_dict.get('auto_disk_config') scheduler_hints = server_dict.get('scheduler_hints', {}) try: inst_type = \ instance_types.get_instance_type_by_flavor_id(flavor_id) (instances, resv_id) = self.compute_api.create( context, inst_type, image_href, display_name=name, display_description=name, key_name=key_name, metadata=server_dict.get('metadata', {}), access_ip_v4=access_ip_v4, access_ip_v6=access_ip_v6, 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, auto_disk_config=auto_disk_config, scheduler_hints=scheduler_hints) except exception.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} server = self._view_builder.create(req, instances[0]) if '_is_precooked' in server['server'].keys(): del server['server']['_is_precooked'] else: server['server']['adminPass'] = password robj = wsgi.ResponseObject(server) return self._add_location(robj)
def test_will_get_instance_by_flavor_id(self): default_instance_type = instance_types.get_default_instance_type() flavorid = default_instance_type['flavorid'] fetched = instance_types.get_instance_type_by_flavor_id(flavorid) self.assertEqual(default_instance_type, fetched)
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.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)
class OverrideHelper(create_instance_helper.CreateInstanceHelper): """Allows keypair name to be passed in request.""" def create_instance(self, req, body, create_method): if not body: raise faults.Fault(exc.HTTPUnprocessableEntity()) context = req.environ['nova.context'] password = self.controller._get_server_admin_password(body['server']) key_name = body['server'].get('key_name') key_data = None if key_name: try: key_pair = db.key_pair_get(context, context.user_id, key_name) key_name = key_pair['name'] key_data = key_pair['public_key'] except: msg = _("Can not load the requested key %s" % key_name) return faults.Fault(exc.HTTPBadRequest(msg)) else: key_name = None key_data = None key_pairs = db.key_pair_get_all_by_user(context, context.user_id) if key_pairs: key_pair = key_pairs[0] key_name = key_pair['name'] key_data = key_pair['public_key'] image_href = self.controller._image_ref_from_req_data(body) try: image_service, image_id = nova.image.get_image_service(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 faults.Fault(exc.HTTPBadRequest(explanation=msg)) personality = body['server'].get('personality') injected_files = [] if personality: injected_files = self._get_injected_files(personality) flavor_id = self.controller._flavor_id_from_req_data(body) if not 'name' in body['server']: msg = _("Server name is not defined") raise exc.HTTPBadRequest(explanation=msg) zone_blob = body['server'].get('blob') name = body['server']['name'] self._validate_server_name(name) name = name.strip() reservation_id = body['server'].get('reservation_id') security_groups = filter(bool, body['server'] .get('security_groups', '') .split(',')) + ['default'] for group_name in security_groups: if not db.security_group_exists(context, context.project_id, group_name): group = {'user_id': context.user_id, 'project_id': context.project_id, 'name': group_name, 'description': ''} db.security_group_create(context, group) try: inst_type = \ instance_types.get_instance_type_by_flavor_id(flavor_id) extra_values = { 'instance_type': inst_type, 'image_ref': image_href, '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, key_data=key_data, metadata=body['server'].get('metadata', {}), injected_files=injected_files, admin_password=password, zone_blob=zone_blob, user_data=body['server'].get('user_data', None), security_group=security_groups, reservation_id=reservation_id)) except quota.QuotaError as error: self._handle_quota_error(error) except exception.ImageNotFound as error: msg = _("Can not find requested image") raise faults.Fault(exc.HTTPBadRequest(explanation=msg))
def test_get_by_flavor_id(self): type = instance_types.get_instance_type_by_flavor_id(1) self.assertEqual(type['name'], 'm1.tiny')
def create(self, req): """ Creates a new server for a given user """ env = self._deserialize_create(req) if not env: return faults.Fault(exc.HTTPUnprocessableEntity()) context = req.environ['nova.context'] password = self._get_server_admin_password(env['server']) key_name = env['server'].get('key_name') key_data = None if key_name: try: key_pair = db.key_pair_get(context, context.user_id, key_name) key_name = key_pair['name'] key_data = key_pair['public_key'] except: msg = _("Can not load the requested key %s" % key_name) return faults.Fault(exc.HTTPBadRequest(msg)) else: # backwards compatibility key_pairs = auth_manager.AuthManager.get_key_pairs(context) if key_pairs: key_pair = key_pairs[0] key_name = key_pair['name'] key_data = key_pair['public_key'] image_id = self._image_id_from_req_data(env) kernel_id, ramdisk_id = self._get_kernel_ramdisk_from_image( req, image_id) personality = env['server'].get('personality') injected_files = [] if personality: injected_files = self._get_injected_files(personality) flavor_id = self._flavor_id_from_req_data(env) if not 'name' in env['server']: msg = _("Server name is not defined") return exc.HTTPBadRequest(msg) print "4444" name = env['server']['name'] self._validate_server_name(name) name = name.strip() try: inst_type = \ instance_types.get_instance_type_by_flavor_id(flavor_id) (inst,) = 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, key_data=key_data, user_data=env['server'].get('user_data'), metadata=env['server'].get('metadata', {}), injected_files=injected_files, admin_password=password) except quota.QuotaError as error: self._handle_quota_error(error) inst['instance_type'] = inst_type inst['image_id'] = image_id builder = self._get_view_builder(req) server = builder.build(inst, is_detail=True) server['server']['adminPass'] = password return server