def test_live_migration_dest_check_auto_set_host(self): instance = self._live_migration_instance() # Confirm dest is picked by scheduler if not set. self.mox.StubOutWithMock(self.driver, 'select_hosts') self.mox.StubOutWithMock(db, 'instance_type_get') instance_type = instance_types.extract_instance_type(instance) request_spec = {'instance_properties': instance, 'instance_type': instance_type, 'instance_uuids': [instance['uuid']], 'image': self.image_service.show(self.context, instance['image_ref']) } ignore_hosts = [instance['host']] filter_properties = {'ignore_hosts': ignore_hosts} db.instance_type_get(self.context, instance_type['id']).AndReturn( instance_type) self.driver.select_hosts(self.context, request_spec, filter_properties).AndReturn(['fake_host2']) self.mox.ReplayAll() result = self.driver._live_migration_dest_check(self.context, instance, None, ignore_hosts) self.assertEqual('fake_host2', result)
def test_get_instance_nw_info(self): self.mox.StubOutWithMock(db, 'fixed_ip_get_by_instance') self.mox.StubOutWithMock(db, 'virtual_interface_get_by_instance') self.mox.StubOutWithMock(db, 'instance_type_get') db.fixed_ip_get_by_instance(mox.IgnoreArg(), mox.IgnoreArg()).AndReturn(fixed_ips) db.virtual_interface_get_by_instance(mox.IgnoreArg(), mox.IgnoreArg()).AndReturn(vifs) db.instance_type_get(mox.IgnoreArg(), mox.IgnoreArg()).AndReturn(flavor) self.mox.ReplayAll() nw_info = self.network.get_instance_nw_info(None, 0, 0, None) self.assertTrue(nw_info) for i, nw in enumerate(nw_info): i8 = i + 8 check = {'bridge': 'fa%s' % i, 'cidr': '192.168.%s.0/24' % i, 'cidr_v6': '2001:db%s::/64' % i8, 'id': i, 'multi_host': False, 'injected': 'DONTCARE', 'bridge_interface': 'fake_fa%s' % i, 'vlan': None} self.assertDictMatch(nw[0], check) check = {'broadcast': '192.168.%s.255' % i, 'dhcp_server': '192.168.%s.1' % i, 'dns': 'DONTCARE', 'gateway': '192.168.%s.1' % i, 'gateway6': '2001:db%s::1' % i8, 'ip6s': 'DONTCARE', 'ips': 'DONTCARE', 'label': 'test%s' % i, 'mac': 'DE:AD:BE:EF:00:0%s' % i, 'vif_uuid': ('00000000-0000-0000-0000-000000000000000%s' % i), 'rxtx_cap': 'DONTCARE', 'should_create_vlan': False, 'should_create_bridge': False} self.assertDictMatch(nw[1], check) check = [{'enabled': 'DONTCARE', 'ip': '2001:db%s::dcad:beff:feef:%s' % (i8, i), 'netmask': '64'}] self.assertDictListMatch(nw[1]['ip6s'], check) check = [{'enabled': '1', 'ip': '192.168.%s.100' % i, 'netmask': '255.255.255.0'}] self.assertDictListMatch(nw[1]['ips'], check)
def test_finish_revert_resize(self): """Ensure that the flavor is reverted to the original on revert""" context = self.context.elevated() instance_id = self._create_instance() def fake(*args, **kwargs): pass self.stubs.Set(self.compute.driver, 'finish_migration', fake) self.stubs.Set(self.compute.driver, 'revert_migration', fake) self.stubs.Set(self.compute.network_api, 'get_instance_nw_info', fake) self.compute.run_instance(self.context, instance_id) # Confirm the instance size before the resize starts inst_ref = db.instance_get(context, instance_id) instance_type_ref = db.instance_type_get(context, inst_ref['instance_type_id']) self.assertEqual(instance_type_ref['flavorid'], 1) db.instance_update(self.context, instance_id, {'host': 'foo'}) self.compute.prep_resize(context, inst_ref['uuid'], 3) migration_ref = db.migration_get_by_instance_and_status(context, inst_ref['uuid'], 'pre-migrating') self.compute.resize_instance(context, inst_ref['uuid'], migration_ref['id']) self.compute.finish_resize(context, inst_ref['uuid'], int(migration_ref['id']), {}) # Prove that the instance size is now the new size inst_ref = db.instance_get(context, instance_id) instance_type_ref = db.instance_type_get(context, inst_ref['instance_type_id']) self.assertEqual(instance_type_ref['flavorid'], 3) # Finally, revert and confirm the old flavor has been applied self.compute.revert_resize(context, inst_ref['uuid'], migration_ref['id']) self.compute.finish_revert_resize(context, inst_ref['uuid'], migration_ref['id']) inst_ref = db.instance_get(context, instance_id) instance_type_ref = db.instance_type_get(context, inst_ref['instance_type_id']) self.assertEqual(instance_type_ref['flavorid'], 1) self.compute.terminate_instance(context, instance_id)
def test_instance_type_get_with_extra_specs(self): instance_type = db.instance_type_get( self.context, self.instance_type_id) self.assertEquals(instance_type['extra_specs'], dict(cpu_arch="x86_64", cpu_model="Nehalem", xpu_arch="fermi", xpus="2", xpu_model="Tesla 2050")) instance_type = db.instance_type_get( self.context, 5) self.assertEquals(instance_type['extra_specs'], {})
def prep_resize(self, context, image, update_db, request_spec, filter_properties, instance=None, instance_uuid=None, instance_type=None, instance_type_id=None, topic=None): """Tries to call schedule_prep_resize on the driver. Sets instance vm_state to ACTIVE on NoHostFound Sets vm_state to ERROR on other exceptions """ if not instance: instance = db.instance_get_by_uuid(context, instance_uuid) if not instance_type: instance_type = db.instance_type_get(context, instance_type_id) try: kwargs = { 'context': context, 'image': image, 'update_db': update_db, 'request_spec': request_spec, 'filter_properties': filter_properties, 'instance': instance, 'instance_type': instance_type, } return self.driver.schedule_prep_resize(**kwargs) except exception.NoValidHost as ex: self._set_vm_state_and_notify('prep_resize', {'vm_state': vm_states.ACTIVE, 'task_state': None}, context, ex, request_spec) except Exception as ex: with excutils.save_and_reraise_exception(): self._set_vm_state_and_notify('prep_resize', {'vm_state': vm_states.ERROR}, context, ex, request_spec)
def test_create_instances_here(self): # Just grab the first instance type inst_type = db.instance_type_get(self.ctxt, 1) image = {"properties": {}} instance_props = { "hostname": "meow", "display_name": "moo", "image_ref": "fake_image_ref", "user_id": self.ctxt.user_id, "project_id": self.ctxt.project_id, } request_spec = { "instance_type": inst_type, "image": image, "security_group": ["default"], "block_device_mapping": [], "instance_properties": instance_props, "instance_uuids": self.instance_uuids, } call_info = {"uuids": []} def _fake_instance_update_at_top(_ctxt, instance): call_info["uuids"].append(instance["uuid"]) self.stubs.Set(self.msg_runner, "instance_update_at_top", _fake_instance_update_at_top) self.scheduler._create_instances_here(self.ctxt, request_spec) self.assertEqual(self.instance_uuids, call_info["uuids"]) for instance_uuid in self.instance_uuids: instance = db.instance_get_by_uuid(self.ctxt, instance_uuid) self.assertEqual("meow", instance["hostname"]) self.assertEqual("moo-%s" % instance["uuid"], instance["display_name"]) self.assertEqual("fake_image_ref", instance["image_ref"])
def test_create_instances_here(self): # Just grab the first instance type inst_type = db.instance_type_get(self.ctxt, 1) image = {'properties': {}} instance_props = {'hostname': 'meow', 'display_name': 'moo', 'image_ref': 'fake_image_ref', 'user_id': self.ctxt.user_id, 'project_id': self.ctxt.project_id} request_spec = {'instance_type': inst_type, 'image': image, 'security_group': ['default'], 'block_device_mapping': [], 'instance_properties': instance_props, 'instance_uuids': self.instance_uuids} call_info = {'uuids': []} def _fake_instance_update_at_top(_ctxt, instance): call_info['uuids'].append(instance['uuid']) self.stubs.Set(self.msg_runner, 'instance_update_at_top', _fake_instance_update_at_top) self.scheduler._create_instances_here(self.ctxt, request_spec) self.assertEqual(self.instance_uuids, call_info['uuids']) for instance_uuid in self.instance_uuids: instance = db.instance_get_by_uuid(self.ctxt, instance_uuid) self.assertEqual('meow', instance['hostname']) self.assertEqual('moo', instance['display_name']) self.assertEqual('fake_image_ref', instance['image_ref'])
def get_instance_type(instance_type_id): """Retrieves single instance type by id.""" if instance_type_id is None: return get_default_instance_type() ctxt = context.get_admin_context() return db.instance_type_get(ctxt, instance_type_id)
def schedule_prep_resize(self, context, request_spec, *args, **kwargs): """Select a target for resize. Selects a target host for the instance, post-resize, and casts the prep_resize operation to it. """ # We need the new instance type ID... instance_type_id = kwargs['instance_type_id'] elevated = context.elevated() LOG.debug(_("Attempting to determine target host for resize to " "instance type %(instance_type_id)s") % locals()) # Convert it to an actual instance type instance_type = db.instance_type_get(elevated, instance_type_id) # Now let's grab a possibility hosts = self._schedule(context, 'compute', request_spec, *args, **kwargs) if not hosts: raise exception.NoValidHost(reason=_("")) host = hosts.pop(0) # NOTE(comstud): Make sure we do not pass this through. It # contains an instance of RpcContext that cannot be serialized. kwargs.pop('filter_properties', None) # Forward off to the host driver.cast_to_compute_host(context, host.host_state.host, 'prep_resize', **kwargs)
def test_create_instances_here(self): # Just grab the first instance type inst_type = db.instance_type_get(self.ctxt, 1) image = {'properties': {}} instance_uuids = self.instance_uuids instance_props = { 'hostname': 'meow', 'display_name': 'moo', 'image_ref': 'fake_image_ref', 'user_id': self.ctxt.user_id, 'project_id': self.ctxt.project_id } call_info = {'uuids': []} def _fake_instance_update_at_top(_ctxt, instance): call_info['uuids'].append(instance['uuid']) self.stubs.Set(self.msg_runner, 'instance_update_at_top', _fake_instance_update_at_top) self.scheduler._create_instances_here(self.ctxt, instance_uuids, instance_props, inst_type, image, ['default'], []) self.assertEqual(instance_uuids, call_info['uuids']) for instance_uuid in instance_uuids: instance = db.instance_get_by_uuid(self.ctxt, instance_uuid) self.assertEqual('meow', instance['hostname']) self.assertEqual('moo-%s' % instance['uuid'], instance['display_name']) self.assertEqual('fake_image_ref', instance['image_ref'])
def schedule_prep_resize(self, context, request_spec, *args, **kwargs): """Select a target for resize. Selects a target host for the instance, post-resize, and casts the prep_resize operation to it. """ # We need the new instance type ID... instance_type_id = kwargs['instance_type_id'] elevated = context.elevated() LOG.debug( _("Attempting to determine target host for resize to " "instance type %(instance_type_id)s") % locals()) # Convert it to an actual instance type instance_type = db.instance_type_get(elevated, instance_type_id) # Now let's grab a possibility hosts = self._schedule(elevated, 'compute', request_spec, *args, **kwargs) if not hosts: raise exception.NoValidHost(reason=_("")) host = hosts.pop(0) # Forward off to the host driver.cast_to_host(context, 'compute', host.host, 'prep_resize', **kwargs)
def test_create_instances_here(self): # Just grab the first instance type inst_type = db.instance_type_get(self.ctxt, 1) image = {'properties': {}} instance_uuids = self.instance_uuids instance_props = {'hostname': 'meow', 'display_name': 'moo', 'image_ref': 'fake_image_ref', 'user_id': self.ctxt.user_id, 'project_id': self.ctxt.project_id} call_info = {'uuids': []} def _fake_instance_update_at_top(_ctxt, instance): call_info['uuids'].append(instance['uuid']) self.stubs.Set(self.msg_runner, 'instance_update_at_top', _fake_instance_update_at_top) self.scheduler._create_instances_here(self.ctxt, instance_uuids, instance_props, inst_type, image, ['default'], []) self.assertEqual(instance_uuids, call_info['uuids']) for instance_uuid in instance_uuids: instance = db.instance_get_by_uuid(self.ctxt, instance_uuid) self.assertEqual('meow', instance['hostname']) self.assertEqual('moo-%s' % instance['uuid'], instance['display_name']) self.assertEqual('fake_image_ref', instance['image_ref'])
def get_network_info(instance): # TODO(tr3buchet): this function needs to go away! network info # MUST be passed down from compute # TODO(adiantum) If we will keep this function # we should cache network_info admin_context = context.get_admin_context() try: fixed_ips = db.fixed_ip_get_by_instance(admin_context, instance['id']) except exception.FixedIpNotFoundForInstance: fixed_ips = [] vifs = db.virtual_interface_get_by_instance(admin_context, instance['id']) flavor = db.instance_type_get(admin_context, instance['instance_type_id']) network_info = [] for vif in vifs: network = vif['network'] # determine which of the instance's IPs belong to this network network_ips = [fixed_ip['address'] for fixed_ip in fixed_ips if fixed_ip['network_id'] == network['id']] def ip_dict(ip): return { 'ip': ip, 'netmask': network['netmask'], 'enabled': '1'} def ip6_dict(): prefix = network['cidr_v6'] mac = vif['address'] project_id = instance['project_id'] return { 'ip': ipv6.to_global(prefix, mac, project_id), 'netmask': network['netmask_v6'], 'enabled': '1'} mapping = { 'label': network['label'], 'gateway': network['gateway'], 'broadcast': network['broadcast'], 'dhcp_server': network['gateway'], 'mac': vif['address'], 'rxtx_cap': flavor['rxtx_cap'], 'dns': [], 'ips': [ip_dict(ip) for ip in network_ips]} if network['dns1']: mapping['dns'].append(network['dns1']) if network['dns2']: mapping['dns'].append(network['dns2']) if FLAGS.use_ipv6: mapping['ip6s'] = [ip6_dict()] mapping['gateway6'] = network['gateway_v6'] network_info.append((network, mapping)) return network_info
def schedule_prep_resize(self, context, request_spec, *args, **kwargs): """Select a target for resize. Selects a target host for the instance, post-resize, and casts the prep_resize operation to it. """ # We need the new instance type ID... instance_type_id = kwargs["instance_type_id"] elevated = context.elevated() LOG.debug( _("Attempting to determine target host for resize to " "instance type %(instance_type_id)s") % locals() ) # Convert it to an actual instance type instance_type = db.instance_type_get(elevated, instance_type_id) # Now let's grab a possibility hosts = self._schedule(elevated, "compute", request_spec, *args, **kwargs) if not hosts: raise exception.NoValidHost(reason=_("")) host = hosts.pop(0) # Forward off to the host driver.cast_to_host(context, "compute", host.host, "prep_resize", **kwargs)
def get_instance_type(id): """Retrieves single instance type by id.""" if id is None: return get_default_instance_type() try: ctxt = context.get_admin_context() return db.instance_type_get(ctxt, id) except exception.DBError: raise exception.ApiError(_("Unknown instance type: %s") % id)
def get_instance_type(instance_type_id): """Retrieves single instance type by id.""" if instance_type_id is None: return get_default_instance_type() ctxt = context.get_admin_context() try: return db.instance_type_get(ctxt, instance_type_id) except exception.InstanceTypeNotFound as e: raise exception.ApiError(e)
def get_instance_type(instance_type_id, ctxt=None, inactive=False): """Retrieves single instance type by id.""" if instance_type_id is None: return get_default_instance_type() if ctxt is None: ctxt = context.get_admin_context() if inactive: ctxt = ctxt.elevated(read_deleted="yes") return db.instance_type_get(ctxt, instance_type_id)
def create_instance(testcase): fake.stub_out_image_service(testcase.stubs) ctxt = context.get_admin_context() instance_type = db.instance_type_get(ctxt, 1) sys_meta = flavors.save_instance_type_info({}, instance_type) return db.instance_create(ctxt, {'user_id': 'fake', 'project_id': 'fake', 'instance_type_id': 1, 'memory_mb': 1024, 'vcpus': 2, 'image_ref': '155d900f-4e14-4e4c-a73d-069cbf4541e6', 'system_metadata': sys_meta})
def create_instance(testcase): fake.stub_out_image_service(testcase.stubs) ctxt = context.get_admin_context() instance_type = db.instance_type_get(ctxt, 1) sys_meta = flavors.save_flavor_info({}, instance_type) return db.instance_create(ctxt, {'user_id': 'fake', 'project_id': 'fake', 'instance_type_id': 1, 'memory_mb': 1024, 'vcpus': 2, 'image_ref': '155d900f-4e14-4e4c-a73d-069cbf4541e6', 'system_metadata': sys_meta})
def _live_migration_dest_check(self, context, instance_ref, dest, ignore_hosts=None): """Live migration check routine (for destination host). :param context: security context :param instance_ref: nova.db.sqlalchemy.models.Instance object :param dest: destination host :param ignore_hosts: hosts that should be avoided as dest host """ # If dest is not specified, have scheduler pick one. if dest is None: instance_type = db.instance_type_get( context, instance_ref['instance_type_id']) image = self.image_service.show(context, instance_ref['image_ref']) request_spec = { 'instance_properties': instance_ref, 'instance_type': instance_type, 'instance_uuids': [instance_ref['uuid']], 'image': image } filter_properties = {'ignore_hosts': ignore_hosts} return self.select_hosts(context, request_spec, filter_properties)[0] # Checking whether The host where instance is running # and dest is not same. src = instance_ref['host'] if dest == src: raise exception.UnableToMigrateToSelf( instance_id=instance_ref['uuid'], host=dest) # Checking dest exists and compute node. try: dservice_ref = db.service_get_by_compute_host(context, dest) except exception.NotFound: raise exception.ComputeServiceUnavailable(host=dest) # Checking dest host is alive. if not self.servicegroup_api.service_is_up(dservice_ref): raise exception.ComputeServiceUnavailable(host=dest) # Check memory requirements self._assert_compute_node_has_enough_memory(context, instance_ref, dest) return dest
def prep_resize(self, context, image, request_spec, filter_properties, update_db=None, instance=None, instance_uuid=None, instance_type=None, instance_type_id=None, reservations=None, topic=None): """Tries to call schedule_prep_resize on the driver. Sets instance vm_state to ACTIVE on NoHostFound Sets vm_state to ERROR on other exceptions """ if not instance: instance = db.instance_get_by_uuid(context, instance_uuid) if not instance_type: instance_type = db.instance_type_get(context, instance_type_id) try: kwargs = { 'context': context, 'image': image, 'request_spec': request_spec, 'filter_properties': filter_properties, 'instance': instance, 'instance_type': instance_type, 'reservations': reservations, } return self.driver.schedule_prep_resize(**kwargs) except exception.NoValidHost as ex: self._set_vm_state_and_notify('prep_resize', { 'vm_state': vm_states.ACTIVE, 'task_state': None }, context, ex, request_spec) if reservations: QUOTAS.rollback(context, reservations) except Exception as ex: with excutils.save_and_reraise_exception(): self._set_vm_state_and_notify('prep_resize', {'vm_state': vm_states.ERROR}, context, ex, request_spec) if reservations: QUOTAS.rollback(context, reservations)
def create_instance(testcase): fake.stub_out_image_service(testcase.stubs) ctxt = context.get_admin_context() instance_type = db.instance_type_get(ctxt, 1) sys_meta = flavors.save_instance_type_info({}, instance_type) return db.instance_create( ctxt, { "user_id": "fake", "project_id": "fake", "instance_type_id": 1, "memory_mb": 1024, "vcpus": 2, "image_ref": "155d900f-4e14-4e4c-a73d-069cbf4541e6", "system_metadata": sys_meta, }, )
def test_create_instances_here(self): # Just grab the first instance type inst_type = db.instance_type_get(self.ctxt, 1) image = {'properties': {}} instance_uuids = self.instance_uuids instance_props = { 'name': 'instance-00000001', 'hostname': 'meow', 'display_name': 'moo', 'image_ref': 'fake_image_ref', 'user_id': self.ctxt.user_id, # Test these as lists 'metadata': [{ 'key': 'moo', 'value': 'cow' }], 'system_metadata': [{ 'key': 'meow', 'value': 'cat' }], 'project_id': self.ctxt.project_id } call_info = {'uuids': []} def _fake_instance_update_at_top(_ctxt, instance): call_info['uuids'].append(instance['uuid']) self.stubs.Set(self.msg_runner, 'instance_update_at_top', _fake_instance_update_at_top) self.scheduler._create_instances_here(self.ctxt, instance_uuids, instance_props, inst_type, image, ['default'], []) self.assertEqual(instance_uuids, call_info['uuids']) for instance_uuid in instance_uuids: instance = db.instance_get_by_uuid(self.ctxt, instance_uuid) meta = utils.instance_meta(instance) self.assertEqual('cow', meta['moo']) sys_meta = utils.instance_sys_meta(instance) self.assertEqual('cat', sys_meta['meow']) self.assertEqual('meow', instance['hostname']) self.assertEqual('moo-%s' % instance['uuid'], instance['display_name']) self.assertEqual('fake_image_ref', instance['image_ref'])
def _live_migration_dest_check(self, context, instance_ref, dest, ignore_hosts=None): """Live migration check routine (for destination host). :param context: security context :param instance_ref: nova.db.sqlalchemy.models.Instance object :param dest: destination host :param ignore_hosts: hosts that should be avoided as dest host """ # If dest is not specified, have scheduler pick one. if dest is None: instance_type = db.instance_type_get( context, instance_ref['instance_type_id']) image = self.image_service.show(context, instance_ref['image_ref']) request_spec = {'instance_properties': instance_ref, 'instance_type': instance_type, 'instance_uuids': [instance_ref['uuid']], 'image': image} filter_properties = {'ignore_hosts': ignore_hosts} return self.select_hosts(context, request_spec, filter_properties)[0] # Checking whether The host where instance is running # and dest is not same. src = instance_ref['host'] if dest == src: raise exception.UnableToMigrateToSelf( instance_id=instance_ref['uuid'], host=dest) # Checking dest exists and compute node. try: dservice_ref = db.service_get_by_compute_host(context, dest) except exception.NotFound: raise exception.ComputeServiceUnavailable(host=dest) # Checking dest host is alive. if not self.servicegroup_api.service_is_up(dservice_ref): raise exception.ComputeServiceUnavailable(host=dest) # Check memory requirements self._assert_compute_node_has_enough_memory(context, instance_ref, dest) return dest
def _check_vdi_size(cls, context, session, instance, vdi_uuid): size_bytes = cls._get_vdi_chain_size(context, session, vdi_uuid) # FIXME(jk0): this was copied directly from compute.manager.py, let's # refactor this to a common area instance_type_id = instance["instance_type_id"] instance_type = db.instance_type_get(context, instance_type_id) allowed_size_gb = instance_type["local_gb"] allowed_size_bytes = allowed_size_gb * 1024 * 1024 * 1024 LOG.debug(_("image_size_bytes=%(size_bytes)d, allowed_size_bytes=" "%(allowed_size_bytes)d") % locals()) if size_bytes > allowed_size_bytes: LOG.info( _("Image size %(size_bytes)d exceeded" " instance_type allowed size " "%(allowed_size_bytes)d") % locals() ) raise exception.ImageTooLarge()
def _check_vdi_size(cls, context, session, instance, vdi_uuid): size_bytes = cls._get_vdi_chain_size(context, session, vdi_uuid) # FIXME(jk0): this was copied directly from compute.manager.py, let's # refactor this to a common area instance_type_id = instance['instance_type_id'] instance_type = db.instance_type_get(context, instance_type_id) allowed_size_gb = instance_type['local_gb'] allowed_size_bytes = allowed_size_gb * 1024 * 1024 * 1024 LOG.debug( _("image_size_bytes=%(size_bytes)d, allowed_size_bytes=" "%(allowed_size_bytes)d") % locals()) if size_bytes > allowed_size_bytes: LOG.info( _("Image size %(size_bytes)d exceeded" " instance_type allowed size " "%(allowed_size_bytes)d") % locals()) raise exception.ImageTooLarge()
def setUp(self): super(LibvirtBlockInfoTest, self).setUp() self.user_id = 'fake' self.project_id = 'fake' self.context = context.get_admin_context() instance_type = db.instance_type_get(self.context, 2) sys_meta = flavors.save_instance_type_info({}, instance_type) nova.tests.image.fake.stub_out_image_service(self.stubs) self.test_instance = { 'uuid': '32dfcb37-5af1-552b-357c-be8c3aa38310', 'memory_kb': '1024000', 'basepath': '/some/path', 'bridge_name': 'br100', 'vcpus': 2, 'project_id': 'fake', 'bridge': 'br101', 'image_ref': '155d900f-4e14-4e4c-a73d-069cbf4541e6', 'root_gb': 10, 'ephemeral_gb': 20, 'instance_type_id': 2, # m1.tiny 'system_metadata': sys_meta}
def setUp(self): super(LibvirtBlockInfoTest, self).setUp() self.user_id = 'fake' self.project_id = 'fake' self.context = context.get_admin_context() instance_type = db.instance_type_get(self.context, 2) sys_meta = instance_types.save_instance_type_info({}, instance_type) nova.tests.image.fake.stub_out_image_service(self.stubs) self.test_instance = { 'uuid': '32dfcb37-5af1-552b-357c-be8c3aa38310', 'memory_kb': '1024000', 'basepath': '/some/path', 'bridge_name': 'br100', 'vcpus': 2, 'project_id': 'fake', 'bridge': 'br101', 'image_ref': '155d900f-4e14-4e4c-a73d-069cbf4541e6', 'root_gb': 10, 'ephemeral_gb': 20, 'instance_type_id': 2, # m1.tiny 'system_metadata': sys_meta }
def test_create_instances_here(self): # Just grab the first instance type inst_type = db.instance_type_get(self.ctxt, 1) image = {'properties': {}} instance_uuids = self.instance_uuids instance_props = {'name': 'instance-00000001', 'hostname': 'meow', 'display_name': 'moo', 'image_ref': 'fake_image_ref', 'user_id': self.ctxt.user_id, # Test these as lists 'metadata': [{'key': 'moo', 'value': 'cow'}], 'system_metadata': [{'key': 'meow', 'value': 'cat'}], 'project_id': self.ctxt.project_id} call_info = {'uuids': []} def _fake_instance_update_at_top(_ctxt, instance): call_info['uuids'].append(instance['uuid']) self.stubs.Set(self.msg_runner, 'instance_update_at_top', _fake_instance_update_at_top) self.scheduler._create_instances_here(self.ctxt, instance_uuids, instance_props, inst_type, image, ['default'], []) self.assertEqual(instance_uuids, call_info['uuids']) for instance_uuid in instance_uuids: instance = db.instance_get_by_uuid(self.ctxt, instance_uuid) meta = utils.instance_meta(instance) self.assertEqual('cow', meta['moo']) sys_meta = utils.instance_sys_meta(instance) self.assertEqual('cat', sys_meta['meow']) self.assertEqual('meow', instance['hostname']) self.assertEqual('moo-%s' % instance['uuid'], instance['display_name']) self.assertEqual('fake_image_ref', instance['image_ref'])
def test_create_instances_here(self): # Just grab the first instance type inst_type = db.instance_type_get(self.ctxt, 1) image = {'properties': {}} instance_props = { 'hostname': 'meow', 'display_name': 'moo', 'image_ref': 'fake_image_ref', 'user_id': self.ctxt.user_id, 'project_id': self.ctxt.project_id } request_spec = { 'instance_type': inst_type, 'image': image, 'security_group': ['default'], 'block_device_mapping': [], 'instance_properties': instance_props, 'instance_uuids': self.instance_uuids } call_info = {'uuids': []} def _fake_instance_update_at_top(_ctxt, instance): call_info['uuids'].append(instance['uuid']) self.stubs.Set(self.msg_runner, 'instance_update_at_top', _fake_instance_update_at_top) self.scheduler._create_instances_here(self.ctxt, request_spec) self.assertEqual(self.instance_uuids, call_info['uuids']) for instance_uuid in self.instance_uuids: instance = db.instance_get_by_uuid(self.ctxt, instance_uuid) self.assertEqual('meow', instance['hostname']) self.assertEqual('moo', instance['display_name']) self.assertEqual('fake_image_ref', instance['image_ref'])
def instance_type_get(self, context, instance_type_id): return db.instance_type_get(context, instance_type_id)
def test_instance_type_get(self): self.mox.StubOutWithMock(db, 'instance_type_get') db.instance_type_get(self.context, 'fake-id').AndReturn('fake-type') self.mox.ReplayAll() result = self.conductor.instance_type_get(self.context, 'fake-id') self.assertEqual(result, 'fake-type')
def _usage_for_period(self, context, period_start, period_stop, tenant_id=None): fields = ['id', 'image_ref', 'project_id', 'user_id', 'vcpus', 'hostname', 'display_name', 'host', 'vm_state', 'instance_type_id', 'launched_at', 'terminated_at'] tenant_clause = '' if tenant_id: tenant_clause = " and project_id='%s'" % tenant_id connection = get_session().connection() rows = connection.execute("select %s from instances where \ (terminated_at is NULL or terminated_at > '%s') \ and (launched_at < '%s') %s" %\ (','.join(fields), period_start.isoformat(' '),\ period_stop.isoformat(' '), tenant_clause )).fetchall() rval = {} flavors = {} for row in rows: o = {} for i in range(len(fields)): o[fields[i]] = row[i] o['hours'] = self._hours_for(o, period_start, period_stop) flavor_type = o['instance_type_id'] try: flavors[flavor_type] = \ db.instance_type_get_by_id(context, flavor_type) except AttributeError: # The most recent version of nova renamed this function flavors[flavor_type] = \ db.instance_type_get(context, flavor_type) except exception.InstanceTypeNotFound: # can't bill if there is no instance type continue flavor = flavors[flavor_type] o['name'] = o['display_name'] del(o['display_name']) o['ram_size'] = flavor['memory_mb'] o['disk_size'] = flavor['local_gb'] o['tenant_id'] = o['project_id'] del(o['project_id']) o['flavor'] = flavor['name'] del(o['instance_type_id']) o['started_at'] = o['launched_at'] del(o['launched_at']) o['ended_at'] = o['terminated_at'] del(o['terminated_at']) if o['ended_at']: o['state'] = 'terminated' else: o['state'] = o['vm_state'] del(o['vm_state']) now = datetime.utcnow() if o['state'] == 'terminated': delta = self._parse_datetime(o['ended_at'])\ - self._parse_datetime(o['started_at']) else: delta = now - self._parse_datetime(o['started_at']) o['uptime'] = delta.days * 24 * 60 + delta.seconds if not o['tenant_id'] in rval: summary = {} summary['tenant_id'] = o['tenant_id'] summary['instances'] = [] summary['total_disk_usage'] = 0 summary['total_cpu_usage'] = 0 summary['total_ram_usage'] = 0 summary['total_active_ram_size'] = 0 summary['total_active_disk_size'] = 0 summary['total_active_vcpus'] = 0 summary['total_active_instances'] = 0 summary['total_hours'] = 0 summary['begin'] = period_start summary['stop'] = period_stop rval[o['tenant_id']] = summary rval[o['tenant_id']]['total_disk_usage'] += o['disk_size'] * o['hours'] rval[o['tenant_id']]['total_cpu_usage'] += o['vcpus'] * o['hours'] rval[o['tenant_id']]['total_ram_usage'] += o['ram_size'] * o['hours'] if o['state'] is not 'terminated': rval[o['tenant_id']]['total_active_ram_size'] += o['ram_size'] rval[o['tenant_id']]['total_active_vcpus'] += o['vcpus'] rval[o['tenant_id']]['total_active_disk_size'] += o['disk_size'] rval[o['tenant_id']]['total_active_instances'] += 1 rval[o['tenant_id']]['total_hours'] += o['hours'] rval[o['tenant_id']]['instances'].append(o) return rval.values()
def _usage_for_period(self, context, period_start, period_stop, tenant_id=None): fields = [ "id", "image_ref", "project_id", "user_id", "vcpus", "hostname", "display_name", "host", "task_state", "instance_type_id", "launched_at", "terminated_at", ] tenant_clause = "" if tenant_id: tenant_clause = " and project_id='%s'" % tenant_id connection = get_session().connection() rows = connection.execute( "select %s from instances where \ (terminated_at is NULL or terminated_at > '%s') \ and (launched_at < '%s') %s" % (",".join(fields), period_start.isoformat(" "), period_stop.isoformat(" "), tenant_clause) ).fetchall() rval = {} flavors = {} for row in rows: o = {} for i in range(len(fields)): o[fields[i]] = row[i] o["hours"] = self._hours_for(o, period_start, period_stop) flavor_type = o["instance_type_id"] try: flavors[flavor_type] = db.instance_type_get_by_id(context, flavor_type) except AttributeError: # The most recent version of nova renamed this function flavors[flavor_type] = db.instance_type_get(context, flavor_type) except exception.InstanceTypeNotFound: # can't bill if there is no instance type continue flavor = flavors[flavor_type] o["name"] = o["display_name"] del (o["display_name"]) o["ram_size"] = flavor["memory_mb"] o["disk_size"] = flavor["local_gb"] o["tenant_id"] = o["project_id"] del (o["project_id"]) o["flavor"] = flavor["name"] del (o["instance_type_id"]) o["started_at"] = o["launched_at"] del (o["launched_at"]) o["ended_at"] = o["terminated_at"] del (o["terminated_at"]) if o["ended_at"]: o["state"] = "terminated" else: o["state"] = o["task_state"] del (o["task_state"]) now = datetime.utcnow() if o["state"] == "terminated": delta = self._parse_datetime(o["ended_at"]) - self._parse_datetime(o["started_at"]) else: delta = now - self._parse_datetime(o["started_at"]) o["uptime"] = delta.days * 24 * 60 + delta.seconds if not o["tenant_id"] in rval: summary = {} summary["tenant_id"] = o["tenant_id"] summary["instances"] = [] summary["total_disk_usage"] = 0 summary["total_cpu_usage"] = 0 summary["total_ram_usage"] = 0 summary["total_active_ram_size"] = 0 summary["total_active_disk_size"] = 0 summary["total_active_vcpus"] = 0 summary["total_active_instances"] = 0 summary["total_hours"] = 0 summary["begin"] = period_start summary["stop"] = period_stop rval[o["tenant_id"]] = summary rval[o["tenant_id"]]["total_disk_usage"] += o["disk_size"] * o["hours"] rval[o["tenant_id"]]["total_cpu_usage"] += o["vcpus"] * o["hours"] rval[o["tenant_id"]]["total_ram_usage"] += o["ram_size"] * o["hours"] if o["state"] is not "terminated": rval[o["tenant_id"]]["total_active_ram_size"] += o["ram_size"] rval[o["tenant_id"]]["total_active_vcpus"] += o["vcpus"] rval[o["tenant_id"]]["total_active_disk_size"] += o["disk_size"] rval[o["tenant_id"]]["total_active_instances"] += 1 rval[o["tenant_id"]]["total_hours"] += o["hours"] rval[o["tenant_id"]]["instances"].append(o) return rval.values()
def test_get_instance_nw_info(self): self.mox.StubOutWithMock(db, 'fixed_ip_get_by_instance') self.mox.StubOutWithMock(db, 'virtual_interface_get_by_instance') self.mox.StubOutWithMock(db, 'instance_type_get') db.fixed_ip_get_by_instance(mox.IgnoreArg(), mox.IgnoreArg()).AndReturn(fixed_ips) db.virtual_interface_get_by_instance(mox.IgnoreArg(), mox.IgnoreArg()).AndReturn(vifs) db.instance_type_get(mox.IgnoreArg(), mox.IgnoreArg()).AndReturn(flavor) self.mox.ReplayAll() nw_info = self.network.get_instance_nw_info(None, 0, 0, None) self.assertTrue(nw_info) for i, nw in enumerate(nw_info): i8 = i + 8 check = { 'bridge': 'fa%s' % i, 'cidr': '192.168.%s.0/24' % i, 'cidr_v6': '2001:db%s::/64' % i8, 'id': i, 'multi_host': False, 'injected': 'DONTCARE', 'bridge_interface': 'fake_fa%s' % i, 'vlan': None } self.assertDictMatch(nw[0], check) check = { 'broadcast': '192.168.%s.255' % i, 'dhcp_server': '192.168.%s.1' % i, 'dns': 'DONTCARE', 'gateway': '192.168.%s.1' % i, 'gateway6': '2001:db%s::1' % i8, 'ip6s': 'DONTCARE', 'ips': 'DONTCARE', 'label': 'test%s' % i, 'mac': 'DE:AD:BE:EF:00:0%s' % i, 'rxtx_cap': 'DONTCARE', 'should_create_vlan': False, 'should_create_bridge': False } self.assertDictMatch(nw[1], check) check = [{ 'enabled': 'DONTCARE', 'ip': '2001:db%s::dcad:beff:feef:%s' % (i8, i), 'netmask': '64' }] self.assertDictListMatch(nw[1]['ip6s'], check) check = [{ 'enabled': '1', 'ip': '192.168.%s.100' % i, 'netmask': '255.255.255.0' }] self.assertDictListMatch(nw[1]['ips'], check)
def test_instance_type_get(self): self.mox.StubOutWithMock(db, "instance_type_get") db.instance_type_get(self.context, "fake-id").AndReturn("fake-type") self.mox.ReplayAll() result = self.conductor.instance_type_get(self.context, "fake-id") self.assertEqual(result, "fake-type")
def test_live_migration_auto_set_dest(self): instance = self._live_migration_instance() # Confirm scheduler picks target host if none given. self.mox.StubOutWithMock(db, 'instance_type_get') self.mox.StubOutWithMock(self.driver, '_live_migration_src_check') self.mox.StubOutWithMock(self.driver, 'select_hosts') self.mox.StubOutWithMock(self.driver, '_live_migration_common_check') self.mox.StubOutWithMock(rpc, 'call') self.mox.StubOutWithMock(self.driver.compute_rpcapi, 'live_migration') dest = None block_migration = False disk_over_commit = False instance_type = instance_types.extract_instance_type(instance) request_spec = {'instance_properties': instance, 'instance_type': instance_type, 'instance_uuids': [instance['uuid']], 'image': self.image_service.show(self.context, instance['image_ref']) } self.driver._live_migration_src_check(self.context, instance) db.instance_type_get(self.context, instance_type['id']).MultipleTimes().AndReturn( instance_type) # First selected host raises exception.InvalidHypervisorType self.driver.select_hosts(self.context, request_spec, {'ignore_hosts': [instance['host']]}).AndReturn(['fake_host2']) self.driver._live_migration_common_check(self.context, instance, 'fake_host2').AndRaise(exception.InvalidHypervisorType()) # Second selected host raises exception.InvalidCPUInfo self.driver.select_hosts(self.context, request_spec, {'ignore_hosts': [instance['host'], 'fake_host2']}).AndReturn(['fake_host3']) self.driver._live_migration_common_check(self.context, instance, 'fake_host3') rpc.call(self.context, "compute.fake_host3", {"method": 'check_can_live_migrate_destination', "args": {'instance': instance, 'block_migration': block_migration, 'disk_over_commit': disk_over_commit}, "version": compute_rpcapi.ComputeAPI.BASE_RPC_API_VERSION}, None).AndRaise(exception.InvalidCPUInfo(reason="")) # Third selected host pass all checks self.driver.select_hosts(self.context, request_spec, {'ignore_hosts': [instance['host'], 'fake_host2', 'fake_host3']}).AndReturn(['fake_host4']) self.driver._live_migration_common_check(self.context, instance, 'fake_host4') rpc.call(self.context, "compute.fake_host4", {"method": 'check_can_live_migrate_destination', "args": {'instance': instance, 'block_migration': block_migration, 'disk_over_commit': disk_over_commit}, "version": compute_rpcapi.ComputeAPI.BASE_RPC_API_VERSION}, None).AndReturn({}) self.driver.compute_rpcapi.live_migration(self.context, host=instance['host'], instance=instance, dest='fake_host4', block_migration=block_migration, migrate_data={}) self.mox.ReplayAll() result = self.driver.schedule_live_migration(self.context, instance=instance, dest=dest, block_migration=block_migration, disk_over_commit=disk_over_commit) self.assertEqual(result, None)