def test_rebuild_failures(self, mock_save, mock_get, mock_driver_fields, mock_fg_bid, mock_set_pstate): node_uuid = uuidutils.generate_uuid() instance_uuid = uuidutils.generate_uuid() node = ironic_utils.get_test_node(uuid=node_uuid, instance_uuid=instance_uuid, instance_type_id=5) mock_get.return_value = node image_meta = ironic_utils.get_test_image_meta() flavor_id = 5 flavor = {'id': flavor_id, 'name': 'baremetal'} mock_fg_bid.return_value = flavor instance = fake_instance.fake_instance_obj(self.ctx, uuid=instance_uuid, node=node_uuid, instance_type_id=flavor_id) exceptions = [ exception.NovaException(), ironic_exception.BadRequest(), ironic_exception.InternalServerError(), ] for e in exceptions: mock_set_pstate.side_effect = e self.assertRaises(exception.InstanceDeployFailure, self.driver.rebuild, context=self.ctx, instance=instance, image_meta=image_meta, injected_files=None, admin_password=None, bdms=None, detach_block_devices=None, attach_block_devices=None)
def test__node_resources_unavailable(self): node_dicts = [ # a node in maintenance /w no instance and power OFF {"uuid": uuidutils.generate_uuid(), "maintenance": True, "power_state": ironic_states.POWER_OFF}, # a node in maintenance /w no instance and ERROR power state {"uuid": uuidutils.generate_uuid(), "maintenance": True, "power_state": ironic_states.ERROR}, # a node not in maintenance /w no instance and bad power state {"uuid": uuidutils.generate_uuid(), "power_state": ironic_states.NOSTATE}, ] for n in node_dicts: node = ironic_utils.get_test_node(**n) self.assertTrue(self.driver._node_resources_unavailable(node)) avail_node = ironic_utils.get_test_node(power_state=ironic_states.POWER_OFF) self.assertFalse(self.driver._node_resources_unavailable(avail_node))
def test_create_vm_invalid_guestid(self, mock_log_warn): """Ensure we warn when create_vm() fails after we passed an unrecognised guestId """ found = [False] def fake_log_warn(msg, values): if not isinstance(values, dict): return if values.get('ostype') == 'invalid_os_type': found[0] = True mock_log_warn.side_effect = fake_log_warn instance_values = {'id': 7, 'name': 'fake-name', 'uuid': uuidutils.generate_uuid(), 'vcpus': 2, 'memory_mb': 2048} instance = fake_instance.fake_instance_obj( context.RequestContext('fake', 'fake', is_admin=False), **instance_values) session = driver.VMwareAPISession() config_spec = vm_util.get_vm_create_spec( session.vim.client.factory, instance, instance.name, 'fake-datastore', [], vm_util.ExtraSpecs(), os_type='invalid_os_type') self.assertRaises(vexc.VMwareDriverException, vm_util.create_vm, session, instance, 'folder', config_spec, 'res-pool') self.assertTrue(found[0])
def test__node_resource(self): node_uuid = uuidutils.generate_uuid() instance_uuid = uuidutils.generate_uuid() props = _get_properties() stats = _get_stats() node = ironic_utils.get_test_node(uuid=node_uuid, instance_uuid=instance_uuid, properties=props) result = self.driver._node_resource(node) self.assertEqual(props["cpus"], result["vcpus"]) self.assertEqual(props["cpus"], result["vcpus_used"]) self.assertEqual(props["memory_mb"], result["memory_mb"]) self.assertEqual(props["memory_mb"], result["memory_mb_used"]) self.assertEqual(props["local_gb"], result["local_gb"]) self.assertEqual(props["local_gb"], result["local_gb_used"]) self.assertEqual(node_uuid, result["hypervisor_hostname"]) self.assertEqual(stats, jsonutils.loads(result["stats"]))
def setUp(self): super(CreateBackupTests, self).setUp() self.stubs.Set(compute_api.API, 'get', fake_compute_api_get) self.backup_stubs = fakes.stub_out_compute_api_backup(self.stubs) self.app = compute.APIRouter(init_only=('servers',)) self.uuid = uuidutils.generate_uuid()
def setUp(self): super(_ImageTestCase, self).setUp() self.INSTANCES_PATH = tempfile.mkdtemp(suffix='instances') self.flags(disable_process_locking=True, instances_path=self.INSTANCES_PATH) self.INSTANCE = {'name': 'instance', 'uuid': uuidutils.generate_uuid()} self.DISK_INFO_PATH = os.path.join(self.INSTANCES_PATH, self.INSTANCE['uuid'], 'disk.info') self.NAME = 'fake.vm' self.TEMPLATE = 'template' self.OLD_STYLE_INSTANCE_PATH = \ fake_libvirt_utils.get_instance_path(self.INSTANCE, forceold=True) self.PATH = os.path.join( fake_libvirt_utils.get_instance_path(self.INSTANCE), self.NAME) # TODO(mikal): rename template_dir to base_dir and template_path # to cached_image_path. This will be less confusing. self.TEMPLATE_DIR = os.path.join(CONF.instances_path, '_base') self.TEMPLATE_PATH = os.path.join(self.TEMPLATE_DIR, 'template') self.useFixture(fixtures.MonkeyPatch( 'nova.virt.libvirt.imagebackend.libvirt_utils', fake_libvirt_utils)) def fake_chown(path, owner_uid=None): return None self.stubs.Set(utils, 'chown', fake_chown)
def test_get_vm_create_spec_with_limit(self): instance_uuid = uuidutils.generate_uuid() fake_instance = {'id': 7, 'name': 'fake!', 'uuid': instance_uuid, 'vcpus': 2, 'memory_mb': 2048} result = vm_util.get_vm_create_spec(fake.FakeFactory(), fake_instance, instance_uuid, 'fake-datastore', [], allocations={'cpu_limit': 7}) expected = """{ 'files': {'vmPathName': '[fake-datastore]', 'obj_name': 'ns0:VirtualMachineFileInfo'}, 'instanceUuid': '%(instance_uuid)s', 'name': '%(instance_uuid)s', 'deviceChange': [], 'extraConfig': [{'value': '%(instance_uuid)s', 'key': 'nvp.vm-uuid', 'obj_name': 'ns0:OptionValue'}], 'memoryMB': 2048, 'managedBy': {'extensionKey': 'org.openstack.compute', 'type': 'instance', 'obj_name': 'ns0:ManagedByInfo'}, 'obj_name': 'ns0:VirtualMachineConfigSpec', 'guestId': 'otherGuest', 'tools': {'beforeGuestStandby': True, 'beforeGuestReboot': True, 'beforeGuestShutdown': True, 'afterResume': True, 'afterPowerOn': True, 'obj_name': 'ns0:ToolsConfigInfo'}, 'cpuAllocation': {'limit': 7, 'obj_name': 'ns0:ResourceAllocationInfo'}, 'numCPUs': 2}""" % {'instance_uuid': instance_uuid} expected = re.sub(r'\s+', '', expected) result = re.sub(r'\s+', '', repr(result)) self.assertEqual(expected, result)
def test_get_instances_on_driver(self): fake_context = context.get_admin_context() driver_instances = [] for x in xrange(10): instance = dict(uuid=uuidutils.generate_uuid()) driver_instances.append(instance) self.mox.StubOutWithMock(self.compute.driver, 'list_instance_uuids') self.mox.StubOutWithMock(self.compute.conductor_api, 'instance_get_all_by_filters') self.compute.driver.list_instance_uuids().AndReturn( [inst['uuid'] for inst in driver_instances]) self.compute.conductor_api.instance_get_all_by_filters( fake_context, {'uuid': [inst['uuid'] for inst in driver_instances]}, columns_to_join=[]).AndReturn( driver_instances) self.mox.ReplayAll() result = self.compute._get_instances_on_driver(fake_context, columns_to_join=[]) self.assertEqual(driver_instances, result)
def test_get_instances_on_driver_fallback(self): # Test getting instances when driver doesn't support # 'list_instance_uuids' self.compute.host = 'host' filters = {'host': self.compute.host} fake_context = context.get_admin_context() all_instances = [] driver_instances = [] for x in xrange(10): instance = dict(name=uuidutils.generate_uuid()) if x % 2: driver_instances.append(instance) all_instances.append(instance) self.mox.StubOutWithMock(self.compute.driver, 'list_instance_uuids') self.mox.StubOutWithMock(self.compute.driver, 'list_instances') self.mox.StubOutWithMock(self.compute.conductor_api, 'instance_get_all_by_filters') self.compute.driver.list_instance_uuids().AndRaise( NotImplementedError()) self.compute.driver.list_instances().AndReturn( [inst['name'] for inst in driver_instances]) self.compute.conductor_api.instance_get_all_by_filters( fake_context, filters, columns_to_join=None).AndReturn(all_instances) self.mox.ReplayAll() result = self.compute._get_instances_on_driver(fake_context, filters) self.assertEqual(driver_instances, result)
def test_get_info_http_not_found(self, mock_gbiu): mock_gbiu.side_effect = ironic_exception.NotFound() expected = {"state": nova_states.NOSTATE, "max_mem": 0, "mem": 0, "num_cpu": 0, "cpu_time": 0} instance = fake_instance.fake_instance_obj(self.ctx, uuid=uuidutils.generate_uuid()) result = self.driver.get_info(instance) self.assertEqual(expected, result)
def test_macs_for_instance_http_not_found(self, mock_get): mock_get.side_effect = ironic_exception.NotFound() instance = fake_instance.fake_instance_obj( self.ctx, node=uuidutils.generate_uuid()) result = self.driver.macs_for_instance(instance) self.assertEqual([], result)
def test_get_vm_create_spec(self): instance_uuid = uuidutils.generate_uuid() fake_instance = {"id": 7, "name": "fake!", "uuid": instance_uuid, "vcpus": 2, "memory_mb": 2048} result = vm_util.get_vm_create_spec(fake.FakeFactory(), fake_instance, instance_uuid, "fake-datastore", []) expected = """{ 'files': {'vmPathName': '[fake-datastore]', 'obj_name': 'ns0:VirtualMachineFileInfo'}, 'instanceUuid': '%(instance_uuid)s', 'name': '%(instance_uuid)s', 'deviceChange': [], 'extraConfig': [{'value': '%(instance_uuid)s', 'key': 'nvp.vm-uuid', 'obj_name': 'ns0:OptionValue'}], 'memoryMB': 2048, 'obj_name': 'ns0:VirtualMachineConfigSpec', 'guestId': 'otherGuest', 'tools': {'beforeGuestStandby': True, 'beforeGuestReboot': True, 'beforeGuestShutdown': True, 'afterResume': True, 'afterPowerOn': True, 'obj_name': 'ns0:ToolsConfigInfo'}, 'numCPUs': 2}""" % { "instance_uuid": instance_uuid } expected = re.sub(r"\s+", "", expected) result = re.sub(r"\s+", "", repr(result)) self.assertEqual(expected, result)
def test_node_is_available(self, mock_get): no_guid = None any_guid = uuidutils.generate_uuid() in_maintenance = True is_available = True not_in_maintenance = False not_available = False power_off = ironic_states.POWER_OFF not_power_off = ironic_states.POWER_ON testing_set = {(no_guid, not_in_maintenance, power_off):is_available, (no_guid, not_in_maintenance, not_power_off):not_available, (no_guid, in_maintenance, power_off):not_available, (no_guid, in_maintenance, not_power_off):not_available, (any_guid, not_in_maintenance, power_off):not_available, (any_guid, not_in_maintenance, not_power_off):not_available, (any_guid, in_maintenance, power_off):not_available, (any_guid, in_maintenance, not_power_off):not_available} for key in testing_set.keys(): node = ironic_utils.get_test_node(instance_uuid=key[0], maintenance=key[1], power_state=key[2]) mock_get.return_value = node expected = testing_set[key] observed = self.driver.node_is_available("dummy_nodename") self.assertEqual(expected, observed)
def _init_cells_scheduler(self): fakes.init(self) self.msg_runner = fakes.get_message_runner('api-cell') self.scheduler = self.msg_runner.scheduler self.state_manager = self.msg_runner.state_manager self.my_cell_state = self.state_manager.get_my_state() self.ctxt = context.RequestContext('fake', 'fake') instance_uuids = [] for x in xrange(3): instance_uuids.append(uuidutils.generate_uuid()) self.instance_uuids = instance_uuids self.instances = [{'uuid': uuid} for uuid in instance_uuids] self.request_spec = { 'instance_uuids': instance_uuids, 'instance_properties': 'fake_properties', 'instance_type': 'fake_type', 'image': 'fake_image', 'security_group': 'fake_sec_groups', 'block_device_mapping': 'fake_bdm'} self.build_inst_kwargs = { 'instances': self.instances, 'image': 'fake_image', 'filter_properties': {'instance_type': 'fake_type'}, 'security_groups': 'fake_sec_groups', 'block_device_mapping': 'fake_bdm'}
def test_spawn_setting_instance_uuid_fail(self): instance = fake_instance.fake_instance_obj(self.ctx, node=uuidutils.generate_uuid()) with mock.patch.object(FAKE_CLIENT.node, 'update') as mock_update: mock_update.side_effect = ironic_exception.HTTPBadRequest() self.assertRaises(exception.NovaException, self.driver.spawn, self.ctx, instance, None, [], None)
def _init_cells_scheduler(self): fakes.init(self) self.msg_runner = fakes.get_message_runner("api-cell") self.scheduler = self.msg_runner.scheduler self.state_manager = self.msg_runner.state_manager self.my_cell_state = self.state_manager.get_my_state() self.ctxt = context.RequestContext("fake", "fake") instance_uuids = [] for x in xrange(3): instance_uuids.append(uuidutils.generate_uuid()) self.instance_uuids = instance_uuids self.instances = [objects.Instance(uuid=uuid, id=id) for id, uuid in enumerate(instance_uuids)] self.request_spec = { "num_instances": len(instance_uuids), "instance_properties": self.instances[0], "instance_type": "fake_type", "image": "fake_image", } self.build_inst_kwargs = { "instances": self.instances, "image": "fake_image", "filter_properties": {"instance_type": "fake_type"}, "security_groups": "fake_sec_groups", "block_device_mapping": "fake_bdm", }
def _login(self): """Logs in and sets the session object in the db.""" self._session = uuidutils.generate_uuid() session = DataObject() session.key = self._session _db_content['session'][self._session] = session return session
def __init__(self, msg_runner, ctxt, method_name, method_kwargs, direction, need_response=False, fanout=False, uuid=None, routing_path=None, hop_count=0, max_hop_count=None, **kwargs): self.ctxt = ctxt self.resp_queue = None self.msg_runner = msg_runner self.state_manager = msg_runner.state_manager # Copy these. self.base_attrs_to_json = self.base_attrs_to_json[:] # Normally this would just be CONF.cells.name, but going through # the msg_runner allows us to stub it more easily. self.our_path_part = self.msg_runner.our_name self.uuid = uuid if self.uuid is None: self.uuid = uuidutils.generate_uuid() self.method_name = method_name self.method_kwargs = method_kwargs self.direction = direction self.need_response = need_response self.fanout = fanout self.routing_path = routing_path self.hop_count = hop_count if max_hop_count is None: max_hop_count = CONF.cells.max_hop_count self.max_hop_count = max_hop_count self.is_broadcast = False self._append_hop() # Each sub-class should set this when the message is inited self.next_hops = [] self.resp_queue = None
def test_macs_for_instance_http_not_found(self): with mock.patch.object(FAKE_CLIENT.node, 'get') as mock_get: mock_get.side_effect = ironic_exception.NotFound() instance = fake_instance.fake_instance_obj( self.ctx, node=uuidutils.generate_uuid()) result = self.driver.macs_for_instance(instance) self.assertEqual([], result)
def setUp(self): super(ResetStateTestsV21, self).setUp() self.uuid = uuidutils.generate_uuid() self.admin_api = self.admin_act.AdminActionsController() self.compute_api = self.admin_api.compute_api self.request = self._get_request() self.context = self.request.environ['nova.context']
def setUp(self): super(AdminActionsTest, self).setUp() self.stubs.Set(compute_api.API, 'get', fake_compute_api_get) self.UUID = uuidutils.generate_uuid() self.app = fakes.wsgi_app_v3(init_only=('servers', 'os-admin-actions')) for _method in self._methods: self.stubs.Set(compute_api.API, _method, fake_compute_api)
def _test_rebuild( self, mock_save, mock_get, mock_driver_fields, mock_fg_bid, mock_set_pstate, mock_looping, mock_wait_active, preserve=False, ): node_uuid = uuidutils.generate_uuid() instance_uuid = uuidutils.generate_uuid() node = ironic_utils.get_test_node(uuid=node_uuid, instance_uuid=instance_uuid, instance_type_id=5) mock_get.return_value = node image_meta = ironic_utils.get_test_image_meta() flavor_id = 5 flavor = {"id": flavor_id, "name": "baremetal"} mock_fg_bid.return_value = flavor instance = fake_instance.fake_instance_obj( self.ctx, uuid=instance_uuid, node=node_uuid, instance_type_id=flavor_id ) fake_looping_call = FakeLoopingCall() mock_looping.return_value = fake_looping_call self.driver.rebuild( context=self.ctx, instance=instance, image_meta=image_meta, injected_files=None, admin_password=None, bdms=None, detach_block_devices=None, attach_block_devices=None, preserve_ephemeral=preserve, ) mock_save.assert_called_once_with(expected_task_state=[task_states.REBUILDING]) mock_driver_fields.assert_called_once_with(node, instance, image_meta, flavor, preserve) mock_set_pstate.assert_called_once_with(node_uuid, ironic_states.REBUILD) mock_looping.assert_called_once_with(mock_wait_active, FAKE_CLIENT_WRAPPER, instance) fake_looping_call.start.assert_called_once_with(interval=CONF.ironic.api_retry_interval) fake_looping_call.wait.assert_called_once()
def test_validate_instance_and_node_failed(self, mock_gbiui): icli = cw.IronicClientWrapper() mock_gbiui.side_effect = ironic_exception.NotFound() instance_uuid = uuidutils.generate_uuid(), instance = fake_instance.fake_instance_obj(self.ctx, uuid=instance_uuid) self.assertRaises(exception.InstanceNotFound, ironic_driver.validate_instance_and_node, icli, instance)
def test_get_available_nodes(self, mock_list): node_dicts = [ # a node in maintenance /w no instance and power OFF {"uuid": uuidutils.generate_uuid(), "maintenance": True, "power_state": ironic_states.POWER_OFF}, # a node /w instance and power ON { "uuid": uuidutils.generate_uuid(), "instance_uuid": uuidutils.generate_uuid(), "power_state": ironic_states.POWER_ON, }, # a node not in maintenance /w no instance and bad power state {"uuid": uuidutils.generate_uuid(), "power_state": ironic_states.ERROR}, ] nodes = [ironic_utils.get_test_node(**n) for n in node_dicts] mock_list.return_value = nodes available_nodes = self.driver.get_available_nodes() expected_uuids = [n["uuid"] for n in node_dicts] self.assertEqual(sorted(expected_uuids), sorted(available_nodes))
def setUp(self): super(ResetStateTestsV21, self).setUp() self.uuid = uuidutils.generate_uuid() self.admin_api = self.admin_act.AdminActionsController() self.compute_api = self.admin_api.compute_api url = "%s/%s/action" % (self.fake_url, self.uuid) self.request = self._get_request(url) self.context = self.request.environ["nova.context"]
def _stub_instance_get(self, uuid=None): if uuid is None: uuid = uuidutils.generate_uuid() instance = fake_instance.fake_db_instance( id=1, uuid=uuid, vm_state=vm_states.ACTIVE, task_state=None, launched_at=timeutils.utcnow() ) instance = objects.Instance._from_db_object(self.context, objects.Instance(), instance) self.compute_api.get(self.context, uuid, want_objects=True).AndReturn(instance) return instance
def _stub_instance_get(self, uuid=None): if uuid is None: uuid = uuidutils.generate_uuid() instance = fake_instance.fake_instance_obj(self.context, id=1, uuid=uuid, vm_state=vm_states.ACTIVE, task_state=None, launched_at=timeutils.utcnow()) self.compute_api.get(self.context, uuid, expected_attrs=None, want_objects=True).AndReturn(instance) return instance
def _stub_instance_get_failure(self, exc_info, uuid=None, objects=True): if uuid is None: uuid = uuidutils.generate_uuid() if objects: self.compute_api.get(self.context, uuid, want_objects=True).AndRaise(exc_info) else: self.compute_api.get(self.context, uuid).AndRaise(exc_info) return uuid
def _stub_instance_get(self, uuid=None): self.mox.StubOutWithMock(compute_api.API, "get") if uuid is None: uuid = uuidutils.generate_uuid() instance = fake_instance.fake_db_instance(id=1, uuid=uuid, vm_state=vm_states.ACTIVE, task_state=None) instance = objects.Instance._from_db_object(self.context, objects.Instance(), instance) self.compute_api.get(self.context, uuid, want_objects=True).AndReturn(instance) return instance
def create(self, req, body): context = req.environ['nova.context'] server_dict = body['app'] name = server_dict['name'] self._validate_server_name(name) name = name.strip() if server_dict.get('uuid') != None: uuid = server_dict['uuid'] app = dict(); app['uuid'] = uuid; app['display_name'] = name; self.compute_api.failover_app (context, app=app) appR = self._view_builder.create(req, app); robj = wsgi.ResponseObject(appR); return robj; else: uuid = ''; network_bandwidth = server_dict.get('network_bandwidth'); memory_mb = server_dict.get('memory_mb'); disk_gb = server_dict.get('disk_gb'); ports = server_dict.get('ports'); for port in ports: LOG.info(_(port)); if network_bandwidth == None: LOG.info(_("None bandwidth")); if memory_mb == None: LOG.info(_("None memory")); if disk_gb == None: LOG.info(_("None disk")); app = dict(); app['network_bandwidth'] = network_bandwidth; app['memory_mb'] = memory_mb; app['disk_gb'] = disk_gb; app['uuid'] = uuidutils.generate_uuid(); app['display_name'] = name; app['ports'] = ports; self.compute_api.create_app (context, app=app, network_bandwidth=network_bandwidth, memory_mb=memory_mb, disk_gb=disk_gb); appR = self._view_builder.create(req, app); robj = wsgi.ResponseObject(appR); return robj;
def generate_request_id(): return 'req-%s' % uuidutils.generate_uuid()
def test_swap_volume_volume_api_usage(self): # This test ensures that volume_id arguments are passed to volume_api # and that volumes return to previous states in case of error. def fake_vol_api_begin_detaching(context, volume_id): self.assertTrue(uuidutils.is_uuid_like(volume_id)) volumes[volume_id]['status'] = 'detaching' def fake_vol_api_roll_detaching(context, volume_id): self.assertTrue(uuidutils.is_uuid_like(volume_id)) if volumes[volume_id]['status'] == 'detaching': volumes[volume_id]['status'] = 'in-use' def fake_vol_api_reserve(context, volume_id): self.assertTrue(uuidutils.is_uuid_like(volume_id)) self.assertTrue(volumes[volume_id]['status'], 'available') volumes[volume_id]['status'] = 'attaching' def fake_vol_api_unreserve(context, volume_id): self.assertTrue(uuidutils.is_uuid_like(volume_id)) if volumes[volume_id]['status'] == 'attaching': volumes[volume_id]['status'] = 'available' def fake_swap_volume_exc(context, instance, old_volume_id, new_volume_id): raise AttributeError # Random exception # Should fail if VM state is not valid instance = {'vm_state': vm_states.BUILDING, 'launched_at': timeutils.utcnow(), 'locked': False, 'availability_zone': 'fake_az', 'uuid': 'fake'} volumes = {} old_volume_id = uuidutils.generate_uuid() volumes[old_volume_id] = {'id': old_volume_id, 'display_name': 'old_volume', 'attach_status': 'attached', 'instance_uuid': 'fake', 'size': 5, 'status': 'in-use'} new_volume_id = uuidutils.generate_uuid() volumes[new_volume_id] = {'id': new_volume_id, 'display_name': 'new_volume', 'attach_status': 'detached', 'instance_uuid': None, 'size': 5, 'status': 'available'} self.assertRaises(exception.InstanceInvalidState, self.compute_api.swap_volume, self.context, instance, volumes[old_volume_id], volumes[new_volume_id]) instance['vm_state'] = vm_states.ACTIVE # Should fail if old volume is not attached volumes[old_volume_id]['attach_status'] = 'detached' self.assertRaises(exception.InvalidVolume, self.compute_api.swap_volume, self.context, instance, volumes[old_volume_id], volumes[new_volume_id]) self.assertEquals(volumes[old_volume_id]['status'], 'in-use') self.assertEquals(volumes[new_volume_id]['status'], 'available') volumes[old_volume_id]['attach_status'] = 'attached' # Should fail if old volume's instance_uuid is not that of the instance volumes[old_volume_id]['instance_uuid'] = 'fake2' self.assertRaises(exception.VolumeUnattached, self.compute_api.swap_volume, self.context, instance, volumes[old_volume_id], volumes[new_volume_id]) self.assertEquals(volumes[old_volume_id]['status'], 'in-use') self.assertEquals(volumes[new_volume_id]['status'], 'available') volumes[old_volume_id]['instance_uuid'] = 'fake' # Should fail if new volume is attached volumes[new_volume_id]['attach_status'] = 'attached' self.assertRaises(exception.InvalidVolume, self.compute_api.swap_volume, self.context, instance, volumes[old_volume_id], volumes[new_volume_id]) self.assertEquals(volumes[old_volume_id]['status'], 'in-use') self.assertEquals(volumes[new_volume_id]['status'], 'available') volumes[new_volume_id]['attach_status'] = 'detached' # Should fail if new volume is smaller than the old volume volumes[new_volume_id]['size'] = 4 self.assertRaises(exception.InvalidVolume, self.compute_api.swap_volume, self.context, instance, volumes[old_volume_id], volumes[new_volume_id]) self.assertEquals(volumes[old_volume_id]['status'], 'in-use') self.assertEquals(volumes[new_volume_id]['status'], 'available') volumes[new_volume_id]['size'] = 5 # Fail call to swap_volume self.stubs.Set(self.compute_api.volume_api, 'begin_detaching', fake_vol_api_begin_detaching) self.stubs.Set(self.compute_api.volume_api, 'roll_detaching', fake_vol_api_roll_detaching) self.stubs.Set(self.compute_api.volume_api, 'reserve_volume', fake_vol_api_reserve) self.stubs.Set(self.compute_api.volume_api, 'unreserve_volume', fake_vol_api_unreserve) self.stubs.Set(self.compute_api.compute_rpcapi, 'swap_volume', fake_swap_volume_exc) self.assertRaises(AttributeError, self.compute_api.swap_volume, self.context, instance, volumes[old_volume_id], volumes[new_volume_id]) self.assertEquals(volumes[old_volume_id]['status'], 'in-use') self.assertEquals(volumes[new_volume_id]['status'], 'available') # Should succeed self.stubs.Set(self.compute_api.compute_rpcapi, 'swap_volume', lambda c, instance, old_volume_id, new_volume_id: True) self.compute_api.swap_volume(self.context, instance, volumes[old_volume_id], volumes[new_volume_id])
def test_swap_volume_volume_api_usage(self): # This test ensures that volume_id arguments are passed to volume_api # and that volume states are OK volumes = {} old_volume_id = uuidutils.generate_uuid() volumes[old_volume_id] = { 'id': old_volume_id, 'display_name': 'old_volume', 'status': 'detaching' } new_volume_id = uuidutils.generate_uuid() volumes[new_volume_id] = { 'id': new_volume_id, 'display_name': 'new_volume', 'status': 'attaching' } def fake_vol_api_func(context, volume, *args): self.assertTrue(uuidutils.is_uuid_like(volume)) return {} def fake_vol_get(context, volume_id): self.assertTrue(uuidutils.is_uuid_like(volume_id)) return volumes[volume_id] def fake_vol_attach(context, volume_id, instance_uuid, connector): self.assertTrue(uuidutils.is_uuid_like(volume_id)) self.assertIn(volumes[volume_id]['status'], ['available', 'attaching']) volumes[volume_id]['status'] = 'in-use' def fake_vol_unreserve(context, volume_id): self.assertTrue(uuidutils.is_uuid_like(volume_id)) if volumes[volume_id]['status'] == 'attaching': volumes[volume_id]['status'] = 'available' def fake_vol_detach(context, volume_id): self.assertTrue(uuidutils.is_uuid_like(volume_id)) volumes[volume_id]['status'] = 'available' def fake_vol_migrate_volume_completion(context, old_volume_id, new_volume_id, error=False): self.assertTrue(uuidutils.is_uuid_like(old_volume_id)) self.assertTrue(uuidutils.is_uuid_like(old_volume_id)) return {'save_volume_id': new_volume_id} def fake_func_exc(*args, **kwargs): raise AttributeError # Random exception self.stubs.Set(self.compute.volume_api, 'get', fake_vol_get) self.stubs.Set(self.compute.volume_api, 'initialize_connection', fake_vol_api_func) self.stubs.Set(self.compute.volume_api, 'attach', fake_vol_attach) self.stubs.Set(self.compute.volume_api, 'unreserve_volume', fake_vol_unreserve) self.stubs.Set(self.compute.volume_api, 'terminate_connection', fake_vol_api_func) self.stubs.Set(self.compute.volume_api, 'detach', fake_vol_detach) self.stubs.Set( self.compute, '_get_instance_volume_bdm', lambda x, y, z: { 'device_name': '/dev/vdb', 'connection_info': '{"foo": "bar"}' }) self.stubs.Set(self.compute.driver, 'get_volume_connector', lambda x: {}) self.stubs.Set(self.compute.driver, 'swap_volume', lambda w, x, y, z: None) self.stubs.Set(self.compute.volume_api, 'migrate_volume_completion', fake_vol_migrate_volume_completion) self.stubs.Set(self.compute.conductor_api, 'block_device_mapping_update_or_create', lambda x, y: None) self.stubs.Set(self.compute.conductor_api, 'instance_fault_create', lambda x, y: None) # Good path self.compute.swap_volume(self.context, old_volume_id, new_volume_id, {'uuid': 'fake'}) self.assertEqual(volumes[old_volume_id]['status'], 'available') self.assertEqual(volumes[new_volume_id]['status'], 'in-use') # Error paths volumes[old_volume_id]['status'] = 'detaching' volumes[new_volume_id]['status'] = 'attaching' self.stubs.Set(self.compute.driver, 'swap_volume', fake_func_exc) self.assertRaises(AttributeError, self.compute.swap_volume, self.context, old_volume_id, new_volume_id, {'uuid': 'fake'}) self.assertEqual(volumes[old_volume_id]['status'], 'detaching') self.assertEqual(volumes[new_volume_id]['status'], 'attaching') volumes[old_volume_id]['status'] = 'detaching' volumes[new_volume_id]['status'] = 'attaching' self.stubs.Set(self.compute.volume_api, 'initialize_connection', fake_func_exc) self.assertRaises(AttributeError, self.compute.swap_volume, self.context, old_volume_id, new_volume_id, {'uuid': 'fake'}) self.assertEqual(volumes[old_volume_id]['status'], 'detaching') self.assertEqual(volumes[new_volume_id]['status'], 'available')
def _stub_instance_get_failure(self, exc_info, uuid=None): if uuid is None: uuid = uuidutils.generate_uuid() self.compute_api.get(self.context, uuid, expected_attrs=None, want_objects=True).AndRaise(exc_info) return uuid
def _make_url(self, uuid=None): if uuid is None: uuid = uuidutils.generate_uuid() return '/servers/%s/action' % uuid
def _generate_key_id(self): key_id = uuidutils.generate_uuid() while key_id in self.keys: key_id = uuidutils.generate_uuid() return key_id
def test_migrate_live_unable_to_migrate_to_self(self): uuid = uuidutils.generate_uuid() self._test_migrate_live_failed_with_exception( exception.UnableToMigrateToSelf(instance_id=uuid, host='host'), uuid=uuid)