def test_fetch_reports_by_name(self):
owner_id = uuid.uuid1()
all_rs = [
Report.insert(owner_id, 'rep%02d' % i) for i in range(10, 20)
]
all_rs[:0] = [
Report.insert(owner_id, 'rep%02d' % i) for i in range(10)
]
rs = reports.fetch_reports_by_name(owner_id)
self.assertEqual(all_rs, rs)
rs = reports.fetch_reports_by_name(owner_id, limit=5)
self.assertEqual(all_rs[:5], rs)
rs = reports.fetch_reports_by_name(owner_id, name_prefix='rep1')
self.assertEqual(all_rs[10:], rs)
rs = reports.fetch_reports_by_name(owner_id,
name_prefix='rep1',
after_name='rep15')
self.assertEqual(all_rs[16:], rs)
rs = reports.fetch_reports_by_name(owner_id, after_name='rep15')
self.assertEqual(all_rs[16:], rs)
rs = reports.fetch_reports_by_name(owner_id, after_name='x')
self.assertFalse(rs)
rs = reports.fetch_reports_by_name(uuid.uuid1())
self.assertFalse(rs)
rs = reports.fetch_reports_by_name(owner_id, after_name='a', limit=1)
self.assertEqual(all_rs[:1], rs)
def test_get_dashboards_by_report_id(self):
od = self.test_inserting()
res = od.get_dashboards_by_report_id()
self.assertEqual({}, res)
r = Report.insert(od.owner_id, 'r')
r2 = Report.insert(od.owner_id, 'r2')
r3 = Report.insert(od.owner_id, 'r3')
tile_config = {
'series_spec_list': [
dataseries.SeriesSpec(0, -1, dict(op='eq', args=['0'])),
],
}
place_tile(Tile.insert(od.owner_id, r.report_id, od.dashboards[3].dashboard_id, tile_config))
place_tile(Tile.insert(od.owner_id, r.report_id, od.dashboards[3].dashboard_id, tile_config))
place_tile(Tile.insert(od.owner_id, r.report_id, od.dashboards[0].dashboard_id, tile_config))
place_tile(Tile.insert(od.owner_id, r2.report_id, od.dashboards[0].dashboard_id, tile_config))
place_tile(Tile.insert(od.owner_id, r3.report_id, od.dashboards[1].dashboard_id, tile_config))
res = od.get_dashboards_by_report_id()
self.assertEqual(3, len(res))
self.assertEqual([od.dashboards[0], od.dashboards[3]], res[r.report_id])
self.assertEqual([od.dashboards[0]], res[r2.report_id])
self.assertEqual([od.dashboards[1]], res[r3.report_id])
def test_owner_has_reports(self):
owner_id = uuid.uuid1()
self.assertFalse(reports.owner_has_reports(owner_id))
Report.insert(owner_id, 'a')
self.assertTrue(reports.owner_has_reports(owner_id))
def test_counts(self):
owner_id = uuid.uuid1()
r = Report.insert(owner_id, 'a')
r.process_input('1')
r.process_input('2')
r2 = Report.insert(owner_id, 'b')
r.process_input('1')
r.process_input('2')
self.assertEqual(4, reports.report_instance_count_for_owner(owner_id))
self.assertEqual(4,
reports.report_instance_diskspace_for_owner(owner_id))
def test_delete_simple(self):
owner_id = uuid.uuid1()
r1 = Report.insert(owner_id, 'r1')
r1.process_input('1')
r2 = Report.insert(owner_id, 'r2')
r2.process_input('2')
ids = reports.fetch_reports_by_name(owner_id, 'r')
self.assertEqual(2, len(ids))
r2.delete()
reps = reports.fetch_reports_by_name(owner_id, 'r')
self.assertEqual([r1], reps)
self.assertIsNone(Report.select(r2.report_id))
def create_multi_day_report(self):
owner_id = uuid.uuid4()
r = Report.select_or_insert(owner_id, 'pi')
def process(val, minus_days, tags):
res = r.process_input(str(val),
created=datetime.datetime.utcnow() -
datetime.timedelta(days=minus_days),
tags=tags)
self.assertIsNotNone(res.report_instance)
process(0, 500, ['t1', 't2'])
process(-1, 532, ['t2'])
process(1, 432, ['t1', 't2'])
process(2, 410, ['t1', 't2'])
process(3, 360, ['t1', 't2'])
process(4, 330, ['t1'])
process(5, 73, ['t1'])
process(6, 12, ['t2'])
process(7, 11, ['t1'])
all_ris = r.fetch_instances(
datetime.datetime.utcnow() - datetime.timedelta(days=600),
datetime.datetime.utcnow())
self.assertEqual('-1 0 1 2 3 4 5 6 7'.split(),
[ri['input_string'] for ri in all_ris])
return r, all_ris
def test_custom_get_parsing_result_desc(self):
old = mqeconfig.get_parsing_result_desc
try:
def get_parsing_result_desc(parsing_result, table):
res = {'num_rows': table.num_rows}
if parsing_result.input_type == 'single':
res['input_is_json'] = True
return res
mqeconfig.get_parsing_result_desc = get_parsing_result_desc
owner_id = uuid.uuid1()
r = Report.insert(owner_id, 'r')
r.process_input('1\n2\n3\n')
ri = r.fetch_instances(order='desc', limit=1)[0]
self.assertEqual(3, ri.parsing_result_desc['num_rows'])
self.assertEqual(None, ri.parsing_result_desc.get('input_is_json'))
r.process_input('1\n2\n', input_type='single')
ri = r.fetch_instances(order='desc', limit=1)[0]
self.assertEqual(1, ri.parsing_result_desc['num_rows'])
self.assertEqual(True, ri.parsing_result_desc.get('input_is_json'))
finally:
mqeconfig.get_parsing_result_desc = old
def test_sscreator_as_mod(self):
owner_id = uuid.uuid4()
dashboard_id = uuid.uuid4()
tile_config = {
'series_spec_list': [
SeriesSpec(1, 0, dict(op='eq', args=['label1'])),
],
'tile_options': {
'sscs': SeriesSpec(1, 0, dict(op='eq', args=['label1']))
}
}
r = Report.insert(owner_id, 'r')
tile = Tile.insert(owner_id, r.report_id, dashboard_id, tile_config)
layouts.place_tile(tile)
ri1 = r.process_input('label1 1',
handle_sscreator=False).report_instance
ri2 = r.process_input('label11 11\nlabel12 12',
handle_sscreator=False).report_instance
ri3 = r.process_input('label21 21\nlabel22 22',
handle_sscreator=False).report_instance
layout_rows = c.dao.LayoutDAO.select_layout_by_report_multi(owner_id, r.report_id,
[], 'sscs', 100)
mods = [sscreator.sscreator_mod(ri1, layout_rows[0]),
sscreator.sscreator_mod(ri2, layout_rows[0]),
sscreator.sscreator_mod(ri3, layout_rows[0])]
layouts.apply_mods(mods, owner_id, dashboard_id, None)
layout = Layout.select(owner_id, dashboard_id)
tile = layout.tile_dict.keys()[0]
def test_sscs_virtual_column(self):
owner_id = uuid.uuid1()
od = dashboards.OwnerDashboards(owner_id)
dashboard_id = od.dashboards[0].dashboard_id
r = Report.insert(owner_id, 'r')
tile_config = {
'tw_type': 'Single',
'series_spec_list': [
SeriesSpec(0, -1, dict(op='eq', args=['0'])),
],
'tile_options': {}
}
tile_config['tile_options']['sscs'] = tile_config['series_spec_list'][
0]
tile = Tile.insert(owner_id, r.report_id, dashboard_id, tile_config)
layouts.place_tile(tile)
for inp in ['0', '1', '2\n3', '3\n4\n5\n']:
res = r.process_input(inp)
tile = Tile.select(
dashboard_id,
Layout.select(owner_id, dashboard_id).layout_dict.keys()[0])
self.assertEqual(3, len(tile.series_specs()))
return tile, r
def main():
owner_id = uuid.uuid4()
report = Report.select_or_insert(owner_id, 'simple_report')
res = report.process_input('1 2 3')
assert res.report_instance
owner_dashboards = OwnerDashboards(
owner_id, insert_if_no_dashboards='Default Dashboard')
assert owner_dashboards.dashboards
tile_config = {
'series_spec_list': [SeriesSpec(0, -1, {
'op': 'eq',
'args': ['0']
})],
}
tile = Tile.insert(owner_id, report.report_id,
owner_dashboards.dashboards[0].dashboard_id,
tile_config)
assert tile
assert tile.get_tile_data()
print 'Successfully created a dashboard with a tile'
owner_dashboards.dashboards[0].delete()
def test_select_multi(self):
owner_id = uuid.uuid1()
d_id1 = uuid.uuid1()
d_id2 = uuid.uuid1()
r = Report.insert(owner_id, 'r')
res = Layout.select_multi(owner_id, [d_id1, d_id2])
self.assertEqual([], res)
tile_config = {
'series_spec_list': [
dataseries.SeriesSpec(0, -1, dict(op='eq', args=['0'])),
],
}
t1 = Tile.insert(owner_id, r.report_id, d_id1, tile_config)
place_tile(t1)
res = Layout.select_multi(owner_id, [d_id1, d_id2])
self.assertEqual(1, len(res))
self.assertEqual(
Layout.select(owner_id, d_id1).layout_id, res[0].layout_id)
t2 = Tile.insert(owner_id, r.report_id, d_id2, tile_config)
place_tile(t2)
res = Layout.select_multi(owner_id, [d_id1, d_id2])
self.assertEqual(2, len(res))
self.assertEqual(
Layout.select(owner_id, d_id1).layout_id, res[0].layout_id)
self.assertEqual(
Layout.select(owner_id, d_id2).layout_id, res[1].layout_id)
def test_promote_first_as_master_multiple_masters_one_apply_mods_run(self):
rd = self.test_repack_dont_put_master_first()
tile_config = {
'tags': ['q1:10'],
'series_spec_list': [
dataseries.SeriesSpec(0, -1, dict(op='eq', args=['0'])),
],
'tile_options': {
'tpcreator_uispec': [{
'tag': 'q1:10',
'prefix': 'q1:'
}],
}
}
r2 = Report.insert(rd.owner_id, 'r2')
master_tile2 = Tile.insert(rd.owner_id, r2.report_id, rd.dashboard_id,
tile_config)
layouts.place_tile(master_tile2)
ri1 = r2.process_input('0', tags=['q1:8'],
handle_tpcreator=False).report_instance
ri2 = r2.process_input('0', tags=['q1:12'],
handle_tpcreator=False).report_instance
ri3 = r2.process_input('0', tags=['q1:6'],
handle_tpcreator=False).report_instance
ri4 = rd.report.process_input('0',
tags=['p1:2'],
handle_tpcreator=False).report_instance
layout_rows_tpcreator = c.dao.LayoutDAO.select_layout_by_report_multi(
rd.owner_id, rd.report_id, [], 'tpcreator', 100)
mods = [
tpcreator.tpcreator_mod(ri1, layout_rows_tpcreator[0]),
tpcreator.tpcreator_mod(ri2, layout_rows_tpcreator[0]),
tpcreator.tpcreator_mod(ri3, layout_rows_tpcreator[0]),
tpcreator.tpcreator_mod(ri4, layout_rows_tpcreator[0]),
layouts.repack_mod(put_master_first=False),
layouts.promote_first_as_master_mod(),
layouts.if_mod(lambda layout_mod: layout_mod.tile_replacement,
layouts.repack_mod())
]
layouts.apply_mods(mods, rd.owner_id, rd.dashboard_id, None)
self.assertEqual([['p1:2'], ['p1:6'], ['p1:8'], ['p1:10'], ['p1:12'],
['q1:6'], ['q1:8'], ['q1:10'], ['q1:12']],
[tile.tags for tile in rd.tiles_sorted_by_vo()])
master1 = rd.get_tile_by_tags(['p1:2'])
master2 = rd.get_tile_by_tags(['q1:6'])
self.assertTrue(master1.is_master_tile())
self.assertTrue(master2.is_master_tile())
for tile in rd.tiles_sorted_by_vo():
if tile.tags[0].startswith(
'p') and tile.tile_id != master1.tile_id:
self.assertEqual(master1.tile_id, tile.get_master_tile_id())
elif tile.tags[0].startswith(
'q') and tile.tile_id != master2.tile_id:
self.assertEqual(master2.tile_id, tile.get_master_tile_id())
def test_process_input_invalid_args(self):
owner_id = uuid.uuid4()
r = Report.select_or_insert(owner_id, 'pi')
self.assertRaises(AssertionError, lambda: r.process_input(43))
self.assertRaises(
ValueError, lambda: r.process_input(
'3', created=datetime.datetime(1990, 3, 4)))
def test_get_dashboards_displaying_report(self):
od = self.test_inserting()
res = od.get_dashboards_displaying_report(uuid.uuid4())
self.assertEqual([], res)
r = Report.insert(od.owner_id, 'r')
tile_config = {
'series_spec_list': [
dataseries.SeriesSpec(0, -1, dict(op='eq', args=['0'])),
],
}
res = od.get_dashboards_displaying_report(r.report_id)
self.assertEqual([], res)
t1 = Tile.insert(od.owner_id, r.report_id, od.dashboards[3].dashboard_id, tile_config)
place_tile(t1)
res = od.get_dashboards_displaying_report(r.report_id)
self.assertEqual(1, len(res))
self.assertEqual('Dash 4', res[0].dashboard_name)
t2 = Tile.insert(od.owner_id, r.report_id, od.dashboards[1].dashboard_id, tile_config)
place_tile(t2)
res = od.get_dashboards_displaying_report(r.report_id)
self.assertEqual(2, len(res))
self.assertEqual('Dash 2', res[0].dashboard_name)
self.assertEqual('Dash 4', res[1].dashboard_name)
t3 = Tile.insert(od.owner_id, r.report_id, od.dashboards[1].dashboard_id, tile_config)
place_tile(t3)
res = od.get_dashboards_displaying_report(r.report_id)
self.assertEqual(2, len(res))
self.assertEqual('Dash 2', res[0].dashboard_name)
self.assertEqual('Dash 4', res[1].dashboard_name)
detach_tile(t3)
res = od.get_dashboards_displaying_report(r.report_id)
self.assertEqual(2, len(res))
self.assertEqual('Dash 2', res[0].dashboard_name)
self.assertEqual('Dash 4', res[1].dashboard_name)
detach_tile(t2)
res = od.get_dashboards_displaying_report(r.report_id)
self.assertEqual(1, len(res))
self.assertEqual('Dash 4', res[0].dashboard_name)
od.dashboards[3].delete()
res = od.get_dashboards_displaying_report(r.report_id)
self.assertEqual(0, len(res))
def test_process_input_format_spec(self):
owner_id = uuid.uuid4()
r = Report.select_or_insert(owner_id, 'pi')
res = r.process_input('v1:10\nv2:20',
input_type='csv',
ip_options={'delimiter': ':'},
force_header=[0])
self.assertEqual(
EnrichedTable(Table([['v1', '10'], ['v2', '20']], [0])),
res.report_instance.table)
def test_tags(self):
r, all_ris = self.create_multi_day_report()
self.assertTrue(r.has_tags())
self.assertEqual(['t1', 't2'], r.fetch_tags_sample())
self.assertEqual(['t1'], r.fetch_tags_sample('t1'))
r2 = Report.insert(uuid.uuid1(), 'r2')
self.assertFalse(r2.has_tags())
self.assertFalse(r2.fetch_tags_sample('t'))
def autocomplete_tag_name():
report_id = request.get_json()['report_id']
term = request.get_json()['term']
check_access(lambda: auth.access_report_instances(report_id))
report = Report.select(report_id)
tags = report.fetch_tags_sample(term, AUTOCOMPLETE_TAG_NAME_LIMIT)
return success(result=dict(data=tags))
def report_instances_days():
report_name = request.get_json()['report_name']
tags = request.get_json().get('tags')
check_access(lambda: auth.access_profile())
report = Report.select_by_name(auth.logged_owner_id(), report_name)
days_dts = report.fetch_days(tags)
days = [dt.strftime('%Y-%m-%d') for dt in days_dts]
return success(result=dict(days=days))
def test_fetch_days(self):
r, all_ris = self.create_multi_day_report()
dts = r.fetch_days()
for dt in dts:
self.assertIsInstance(dt, datetime.datetime)
r2 = Report.insert(uuid.uuid1(), 'r2')
self.assertFalse(r2.fetch_days())
ri = r2.process_input('2').report_instance
self.assertEqual(datetime.datetime.utcnow().date(), ri.created.date())
def render_series_spec_creator_spec():
report_id = request.get_json()['report_id']
report_instance_id = request.get_json()['report_instance_id']
template_ss = request.get_json()['template_ss']
check_access(lambda: auth.access_report_instances(report_id))
report = Report.select(report_id)
report_instance = report.fetch_single_instance(report_instance_id)
html = get_template_attribute('m.html', 'series_spec_creator_spec')(template_ss,
report_instance)
return success(result=dict(html=html))
def test_delete_single_instance_same_created_dt(self):
owner_id = uuid.uuid1()
r = Report.insert(owner_id, 'r')
created_ris = []
for i in xrange(20):
res = r.process_input(str(i),
created=datetime.datetime(2017, 1, 1))
created_ris.append(res.report_instance)
r.delete_single_instance(created_ris[10].report_instance_id)
ris = r.fetch_instances()
self.assertEqual({str(i)
for i in xrange(20) if i != 10},
{ri['input_string']
for ri in ris})
def compute_series_spec():
report_id = request.get_json()['report_id']
report_instance_id = request.get_json()['report_instance_id']
sample = request.get_json()['sample']
check_access(lambda: auth.access_report_instances(report_id))
report = Report.select(report_id)
report_instance = report.fetch_single_instance(report_instance_id)
series_spec = dataseries.guess_series_spec(report, report_instance, sample['rowno'],
sample['colno'])
if series_spec is None:
return error()
series_spec_html = get_template_attribute('m.html', 'series_spec')(series_spec, report_instance)
return success(result=dict(series_spec=series_spec, series_spec_html=series_spec_html))
def render_empty_series_spec():
report_id = request.get_json()['report_id']
report_instance_id = request.get_json()['report_instance_id']
check_access(lambda: auth.access_report_instances(report_id))
report = Report.select(report_id)
report_instance = report.fetch_single_instance(report_instance_id)
if report_instance.table.num_columns > 1:
series_spec = dataseries.SeriesSpec(0, 0, {'op': 'eq', 'args': []})
else:
series_spec = dataseries.SeriesSpec(0, -1, {'op': 'eq', 'args': ['0']})
series_spec.set_name('')
series_spec_html = get_template_attribute('m.html', 'series_spec')(series_spec, report_instance)
return success(result=dict(series_spec_html=series_spec_html))
def report_instance_for_viewer():
report_name = request.get_json()['report_name']
tags = request.get_json().get('tags')
curr_report_instance_id = request.get_json()['curr_report_instance_id']
direction = request.get_json().get('direction')
search_date = request.get_json().get('search_date')
check_access(lambda: auth.access_profile())
report = Report.select_by_name(auth.logged_owner_id(), report_name)
if not curr_report_instance_id:
curr_report_instance_id = report.fetch_latest_instance_id(tags)
if not curr_report_instance_id:
return error()
if not direction:
if search_date is not None:
ri = report.find_report_instance_by_dt(search_date, tags)
else:
ri = report.fetch_single_instance(curr_report_instance_id)
elif direction == 'next':
ri = report.fetch_next_instance(curr_report_instance_id, tags)
elif direction == 'prev':
ri = report.fetch_prev_instance(curr_report_instance_id, tags)
else:
return error('Wrong direction')
res = {}
res['report_id'] = report.report_id
res['report_has_tags'] = report.has_tags()
if ri:
res['html_newest_table'] = get_template_attribute('m.html', 'table_as_html_table')(ri.table)
res['created_raw'] = datetime_from_uuid1(ri.report_instance_id)
res['created'] = format_datetime(datetime_from_uuid1(ri.report_instance_id))
res['tags'] = Markup(' '.join('<span class="selected-tag-name clickable">%s</span>' % tag for tag in ri.all_tags))
res['curr_report_instance_id'] = ri.report_instance_id
res['has_next'] = report.fetch_next_instance(ri.report_instance_id, tags) is not None
res['has_prev'] = report.fetch_prev_instance(ri.report_instance_id, tags) is not None
else:
res['html_newest_table'] = ''
res['created_raw'] = ''
res['created'] = ''
res['tags'] = ''
res['curr_report_instance_id'] = None
res['has_next'] = False
res['has_prev'] = False
return success(result=res)
def matching_cell_for_series_spec():
report_id = request.get_json()['report_id']
report_instance_id = request.get_json()['report_instance_id']
series_spec = request.get_json()['series_spec']
check_access(lambda: auth.access_report_instances(report_id))
report = Report.select(report_id)
report_instance = report.fetch_single_instance(report_instance_id)
if not report_instance:
return error('No report instance')
cell = series_spec.get_cell(report_instance)
if not cell:
return success()
return success(result=dict(rowno=cell.rowno,
colno=cell.colno))
def selected_tags_change():
report_id = request.get_json()['report_id']
tags = request.get_json()['tags']
check_access(lambda: auth.access_report_instances(report_id))
report = Report.select(report_id)
latest_instance_id = report.fetch_latest_instance_id(tags)
if not latest_instance_id:
return error()
ri = report.fetch_single_instance(latest_instance_id, tags)
if not ri:
return error('No report instance %s' % latest_instance_id)
res = {}
res['html_newest_table'] = get_template_attribute('m.html', 'table_as_html_table')(ri.table)
res['latest_instance_id'] = latest_instance_id
return success(result=res)
def test_process_input(self):
owner_id = uuid.uuid4()
r = Report.select_or_insert(owner_id, 'pi')
dt = datetime.datetime(2010, 5, 30, 6, 30)
res = r.process_input('10 20 30',
tags=['t1', 't2', 't3'],
created=dt,
extra_ri_data=[1, 2, 3])
self.assertEqual(['t1', 't2', 't3'], res.report_instance.all_tags)
self.assertEqual(dt, res.report_instance.created)
self.assertEqual(EnrichedTable(Table([['10', '20', '30']])),
res.report_instance.table)
self.assertEqual([1, 2, 3], res.report_instance.fetch_extra_ri_data())
desc = res.report_instance.desc(True, True)
self.assertEqual(res.report_instance.report_instance_id.hex,
desc['id'])
self.assertEqual(1, len(desc['rows']))
self.assertIn(' 20 ', desc['input'])
def test_find_report_instance_by_dt(self):
r, all_ris = self.create_multi_day_report()
ri = r.find_report_instance_by_dt(all_ris[3].created +
datetime.timedelta(hours=1))
self.assertEqual(all_ris[3], ri)
ri = r.find_report_instance_by_dt(all_ris[3].created -
datetime.timedelta(hours=1))
self.assertEqual(all_ris[3], ri)
ri = r.find_report_instance_by_dt(util.MIN_DATETIME)
self.assertEqual(all_ris[0], ri)
ri = r.find_report_instance_by_dt(util.MAX_DATETIME)
self.assertEqual(all_ris[-1], ri)
r2 = Report.insert(uuid.uuid1(), 'r2')
ri = r2.find_report_instance_by_dt(util.MIN_DATETIME)
self.assertIsNone(ri)
def test_insert_and_select(self):
owner_id = uuid.uuid4()
r1 = Report.insert(owner_id, 'rep')
self.assertIsNotNone(r1)
r2 = Report.insert(owner_id, 'rep')
self.assertIsNone(r2)
rs = Report.select_by_name(owner_id, 'rep')
self.assertEqual(r1, rs)
rs2 = Report.select(rs.report_id)
self.assertEqual(rs2, rs)
r2 = Report.insert(owner_id, 'rep_2')
self.assertIsNotNone(r2)
self.assertNotEqual(r2, rs)
r3 = Report.select_or_insert(owner_id, 'rep_3')
r3_2 = Report.select(r3.report_id)
r3_3 = Report.select_or_insert(owner_id, 'rep_3')
self.assertEqual(r3, r3_2)
self.assertEqual(r3, r3_3)
def main():
vars = tutorial.main()
owner_id = vars['owner_id']
owner_dashboards = vars['owner_dashboards']
dashboard = vars['dashboard']
SECTION('tags')
cpu_report = Report.select_or_insert(owner_id, 'cpu_usage')
metrics = [
('user', 92.3),
('system', 3.4),
('io', 4.4),
]
cpu_report.process_input(json.dumps(metrics),
tags=['ip:192.168.1.18', 'warning'])
tile_config_1 = {
'tags': ['ip:192.168.1.18'],
'series_spec_list': [
SeriesSpec(1, 0, {
'op': 'eq',
'args': ['user']
}),
],
}
tile_1 = Tile.insert(owner_id, cpu_report.report_id,
dashboard.dashboard_id, tile_config_1)
tile_config_2 = {
'tags': ['ip:192.168.1.18', 'warning'],
'series_spec_list': [
SeriesSpec(1, 0, {
'op': 'eq',
'args': ['user']
}),
],
}
tile_2 = Tile.insert(owner_id, cpu_report.report_id,
dashboard.dashboard_id, tile_config_2)
