def put(self, ident):
data = self.request.data
entity = get_one(self.session, Entity,
id=ident) # to ensure that the entity exists
if 'parent_id' in data:
get_one(self.session, Entity, id=data['parent_id'])
entity.parent_id_fk = data['parent_id']
# add tags and meta
for key in data:
if 'tag_' in key:
tag = get_one(self.session,
EntityTag,
entity=entity,
tag_id_fk=key.split('_')[1])
tag.value = data[key]
elif 'meta_' in key:
meta = get_one(self.session,
EntityMeta,
entity=entity,
meta_id_fk=key.split('_')[1])
meta.value = data[key]
self.session.commit()
update_last_data_modification_ts(self.session)
return {
'success': True,
'ID': entity.id,
}
def put(self, ident):
data = self.request.data
alert = get_one(self.session, Alert, id=ident)
if 'entity_id' in data:
entity = get_one(self.session, Entity, id=data['entity_id'])
alert.entity_id_fk = entity.id
if 'series_id' in data:
series = get_one(self.session,
SeriesAttribute,
id=data['series_id'])
alert.series_id_fk = series.id
if 'alert_predicate_type' in data:
alert.alert_predicate_type = data['alert_predicate_type']
if 'value' in data:
alert.value = data['value']
if 'is_enabled' in data:
alert.is_enabled = data['is_enabled']
if 'alert_recipient_email' in data:
alert.alert_recipient_email = data['alert_recipient_email']
# reset last check status
alert.last_check_status = None
self.session.commit()
return {
'success': True,
'ID': alert.id,
}
def __enter__(self):
self._session = Session()
self._entity = get_one(self._session, Entity, id=self._entity_id)
self._entity_measurement_names = {}
for measurement_id in self._measurements:
if measurement_id not in self._entity_measurement_names:
measurement_name = get_one(self._session, SeriesAttribute, id=measurement_id).name
self._entity_measurement_names[measurement_id] = measurement_name
return self
def delete(self, entity_type_id, ident):
entity_type = get_one(self.session, EntityType, id=entity_type_id) # check if route is correct
meta = get_one(self.session, MetaAttribute, entity_type=entity_type, id=ident)
now = time.time()
meta.delete_ts = now
for entity_meta in get_all(self.session, EntityMeta, attribute=meta):
entity_meta.delete_ts = now
self.session.commit()
update_last_data_modification_ts(self.session)
return {'success': True}
def get(self, entity_type_id, ident=None):
entity_type = get_one(self.session, EntityType, id=entity_type_id)
if ident is None:
return [
series.to_dict() for series in get_all(
self.session, SeriesAttribute, entity_type=entity_type)
]
else:
return get_one(self.session,
SeriesAttribute,
entity_type=entity_type,
id=ident).to_dict()
def get(self, entity_type_id, ident=None):
entity_type = get_one(self.session, EntityType, id=entity_type_id)
if ident is None:
return [
tag.to_dict() for tag in get_all(
self.session, TagAttribute, entity_type=entity_type)
]
else:
return get_one(self.session,
TagAttribute,
entity_type=entity_type,
id=ident).to_dict()
def test_put_updates_fields(self):
result = get_handler(EntityHandler, {
'tag_1': 'tag_foo',
'meta_1': 'meta_foo'
}).put(1)
self.assertEqual({'success': True, 'ID': 1}, result)
self.assertEqual(len(get_all(Session(), EntityTag)), 1)
self.assertEqual(len(get_all(Session(), EntityMeta)), 1)
self.assertEqual(
get_one(Session(), EntityTag, entity_id_fk=1).value, 'tag_foo')
self.assertEqual(
get_one(Session(), EntityMeta, entity_id_fk=1).value, 'meta_foo')
def __init__(self, request_id: int, payload: dict):
super().__init__(request_id, payload)
self._last_data_timestamp = 0
session = Session()
self._measurement = get_one(session,
SeriesAttribute,
id=self._raw_payload.measurement_id,
exception_cls=ValueError)
self._entity = get_one(session,
Entity,
id=self._raw_payload.node_id,
exception_cls=ValueError)
self._run_assertions()
def post(self):
data = self.request.data
entity = get_one(self.session, Entity, id=data['entity_id'])
series = get_one(self.session, SeriesAttribute, id=data['series_id'])
alert = Alert(entity=entity,
series=series,
alert_predicate_type=data['alert_predicate_type'],
value=data['value'],
is_enabled=data['is_enabled'],
alert_recipient_email=data['alert_recipient_email'])
self.session.add(alert)
self.session.commit()
return {'success': True, 'ID': alert.id}
def put(self, entity_type_id, ident):
data = self.request.data
entity_type = get_one(self.session, EntityType, id=entity_type_id) # check if route is correct
meta = get_one(self.session, MetaAttribute, entity_type=entity_type, id=ident)
if 'name' in data:
meta.name = data['name']
self.session.commit()
update_last_data_modification_ts(self.session)
return {
'success': True,
'ID': meta.id,
}
def delete(self, entity_type_id, ident):
entity_type = get_one(self.session, EntityType,
id=entity_type_id) # check if route is correct
tag = get_one(self.session,
TagAttribute,
entity_type=entity_type,
id=ident)
now = time.time()
tag.delete_ts = now
for entity_tag in get_all(self.session, EntityTag, attribute=tag):
entity_tag.delete_ts = now
self.session.commit()
update_last_data_modification_ts(self.session)
return {'success': True}
def put(self, entity_type_id, ident):
data = self.request.data
entity_type = get_one(self.session, EntityType, id=entity_type_id)
series = get_one(self.session,
SeriesAttribute,
entity_type=entity_type,
id=ident)
if 'refresh_time' in data:
series.refresh_time = data['refresh_time']
if 'is_favourite' in data:
series.is_favourite = data['is_favourite']
self.session.commit()
update_last_data_modification_ts(self.session)
return {'success': True, 'ID': series.id}
def delete(self, entity_type_id, ident):
now = time.time()
entity_type = get_one(self.session, EntityType,
id=entity_type_id) # check if route is correct
series = get_one(self.session,
SeriesAttribute,
entity_type=entity_type,
id=ident)
series.delete_ts = now
for alert in series.alerts:
alert.delete_ts = now
self.session.commit()
update_last_data_modification_ts(self.session)
return {'success': True}
def post(self):
data = self.request.data
entity_type = get_one(self.session,
EntityType,
id=data['entity_type_id'])
# check if we got all tags and meta
tag_ids = sorted(
int(key.split('_')[1]) for key in data if 'tag_' in key)
meta_ids = sorted(
int(key.split('_')[1]) for key in data if 'meta_' in key)
self._assert_got_all_needed_tag_and_meta_ids(entity_type, tag_ids,
meta_ids)
entity = Entity(
entity_type=entity_type,
parent=None if data['parent_id'] is None else get_one(
self.session, Entity, id=data['parent_id']),
)
self.session.add(entity)
# add tags and meta
for key in data:
if 'tag_' in key:
self.session.add(
EntityTag(
entity=entity,
attribute=get_one(self.session,
TagAttribute,
id=int(key.split('_')[1])),
value=data[key],
))
elif 'meta_' in key:
self.session.add(
EntityMeta(
entity=entity,
attribute=get_one(self.session,
MetaAttribute,
id=int(key.split('_')[1])),
value=data[key],
))
self.session.commit()
update_last_data_modification_ts(self.session)
return {
'success': True,
'ID': entity.id,
}
def __init__(self, entity_id: int, aggregation_length: int,
aggregation_type: str, measurement_id: int):
super().__init__(entity_id, aggregation_length, aggregation_type)
self._measurement_id = measurement_id
self._measurement = get_one(Session(),
SeriesAttribute,
id=measurement_id)
def put(self, ident):
data = self.request.data
entity_type = get_one(self.session, EntityType, id=ident)
if 'name' in data:
entity_type.name = data['name']
# add tags, meta and series
if 'tags' in data:
for tag in data['tags']:
self.session.add(
TagAttribute(
entity_type=entity_type,
name=tag,
))
if 'meta' in data:
for meta in data['meta']:
self.session.add(
MetaAttribute(
entity_type=entity_type,
name=meta,
))
if 'series' in data:
for series in data['series']:
self.session.add(
SeriesAttribute(
entity_type=entity_type,
name=series,
))
self.session.commit()
update_last_data_modification_ts(self.session)
return {
'success': True,
'ID': entity_type.id,
}
def get(self, ident=None):
if ident is None:
return [
entity.to_dict(deep=False)
for entity in get_all(self.session, Entity)
]
else:
return get_one(self.session, Entity, id=ident).to_dict(deep=False)
def delete(self, ident):
alert = get_one(self.session, Alert, id=ident)
now = time.time()
alert.delete_ts = now
self.session.commit()
update_last_data_modification_ts(self.session)
return {'success': True}
def get(self, ident=None):
if ident is None:
return [
entity_type.to_dict()
for entity_type in get_all(self.session, EntityType)
]
else:
return get_one(self.session, EntityType, id=ident).to_dict()
def test_put_updates_name(self):
result = get_handler(MetaAttributeHandler, {
'name': 'meta_foo'
}).put(1, 1)
self.assertEqual({'success': True, 'ID': 1}, result)
self.assertEqual(len(get_all(Session(), MetaAttribute)), 4)
self.assertEqual(
get_one(Session(), MetaAttribute, id=1).name, 'meta_foo')
def test_delete_removes_object_and_dependants(self):
result = get_handler(EntityTypeHandler).delete(1)
self.assertEqual({'success': True}, result)
self.assertEqual(len(get_all(Session(), EntityType)), 1)
self.assertEqual(get_one(Session(), EntityType).id, 2)
self.assertEqual(len(get_all(Session(), TagAttribute)), 1)
self.assertEqual(len(get_all(Session(), SeriesAttribute)), 0)
self.assertEqual(len(get_all(Session(), MetaAttribute)), 1)
self.assertEqual(len(get_all(Session(), Entity)), 1)
def post(self, entity_type_id):
data = self.request.data
entity_type = get_one(self.session, EntityType, id=entity_type_id)
tag = TagAttribute(entity_type=entity_type, name=data['name'])
self.session.add(tag)
self.session.commit()
update_last_data_modification_ts(self.session)
return {'success': True, 'ID': tag.id}
def post(self, entity_type_id):
data = self.request.data
entity_type = get_one(self.session, EntityType, id=entity_type_id)
series = SeriesAttribute(entity_type=entity_type,
name=data['name'],
type=data.get('type', 'real'),
refresh_time=data.get('refresh_time'),
is_favourite=data.get('is_favourite', False))
self.session.add(series)
self.session.commit()
update_last_data_modification_ts(self.session)
return {'success': True, 'ID': series.id}
def __init__(self, request_id: int, payload: dict):
super().__init__(request_id, payload)
session = Session()
self._entity = get_one(session,
Entity,
id=self._raw_payload.node_id,
exception_cls=ValueError)
self._requested_data = [
create_measurement_handler(self._raw_payload.node_id,
self._raw_payload.aggregation_length,
self._raw_payload.aggregation_type,
data)
for data in self._raw_payload.requested_data
]
self._run_assertions()
def delete(self, ident):
entity = get_one(self.session, Entity, id=ident)
now = time.time()
entity.delete_ts = now
for tag in entity.tags:
tag.delete_ts = now
for meta in entity.meta:
meta.delete_ts = now
for alert in entity.alerts:
alert.delete_ts = now
for child in entity.children:
child.parent = entity.parent
self.session.commit()
update_last_data_modification_ts(self.session)
return {'success': True}
def get(self, ident=None):
if ident:
# TODO this data is also cached, we can retrieve it from there
mapped_measurements = {
ser_attr.id: ser_attr.to_tree_dict()
for ser_attr in get_all(self.session, SeriesAttribute)
}
tree_model = get_one(self.session, Entity, id=ident)
return {
"tree_metadata": tree_model.map_nodes(),
"tree": tree_model.tree_structure_dict(),
"measurements_metadata": mapped_measurements,
"timestamp": get_last_data_modification_ts(self.session),
}
else:
last_update_ts = get_last_data_modification_ts(self.session)
if last_update_ts > self._cached_tree['timestamp']:
self._update_cache()
return self._cached_tree
def test_put_updates_name(self):
result = get_handler(EntityTypeHandler, {'name': 'bar'}).put(1)
self.assertEqual({'success': True, 'ID': 1}, result)
self.assertEqual(len(get_all(Session(), EntityType)), 1)
self.assertEqual(get_one(Session(), EntityType, id=1).name, 'bar')
def test_delete_non_leaf_changes_parent_id_of_children(self):
result = get_handler(EntityHandler).delete(1)
self.assertEqual({'success': True}, result)
self.assertEqual(get_one(Session(), Entity, id=2).parent_id_fk, None)
def __init__(self, entity_id, filename):
self._entity = get_one(Session(), Entity, id=entity_id)
self._filename = filename
def get(self, ident=None):
if ident is None:
return [alert.to_dict() for alert in get_all(self.session, Alert)]
else:
return get_one(self.session, Alert, id=ident).to_dict()
