def get_point(
self, metric_id, period=None, with_meta=True, timestamp=None
):
"""Get the closest point before input timestamp. Add meta informations
if with_meta.
"""
if timestamp is None:
timestamp = time()
timewindow = get_offset_timewindow(timestamp)
period = self.get_period(metric_id, period=period)
result = self[PerfData.PERFDATA_STORAGE].get(
data_id=metric_id, timewindow=timewindow, period=period,
limit=1
)
if with_meta is not None:
meta = self[PerfData.META_STORAGE].get(
data_id=metric_id, timewindow=timewindow
)
result = result, meta
return result
def get_current_alarm(self, alarm_id):
"""
Get current unresolved alarm.
:param alarm_id: Alarm entity ID
:type alarm_id: str
:returns: Alarm as dict if found, else None
"""
storage = self[Alerts.ALARM_STORAGE]
result = storage.get(
alarm_id,
timewindow=get_offset_timewindow(),
_filter={
'resolved': None
},
limit=1
)
if result is not None:
result = result[0]
result[storage.DATA_ID] = alarm_id
return result
def get_current_alarm(self, alarm_entity_id):
"""
Get current unresolved alarm.
:param alarm_id: Alarm entity ID
:type alarm_id: str
:returns: Alarm as dict if found, else None
"""
storage = self.alerts_storage
result = storage.get(
alarm_entity_id,
timewindow=get_offset_timewindow(),
_filter={
AlarmField.resolved.value: None
},
limit=1
)
if result is not None:
result = result[0]
result[storage.DATA_ID] = alarm_entity_id
return result
def test_resolve_alarms(self):
storage = self.manager[Alerts.ALARM_STORAGE]
alarm_id = '/fake/alarm/id'
self.manager.make_alarm(alarm_id, {'timestamp': 0})
alarm = self.manager.get_current_alarm(alarm_id)
self.assertIsNotNone(alarm)
value = alarm[storage.VALUE]
value['status'] = {
't': 0,
'val': OFF
}
self.manager.update_current_alarm(alarm, value)
self.manager.resolve_alarms()
alarm = self.manager.get_current_alarm(alarm_id)
self.assertIsNone(alarm)
alarm = storage.get(
alarm_id,
timewindow=get_offset_timewindow(),
_filter={
'resolved': {'$exists': True}
},
limit=1
)
self.assertTrue(alarm)
alarm = alarm[0]
value = alarm[storage.VALUE]
self.assertEqual(value['resolved'], value['status']['t'])
def get_current_alarm(self, alarm_entity_id):
"""
Get current unresolved alarm.
:param alarm_id: Alarm entity ID
:type alarm_id: str
:returns: Alarm as dict if found, else None
"""
storage = self.alerts_storage
result = storage.get(
alarm_entity_id,
timewindow=get_offset_timewindow(),
_filter={
AlarmField.resolved.value: None
},
limit=1
)
if result is not None:
result = result[0]
result[storage.DATA_ID] = alarm_entity_id
return result
def test_resolve_stealthy(self):
storage = self.manager.alerts_storage
now = int(time()) - self.manager.stealthy_interval - 1
alarm_id = '/fake/alarm/id'
alarm = self.manager.make_alarm(
alarm_id,
{
'connector': 'ut-connector',
'connector_name': 'ut-connector0',
'component': 'c',
'timestamp': now
}
)
self.assertIsNotNone(alarm)
# Init stealthy state
value = alarm[storage.VALUE]
value[AlarmField.status.value] = {
't': now,
'val': STEALTHY
}
value[AlarmField.state.value] = {
't': now,
'val': Check.OK
}
value[AlarmField.steps.value] = [
{
'_t': 'stateinc',
't': now - 1,
'a': 'test',
'm': 'test',
'val': Check.CRITICAL
},
{
'_t': 'statedec',
't': now,
'a': 'test',
'm': 'test',
'val': Check.OK
}
]
self.manager.update_current_alarm(alarm, value)
unresolved_alarms = self.manager.get_alarms(resolved=False)
self.manager.resolve_stealthy(unresolved_alarms)
alarm = storage.get(
alarm_id,
timewindow=get_offset_timewindow(),
_filter={
AlarmField.resolved.value: {'$exists': True}
},
limit=1
)
self.assertTrue(alarm)
alarm = alarm[0]
value = alarm[storage.VALUE]
self.assertEqual(value[AlarmField.status.value]['val'], OFF)
def get_meta(
self, metric_id, timewindow=None, limit=0, sort=None
):
"""Get the meta data related to input data_id and timewindow."""
if timewindow is None:
timewindow = get_offset_timewindow()
result = self[PerfData.META_STORAGE].get(
data_ids=metric_id,
timewindow=timewindow,
limit=limit,
sort=sort
)
return result
def test_resolve_stealthy(self):
storage = self.manager.alerts_storage
now = int(time()) - self.manager.stealthy_interval - 1
alarm_id = '/fake/alarm/id'
alarm = self.manager.make_alarm(
alarm_id, {
'connector': 'ut-connector',
'connector_name': 'ut-connector0',
'component': 'c',
'timestamp': now
})
self.assertIsNotNone(alarm)
# Init stealthy state
value = alarm[storage.VALUE]
value[AlarmField.status.value] = {'t': now, 'val': STEALTHY}
value[AlarmField.state.value] = {'t': now, 'val': Check.OK}
value[AlarmField.steps.value] = [{
'_t': 'stateinc',
't': now - 1,
'a': 'test',
'm': 'test',
'val': Check.CRITICAL
}, {
'_t': 'statedec',
't': now,
'a': 'test',
'm': 'test',
'val': Check.OK
}]
self.manager.update_current_alarm(alarm, value)
unresolved_alarms = self.manager.get_alarms(resolved=False)
self.manager.resolve_stealthy(unresolved_alarms)
alarm = storage.get(
alarm_id,
timewindow=get_offset_timewindow(),
_filter={AlarmField.resolved.value: {
'$exists': True
}},
limit=1)
self.assertTrue(alarm)
alarm = alarm[0]
value = alarm[storage.VALUE]
self.assertEqual(value[AlarmField.status.value]['val'], OFF)
def get_point(self, metric_id, with_meta=True, timestamp=None, meta=None):
"""Get the closest point before input timestamp. Add tags informations
if with_tags.
"""
data_id, tags = self._data_id_tags(metric_id, meta)
if timestamp is None:
timestamp = time()
timewindow = get_offset_timewindow(timestamp)
result = self[PerfData.PERFDATA_STORAGE].get(
data_id=data_id, timewindow=timewindow,
limit=1, tags=tags, with_tags=with_meta
)
return result
def test_resolve_alarms(self):
storage = self.manager.alerts_storage
alarm_id = '/fake/alarm/id'
alarm = self.manager.make_alarm(
alarm_id,
{
'connector': 'ut-connector',
'connector_name': 'ut-connector0',
'component': 'c',
'timestamp': 0
}
)
self.assertIsNotNone(alarm)
value = alarm[storage.VALUE]
value[AlarmField.status.value] = {
't': 0,
'val': OFF
}
self.manager.update_current_alarm(alarm, value)
unresolved_alarms = self.manager.get_alarms(resolved=False)
self.manager.resolve_alarms(unresolved_alarms)
alarm = self.manager.get_current_alarm(alarm_id)
self.assertIsNone(alarm)
alarm = storage.get(
alarm_id,
timewindow=get_offset_timewindow(),
_filter={
AlarmField.resolved.value: {'$exists': True}
},
limit=1
)
self.assertTrue(alarm)
alarm = alarm[0]
value = alarm[storage.VALUE]
self.assertEqual(value[AlarmField.resolved.value],
value[AlarmField.status.value]['t'])
def put(self, data_id, value, timestamp, *args, **kwargs):
timewindow = get_offset_timewindow(offset=timestamp)
data = self.get(
data_ids=[data_id], timewindow=timewindow, limit=1)
data_value = None
if data:
data_value = data[data_id][0][TimedStorage.VALUE]
if value != data_value: # new entry to insert
values_to_insert = {
MongoTimedStorage.Key.DATA_ID: data_id,
MongoTimedStorage.Key.TIMESTAMP: timestamp,
MongoTimedStorage.Key.VALUE: value
}
self._insert(document=values_to_insert)
def put(self, data_id, value, timestamp, cache=False, *args, **kwargs):
timewindow = get_offset_timewindow(offset=timestamp)
data = self.get(
data_ids=data_id, timewindow=timewindow, limit=1
)
data_value = None
if data:
data = data[0]
data_value = data[PeriodicalStorage.VALUE]
if value != data_value: # new entry to insert
document = {
MongoPeriodicalStorage.Key.DATA_ID: data_id,
MongoPeriodicalStorage.Key.TIMESTAMP: timestamp,
MongoPeriodicalStorage.Key.VALUE: value
}
if data and data[PeriodicalStorage.TIMESTAMP] == timestamp:
spec = {
MongoPeriodicalStorage.Key.DATA_ID: data_id,
MongoPeriodicalStorage.Key.TIMESTAMP: timestamp
}
self._update(
spec=spec,
document=document,
cache=cache,
multi=False,
upsert=False
)
else:
self._insert(document=document, cache=cache)
def put(self, data_id, value, timestamp, cache=False, *args, **kwargs):
timewindow = get_offset_timewindow(offset=timestamp)
data = self.get(
data_ids=data_id, timewindow=timewindow, limit=1
)
data_value = None
if data:
data = data[0]
data_value = data[PeriodicalStorage.VALUE]
if value != data_value: # new entry to insert
document = {
MongoPeriodicalStorage.Key.DATA_ID: data_id,
MongoPeriodicalStorage.Key.TIMESTAMP: timestamp,
MongoPeriodicalStorage.Key.VALUE: value
}
if data and data[PeriodicalStorage.TIMESTAMP] == timestamp:
spec = {
MongoPeriodicalStorage.Key.DATA_ID: data_id,
MongoPeriodicalStorage.Key.TIMESTAMP: timestamp
}
self._update(
spec=spec,
document=document,
cache=cache,
multi=False,
upsert=False
)
else:
self._insert(document=document, cache=cache)
def test_resolve_alarms(self):
storage = self.manager.alerts_storage
alarm_id = '/fake/alarm/id'
alarm = self.manager.make_alarm(
alarm_id, {
'connector': 'ut-connector',
'connector_name': 'ut-connector0',
'component': 'c',
'timestamp': 0
})
self.assertIsNotNone(alarm)
value = alarm[storage.VALUE]
value[AlarmField.status.value] = {'t': 0, 'val': OFF}
self.manager.update_current_alarm(alarm, value)
unresolved_alarms = self.manager.get_alarms(resolved=False)
self.manager.resolve_alarms(unresolved_alarms)
alarm = self.manager.get_current_alarm(alarm_id)
self.assertIsNone(alarm)
alarm = storage.get(
alarm_id,
timewindow=get_offset_timewindow(),
_filter={AlarmField.resolved.value: {
'$exists': True
}},
limit=1)
self.assertTrue(alarm)
alarm = alarm[0]
value = alarm[storage.VALUE]
self.assertEqual(value[AlarmField.resolved.value],
value[AlarmField.status.value]['t'])
def test_put_get_data(self):
timewindow = TimeWindow()
metric_id = 'test_manager'
self.perfdata.remove(metric_id=metric_id, with_meta=True)
count = self.perfdata.count(metric_id=metric_id)
self.assertEqual(count, 0)
tv0 = (int(timewindow.start()), None)
tv1 = (int(timewindow.start() + 1), 0)
tv2 = (int(timewindow.stop()), 2)
tv3 = (int(timewindow.stop() + 1000000), 3)
# set values with timestamp without order
points = [tv0, tv2, tv1, tv3]
meta = {'plop': None}
self.perfdata.put(
metric_id=metric_id,
points=points,
meta=meta
)
data, _meta = self.perfdata.get(
metric_id=metric_id,
timewindow=timewindow,
with_meta=True
)
self.assertEqual(meta, _meta[0][PerfData.META_VALUE])
self.assertEqual([tv0, tv1, tv2], data)
# remove 1 data at stop point
_timewindow = get_offset_timewindow(timewindow.stop())
self.perfdata.remove(
metric_id=metric_id,
timewindow=_timewindow
)
data, _meta = self.perfdata.get(
metric_id=metric_id,
timewindow=timewindow,
with_meta=True
)
self.assertEqual(meta, _meta[0][PerfData.META_VALUE])
self.assertEqual(data, [tv0, tv1])
# get data on timewindow
data, _meta = self.perfdata.get(
metric_id=metric_id,
timewindow=timewindow,
with_meta=True
)
self.assertEqual(meta, _meta[0][PerfData.META_VALUE])
# get all data
data, _meta = self.perfdata.get(
metric_id=metric_id,
with_meta=True
)
self.assertEqual(meta, _meta[0][PerfData.META_VALUE])
self.assertEqual(len(data), 3)
# remove all data
self.perfdata.remove(
metric_id=metric_id,
with_meta=True
)
data, _meta = self.perfdata.get(
metric_id=metric_id,
with_meta=True
)
self.assertIsNone(_meta)
self.assertEqual(len(data), 0)
