def test_build_instances(self):
call_info = self._stub_rpc_method('cast', None)
instances = [objects.Instance(id=1), objects.Instance(id=2)]
self.cells_rpcapi.build_instances(self.fake_context,
instances=instances,
image={'fake': 'image'},
arg1=1,
arg2=2,
arg3=3)
expected_args = {
'build_inst_kwargs': {
'instances': instances,
'image': {
'fake': 'image'
},
'arg1': 1,
'arg2': 2,
'arg3': 3
}
}
self._check_result(call_info,
'build_instances',
expected_args,
version='1.34')
def test_format_instance_mapping(self):
# Make sure that _format_instance_mappings works.
ctxt = None
instance_ref0 = objects.Instance(**{'id': 0,
'uuid': 'e5fe5518-0288-4fa3-b0c4-c79764101b85',
'root_device_name': None,
'default_ephemeral_device': None,
'default_swap_device': None})
instance_ref1 = objects.Instance(**{'id': 0,
'uuid': 'b65cee2f-8c69-4aeb-be2f-f79742548fc2',
'root_device_name': '/dev/sda1',
'default_ephemeral_device': None,
'default_swap_device': None})
def fake_bdm_get(ctxt, uuid, use_slave=False):
return [fake_block_device.FakeDbBlockDeviceDict(
{'volume_id': 87654321,
'snapshot_id': None,
'no_device': None,
'source_type': 'volume',
'destination_type': 'volume',
'delete_on_termination': True,
'device_name': '/dev/sdh'}),
fake_block_device.FakeDbBlockDeviceDict(
{'volume_id': None,
'snapshot_id': None,
'no_device': None,
'source_type': 'blank',
'destination_type': 'local',
'guest_format': 'swap',
'delete_on_termination': None,
'device_name': '/dev/sdc'}),
fake_block_device.FakeDbBlockDeviceDict(
{'volume_id': None,
'snapshot_id': None,
'no_device': None,
'source_type': 'blank',
'destination_type': 'local',
'guest_format': None,
'delete_on_termination': None,
'device_name': '/dev/sdb'})]
self.stubs.Set(db, 'block_device_mapping_get_all_by_instance',
fake_bdm_get)
expected = {'ami': 'sda1',
'root': '/dev/sda1',
'ephemeral0': '/dev/sdb',
'swap': '/dev/sdc',
'ebs0': '/dev/sdh'}
conductor_api.LocalAPI()
self.assertEqual(base._format_instance_mapping(ctxt,
instance_ref0), block_device._DEFAULT_MAPPINGS)
self.assertEqual(base._format_instance_mapping(ctxt,
instance_ref1), expected)
def test_build_instances(self):
build_inst_kwargs = {'instances': [objects.Instance(),
objects.Instance()]}
self.mox.StubOutWithMock(self.msg_runner, 'build_instances')
our_cell = self.msg_runner.state_manager.get_my_state()
self.msg_runner.build_instances(self.ctxt, our_cell, build_inst_kwargs)
self.mox.ReplayAll()
self.cells_manager.build_instances(self.ctxt,
build_inst_kwargs=build_inst_kwargs)
def test_instance_uuids_overlap(self):
inst1 = objects.Instance(uuid='aa')
inst2 = objects.Instance(uuid='bb')
instances = [inst1, inst2]
host_state = fakes.FakeHostState('host1', 'node1', {})
host_state.instances = {
instance.uuid: instance
for instance in instances
}
self.assertTrue(utils.instance_uuids_overlap(host_state, ['aa']))
self.assertFalse(utils.instance_uuids_overlap(host_state, ['zz']))
def _stub_migrate_instance_calls(self, method, multi_host, info):
fake_flavor = flavors.get_default_flavor()
fake_flavor['rxtx_factor'] = 1.21
sys_meta = flavors.save_flavor_info({}, fake_flavor)
fake_instance = objects.Instance(
uuid=uuid.uuid4().hex,
project_id='fake_project_id',
instance_type_id=fake_flavor['id'],
system_metadata=sys_meta)
fake_migration = {'source_compute': 'fake_compute_source',
'dest_compute': 'fake_compute_dest'}
def fake_mig_inst_method(*args, **kwargs):
info['kwargs'] = kwargs
def fake_get_multi_addresses(*args, **kwargs):
return multi_host, ['fake_float1', 'fake_float2']
self.stubs.Set(network_rpcapi.NetworkAPI, method,
fake_mig_inst_method)
self.stubs.Set(self.network_api, '_get_multi_addresses',
fake_get_multi_addresses)
expected = {'instance_uuid': fake_instance.uuid,
'source_compute': 'fake_compute_source',
'dest_compute': 'fake_compute_dest',
'rxtx_factor': 1.21,
'project_id': 'fake_project_id',
'floating_addresses': None}
if multi_host:
expected['floating_addresses'] = ['fake_float1', 'fake_float2']
return fake_instance, fake_migration, expected
def get_test_instance(context=None, flavor=None, obj=False):
if not context:
context = get_test_admin_context()
if not flavor:
flavor = get_test_flavor(context)
test_instance = {
'memory_kb': '2048000',
'basepath': '/some/path',
'bridge_name': 'br100',
'vcpus': 4,
'root_gb': 40,
'bridge': 'br101',
'image_ref': 'cedef40a-ed67-4d10-800e-17455edce175',
'instance_type_id': flavor['id'],
'system_metadata': {},
'extra_specs': {},
'user_id': context.user_id,
'project_id': context.project_id,
}
if obj:
instance = objects.Instance(context, **test_instance)
with mock.patch.object(instance, 'save'):
instance.set_flavor(objects.Flavor.get_by_id(
context, flavor['id']))
instance.create()
else:
flavors.save_flavor_info(test_instance['system_metadata'], flavor, '')
instance = patron.db.instance_create(context, test_instance)
return instance
def migrate_server(self, context, instance, scheduler_hint, live, rebuild,
flavor, block_migration, disk_over_commit, reservations=None,
clean_shutdown=True):
if instance and not isinstance(instance, patron_object.NovaObject):
# NOTE(danms): Until v2 of the RPC API, we need to tolerate
# old-world instance objects here
attrs = ['metadata', 'system_metadata', 'info_cache',
'security_groups']
instance = objects.Instance._from_db_object(
context, objects.Instance(), instance,
expected_attrs=attrs)
# NOTE(melwitt): Remove this in version 2.0 of the RPC API
if flavor and not isinstance(flavor, objects.Flavor):
# Code downstream may expect extra_specs to be populated since it
# is receiving an object, so lookup the flavor to ensure this.
flavor = objects.Flavor.get_by_id(context, flavor['id'])
if live and not rebuild and not flavor:
self._live_migrate(context, instance, scheduler_hint,
block_migration, disk_over_commit)
elif not live and not rebuild and flavor:
instance_uuid = instance['uuid']
with compute_utils.EventReporter(context, 'cold_migrate',
instance_uuid):
self._cold_migrate(context, instance, flavor,
scheduler_hint['filter_properties'],
reservations, clean_shutdown)
else:
raise NotImplementedError()
def _create_fake_instance(self):
self.inst = objects.Instance()
self.inst.uuid = 'fake-inst-uuid'
self.inst.pci_devices = objects.PciDeviceList()
self.inst.vm_state = vm_states.ACTIVE
self.inst.task_state = None
self.inst.numa_topology = None
def fake_inst_obj(context):
inst = objects.Instance(
context=context,
id=1,
user_id='fake_user',
uuid='b65cee2f-8c69-4aeb-be2f-f79742548fc2',
project_id='test',
key_name="key",
key_data="ssh-rsa AAAAB3Nzai....N3NtHw== someuser@somehost",
host='test',
launch_index=1,
reservation_id='r-xxxxxxxx',
user_data=ENCODE_USER_DATA_STRING,
image_ref=7,
vcpus=1,
fixed_ips=[],
root_device_name='/dev/sda1',
hostname='test.patrondomain',
display_name='my_displayname',
metadata={},
default_ephemeral_device=None,
default_swap_device=None,
system_metadata={})
nwinfo = network_model.NetworkInfo([])
inst.info_cache = objects.InstanceInfoCache(context=context,
instance_uuid=inst.uuid,
network_info=nwinfo)
with mock.patch.object(inst, 'save'):
inst.set_flavor(flavors.get_default_flavor())
return inst
def get_by_network(cls, context, network, host=None):
ipinfo = db.network_get_associated_fixed_ips(context,
network['id'],
host=host)
if not ipinfo:
return []
fips = cls(context=context, objects=[])
for info in ipinfo:
inst = objects.Instance(context=context,
uuid=info['instance_uuid'],
hostname=info['instance_hostname'],
created_at=info['instance_created'],
updated_at=info['instance_updated'])
vif = objects.VirtualInterface(context=context,
id=info['vif_id'],
address=info['vif_address'])
fip = objects.FixedIP(context=context,
address=info['address'],
instance_uuid=info['instance_uuid'],
network_id=info['network_id'],
virtual_interface_id=info['vif_id'],
allocated=info['allocated'],
leased=info['leased'],
default_route=info['default_route'],
instance=inst,
virtual_interface=vif)
fips.objects.append(fip)
fips.obj_reset_changes()
return fips
def test_get_disk_mapping_rescue(self):
# A simple disk mapping setup, but in rescue mode
instance_ref = objects.Instance(**self.test_instance)
image_meta = {}
mapping = blockinfo.get_disk_mapping("kvm",
instance_ref,
"virtio",
"ide",
image_meta,
rescue=True)
expect = {
'disk.rescue': {
'bus': 'virtio',
'dev': 'vda',
'type': 'disk',
'boot_index': '1'
},
'disk': {
'bus': 'virtio',
'dev': 'vdb',
'type': 'disk'
},
'root': {
'bus': 'virtio',
'dev': 'vda',
'type': 'disk',
'boot_index': '1'
},
}
self.assertEqual(expect, mapping)
def test_create_console(self, mock_get_instance_by_uuid,
mock_get_console_topic):
mock_get_instance_by_uuid.return_value = objects.Instance(
**self.fake_instance)
self.console_api.create_console(self.context, self.fake_uuid)
mock_get_console_topic.assert_called_once_with(self.context,
'fake_host')
def test_get_disk_mapping_simple_iso(self):
# A simple disk mapping setup, but with a ISO for root device
instance_ref = objects.Instance(**self.test_instance)
image_meta = {'disk_format': 'iso'}
mapping = blockinfo.get_disk_mapping("kvm", instance_ref, "virtio",
"ide", image_meta)
expect = {
'disk': {
'bus': 'ide',
'dev': 'hda',
'type': 'cdrom',
'boot_index': '1'
},
'disk.local': {
'bus': 'virtio',
'dev': 'vda',
'type': 'disk'
},
'root': {
'bus': 'ide',
'dev': 'hda',
'type': 'cdrom',
'boot_index': '1'
},
}
self.assertEqual(expect, mapping)
def test_get_disk_mapping_simple_swap(self):
# A simple disk mapping setup, but with a swap device added
instance_ref = objects.Instance(**self.test_instance)
instance_ref.flavor.swap = 5
image_meta = {}
mapping = blockinfo.get_disk_mapping("kvm", instance_ref, "virtio",
"ide", image_meta)
expect = {
'disk': {
'bus': 'virtio',
'dev': 'vda',
'type': 'disk',
'boot_index': '1'
},
'disk.local': {
'bus': 'virtio',
'dev': 'vdb',
'type': 'disk'
},
'disk.swap': {
'bus': 'virtio',
'dev': 'vdc',
'type': 'disk'
},
'root': {
'bus': 'virtio',
'dev': 'vda',
'type': 'disk',
'boot_index': '1'
},
}
self.assertEqual(expect, mapping)
def test_get_disk_mapping_simple(self):
# The simplest possible disk mapping setup, all defaults
instance_ref = objects.Instance(**self.test_instance)
image_meta = {}
mapping = blockinfo.get_disk_mapping("kvm", instance_ref, "virtio",
"ide", image_meta)
expect = {
'disk': {
'bus': 'virtio',
'dev': 'vda',
'type': 'disk',
'boot_index': '1'
},
'disk.local': {
'bus': 'virtio',
'dev': 'vdb',
'type': 'disk'
},
'root': {
'bus': 'virtio',
'dev': 'vda',
'type': 'disk',
'boot_index': '1'
}
}
self.assertEqual(expect, mapping)
def test_get_disk_mapping_simple_rootdev(self):
# A simple disk mapping setup, but with custom root device name
instance_ref = objects.Instance(**self.test_instance)
image_meta = {}
block_device_info = {'root_device_name': '/dev/sda'}
mapping = blockinfo.get_disk_mapping("kvm", instance_ref, "virtio",
"ide", image_meta,
block_device_info)
expect = {
'disk': {
'bus': 'scsi',
'dev': 'sda',
'type': 'disk',
'boot_index': '1'
},
'disk.local': {
'bus': 'virtio',
'dev': 'vda',
'type': 'disk'
},
'root': {
'bus': 'scsi',
'dev': 'sda',
'type': 'disk',
'boot_index': '1'
}
}
self.assertEqual(expect, mapping)
def setUp(self):
super(PciDeviceTestCase, self).setUp()
self.ctxt = context.get_admin_context()
self.inst = objects.Instance()
self.inst.uuid = 'fake-inst-uuid'
self.inst.pci_devices = objects.PciDeviceList()
self.devobj = objects.PciDevice._from_db_object(
self.ctxt, objects.PciDevice(), dev_dict)
def setUp(self):
super(TestUpdateInstanceCache, self).setUp()
self.context = context.get_admin_context()
self.instance = objects.Instance(uuid=FAKE_UUID)
vifs = [network_model.VIF(id='super_vif')]
self.nw_info = network_model.NetworkInfo(vifs)
self.nw_json = fields.NetworkModel.to_primitive(self, 'network_info',
self.nw_info)
def _get_instance(self):
updates = self._get_instance_data()
expected_attrs = updates.pop('expected_attrs', None)
return objects.Instance._from_db_object(
context,
objects.Instance(),
fake_instance.fake_db_instance(**updates),
expected_attrs=expected_attrs)
def fake_vpn_instance():
return objects.Instance(
id=7,
image_ref=CONF.vpn_image_id,
vm_state='active',
created_at=timeutils.parse_strtime('1981-10-20T00:00:00.000000'),
uuid=uuid,
project_id=project_id)
def test_get_disk_mapping_blockdev_many(self):
# A disk mapping with a blockdev replacing all devices
instance_ref = objects.Instance(**self.test_instance)
image_meta = {}
block_device_info = {
'block_device_mapping': [
{
'connection_info': "fake",
'mount_device': "/dev/vda",
'boot_index': 0,
'disk_bus': 'scsi',
'delete_on_termination': True
},
{
'connection_info': "fake",
'mount_device': "/dev/vdb",
'boot_index': -1,
'delete_on_termination': True
},
{
'connection_info': "fake",
'mount_device': "/dev/vdc",
'boot_index': -1,
'device_type': 'cdrom',
'delete_on_termination': True
},
]
}
mapping = blockinfo.get_disk_mapping("kvm", instance_ref, "virtio",
"ide", image_meta,
block_device_info)
expect = {
'/dev/vda': {
'bus': 'scsi',
'dev': 'vda',
'type': 'disk',
'boot_index': '1'
},
'/dev/vdb': {
'bus': 'virtio',
'dev': 'vdb',
'type': 'disk'
},
'/dev/vdc': {
'bus': 'virtio',
'dev': 'vdc',
'type': 'cdrom'
},
'root': {
'bus': 'scsi',
'dev': 'vda',
'type': 'disk',
'boot_index': '1'
},
}
self.assertEqual(expect, mapping)
def test_fetch_image(self):
"""Test fetching images."""
dc_name = 'fake-dc'
file_path = 'fake_file'
ds_name = 'ds1'
host = mock.MagicMock()
port = 7443
context = mock.MagicMock()
image_data = {
'id': patron.tests.unit.image.fake.get_valid_image_id(),
'disk_format': 'vmdk',
'size': 512,
}
read_file_handle = mock.MagicMock()
write_file_handle = mock.MagicMock()
read_iter = mock.MagicMock()
instance = objects.Instance(id=1,
uuid='fake-uuid',
image_ref=image_data['id'])
def fake_read_handle(read_iter):
return read_file_handle
def fake_write_handle(host, port, dc_name, ds_name, cookies, file_path,
file_size):
return write_file_handle
with contextlib.nested(
mock.patch.object(rw_handles,
'ImageReadHandle',
side_effect=fake_read_handle),
mock.patch.object(rw_handles,
'FileWriteHandle',
side_effect=fake_write_handle),
mock.patch.object(images, 'start_transfer'),
mock.patch.object(images.IMAGE_API,
'get',
return_value=image_data),
mock.patch.object(images.IMAGE_API,
'download',
return_value=read_iter),
) as (glance_read, http_write, start_transfer, image_show,
image_download):
images.fetch_image(context, instance, host, port, dc_name, ds_name,
file_path)
glance_read.assert_called_once_with(read_iter)
http_write.assert_called_once_with(host, port, dc_name, ds_name, None,
file_path, image_data['size'])
start_transfer.assert_called_once_with(
context,
read_file_handle,
image_data['size'],
write_file_handle=write_file_handle)
image_download.assert_called_once_with(context, instance['image_ref'])
image_show.assert_called_once_with(context, instance['image_ref'])
def test_affinity_different_filter_handles_none(self):
inst1 = objects.Instance(uuid='same')
host = fakes.FakeHostState('host1', 'node1', {})
host.instances = {inst1.uuid: inst1}
filter_properties = {
'context': mock.sentinel.ctx,
'scheduler_hints': None
}
self.assertTrue(self.filt_cls.host_passes(host, filter_properties))
def test_get_instance_disk_info_is_implemented(self):
instance = objects.Instance()
# Ensure that the method has been implemented in the driver
try:
disk_info = self._conn.get_instance_disk_info(instance)
self.assertIsNone(disk_info)
except NotImplementedError:
self.fail("test_get_instance_disk_info() should not raise "
"NotImplementedError")
def compute_api_get(self,
context,
instance_id,
expected_attrs=None,
want_objects=False):
return objects.Instance(uuid=FAKE_UUID,
id=instance_id,
instance_type_id=1,
host='bob')
def fake_instance_get(context, instance_id):
return objects.Instance(
**{
"id": 1,
"uuid": uuid.uuid4(),
"name": 'fake',
"user_id": 'fakeuser',
"project_id": '123'
})
def test_is_multi_host_instance_has_no_fixed_ip(self):
def fake_fixed_ip_get_by_instance(ctxt, uuid):
raise exception.FixedIpNotFoundForInstance(instance_uuid=uuid)
self.stubs.Set(self.network_api.db, 'fixed_ip_get_by_instance',
fake_fixed_ip_get_by_instance)
instance = objects.Instance(uuid=FAKE_UUID)
result, floats = self.network_api._get_multi_addresses(self.context,
instance)
self.assertFalse(result)
def instance_delete_everywhere(self, ctxt, instance, delete_type):
"""This is used by API cell when it didn't know what cell
an instance was in, but the instance was requested to be
deleted or soft_deleted. So, we'll broadcast this everywhere.
"""
if isinstance(instance, dict):
instance = objects.Instance._from_db_object(
ctxt, objects.Instance(), instance)
self.msg_runner.instance_delete_everywhere(ctxt, instance, delete_type)
def test_get_domain(self, fake_get_domain):
dom = fakelibvirt.virDomain(self.host.get_connection(),
"<domain id='7'/>")
fake_get_domain.return_value = dom
instance = objects.Instance(id="124")
self.assertEqual(dom, self.host.get_domain(instance))
fake_get_domain.assert_called_once_with("instance-0000007c")
def test_do_refresh_security_group_rules_instance_gone(self):
instance1 = objects.Instance(None, id=1, uuid='fake-uuid1')
instance2 = objects.Instance(None, id=2, uuid='fake-uuid2')
self.fw.instance_info = {1: (instance1, 'netinfo1'),
2: (instance2, 'netinfo2')}
mock_filter = mock.MagicMock()
with mock.patch.dict(self.fw.iptables.ipv4, {'filter': mock_filter}):
mock_filter.has_chain.return_value = False
with mock.patch.object(self.fw, 'instance_rules') as mock_ir:
mock_ir.return_value = (None, None)
self.fw.do_refresh_security_group_rules('secgroup')
self.assertEqual(2, mock_ir.call_count)
# NOTE(danms): Make sure that it is checking has_chain each time,
# continuing to process all the instances, and never adding the
# new chains back if has_chain() is False
mock_filter.has_chain.assert_has_calls([mock.call('inst-1'),
mock.call('inst-2')],
any_order=True)
self.assertEqual(0, mock_filter.add_chain.call_count)
