def test_evaluate_suspend(self): rule = {'EvaluationPeriods': '1', 'MetricName': 'test_metric', 'Period': '300', 'Statistic': 'Maximum', 'ComparisonOperator': 'GreaterThanOrEqualToThreshold', 'Threshold': '30'} now = timeutils.utcnow() timeutils.set_time_override(now) self.addCleanup(timeutils.clear_time_override) # Now data breaches Threshold, but we're suspended last = now - datetime.timedelta(seconds=300) data = WatchData(35, now - datetime.timedelta(seconds=150)) self.wr = watchrule.WatchRule(context=self.ctx, watch_name="testwatch", rule=rule, watch_data=[data], stack_id=self.stack_id, last_evaluated=last) self.wr.state_set(self.wr.SUSPENDED) actions = self.wr.evaluate() self.assertEqual(self.wr.SUSPENDED, self.wr.state) self.assertEqual([], actions)
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 _shelve_offload(self, clean_shutdown=True): instance = self._create_fake_instance_obj() instance.task_state = task_states.SHELVING instance.save() cur_time = timeutils.utcnow() timeutils.set_time_override(cur_time) 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.compute._notify_about_instance_usage(self.context, instance, 'shelve_offload.start') if clean_shutdown: self.compute.driver.power_off(instance, CONF.shutdown_timeout, self.compute.SHUTDOWN_RETRY_INTERVAL) else: self.compute.driver.power_off(instance, 0, 0) self.compute._get_power_state(self.context, instance).AndReturn(123) self.compute._notify_about_instance_usage(self.context, instance, 'shelve_offload.end') self.mox.ReplayAll() with mock.patch.object(instance, 'save'): self.compute.shelve_offload_instance(self.context, instance, clean_shutdown=clean_shutdown) self.assertEqual(vm_states.SHELVED_OFFLOADED, instance.vm_state) self.assertIsNone(instance.task_state)
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_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_evaluate_ceilometer_controlled(self): rule = { 'EvaluationPeriods': '1', 'MetricName': 'test_metric', 'Period': '300', 'Statistic': 'Maximum', 'ComparisonOperator': 'GreaterThanOrEqualToThreshold', 'Threshold': '30' } now = timeutils.utcnow() timeutils.set_time_override(now) self.addCleanup(timeutils.clear_time_override) # Now data breaches Threshold, but we're suspended last = now - datetime.timedelta(seconds=300) data = WatchData(35, now - datetime.timedelta(seconds=150)) self.wr = watchrule.WatchRule(context=self.ctx, watch_name="testwatch", rule=rule, watch_data=[data], stack_id=self.stack_id, last_evaluated=last) self.wr.state_set(self.wr.CEILOMETER_CONTROLLED) actions = self.wr.evaluate() self.assertEqual(self.wr.CEILOMETER_CONTROLLED, self.wr.state) self.assertEqual([], actions)
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 _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_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_utcnow(self): timeutils.set_time_override(mock.sentinel.utcnow) self.assertEqual(timeutils.utcnow(), mock.sentinel.utcnow) timeutils.clear_time_override() self.assertFalse(timeutils.utcnow() == mock.sentinel.utcnow) self.assertTrue(timeutils.utcnow())
def setUp(self): super(TestProtocol, self).setUp() timeutils.set_time_override() self.addCleanup(timeutils.clear_time_override) self.task = utils.DummyTask() self.task_uuid = 'task-uuid' self.task_action = 'execute' self.task_args = {'a': 'a'} self.timeout = 60
def test_evaluate(self): rule = { 'EvaluationPeriods': '1', 'MetricName': 'test_metric', 'Period': '300', 'Statistic': 'Maximum', 'ComparisonOperator': 'GreaterThanOrEqualToThreshold', 'Threshold': '30' } now = timeutils.utcnow() timeutils.set_time_override(now) self.addCleanup(timeutils.clear_time_override) # It's not time to evaluate, so should stay NODATA last = now - datetime.timedelta(seconds=299) data = WatchData(25, now - datetime.timedelta(seconds=150)) self.wr = watchrule.WatchRule(context=self.ctx, watch_name="testwatch", rule=rule, watch_data=[data], stack_id=self.stack_id, last_evaluated=last) actions = self.wr.evaluate() self.assertEqual('NODATA', self.wr.state) self.assertEqual([], actions) # now - last == Period, so should set NORMAL last = now - datetime.timedelta(seconds=300) data = WatchData(25, now - datetime.timedelta(seconds=150)) self.wr = watchrule.WatchRule(context=self.ctx, watch_name="testwatch", rule=rule, watch_data=[data], stack_id=self.stack_id, last_evaluated=last) actions = self.wr.evaluate() self.assertEqual('NORMAL', self.wr.state) self.assertEqual(now, self.wr.last_evaluated) self.assertEqual([], actions) # Now data breaches Threshold, so should set ALARM last = now - datetime.timedelta(seconds=300) data = WatchData(35, now - datetime.timedelta(seconds=150)) self.wr = watchrule.WatchRule(context=self.ctx, watch_name="testwatch", rule=rule, watch_data=[data], stack_id=self.stack_id, last_evaluated=last) actions = self.wr.evaluate() self.assertEqual('ALARM', self.wr.state) self.assertEqual(now, self.wr.last_evaluated) self.assertEqual([], actions)
def setUp(self): super(TestProtocol, self).setUp() timeutils.set_time_override() self.addCleanup(timeutils.clear_time_override) self.task = utils.DummyTask() self.task_uuid = "task-uuid" self.task_action = "execute" self.task_args = {"a": "a"} self.timeout = 60
def _shelve_offload(self, clean_shutdown=True): instance = self._create_fake_instance_obj() instance.task_state = task_states.SHELVING instance.save() db_instance = obj_base.obj_to_primitive(instance) 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') if clean_shutdown: self.compute.driver.power_off(instance, CONF.shutdown_timeout, self.compute.SHUTDOWN_RETRY_INTERVAL) else: self.compute.driver.power_off(instance, 0, 0) 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', 'info_cache', 'security_groups' ], ).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, clean_shutdown=clean_shutdown)
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): 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_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_evaluate(self): rule = {'EvaluationPeriods': '1', 'MetricName': 'test_metric', 'Period': '300', 'Statistic': 'Maximum', 'ComparisonOperator': 'GreaterThanOrEqualToThreshold', 'Threshold': '30'} now = timeutils.utcnow() timeutils.set_time_override(now) self.addCleanup(timeutils.clear_time_override) # It's not time to evaluate, so should stay NODATA last = now - datetime.timedelta(seconds=299) data = WatchData(25, now - datetime.timedelta(seconds=150)) self.wr = watchrule.WatchRule(context=self.ctx, watch_name="testwatch", rule=rule, watch_data=[data], stack_id=self.stack_id, last_evaluated=last) actions = self.wr.evaluate() self.assertEqual('NODATA', self.wr.state) self.assertEqual([], actions) # now - last == Period, so should set NORMAL last = now - datetime.timedelta(seconds=300) data = WatchData(25, now - datetime.timedelta(seconds=150)) self.wr = watchrule.WatchRule(context=self.ctx, watch_name="testwatch", rule=rule, watch_data=[data], stack_id=self.stack_id, last_evaluated=last) actions = self.wr.evaluate() self.assertEqual('NORMAL', self.wr.state) self.assertEqual(now, self.wr.last_evaluated) self.assertEqual([], actions) # Now data breaches Threshold, so should set ALARM last = now - datetime.timedelta(seconds=300) data = WatchData(35, now - datetime.timedelta(seconds=150)) self.wr = watchrule.WatchRule(context=self.ctx, watch_name="testwatch", rule=rule, watch_data=[data], stack_id=self.stack_id, last_evaluated=last) actions = self.wr.evaluate() self.assertEqual('ALARM', self.wr.state) self.assertEqual(now, self.wr.last_evaluated) self.assertEqual([], actions)
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_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_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_set_time_override_using_default(self): now = timeutils.utcnow_ts() # NOTE(kgriffs): Normally it's bad form to sleep in a unit test, # but this is the only way to test that set_time_override defaults # to setting the override to the current time. time.sleep(1) timeutils.set_time_override() overriden_now = timeutils.utcnow_ts() self.assertThat(now, matchers.LessThan(overriden_now))
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 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_event_start(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=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) 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=False) mock_finish.assert_called_once_with(self.context, expected_packed_values) self.assertIsNone(event)
def _action_set_stubs(self, now, action_expected=True): # Setup stubs for the action tests timeutils.set_time_override(now) self.addCleanup(timeutils.clear_time_override) if action_expected: dummy_action = DummyAction() self.m.StubOutWithMock(parser.Stack, 'resource_by_refid') parser.Stack.resource_by_refid(mox.IgnoreArg()).\ MultipleTimes().AndReturn(dummy_action) self.m.ReplayAll()
def _action_set_stubs(self, now, action_expected=True): # Setup stubs for the action tests timeutils.set_time_override(now) self.addCleanup(timeutils.clear_time_override) if action_expected: dummy_action = DummyAction() self.m.StubOutWithMock(parser.Stack, 'resource_by_refid') parser.Stack.resource_by_refid( mox.IgnoreArg()).MultipleTimes().AndReturn(dummy_action) self.m.ReplayAll()
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 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 test_shelved_poll_not_timedout(self): instance = self._create_fake_instance_obj() sys_meta = 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 _stub_meta_expected(self, now, data, nmeta=1): # Stop time at now timeutils.set_time_override(now) self.addCleanup(timeutils.clear_time_override) # Then set a stub to ensure the metadata update is as # expected based on the timestamp and data self.m.StubOutWithMock(resource.Resource, 'metadata_set') expected = {timeutils.strtime(now): data} # Note for ScalingPolicy, we expect to get a metadata # update for the policy and autoscaling group, so pass nmeta=2 for x in range(nmeta): resource.Resource.metadata_set(expected).AndReturn(None)
def test_shelve_volume_backed(self): db_instance = jsonutils.to_primitive(self._create_fake_instance()) instance = objects.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)
def test_on_wait_task_expired(self): now = timeutils.utcnow() self.request_inst_mock.expired = True self.request_inst_mock.created_on = now timeutils.set_time_override(now) self.addCleanup(timeutils.clear_time_override) timeutils.advance_time_seconds(120) ex = self.executor() ex._requests_cache[self.task_uuid] = self.request_inst_mock self.assertEqual(len(ex._requests_cache), 1) ex._on_wait() self.assertEqual(len(ex._requests_cache), 0)
def test_event_finish_with_failure(self, mock_finish, mock_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=True) mock_finish.assert_called_once_with(self.context, expected_packed_values) self.compare_obj(event, fake_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.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 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_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_utcnow_ts_microsecond(self): skynet_self_aware_ts = 872835240.000123 skynet_dt = datetime.datetime.utcfromtimestamp(skynet_self_aware_ts) self.assertEqual(self.skynet_self_aware_ms_time, skynet_dt) # NOTE(kgriffs): timeutils.utcnow_ts() uses time.time() # IFF time override is not set. with mock.patch('time.time') as time_mock: time_mock.return_value = skynet_self_aware_ts ts = timeutils.utcnow_ts(microsecond=True) self.assertEqual(ts, skynet_self_aware_ts) timeutils.set_time_override(skynet_dt) ts = timeutils.utcnow_ts(microsecond=True) self.assertEqual(ts, skynet_self_aware_ts)
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 _shelve_offload(self, clean_shutdown=True): instance = self._create_fake_instance_obj() instance.task_state = task_states.SHELVING instance.save() db_instance = obj_base.obj_to_primitive(instance) 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') if clean_shutdown: self.compute.driver.power_off(instance, CONF.shutdown_timeout, self.compute.SHUTDOWN_RETRY_INTERVAL) else: self.compute.driver.power_off(instance, 0, 0) 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', 'info_cache', 'security_groups'], ).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, clean_shutdown=clean_shutdown)
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_shelved_poll_timedout(self): instance = self._create_fake_instance_obj() sys_meta = 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_event_finish_with_failure_legacy(self, mock_finish, mock_tb): # Tests that exc_tb is serialized when it's not a string type. 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 fake_tb = mock.sentinel.fake_tb event = test_class.event_finish_with_failure(self.context, 'fake-uuid', 'fake-event', exc_val='val', exc_tb=fake_tb, want_result=True) mock_finish.assert_called_once_with(self.context, expected_packed_values) self.compare_obj(event, fake_event) mock_tb.assert_called_once_with(fake_tb)
def test_event_finish_with_failure_no_result(self, mock_finish, mock_tb): # Tests that traceback.format_tb is not called when exc_tb is a str # and want_result is False, so no event should come back. 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) self.assertFalse(mock_tb.called)