def test_shelved_poll_timedout(self): active_instance = jsonutils.to_primitive(self._create_fake_instance()) self.compute.run_instance(self.context, active_instance, {}, {}, [], None, None, True, None, False) instance = jsonutils.to_primitive(self._create_fake_instance()) self.compute.run_instance(self.context, instance, {}, {}, [], None, None, True, None, False) sys_meta = utils.metadata_to_dict(instance['system_metadata']) shelved_time = timeutils.utcnow() timeutils.set_time_override(shelved_time) timeutils.advance_time_seconds(CONF.shelved_offload_time + 1) sys_meta['shelved_at'] = timeutils.strtime(at=shelved_time) (old, instance) = db.instance_update_and_get_original( self.context, instance['uuid'], { 'vm_state': vm_states.SHELVED, 'system_metadata': sys_meta }) def fake_destroy(inst, nw_info, bdm): # NOTE(alaski) There are too many differences between an instance # as returned by instance_update_and_get_original and # instance_get_all_by_filters so just compare the uuid. self.assertEqual(instance['uuid'], inst['uuid']) self.stubs.Set(self.compute.driver, 'destroy', fake_destroy) self.compute._poll_shelved_instances(self.context)
def _force_reclaim(self): # Make sure that compute manager thinks the instance is # old enough to be expired the_past = timeutils.utcnow() + datetime.timedelta(hours=1) timeutils.set_time_override(override_time=the_past) ctxt = context.get_admin_context() self.compute._reclaim_queued_deletes(ctxt)
def test_shelved_poll_timedout(self): active_instance = jsonutils.to_primitive(self._create_fake_instance()) self.compute.run_instance(self.context, active_instance, {}, {}, [], None, None, True, None, False) instance = jsonutils.to_primitive(self._create_fake_instance()) self.compute.run_instance(self.context, instance, {}, {}, [], None, None, True, None, False) sys_meta = utils.metadata_to_dict(instance['system_metadata']) shelved_time = timeutils.utcnow() timeutils.set_time_override(shelved_time) timeutils.advance_time_seconds(CONF.shelved_offload_time + 1) sys_meta['shelved_at'] = timeutils.strtime(at=shelved_time) (old, instance) = db.instance_update_and_get_original(self.context, instance['uuid'], {'vm_state': vm_states.SHELVED, 'system_metadata': sys_meta}) def fake_destroy(inst, nw_info, bdm): # NOTE(alaski) There are too many differences between an instance # as returned by instance_update_and_get_original and # instance_get_all_by_filters so just compare the uuid. self.assertEqual(instance['uuid'], inst['uuid']) self.stubs.Set(self.compute.driver, 'destroy', fake_destroy) self.compute._poll_shelved_instances(self.context)
def test_pack_action_finish(self): timeutils.set_time_override(override_time=NOW) values = instance_action.InstanceAction.pack_action_finish( self.context, 'fake-uuid') self.assertEqual(values['request_id'], self.context.request_id) self.assertEqual(values['instance_uuid'], 'fake-uuid') self.assertEqual(values['finish_time'].replace(tzinfo=None), NOW)
def test_trusted_filter_update_cache(self, req_mock): oat_data = { "hosts": [{ "host_name": "node1", "trust_lvl": "untrusted", "vtime": timeutils.isotime() }] } req_mock.return_value = requests.codes.OK, oat_data extra_specs = {'trust:trusted_host': 'untrusted'} filter_properties = { 'context': mock.sentinel.ctx, 'instance_type': { 'memory_mb': 1024, 'extra_specs': extra_specs } } host = fakes.FakeHostState('host1', 'node1', {}) self.filt_cls.host_passes(host, filter_properties) # Fill the caches req_mock.reset_mock() self.filt_cls.host_passes(host, filter_properties) self.assertFalse(req_mock.called) req_mock.reset_mock() timeutils.set_time_override(timeutils.utcnow()) timeutils.advance_time_seconds( CONF.trusted_computing.attestation_auth_timeout + 80) self.filt_cls.host_passes(host, filter_properties) self.assertTrue(req_mock.called) timeutils.clear_time_override()
def test_unshelve_volume_backed(self): db_instance = jsonutils.to_primitive(self._create_fake_instance()) host = 'fake-mini' cur_time = timeutils.utcnow() cur_time_tz = cur_time.replace(tzinfo=iso8601.iso8601.Utc()) timeutils.set_time_override(cur_time) self.compute.run_instance(self.context, instance=db_instance) instance = instance_obj.Instance.get_by_uuid( self.context, db_instance['uuid'], expected_attrs=['metadata', 'system_metadata']) instance.task_state = task_states.UNSHELVING instance.save() sys_meta = dict(instance.system_metadata) sys_meta['shelved_at'] = timeutils.strtime(at=cur_time) sys_meta['shelved_image_id'] = None sys_meta['shelved_host'] = host self.mox.StubOutWithMock(self.compute, '_notify_about_instance_usage') self.mox.StubOutWithMock(self.compute, '_prep_block_device') self.mox.StubOutWithMock(self.compute.driver, 'spawn') self.mox.StubOutWithMock(self.compute, '_get_power_state') self.mox.StubOutWithMock(db, 'instance_update_and_get_original') self.compute._notify_about_instance_usage(self.context, instance, 'unshelve.start') db.instance_update_and_get_original(self.context, instance['uuid'], {'task_state': task_states.SPAWNING}, update_cells=False, columns_to_join=['metadata', 'system_metadata'] ).AndReturn((db_instance, db_instance)) self.compute._prep_block_device(self.context, instance, []).AndReturn('fake_bdm') db_instance['key_data'] = None db_instance['auto_disk_config'] = None self.compute.driver.spawn(self.context, instance, None, injected_files=[], admin_password=None, network_info=[], block_device_info='fake_bdm') self.compute._get_power_state(self.context, instance).AndReturn(123) db.instance_update_and_get_original(self.context, instance['uuid'], {'power_state': 123, 'vm_state': vm_states.ACTIVE, 'task_state': None, 'key_data': None, 'auto_disk_config': False, 'expected_task_state': task_states.SPAWNING, 'launched_at': cur_time_tz}, update_cells=False, columns_to_join=['metadata', 'system_metadata'] ).AndReturn((db_instance, db_instance)) self.compute._notify_about_instance_usage(self.context, instance, 'unshelve.end') self.mox.ReplayAll() self.compute.unshelve_instance(self.context, instance, image=None) self.mox.VerifyAll() self.mox.UnsetStubs() self.compute.terminate_instance(self.context, instance=instance)
def test_log_progress_if_not_required(self): self.mox.StubOutWithMock(vm_utils.LOG, "debug") current = timeutils.utcnow() timeutils.set_time_override(current) timeutils.advance_time_seconds(vm_utils.PROGRESS_INTERVAL_SECONDS - 1) self.mox.ReplayAll() vm_utils._log_progress_if_required(1, current, 2)
def test_periodic_tasks_idle_calculation(self): fake_time = datetime.datetime(3000, 1, 1) timeutils.set_time_override(fake_time) class Manager(manager.Manager): @manager.periodic_task(spacing=10) def bar(self, context): return 'bar' m = Manager() # Ensure initial values are correct self.assertEqual(1, len(m._periodic_tasks)) task_name, task = m._periodic_tasks[0] # Test task values self.assertEqual('bar', task_name) self.assertEqual(10, task._periodic_spacing) self.assertEqual(True, task._periodic_enabled) self.assertEqual(False, task._periodic_external_ok) self.assertEqual(False, task._periodic_immediate) self.assertNotEqual(None, task._periodic_last_run) # Test the manager's representation of those values self.assertEqual(10, m._periodic_spacing[task_name]) self.assertNotEqual(None, m._periodic_last_run[task_name]) timeutils.advance_time_delta(datetime.timedelta(seconds=5)) m.periodic_tasks(None) timeutils.advance_time_delta(datetime.timedelta(seconds=5)) idle = m.periodic_tasks(None) self.assertAlmostEqual(10, idle, 1)
def test_finish(self, mock_start, mock_finish): timeutils.set_time_override(override_time=NOW) expected_packed_action_start = { 'request_id': self.context.request_id, 'user_id': self.context.user_id, 'project_id': self.context.project_id, 'instance_uuid': 'fake-uuid', 'action': 'fake-action', 'start_time': self.context.timestamp, } expected_packed_action_finish = { 'request_id': self.context.request_id, 'instance_uuid': 'fake-uuid', 'finish_time': NOW, } mock_start.return_value = fake_action mock_finish.return_value = fake_action action = instance_action.InstanceAction.action_start( self.context, 'fake-uuid', 'fake-action') action.finish(self.context) mock_start.assert_called_once_with(self.context, expected_packed_action_start) mock_finish.assert_called_once_with(self.context, expected_packed_action_finish) self.compare_obj(action, fake_action)
def test_trusted_filter_update_cache_timezone(self, req_mock): oat_data = {"hosts": [{"host_name": "node1", "trust_lvl": "untrusted", "vtime": "2012-09-09T05:10:40-04:00"}]} req_mock.return_value = requests.codes.OK, oat_data extra_specs = {'trust:trusted_host': 'untrusted'} filter_properties = {'context': mock.sentinel.ctx, 'instance_type': {'memory_mb': 1024, 'extra_specs': extra_specs}} host = fakes.FakeHostState('host1', 'node1', {}) timeutils.set_time_override( timeutils.normalize_time( timeutils.parse_isotime("2012-09-09T09:10:40Z"))) self.filt_cls.host_passes(host, filter_properties) # Fill the caches req_mock.reset_mock() self.filt_cls.host_passes(host, filter_properties) self.assertFalse(req_mock.called) req_mock.reset_mock() timeutils.advance_time_seconds( CONF.trusted_computing.attestation_auth_timeout - 10) self.filt_cls.host_passes(host, filter_properties) self.assertFalse(req_mock.called) timeutils.clear_time_override()
def test_show(self): url = '/v3/servers/%s' % UUID3 res = self._make_request(url) self.assertEqual(res.status_int, 200) now = timeutils.utcnow() timeutils.set_time_override(now) self.assertServerUsage( self._get_server(res.body), launched_at=DATE1, terminated_at=DATE2)
def test_shelve_volume_backed(self): db_instance = jsonutils.to_primitive(self._create_fake_instance()) self.compute.run_instance(self.context, instance=db_instance) instance = instance_obj.Instance.get_by_uuid( self.context, db_instance['uuid'], expected_attrs=['metadata', 'system_metadata']) instance.task_state = task_states.SHELVING instance.save() host = 'fake-mini' cur_time = timeutils.utcnow() timeutils.set_time_override(cur_time) sys_meta = dict(instance.system_metadata) sys_meta['shelved_at'] = timeutils.strtime(at=cur_time) sys_meta['shelved_image_id'] = None sys_meta['shelved_host'] = host db_instance['system_metadata'] = utils.dict_to_metadata(sys_meta) self.mox.StubOutWithMock(self.compute, '_notify_about_instance_usage') self.mox.StubOutWithMock(self.compute.driver, 'power_off') self.mox.StubOutWithMock(self.compute, '_get_power_state') self.mox.StubOutWithMock(db, 'instance_update_and_get_original') self.compute._notify_about_instance_usage(self.context, instance, 'shelve_offload.start') self.compute.driver.power_off(instance) self.compute._get_power_state(self.context, instance).AndReturn(123) db.instance_update_and_get_original( self.context, instance['uuid'], { 'power_state': 123, 'host': None, 'node': None, 'vm_state': vm_states.SHELVED_OFFLOADED, 'task_state': None, 'expected_task_state': [task_states.SHELVING, task_states.SHELVING_OFFLOADING] }, update_cells=False, columns_to_join=['metadata', 'system_metadata'], ).AndReturn((db_instance, db_instance)) self.compute._notify_about_instance_usage(self.context, instance, 'shelve_offload.end') self.mox.ReplayAll() self.compute.shelve_offload_instance(self.context, instance) self.mox.VerifyAll() self.mox.UnsetStubs() self.compute.terminate_instance(self.context, instance=instance)
def test_action_finish_no_result(self): timeutils.set_time_override() self.mox.StubOutWithMock(db, 'action_finish') db.action_finish(self.context, compute_utils.pack_action_finish( self.context, 'fake-uuid')).AndReturn(fake_action) self.mox.ReplayAll() action = instance_action.InstanceAction.action_finish( self.context, 'fake-uuid', want_result=False) self.assertEqual(None, action)
def test_bw_usage_calls(self): ctxt = context.get_admin_context() now = timeutils.utcnow() timeutils.set_time_override(now) start_period = now - datetime.timedelta(seconds=10) uuid3_refreshed = now - datetime.timedelta(seconds=5) expected_bw_usages = [ { "uuid": "fake_uuid1", "mac": "fake_mac1", "start_period": start_period, "bw_in": 100, "bw_out": 200, "last_refreshed": now, }, { "uuid": "fake_uuid2", "mac": "fake_mac2", "start_period": start_period, "bw_in": 200, "bw_out": 300, "last_refreshed": now, }, { "uuid": "fake_uuid3", "mac": "fake_mac3", "start_period": start_period, "bw_in": 400, "bw_out": 500, "last_refreshed": uuid3_refreshed, }, ] def _compare(bw_usage, expected): for key, value in expected.items(): self.assertEqual(bw_usage[key], value) bw_usages = db.bw_usage_get_by_uuids(ctxt, ["fake_uuid1", "fake_uuid2"], start_period) # No matches self.assertEqual(len(bw_usages), 0) # Add 3 entries db.bw_usage_update(ctxt, "fake_uuid1", "fake_mac1", start_period, 100, 200) db.bw_usage_update(ctxt, "fake_uuid2", "fake_mac2", start_period, 100, 200) # Test explicit refreshed time db.bw_usage_update(ctxt, "fake_uuid3", "fake_mac3", start_period, 400, 500, last_refreshed=uuid3_refreshed) # Update 2nd entry db.bw_usage_update(ctxt, "fake_uuid2", "fake_mac2", start_period, 200, 300) bw_usages = db.bw_usage_get_by_uuids(ctxt, ["fake_uuid1", "fake_uuid2", "fake_uuid3"], start_period) self.assertEqual(len(bw_usages), 3) _compare(bw_usages[0], expected_bw_usages[0]) _compare(bw_usages[1], expected_bw_usages[1]) _compare(bw_usages[2], expected_bw_usages[2]) timeutils.clear_time_override()
def test_action_finish(self): timeutils.set_time_override() ctxt = context.get_admin_context() self.mox.StubOutWithMock(db, 'action_finish') db.action_finish(ctxt, compute_utils.pack_action_finish( ctxt, 'fake-uuid')).AndReturn(fake_action) self.mox.ReplayAll() action = instance_action.InstanceAction.action_finish( ctxt, 'fake-uuid', want_result=True) self.assertEqual(fake_action['id'], action.id)
def test_event_start(self, mock_start): timeutils.set_time_override(override_time=NOW) expected_packed_values = compute_utils.pack_action_event_start( self.context, 'fake-uuid', 'fake-event') mock_start.return_value = fake_event event = instance_action.InstanceActionEvent.event_start( self.context, 'fake-uuid', 'fake-event', want_result=True) mock_start.assert_called_once_with(self.context, expected_packed_values) self.compare_obj(event, fake_event)
def test_event_finish_no_result(self, mock_finish): timeutils.set_time_override(override_time=NOW) expected_packed_values = compute_utils.pack_action_event_finish( self.context, 'fake-uuid', 'fake-event') mock_finish.return_value = fake_event event = instance_action.InstanceActionEvent.event_finish( self.context, 'fake-uuid', 'fake-event', want_result=False) mock_finish.assert_called_once_with(self.context, expected_packed_values) self.assertIsNone(event)
def test_action_finish(self, mock_finish): timeutils.set_time_override(override_time=NOW) expected_packed_values = compute_utils.pack_action_finish( self.context, 'fake-uuid') mock_finish.return_value = fake_action action = instance_action.InstanceAction.action_finish( self.context, 'fake-uuid', want_result=True) mock_finish.assert_called_once_with(self.context, expected_packed_values) self.compare_obj(action, fake_action)
def setUp(self): super(InstanceUsageAuditLogTest, self).setUp() self.context = context.get_admin_context() timeutils.set_time_override(datetime.datetime(2012, 7, 5, 10, 0, 0)) self.controller = ial.InstanceUsageAuditLogController() self.stubs.Set(utils, 'last_completed_audit_period', fake_last_completed_audit_period) self.stubs.Set(db, 'service_get_all', fake_service_get_all) self.stubs.Set(db, 'task_log_get_all', fake_task_log_get_all)
def setUp(self): super(AuditPeriodTest, self).setUp() #a fairly random time to test with self.test_time = datetime.datetime(second=23, minute=12, hour=8, day=5, month=3, year=2012) timeutils.set_time_override(override_time=self.test_time)
def test_action_finish_no_result(self, mock_finish): timeutils.set_time_override(override_time=NOW) expected_packed_values = compute_utils.pack_action_finish( self.context, 'fake-uuid') mock_finish.return_value = fake_action action = instance_action.InstanceAction.action_finish( self.context, 'fake-uuid', want_result=False) mock_finish.assert_called_once_with(self.context, expected_packed_values) self.assertIsNone(action)
def test_show(self): url = self._prefix + ('/servers/%s' % UUID3) res = self._make_request(url) self.assertEqual(res.status_int, 200) now = timeutils.utcnow() timeutils.set_time_override(now) self.assertServerUsage(self._get_server(res.body), launched_at=DATE1, terminated_at=DATE2)
def setUp(self): """setUp method for simple tenant usage""" super(SimpleTenantUsageSampleJsonTest, self).setUp() self._post_server() timeutils.set_time_override(timeutils.utcnow() + datetime.timedelta(hours=1)) self.query = { 'start': str(timeutils.utcnow() - datetime.timedelta(hours=1)), 'end': str(timeutils.utcnow()) }
def test_shelve(self): CONF.shelved_offload_time = -1 db_instance = jsonutils.to_primitive(self._create_fake_instance()) self.compute.run_instance(self.context, instance=db_instance) instance = instance_obj.Instance.get_by_uuid( self.context, db_instance['uuid'], expected_attrs=['metadata', 'system_metadata']) image_id = 'fake_image_id' host = 'fake-mini' cur_time = timeutils.utcnow() timeutils.set_time_override(cur_time) instance.task_state = task_states.SHELVING instance.save() sys_meta = dict(instance.system_metadata) sys_meta['shelved_at'] = timeutils.strtime(at=cur_time) sys_meta['shelved_image_id'] = image_id sys_meta['shelved_host'] = host db_instance['system_metadata'] = utils.dict_to_metadata(sys_meta) self.mox.StubOutWithMock(self.compute, '_notify_about_instance_usage') self.mox.StubOutWithMock(self.compute.driver, 'snapshot') self.mox.StubOutWithMock(self.compute.driver, 'power_off') self.mox.StubOutWithMock(self.compute, '_get_power_state') self.mox.StubOutWithMock(db, 'instance_update_and_get_original') self.compute._notify_about_instance_usage(self.context, instance, 'shelve.start') self.compute.driver.power_off(instance) self.compute._get_power_state(self.context, instance).AndReturn(123) self.compute.driver.snapshot(self.context, instance, 'fake_image_id', mox.IgnoreArg()) db.instance_update_and_get_original(self.context, instance['uuid'], {'power_state': 123, 'vm_state': vm_states.SHELVED, 'task_state': None, 'expected_task_state': [task_states.SHELVING, task_states.SHELVING_IMAGE_UPLOADING], 'system_metadata': sys_meta}, update_cells=False, columns_to_join=['metadata', 'system_metadata'], ).AndReturn((db_instance, db_instance)) self.compute._notify_about_instance_usage(self.context, instance, 'shelve.end') self.mox.ReplayAll() self.compute.shelve_instance(self.context, instance, image_id=image_id) self.mox.VerifyAll() self.mox.UnsetStubs() self.compute.terminate_instance(self.context, instance=instance)
def test_get_list(self): timeutils.set_time_override() self.mox.StubOutWithMock(db, 'actions_get') actions = [dict(fake_action, id=1234), dict(fake_action, id=5678)] db.actions_get(self.context, 'fake-uuid').AndReturn(actions) self.mox.ReplayAll() action_list = instance_action.InstanceActionList.get_by_instance_uuid( self.context, 'fake-uuid') self.assertEqual(2, len(action_list)) for index, action in enumerate(action_list): self.assertEqual(actions[index]['id'], action.id)
def test_action_finish_no_result(self): timeutils.set_time_override() self.mox.StubOutWithMock(db, 'action_finish') db.action_finish( self.context, compute_utils.pack_action_finish( self.context, 'fake-uuid')).AndReturn(fake_action) self.mox.ReplayAll() action = instance_action.InstanceAction.action_finish( self.context, 'fake-uuid', want_result=False) self.assertEqual(None, action)
def test_age_cached_images(self): def fake_get_ds_browser(ds_ref): return 'fake-ds-browser' def fake_get_timestamp(ds_browser, ds_path): self._get_timestamp_called += 1 path = str(ds_path) if path == '[fake-ds] fake-path/fake-image-1': # No time stamp exists return if path == '[fake-ds] fake-path/fake-image-2': # Timestamp that will be valid => no deletion return 'ts-2012-11-22-10-00-00' if path == '[fake-ds] fake-path/fake-image-3': # Timestamp that will be invalid => deletion return 'ts-2012-11-20-12-00-00' self.fail() def fake_mkdir(session, ts_path, dc_ref): self.assertEqual( '[fake-ds] fake-path/fake-image-1/ts-2012-11-22-12-00-00', str(ts_path)) def fake_file_delete(session, ds_path, dc_ref): self.assertEqual('[fake-ds] fake-path/fake-image-3', str(ds_path)) def fake_timestamp_cleanup(dc_ref, ds_browser, ds_path): self.assertEqual('[fake-ds] fake-path/fake-image-4', str(ds_path)) with contextlib.nested( mock.patch.object(self._imagecache, '_get_ds_browser', fake_get_ds_browser), mock.patch.object(self._imagecache, '_get_timestamp', fake_get_timestamp), mock.patch.object(ds_util, 'mkdir', fake_mkdir), mock.patch.object(ds_util, 'file_delete', fake_file_delete), mock.patch.object(self._imagecache, 'timestamp_cleanup', fake_timestamp_cleanup), ) as (_get_ds_browser, _get_timestamp, _mkdir, _file_delete, _timestamp_cleanup): timeutils.set_time_override(override_time=self._time) datastore = ds_util.Datastore(name='ds', ref='fake-ds-ref') dc_info = vmops.DcInfo(ref='dc_ref', name='name', vmFolder='vmFolder') self._get_timestamp_called = 0 self._imagecache.originals = set([ 'fake-image-1', 'fake-image-2', 'fake-image-3', 'fake-image-4' ]) self._imagecache.used_images = set(['fake-image-4']) self._imagecache._age_cached_images( 'fake-context', datastore, dc_info, ds_util.DatastorePath('fake-ds', 'fake-path')) self.assertEqual(3, self._get_timestamp_called)
def setUp(self): super(MuteWeigherTestClass, self).setUp() self.flags(mute_weight_multiplier=-10.0, mute_child_interval=100, mute_weight_value=1000.0, group='cells') self.now = timeutils.utcnow() timeutils.set_time_override(self.now) self.cells = _get_fake_cells() for cell in self.cells: cell.last_seen = self.now
def test_event_start_no_result(self, mock_start): timeutils.set_time_override(override_time=NOW) test_class = instance_action.InstanceActionEvent expected_packed_values = test_class.pack_action_event_start( self.context, 'fake-uuid', 'fake-event') mock_start.return_value = fake_event event = instance_action.InstanceActionEvent.event_start( self.context, 'fake-uuid', 'fake-event', want_result=False) mock_start.assert_called_once_with(self.context, expected_packed_values) self.assertIsNone(event)
def test_age_cached_images(self): def fake_get_ds_browser(ds_ref): return 'fake-ds-browser' def fake_get_timestamp(ds_browser, ds_path): self._get_timestamp_called += 1 path = str(ds_path) if path == '[fake-ds] fake-path/fake-image-1': # No time stamp exists return if path == '[fake-ds] fake-path/fake-image-2': # Timestamp that will be valid => no deletion return 'ts-2012-11-22-10-00-00' if path == '[fake-ds] fake-path/fake-image-3': # Timestamp that will be invalid => deletion return 'ts-2012-11-20-12-00-00' self.fail() def fake_mkdir(session, ts_path, dc_ref): self.assertEqual( '[fake-ds] fake-path/fake-image-1/ts-2012-11-22-12-00-00', str(ts_path)) def fake_file_delete(session, ds_path, dc_ref): self.assertEqual('[fake-ds] fake-path/fake-image-3', str(ds_path)) def fake_timestamp_cleanup(dc_ref, ds_browser, ds_path): self.assertEqual('[fake-ds] fake-path/fake-image-4', str(ds_path)) with contextlib.nested( mock.patch.object(self._imagecache, '_get_ds_browser', fake_get_ds_browser), mock.patch.object(self._imagecache, '_get_timestamp', fake_get_timestamp), mock.patch.object(ds_util, 'mkdir', fake_mkdir), mock.patch.object(ds_util, 'file_delete', fake_file_delete), mock.patch.object(self._imagecache, 'timestamp_cleanup', fake_timestamp_cleanup), ) as (_get_ds_browser, _get_timestamp, _mkdir, _file_delete, _timestamp_cleanup): timeutils.set_time_override(override_time=self._time) datastore = ds_util.Datastore(name='ds', ref='fake-ds-ref') dc_info = vmops.DcInfo(ref='dc_ref', name='name', vmFolder='vmFolder') self._get_timestamp_called = 0 self._imagecache.originals = set(['fake-image-1', 'fake-image-2', 'fake-image-3', 'fake-image-4']) self._imagecache.used_images = set(['fake-image-4']) self._imagecache._age_cached_images( 'fake-context', datastore, dc_info, ds_util.DatastorePath('fake-ds', 'fake-path')) self.assertEqual(3, self._get_timestamp_called)
def test_log_progress_if_required(self): self.mox.StubOutWithMock(vm_utils.LOG, "debug") vm_utils.LOG.debug(_("Sparse copy in progress, " "%(complete_pct).2f%% complete. " "%(left) bytes left to copy"), {"complete_pct": 50.0, "left": 1}) current = timeutils.utcnow() timeutils.set_time_override(current) timeutils.advance_time_seconds(vm_utils.PROGRESS_INTERVAL_SECONDS + 1) self.mox.ReplayAll() vm_utils._log_progress_if_required(1, current, 2)
def test_action_finish_no_result(self, mock_finish): timeutils.set_time_override(override_time=NOW) test_class = instance_action.InstanceAction expected_packed_values = test_class.pack_action_finish( self.context, 'fake-uuid') mock_finish.return_value = fake_action action = instance_action.InstanceAction.action_finish( self.context, 'fake-uuid', want_result=False) mock_finish.assert_called_once_with(self.context, expected_packed_values) self.assertIsNone(action)
def test_action_finish(self, mock_finish): timeutils.set_time_override(override_time=NOW) test_class = instance_action.InstanceAction expected_packed_values = test_class.pack_action_finish( self.context, 'fake-uuid') mock_finish.return_value = fake_action action = instance_action.InstanceAction.action_finish( self.context, 'fake-uuid', want_result=True) mock_finish.assert_called_once_with(self.context, expected_packed_values) self.compare_obj(action, fake_action)
def test_event_finish(self, mock_finish): timeutils.set_time_override(override_time=NOW) test_class = instance_action.InstanceActionEvent expected_packed_values = test_class.pack_action_event_finish( self.context, 'fake-uuid', 'fake-event') expected_packed_values['finish_time'] = timeutils.utcnow() mock_finish.return_value = fake_event event = instance_action.InstanceActionEvent.event_finish( self.context, 'fake-uuid', 'fake-event', want_result=True) mock_finish.assert_called_once_with(self.context, expected_packed_values) self.compare_obj(event, fake_event)
def setUp(self): """setUp method for simple tenant usage.""" super(SimpleTenantUsageSampleJsonTest, self).setUp() started = timeutils.utcnow() now = started + datetime.timedelta(hours=1) timeutils.set_time_override(started) self._post_server() timeutils.set_time_override(now) self.query = {'start': str(started), 'end': str(now)}
def setUp(self): """setUp method for simple tenant usage.""" super(SimpleTenantUsageSampleJsonTest, self).setUp() started = timeutils.utcnow() now = started + datetime.timedelta(hours=1) timeutils.set_time_override(started) self._post_server() timeutils.set_time_override(now) self.query = {"start": str(started), "end": str(now)}
def test_action_finish(self): timeutils.set_time_override() ctxt = context.get_admin_context() self.mox.StubOutWithMock(db, 'action_finish') db.action_finish(ctxt, compute_utils.pack_action_finish( ctxt, 'fake-uuid')).AndReturn(fake_action) self.mox.ReplayAll() action = instance_action.InstanceAction.action_finish(ctxt, 'fake-uuid', want_result=True) self.assertEqual(fake_action['id'], action.id)
def test_shelve(self): CONF.shelved_offload_time = -1 db_instance = jsonutils.to_primitive(self._create_fake_instance()) self.compute.run_instance(self.context, instance=db_instance) instance = instance_obj.Instance.get_by_uuid( self.context, db_instance['uuid'], expected_attrs=['metadata', 'system_metadata']) image_id = 'fake_image_id' host = 'fake-mini' cur_time = timeutils.utcnow() timeutils.set_time_override(cur_time) instance.task_state = task_states.SHELVING instance.save() sys_meta = instance.system_metadata sys_meta['shelved_at'] = timeutils.strtime(at=cur_time) sys_meta['shelved_image_id'] = image_id sys_meta['shelved_host'] = host db_instance['system_metadata'] = utils.dict_to_metadata(sys_meta) self.mox.StubOutWithMock(self.compute, '_notify_about_instance_usage') self.mox.StubOutWithMock(self.compute.driver, 'snapshot') self.mox.StubOutWithMock(self.compute.driver, 'power_off') self.mox.StubOutWithMock(self.compute, '_get_power_state') self.mox.StubOutWithMock(db, 'instance_update_and_get_original') self.compute._notify_about_instance_usage(self.context, instance, 'shelve.start') self.compute.driver.power_off(instance) self.compute._get_power_state(self.context, instance).AndReturn(123) self.compute.driver.snapshot(self.context, instance, 'fake_image_id', mox.IgnoreArg()) db.instance_update_and_get_original(self.context, instance['uuid'], {'power_state': 123, 'vm_state': vm_states.SHELVED, 'task_state': None, 'expected_task_state': [task_states.SHELVING, task_states.SHELVING_IMAGE_UPLOADING], 'system_metadata': sys_meta}).AndReturn((db_instance, db_instance)) self.compute._notify_about_instance_usage(self.context, instance, 'shelve.end') self.mox.ReplayAll() self.compute.shelve_instance(self.context, instance, image_id=image_id) self.mox.VerifyAll() self.mox.UnsetStubs() self.compute.terminate_instance(self.context, instance=instance)
def test_finish(self): timeutils.set_time_override() self.mox.StubOutWithMock(db, 'action_start') self.mox.StubOutWithMock(db, 'action_finish') db.action_start(self.context, compute_utils.pack_action_start( self.context, 'fake-uuid', 'fake-action')).AndReturn( fake_action) db.action_finish(self.context, compute_utils.pack_action_finish( self.context, 'fake-uuid')).AndReturn(fake_action) self.mox.ReplayAll() action = instance_action.InstanceAction.action_start( self.context, 'fake-uuid', 'fake-action') action.finish()
def test_event_finish_with_failure(self, mock_finish, mock_tb): mock_tb.return_value = 'fake-tb' timeutils.set_time_override(override_time=NOW) expected_packed_values = compute_utils.pack_action_event_finish( self.context, 'fake-uuid', 'fake-event', 'val', 'invalid-tb') mock_finish.return_value = fake_event test_class = instance_action.InstanceActionEvent event = test_class.event_finish_with_failure( self.context, 'fake-uuid', 'fake-event', 'val', 'invalid-tb') mock_finish.assert_called_once_with(self.context, expected_packed_values) self.compare_obj(event, fake_event)
def test_shelved_poll_not_timedout(self): instance = jsonutils.to_primitive(self._create_fake_instance()) sys_meta = utils.metadata_to_dict(instance['system_metadata']) shelved_time = timeutils.utcnow() timeutils.set_time_override(shelved_time) timeutils.advance_time_seconds(CONF.shelved_offload_time - 1) sys_meta['shelved_at'] = timeutils.strtime(at=shelved_time) db.instance_update_and_get_original(self.context, instance['uuid'], {'vm_state': vm_states.SHELVED, 'system_metadata': sys_meta}) self.mox.StubOutWithMock(self.compute.driver, 'destroy') self.mox.ReplayAll() self.compute._poll_shelved_instances(self.context)
def setUp(self): super(InstanceUsageAuditLogTest, self).setUp() self.context = context.get_admin_context() timeutils.set_time_override(datetime.datetime(2012, 7, 5, 10, 0, 0)) self.controller = ial.InstanceUsageAuditLogController() self.host_api = self.controller.host_api def fake_service_get_all(context, disabled): self.assertIsNone(disabled) return TEST_COMPUTE_SERVICES self.stubs.Set(utils, "last_completed_audit_period", fake_last_completed_audit_period) self.stubs.Set(db, "service_get_all", fake_service_get_all) self.stubs.Set(db, "task_log_get_all", fake_task_log_get_all)
def test_shelved_poll_not_timedout(self): instance = jsonutils.to_primitive(self._create_fake_instance()) self.compute.run_instance(self.context, instance=instance) sys_meta = utils.metadata_to_dict(instance['system_metadata']) shelved_time = timeutils.utcnow() timeutils.set_time_override(shelved_time) timeutils.advance_time_seconds(CONF.shelved_offload_time - 1) sys_meta['shelved_at'] = timeutils.strtime(at=shelved_time) db.instance_update_and_get_original(self.context, instance['uuid'], {'vm_state': vm_states.SHELVED, 'system_metadata': sys_meta}) self.mox.StubOutWithMock(self.compute.driver, 'destroy') self.mox.ReplayAll() self.compute._poll_shelved_instances(self.context)
def test_event_finish_with_failure_legacy_unicode(self, mock_finish): # Tests that traceback.format_tb is not called when exc_tb is unicode. timeutils.set_time_override(override_time=NOW) test_class = instance_action.InstanceActionEvent expected_packed_values = test_class.pack_action_event_finish( self.context, 'fake-uuid', 'fake-event', 'val', unicode('fake-tb')) expected_packed_values['finish_time'] = timeutils.utcnow() mock_finish.return_value = fake_event event = test_class.event_finish_with_failure( self.context, 'fake-uuid', 'fake-event', exc_val='val', exc_tb=unicode('fake-tb'), want_result=True) mock_finish.assert_called_once_with(self.context, expected_packed_values) self.compare_obj(event, fake_event)
def test_event_finish_with_failure_legacy(self, mock_finish, mock_tb): mock_tb.return_value = 'fake-tb' timeutils.set_time_override(override_time=NOW) test_class = instance_action.InstanceActionEvent expected_packed_values = test_class.pack_action_event_finish( self.context, 'fake-uuid', 'fake-event', 'val', 'fake-tb') expected_packed_values['finish_time'] = timeutils.utcnow() mock_finish.return_value = fake_event event = test_class.event_finish_with_failure( self.context, 'fake-uuid', 'fake-event', exc_val='val', exc_tb=mock.sentinel.fake_tb, want_result=True) mock_finish.assert_called_once_with(self.context, expected_packed_values) self.compare_obj(event, fake_event)
def test_event_finish_with_failure_no_result(self, mock_finish, mock_tb): mock_tb.return_value = 'fake-tb' timeutils.set_time_override(override_time=NOW) test_class = instance_action.InstanceActionEvent expected_packed_values = test_class.pack_action_event_finish( self.context, 'fake-uuid', 'fake-event', 'val', 'fake-tb') expected_packed_values['finish_time'] = timeutils.utcnow() mock_finish.return_value = fake_event event = test_class.event_finish_with_failure( self.context, 'fake-uuid', 'fake-event', 'val', 'fake-tb', want_result=False) mock_finish.assert_called_once_with(self.context, expected_packed_values) self.assertIsNone(event)
def setUp(self): super(InstanceUsageAuditLogTest, self).setUp() self.context = context.get_admin_context() timeutils.set_time_override(datetime.datetime(2012, 7, 5, 10, 0, 0)) self.controller = ial.InstanceUsageAuditLogController() self.host_api = self.controller.host_api def fake_service_get_all(context, disabled): self.assertTrue(disabled is None) return TEST_COMPUTE_SERVICES self.stubs.Set(utils, 'last_completed_audit_period', fake_last_completed_audit_period) self.stubs.Set(db, 'service_get_all', fake_service_get_all) self.stubs.Set(db, 'task_log_get_all', fake_task_log_get_all)
def test_finish(self): timeutils.set_time_override() ctxt = context.get_admin_context() self.mox.StubOutWithMock(db, 'action_start') self.mox.StubOutWithMock(db, 'action_finish') db.action_start( ctxt, compute_utils.pack_action_start( ctxt, 'fake-uuid', 'fake-action')).AndReturn(fake_action) db.action_finish(ctxt, compute_utils.pack_action_finish( ctxt, 'fake-uuid')).AndReturn(fake_action) self.mox.ReplayAll() action = instance_action.InstanceAction.action_start( ctxt, 'fake-uuid', 'fake-action') action.finish()