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 test_put_creates_new_objects(self):
result = get_handler(EntityTypeHandler, {'tags': ['t2']}).put(1)
self.assertEqual({'success': True, 'ID': 1}, result)
self.assertEqual(len(get_all(Session(), TagAttribute)), 2)
result = get_handler(EntityTypeHandler, {'series': ['s2']}).put(1)
self.assertEqual({'success': True, 'ID': 1}, result)
self.assertEqual(len(get_all(Session(), SeriesAttribute)), 2)
result = get_handler(EntityTypeHandler, {'meta': ['m2']}).put(1)
self.assertEqual({'success': True, 'ID': 1}, result)
self.assertEqual(len(get_all(Session(), MetaAttribute)), 2)
def test_post_creates_object(self):
result = get_handler(EntityTypeHandler, {
'name': 'foo',
'tags': [],
'series': [],
'meta': []
}).post()
self.assertEqual({'success': True, 'ID': 1}, result)
self.assertEqual(len(get_all(Session(), EntityType)), 1)
self.assertEqual(len(get_all(Session(), TagAttribute)), 0)
self.assertEqual(len(get_all(Session(), MetaAttribute)), 0)
self.assertEqual(len(get_all(Session(), SeriesAttribute)), 0)
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 test_invalid_request_raises(self):
self.assertEqual(len(get_all(Session(), TagAttribute)), 1)
handler = get_handler(TagAttributeHandler)
with self.assertRaises(HTTP_400):
handler.request._data = {} # no name
handler.post(1)
with self.assertRaises(HTTP_400):
handler.request._data = {'name': 'tag_name'} # existing name
handler.post(1)
with self.assertRaises(HTTP_404):
handler.request._data = {'name': 'foo'}
handler.post(2) # non-existing entity type
self.assertEqual(len(get_all(Session(), TagAttribute)), 1)
def test_post_creates_object(self):
self.assertEqual(len(get_all(Session(), SeriesAttribute)), 1)
result = get_handler(SeriesAttributeHandler, {'name': 'foo'}).post(1)
self.assertEqual({'success': True, 'ID': 2}, result)
self.assertEqual(len(get_all(Session(), SeriesAttribute)), 2)
# post with more params
result = get_handler(SeriesAttributeHandler, {
'name': 'foo_prim',
'type': 'enum',
'refresh_time': 3600
}).post(1)
self.assertEqual({'success': True, 'ID': 3}, result)
self.assertEqual(len(get_all(Session(), SeriesAttribute)), 3)
def test_invalid_request_raises(self):
handler = get_handler(EntityTypeHandler)
with self.assertRaises(HTTP_400):
handler.request._data = {
'name': 'foo',
'tags': [],
'series': []
} # no meta
handler.post()
with self.assertRaises(HTTP_400):
handler.request._data = {
'name': 'foo',
'tags': [],
'meta': []
} # no series
handler.post()
with self.assertRaises(HTTP_400):
handler.request._data = {
'name': 'foo',
'series': [],
'meta': []
} # no tags
handler.post()
with self.assertRaises(HTTP_400):
handler.request._data = {
'tags': [],
'series': [],
'meta': []
} # no name
handler.post()
self.assertEqual(len(get_all(Session(), EntityType)), 0)
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 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 _update_cache(self):
mapped_measurements = {
ser_attr.id: ser_attr.to_tree_dict()
for ser_attr in get_all(self.session, SeriesAttribute)
}
roots = [
root for root in get_all(self.session, Entity)
if root.parent is None
]
mapped_nodes = {}
for root in roots:
root.add_nodes_rec(mapped_nodes)
self._cached_tree = {
"tree_metadata": mapped_nodes,
"tree": [root.tree_structure_dict() for root in roots],
"measurements_metadata": mapped_measurements,
"timestamp": get_last_data_modification_ts(self.session),
}
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 run_assertion(data, entity_type_id, attribute_id=None):
attributes = [
m.name
for m in get_all(Session(), cls, entity_type_id_fk=entity_type_id)
if m.id != attribute_id
]
if 'name' in data and data['name'] in attributes:
raise ValueError("attribute {} exists for entity type {}".format(
data['name'], entity_type_id))
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 _assert_objects_were_not_created(data, entity_type_id):
session = Session()
existing_objects = {
'tags': [
tag.name for tag in get_all(
session, TagAttribute, entity_type_id_fk=entity_type_id)
],
'meta': [
meta.name for meta in get_all(
session, MetaAttribute, entity_type_id_fk=entity_type_id)
],
'series': [
series.name for series in get_all(
session, SeriesAttribute, entity_type_id_fk=entity_type_id)
]
}
for object_type in ('tags', 'meta', 'series'):
for obj in data.get(object_type, []):
if obj in existing_objects[object_type]:
raise ValueError('{} is in existing {}'.format(
obj, object_type))
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 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 test_post_creates_object(self):
result = get_handler(
EntityHandler, {
'parent_id': None,
'entity_type_id': 1,
'tag_1': 'tag_val',
'meta_1': 'meta_val'
}).post()
self.assertEqual({'success': True, 'ID': 1}, result)
self.assertEqual(len(get_all(Session(), Entity)), 1)
result = get_handler(
EntityHandler, {
'parent_id': 1,
'entity_type_id': 1,
'tag_1': 'tag_val_1',
'meta_1': 'meta_val'
}).post()
self.assertEqual({'success': True, 'ID': 2}, result)
self.assertEqual(len(get_all(Session(), Entity)), 2)
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 test_invalid_request_raises(self):
self.assertEqual(len(get_all(Session(), SeriesAttribute)), 1)
handler = get_handler(SeriesAttributeHandler)
with self.assertRaises(HTTP_400):
handler.request._data = {} # no name
handler.post(1)
with self.assertRaises(HTTP_400):
handler.request._data = {'name': 'foo', 'type': 'nop'} # bad type
handler.post(1)
with self.assertRaises(HTTP_400):
handler.request._data = {
'name': 'foo',
'refresh_time': '2'
} # bad refresh time
handler.post(1)
with self.assertRaises(HTTP_400):
handler.request._data = {'name': 'series_name'} # existing name
handler.post(1)
with self.assertRaises(HTTP_404):
handler.request._data = {'name': 'foo'}
handler.post(2) # non-existing entity type
self.assertEqual(len(get_all(Session(), SeriesAttribute)), 1)
def check_all_alerts(
on_state_change: Iterable[Callable[[Alert, str], Any]]) -> None:
session = Session()
for alert in get_all(session, Alert, is_enabled=True):
status = check_alert(alert)
if status and not alert.last_check_status:
[callback(alert, str(status)) for callback in on_state_change
] # call all callbacks in on_state_change
alert.last_check_status = True
if alert.last_check_status is None or (not status
and alert.last_check_status):
[callback(alert, str(status)) for callback in on_state_change]
alert.last_check_status = False
session.commit()
session.close()
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 push_new_measurements(directory, pattern):
session = Session()
files = os.listdir(directory)
for node in get_all(session, Entity):
to_read = [
directory + '/' + f for f in files
if re.match(pattern.format(ID=node.id), f) and
os.path.getmtime(directory + '/' + f) >= node.last_data_fetch_ts
]
# get input files sorted by modification time
for file in sorted(to_read, key=os.path.getmtime):
try:
InfluxWriter().write(
PointGenerator(node, FileParser(node.id,
file)).generate_points())
node.last_data_fetch_ts = int(os.path.getmtime(file))
session.commit()
except Exception as err:
logging.error(err)
session.close()
def test_invalid_request_raises(self):
handler = get_handler(EntityHandler)
with self.assertRaises(HTTP_400):
handler.request._data = {
'parent_id': None,
'entity_type_id': 1,
'tag_1': 'tag_val'
} # no meta_1
handler.post()
with self.assertRaises(HTTP_400):
handler.request._data = {
'parent_id': None,
'entity_type_id': 1,
'meta_1': 'meta_val'
} # no tag_1
handler.post()
with self.assertRaises(HTTP_400):
handler.request._data = {
'parent_id': None,
'entity_type_id': 1,
'tag_1': 't',
'meta_1': 'm',
'tag_10': 'f'
} # unexpected tag_10
handler.post()
with self.assertRaises(HTTP_400):
handler.request._data = {
'parent_id': None,
'entity_type_id': 1,
'tag_1': 't',
'meta_1': 'm',
'meta_10': 'f'
} # unexpected meta_10
handler.post()
with self.assertRaises(HTTP_400):
handler.request._data = {
'parent_id': None,
'tag_1': 't',
'meta_1': 'm'
} # no entity type
handler.post()
with self.assertRaises(HTTP_400):
handler.request._data = {
'entity_type_id': 1,
'tag_1': 't',
'meta_1': 'm'
} # no parent_id
handler.post()
with self.assertRaises(HTTP_404):
handler.request._data = {
'parent_id': 10,
'entity_type_id': 1,
'tag_1': 't',
'meta_1': 'm'
} # non-existent parent id
handler.post()
with self.assertRaises(HTTP_404):
handler.request._data = {
'parent_id': None,
'entity_type_id': 10
} # non-existent entity id
handler.post()
self.assertEqual(len(get_all(Session(), Entity)), 0)
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 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()
def test_post_creates_object(self):
self.assertEqual(len(get_all(Session(), MetaAttribute)), 1)
result = get_handler(MetaAttributeHandler, {'name': 'foo'}).post(1)
self.assertEqual({'success': True, 'ID': 2}, result)
self.assertEqual(len(get_all(Session(), MetaAttribute)), 2)
def test_delete_leaf_removes_object_and_dependants(self):
result = get_handler(EntityHandler).delete(3)
self.assertEqual({'success': True}, result)
self.assertEqual(len(get_all(Session(), Entity)), 2)
self.assertEqual(len(get_all(Session(), EntityTag)), 2)
self.assertEqual(len(get_all(Session(), EntityMeta)), 2)
def test_delete_removes_object_and_dependants(self):
result = get_handler(MetaAttributeHandler).delete(1, 1)
self.assertEqual({'success': True}, result)
self.assertEqual(len(get_all(Session(), EntityType)), 2)
self.assertEqual(len(get_all(Session(), MetaAttribute)), 1)
self.assertEqual(len(get_all(Session(), EntityMeta)), 0)
