def test_instance_type_get_by_name_with_extra_specs(self): instance_type = db.instance_type_get_by_name(self.context, "cg1.4xlarge") 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_by_name(self.context, "m1.small") self.assertEquals(instance_type['extra_specs'], {})
def test_instance_type_get_by_name_with_extra_specs(self): instance_type = db.instance_type_get_by_name( self.context, "cg1.4xlarge") 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_by_name( self.context, "m1.small") self.assertEquals(instance_type['extra_specs'], {})
def setUp(self): super(_IntegratedTestBase, self).setUp() f = self._get_flags() self.flags(**f) self.flags(verbose=True) nova.tests.image.fake.stub_out_image_service(self.stubs) self.flags(compute_scheduler_driver='nova.scheduler.' 'chance.ChanceScheduler') all_types = {'m1.tiny': 1, 'm1.small': 2, 'm1.medium': 2, 'm1.large': 4, 'm1.xlarge': 4} admin_context = context.get_admin_context() for name, value in all_types.iteritems(): inst_type = db.instance_type_get_by_name(admin_context, name) ext_spec = {'ecus_per_vcpu:': value} db.instance_type_extra_specs_update_or_create(admin_context, inst_type["flavorid"], ext_spec) # set up services self.compute = self.start_service('compute') self.volume = self.start_service('volume') self.network = self.start_service('network') self.scheduler = self.start_service('scheduler') self._start_api_service() self.api = client.TestOpenStackClient('fake', 'fake', self.auth_url)
def get_instance_type_by_name(name): """Retrieves single instance type by name.""" if name is None: return get_default_instance_type() ctxt = context.get_admin_context() return db.instance_type_get_by_name(ctxt, name)
def test_migrate_disk_and_power_off(self): instance = db.instance_create(self.context, self.instance_values) instance_type = db.instance_type_get_by_name(self.context, 'm1.large') stubs.stubout_session(self.stubs, stubs.FakeSessionForMigrationTests) conn = xenapi_conn.get_connection(False) conn.migrate_disk_and_power_off(self.context, instance, '127.0.0.1', instance_type)
def _create_vm(self): """Create and spawn the VM.""" self._create_instance_in_the_db() self.type_data = db.instance_type_get_by_name(None, 'm1.large') self.conn.spawn(self.context, self.instance, self.image, self.network_info) self._check_vm_record()
def check_vm_record(self, conn): instances = conn.list_instances() self.assertEquals(instances, [1]) # Get Nova record for VM vm_info = conn.get_info(1) # Get XenAPI record for VM vms = [rec for ref, rec in xenapi_fake.get_all_records('VM').iteritems() if not rec['is_control_domain']] vm = vms[0] # Check that m1.large above turned into the right thing. instance_type = db.instance_type_get_by_name(conn, 'm1.large') mem_kib = long(instance_type['memory_mb']) << 10 mem_bytes = str(mem_kib << 10) vcpus = instance_type['vcpus'] self.assertEquals(vm_info['max_mem'], mem_kib) self.assertEquals(vm_info['mem'], mem_kib) self.assertEquals(vm['memory_static_max'], mem_bytes) self.assertEquals(vm['memory_dynamic_max'], mem_bytes) self.assertEquals(vm['memory_dynamic_min'], mem_bytes) self.assertEquals(vm['VCPUs_max'], str(vcpus)) self.assertEquals(vm['VCPUs_at_startup'], str(vcpus)) # Check that the VM is running according to Nova self.assertEquals(vm_info['state'], power_state.RUNNING) # Check that the VM is running according to XenAPI. self.assertEquals(vm['power_state'], 'Running')
def get_instance_type_by_name(name): """Retrieves single instance type by name.""" if name is None: return get_default_instance_type() try: ctxt = context.get_admin_context() return db.instance_type_get_by_name(ctxt, name) except exception.DBError: raise exception.ApiError(_("Unknown instance type: %s") % name)
def _create_vm(self): """Create and spawn the VM.""" self._create_instance_in_the_db() self.type_data = db.instance_type_get_by_name(None, 'm1.large') self.conn.spawn(self.context, self.instance, self.image, injected_files=[], admin_password=None, network_info=self.network_info, block_device_info=None) self._check_vm_record()
def get_flavor_by_name(name, ctxt=None): """Retrieves single flavor by name.""" if name is None: return get_default_flavor() if ctxt is None: ctxt = context.get_admin_context() return db.instance_type_get_by_name(ctxt, name)
def test_instance_update_of_instance_type_id(self): ctxt = context.get_admin_context() inst_type1 = db.instance_type_get_by_name(ctxt, 'm1.tiny') inst_type2 = db.instance_type_get_by_name(ctxt, 'm1.small') values = {'instance_type_id': inst_type1['id']} instance = db.instance_create(ctxt, values) self.assertEqual(instance['instance_type']['id'], inst_type1['id']) self.assertEqual(instance['instance_type']['name'], inst_type1['name']) values = {'instance_type_id': inst_type2['id']} instance = db.instance_update(ctxt, instance['uuid'], values) self.assertEqual(instance['instance_type']['id'], inst_type2['id']) self.assertEqual(instance['instance_type']['name'], inst_type2['name'])
def get_instance_type(name): """Retrieves single instance type by name""" if name is None: return FLAGS.default_instance_type try: ctxt = context.get_admin_context() inst_type = db.instance_type_get_by_name(ctxt, name) return inst_type except exception.DBError: raise exception.ApiError(_("Unknown instance type: %s" % name))
def get_instance_type_by_name(name): """Retrieves single instance type by name.""" if name is None: return get_default_instance_type() ctxt = context.get_admin_context() try: return db.instance_type_get_by_name(ctxt, name) except exception.InstanceTypeNotFound as e: raise exception.ApiError(e)
def get_by_type(instance_type): """retrieve instance type name""" if instance_type is None: return FLAGS.default_instance_type try: ctxt = context.get_admin_context() inst_type = db.instance_type_get_by_name(ctxt, instance_type) return inst_type['name'] except exception.DBError, e: LOG.exception(_('DB error: %s' % e)) raise exception.ApiError(_("Unknown instance type: %s" %\ instance_type))
def test_migrate_disk_and_power_off_passes_exceptions(self): instance = db.instance_create(self.context, self.instance_values) instance_type = db.instance_type_get_by_name(self.context, 'm1.large') stubs.stubout_session(self.stubs, stubs.FakeSessionForMigrationTests) def fake_raise(*args, **kwargs): raise exception.MigrationError(reason='test failure') self.stubs.Set(vmops.VMOps, "_migrate_vhd", fake_raise) conn = xenapi_conn.get_connection(False) self.assertRaises(exception.MigrationError, conn.migrate_disk_and_power_off, self.context, instance, '127.0.0.1', instance_type)
def check_vm_record(self, conn, check_injection=False): # Check that m1.large above turned into the right thing. instance_type = db.instance_type_get_by_name(conn, 'm1.large') mem_kib = long(instance_type['memory_mb']) << 10 mem_bytes = str(mem_kib << 10) vcpus = instance_type['vcpus'] self.assertEquals(self.vm_info['max_mem'], mem_kib) self.assertEquals(self.vm_info['mem'], mem_kib) self.assertEquals(self.vm['memory_static_max'], mem_bytes) self.assertEquals(self.vm['memory_dynamic_max'], mem_bytes) self.assertEquals(self.vm['memory_dynamic_min'], mem_bytes) self.assertEquals(self.vm['VCPUs_max'], str(vcpus)) self.assertEquals(self.vm['VCPUs_at_startup'], str(vcpus)) # Check that the VM is running according to Nova self.assertEquals(self.vm_info['state'], power_state.RUNNING) # Check that the VM is running according to XenAPI. self.assertEquals(self.vm['power_state'], 'Running') if check_injection: xenstore_data = self.vm['xenstore_data'] key = 'vm-data/networking/aabbccddeeff' xenstore_value = xenstore_data[key] tcpip_data = ast.literal_eval(xenstore_value) self.assertEquals( tcpip_data, { 'label': 'fake_flat_network', 'broadcast': '10.0.0.255', 'ips': [{ 'ip': '10.0.0.3', 'netmask': '255.255.255.0', 'enabled': '1' }], 'ip6s': [{ 'ip': 'fe80::a8bb:ccff:fedd:eeff', 'netmask': '120', 'enabled': '1' }], 'mac': 'aa:bb:cc:dd:ee:ff', 'dns': ['10.0.0.2'], 'gateway': '10.0.0.1', 'gateway6': 'fe80::a00:1' })
def check_vm_record(self, conn, check_injection=False): # Check that m1.large above turned into the right thing. instance_type = db.instance_type_get_by_name(conn, 'm1.large') mem_kib = long(instance_type['memory_mb']) << 10 mem_bytes = str(mem_kib << 10) vcpus = instance_type['vcpus'] self.assertEquals(self.vm_info['max_mem'], mem_kib) self.assertEquals(self.vm_info['mem'], mem_kib) self.assertEquals(self.vm['memory_static_max'], mem_bytes) self.assertEquals(self.vm['memory_dynamic_max'], mem_bytes) self.assertEquals(self.vm['memory_dynamic_min'], mem_bytes) self.assertEquals(self.vm['VCPUs_max'], str(vcpus)) self.assertEquals(self.vm['VCPUs_at_startup'], str(vcpus)) # Check that the VM is running according to Nova self.assertEquals(self.vm_info['state'], power_state.RUNNING) # Check that the VM is running according to XenAPI. self.assertEquals(self.vm['power_state'], 'Running') if check_injection: xenstore_data = self.vm['xenstore_data'] key = 'vm-data/networking/DEADBEEF0000' xenstore_value = xenstore_data[key] tcpip_data = ast.literal_eval(xenstore_value) self.assertEquals( tcpip_data, { 'broadcast': '192.168.0.255', 'dns': ['192.168.0.1'], 'gateway': '192.168.0.1', 'gateway6': 'dead:beef::1', 'ip6s': [{ 'enabled': '1', 'ip': 'dead:beef::dcad:beff:feef:0', 'netmask': '64' }], 'ips': [{ 'enabled': '1', 'ip': '192.168.0.100', 'netmask': '255.255.255.0' }], 'label': 'fake', 'mac': 'DE:AD:BE:EF:00:00' })
def _get_network_info(self, instance): """creates network info list for instance""" admin_context = context.get_admin_context() IPs = db.fixed_ip_get_all_by_instance(admin_context, instance['id']) networks = db.network_get_all_by_instance(admin_context, instance['id']) flavor = db.instance_type_get_by_name(admin_context, instance['instance_type']) network_info = [] for network in networks: network_IPs = [ip for ip in IPs if ip.network_id == network.id] def ip_dict(ip): return { "ip": ip.address, "netmask": network["netmask"], "enabled": "1" } def ip6_dict(ip6): return { "ip": utils.to_global_ipv6(network['cidr_v6'], instance['mac_address']), "netmask": network['netmask_v6'], "gateway": network['gateway_v6'], "enabled": "1" } info = { 'label': network['label'], 'gateway': network['gateway'], 'mac': instance.mac_address, 'rxtx_cap': flavor['rxtx_cap'], 'dns': [network['dns']], 'ips': [ip_dict(ip) for ip in network_IPs] } if network['cidr_v6']: info['ip6s'] = [ip6_dict(ip) for ip in network_IPs] network_info.append((network, info)) return network_info
def check_vm_record(self, conn): # Check that m1.large above turned into the right thing. instance_type = db.instance_type_get_by_name(conn, 'm1.large') mem_kib = long(instance_type['memory_mb']) << 10 mem_bytes = str(mem_kib << 10) vcpus = instance_type['vcpus'] self.assertEquals(self.vm_info['max_mem'], mem_kib) self.assertEquals(self.vm_info['mem'], mem_kib) self.assertEquals(self.vm['memory_static_max'], mem_bytes) self.assertEquals(self.vm['memory_dynamic_max'], mem_bytes) self.assertEquals(self.vm['memory_dynamic_min'], mem_bytes) self.assertEquals(self.vm['VCPUs_max'], str(vcpus)) self.assertEquals(self.vm['VCPUs_at_startup'], str(vcpus)) # Check that the VM is running according to Nova self.assertEquals(self.vm_info['state'], power_state.RUNNING) # Check that the VM is running according to XenAPI. self.assertEquals(self.vm['power_state'], 'Running')
def check_vm_record(self, conn, check_injection=False): # Check that m1.large above turned into the right thing. instance_type = db.instance_type_get_by_name(conn, 'm1.large') mem_kib = long(instance_type['memory_mb']) << 10 mem_bytes = str(mem_kib << 10) vcpus = instance_type['vcpus'] self.assertEquals(self.vm_info['max_mem'], mem_kib) self.assertEquals(self.vm_info['mem'], mem_kib) self.assertEquals(self.vm['memory_static_max'], mem_bytes) self.assertEquals(self.vm['memory_dynamic_max'], mem_bytes) self.assertEquals(self.vm['memory_dynamic_min'], mem_bytes) self.assertEquals(self.vm['VCPUs_max'], str(vcpus)) self.assertEquals(self.vm['VCPUs_at_startup'], str(vcpus)) # Check that the VM is running according to Nova self.assertEquals(self.vm_info['state'], power_state.RUNNING) # Check that the VM is running according to XenAPI. self.assertEquals(self.vm['power_state'], 'Running') if check_injection: xenstore_data = self.vm['xenstore_data'] key = 'vm-data/networking/DEADBEEF0000' xenstore_value = xenstore_data[key] tcpip_data = ast.literal_eval(xenstore_value) self.assertEquals(tcpip_data, {'broadcast': '192.168.0.255', 'dns': ['192.168.0.1'], 'gateway': '192.168.0.1', 'gateway_v6': 'dead:beef::1', 'ip6s': [{'enabled': '1', 'ip': 'dead:beef::dcad:beff:feef:0', 'netmask': '64'}], 'ips': [{'enabled': '1', 'ip': '192.168.0.100', 'netmask': '255.255.255.0'}], 'label': 'fake', 'mac': 'DE:AD:BE:EF:00:00', 'rxtx_cap': 3})
def check_vm_record(self, conn, check_injection=False): # Check that m1.large above turned into the right thing. instance_type = db.instance_type_get_by_name(conn, 'm1.large') mem_kib = long(instance_type['memory_mb']) << 10 mem_bytes = str(mem_kib << 10) vcpus = instance_type['vcpus'] self.assertEquals(self.vm_info['max_mem'], mem_kib) self.assertEquals(self.vm_info['mem'], mem_kib) self.assertEquals(self.vm['memory_static_max'], mem_bytes) self.assertEquals(self.vm['memory_dynamic_max'], mem_bytes) self.assertEquals(self.vm['memory_dynamic_min'], mem_bytes) self.assertEquals(self.vm['VCPUs_max'], str(vcpus)) self.assertEquals(self.vm['VCPUs_at_startup'], str(vcpus)) # Check that the VM is running according to Nova self.assertEquals(self.vm_info['state'], power_state.RUNNING) # Check that the VM is running according to XenAPI. self.assertEquals(self.vm['power_state'], 'Running') if check_injection: xenstore_data = self.vm['xenstore_data'] key = 'vm-data/networking/aabbccddeeff' xenstore_value = xenstore_data[key] tcpip_data = ast.literal_eval(xenstore_value) self.assertEquals(tcpip_data, {'label': 'fake_flat_network', 'broadcast': '10.0.0.255', 'ips': [{'ip': '10.0.0.3', 'netmask':'255.255.255.0', 'enabled':'1'}], 'ip6s': [{'ip': 'fe80::a8bb:ccff:fedd:eeff', 'netmask': '120', 'enabled': '1'}], 'mac': 'aa:bb:cc:dd:ee:ff', 'dns': ['10.0.0.2'], 'gateway': '10.0.0.1', 'gateway6': 'fe80::a00:1'})
def check_vm_record(self, conn, check_injection=False): # Check that m1.large above turned into the right thing. instance_type = db.instance_type_get_by_name(conn, "m1.large") mem_kib = long(instance_type["memory_mb"]) << 10 mem_bytes = str(mem_kib << 10) vcpus = instance_type["vcpus"] self.assertEquals(self.vm_info["max_mem"], mem_kib) self.assertEquals(self.vm_info["mem"], mem_kib) self.assertEquals(self.vm["memory_static_max"], mem_bytes) self.assertEquals(self.vm["memory_dynamic_max"], mem_bytes) self.assertEquals(self.vm["memory_dynamic_min"], mem_bytes) self.assertEquals(self.vm["VCPUs_max"], str(vcpus)) self.assertEquals(self.vm["VCPUs_at_startup"], str(vcpus)) # Check that the VM is running according to Nova self.assertEquals(self.vm_info["state"], power_state.RUNNING) # Check that the VM is running according to XenAPI. self.assertEquals(self.vm["power_state"], "Running") if check_injection: xenstore_data = self.vm["xenstore_data"] key = "vm-data/networking/aabbccddeeff" xenstore_value = xenstore_data[key] tcpip_data = ast.literal_eval(xenstore_value) self.assertEquals( tcpip_data, { "label": "fake_flat_network", "broadcast": "10.0.0.255", "ips": [{"ip": "10.0.0.3", "netmask": "255.255.255.0", "enabled": "1"}], "ip6s": [{"ip": "fe80::a8bb:ccff:fedd:eeff", "netmask": "120", "enabled": "1"}], "mac": "aa:bb:cc:dd:ee:ff", "dns": ["10.0.0.2"], "gateway": "10.0.0.1", "gateway6": "fe80::a00:1", }, )
def _get_network_info(self, instance): """creates network info list for instance""" admin_context = context.get_admin_context() IPs = db.fixed_ip_get_all_by_instance(admin_context, instance['id']) networks = db.network_get_all_by_instance(admin_context, instance['id']) flavor = db.instance_type_get_by_name(admin_context, instance['instance_type']) network_info = [] for network in networks: network_IPs = [ip for ip in IPs if ip.network_id == network.id] def ip_dict(ip): return { "ip": ip.address, "netmask": network["netmask"], "enabled": "1"} def ip6_dict(ip6): return { "ip": utils.to_global_ipv6(network['cidr_v6'], instance['mac_address']), "netmask": network['netmask_v6'], "gateway": network['gateway_v6'], "enabled": "1"} info = { 'label': network['label'], 'gateway': network['gateway'], 'mac': instance.mac_address, 'rxtx_cap': flavor['rxtx_cap'], 'dns': [network['dns']], 'ips': [ip_dict(ip) for ip in network_IPs]} if network['cidr_v6']: info['ip6s'] = [ip6_dict(ip) for ip in network_IPs] network_info.append((network, info)) return network_info
def check_vm_record(self, conn, check_injection=False): # Check that m1.large above turned into the right thing. instance_type = db.instance_type_get_by_name(conn, "m1.large") mem_kib = long(instance_type["memory_mb"]) << 10 mem_bytes = str(mem_kib << 10) vcpus = instance_type["vcpus"] self.assertEquals(self.vm_info["max_mem"], mem_kib) self.assertEquals(self.vm_info["mem"], mem_kib) self.assertEquals(self.vm["memory_static_max"], mem_bytes) self.assertEquals(self.vm["memory_dynamic_max"], mem_bytes) self.assertEquals(self.vm["memory_dynamic_min"], mem_bytes) self.assertEquals(self.vm["VCPUs_max"], str(vcpus)) self.assertEquals(self.vm["VCPUs_at_startup"], str(vcpus)) # Check that the VM is running according to Nova self.assertEquals(self.vm_info["state"], power_state.RUNNING) # Check that the VM is running according to XenAPI. self.assertEquals(self.vm["power_state"], "Running") if check_injection: xenstore_data = self.vm["xenstore_data"] key = "vm-data/networking/DEADBEEF0000" xenstore_value = xenstore_data[key] tcpip_data = ast.literal_eval(xenstore_value) self.assertEquals( tcpip_data, { "broadcast": "192.168.0.255", "dns": ["192.168.0.1"], "gateway": "192.168.0.1", "gateway6": "dead:beef::1", "ip6s": [{"enabled": "1", "ip": "dead:beef::dcad:beff:feef:0", "netmask": "64"}], "ips": [{"enabled": "1", "ip": "192.168.0.100", "netmask": "255.255.255.0"}], "label": "fake", "mac": "DE:AD:BE:EF:00:00", }, )
def setUp(self): super(CinderCloudTestCase, self).setUp() vol_tmpdir = tempfile.mkdtemp() self.flags(compute_driver='nova.virt.fake.FakeDriver', volume_api_class='nova.tests.fake_volume.API', volumes_dir=vol_tmpdir) def fake_show(meh, context, id): return {'id': id, 'name': 'fake_name', 'container_format': 'ami', 'status': 'active', 'properties': { 'kernel_id': 'cedef40a-ed67-4d10-800e-17455edce175', 'ramdisk_id': 'cedef40a-ed67-4d10-800e-17455edce175', 'type': 'machine', 'image_state': 'available'}} def fake_detail(_self, context, **kwargs): image = fake_show(None, context, None) image['name'] = kwargs.get('filters', {}).get('name') return [image] self.stubs.Set(fake._FakeImageService, 'show', fake_show) self.stubs.Set(fake._FakeImageService, 'detail', fake_detail) fake.stub_out_image_service(self.stubs) def dumb(*args, **kwargs): pass self.stubs.Set(compute_utils, 'notify_about_instance_usage', dumb) fake_network.set_stub_network_methods(self.stubs) # set up our cloud self.cloud = cloud.CloudController() self.flags(compute_scheduler_driver='nova.scheduler.' 'chance.ChanceScheduler') # set up services self.compute = self.start_service('compute') self.scheduler = self.start_service('scheduler') self.network = self.start_service('network') self.volume = self.start_service('volume') self.user_id = 'fake' self.project_id = 'fake' self.context = context.RequestContext(self.user_id, self.project_id, is_admin=True) self.volume_api = volume.API() self.volume_api.reset_fake_api(self.context) all_types = {'m1.tiny': 1, 'm1.small': 2, 'm1.medium': 2, 'm1.large': 4, 'm1.xlarge': 4} admin_context = context.get_admin_context() for name, value in all_types.iteritems(): inst_type = db.instance_type_get_by_name(admin_context, name) ext_spec = {'ecus_per_vcpu:': value} db.instance_type_extra_specs_update_or_create(admin_context, inst_type["flavorid"], ext_spec) # NOTE(comstud): Make 'cast' behave like a 'call' which will # ensure that operations complete self.stubs.Set(rpc, 'cast', rpc.call) # make sure we can map ami-00000001/2 to a uuid in FakeImageService db.api.s3_image_create(self.context, 'cedef40a-ed67-4d10-800e-17455edce175') db.api.s3_image_create(self.context, '76fa36fc-c930-4bf3-8c8a-ea2a2420deb6')
def _setup_test_migrate_disk_and_power_off_mocks(self, same_host=False, copy_exception=False, size_exception=False): self._instance_data = self._get_instance_data() instance = db.instance_create(self._context, self._instance_data) network_info = fake_network.fake_get_instance_nw_info( self.stubs, spectacular=True) instance['root_gb'] = 10 fake_local_ip = '10.0.0.1' if same_host: fake_dest_ip = fake_local_ip else: fake_dest_ip = '10.0.0.2' if size_exception: flavor = 'm1.tiny' else: flavor = 'm1.small' instance_type = db.instance_type_get_by_name(self._context, flavor) if not size_exception: fake_root_vhd_path = 'C:\\FakePath\\root.vhd' fake_revert_path = os.path.join(self._test_instance_dir, '_revert') func = mox.Func(self._check_instance_name) vmutils.VMUtils.set_vm_state(func, constants.HYPERV_VM_STATE_DISABLED) m = vmutils.VMUtils.get_vm_storage_paths(func) m.AndReturn(([fake_root_vhd_path], [])) m = hostutils.HostUtils.get_local_ips() m.AndReturn([fake_local_ip]) m = fake.PathUtils.get_instance_dir(mox.IsA(str)) m.AndReturn(self._test_instance_dir) m = pathutils.PathUtils.get_instance_migr_revert_dir( instance['name'], remove_dir=True) m.AndReturn(fake_revert_path) if same_host: fake.PathUtils.makedirs(mox.IsA(str)) m = fake.PathUtils.copy(fake_root_vhd_path, mox.IsA(str)) if copy_exception: m.AndRaise(shutil.Error('Simulated copy error')) m = fake.PathUtils.get_instance_dir(mox.IsA(str), mox.IsA(str), remove_dir=True) m.AndReturn(self._test_instance_dir) else: fake.PathUtils.rename(mox.IsA(str), mox.IsA(str)) destroy_disks = True if same_host: fake.PathUtils.rename(mox.IsA(str), mox.IsA(str)) destroy_disks = False self._setup_destroy_mocks(False) if destroy_disks: m = fake.PathUtils.get_instance_dir(mox.IsA(str), mox.IsA(str), remove_dir=True) m.AndReturn(self._test_instance_dir) return (instance, fake_dest_ip, network_info, instance_type)