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_expire_tiles_without_data(self): rd1 = new_report_data('points') rd2 = new_report_data('points') tile_config_1 = { 'tw_type': 'Range', 'series_spec_list': [ dataseries.SeriesSpec(2, 0, dict(op='eq', args=['monique'])), ], 'tile_options': { 'seconds_back': 86400, } } tile1 = tiles.Tile.insert(rd1.owner_id, rd1.report.report_id, rd1.dashboard_id, tile_config_1) place_tile(tile1) self.assertTrue(tile1.get_tile_data()['series_data'][0]['data_points']) tile_config_2 = { 'tw_type': 'Range', 'series_spec_list': [ dataseries.SeriesSpec(2, 0, dict(op='eq', args=['john20'])), ], 'tile_options': { 'seconds_back': 86400, } } tile2 = tiles.Tile.insert(rd2.owner_id, rd2.report.report_id, rd2.dashboard_id, tile_config_2) place_tile(tile2) self.assertFalse( tile2.get_tile_data()['series_data'][0]['data_points']) res = tiles.expire_tiles_without_data([tile1, tile2], 3600, Layout.select( rd1.owner_id, rd1.dashboard_id).layout_id, optimize_check=True) self.assertIsNone(res) time.sleep(0.5) rd2.report.process_input('0') res = tiles.expire_tiles_without_data([tile1, tile2], 0.5, Layout.select( rd1.owner_id, rd1.dashboard_id).layout_id, optimize_check=True) self.assertTrue(res) self.assertFalse(Tile.select(rd1.dashboard_id, tile1.tile_id)) self.assertTrue(Tile.select(rd2.dashboard_id, tile2.tile_id))
def test_deleting_layout_by_report_row(self): owner_id = uuid.uuid1() dashboard_id_1 = uuid.uuid1() r = reports.Report.insert(owner_id, 'r') tile_config = { 'tw_type': 'Single', 'tags': ['p1:10'], 'series_spec_list': [ dataseries.SeriesSpec(0, -1, dict(op='eq', args=['0'])), ], 'tile_options': {} } tile_config['tile_options'][ 'tpcreator_uispec'] = tpcreator.suggested_tpcreator_uispec( ['p1:10']) master_tile_1 = Tile.insert(owner_id, r.report_id, dashboard_id_1, tile_config) layouts.place_tile(master_tile_1) r.process_input('1', tags=['p1:11']) self.assertEqual( 2, len( Layout.select(master_tile_1.owner_id, master_tile_1.dashboard_id).layout_dict)) rows = c.dao.LayoutDAO.select_layout_by_report_multi( master_tile_1.owner_id, master_tile_1.report_id, [], 'tpcreator', 100) self.assertTrue(rows) layouts.detach_tile(master_tile_1) r.process_input('1', tags=['p1:12']) self.assertEqual( 1, len( Layout.select(master_tile_1.owner_id, master_tile_1.dashboard_id).layout_dict)) rows = c.dao.LayoutDAO.select_layout_by_report_multi( master_tile_1.owner_id, master_tile_1.report_id, [], 'tpcreator', 100) self.assertFalse(rows)
def profile_dashboard(dashboard_id_str=None, dashboard_name=None): if not auth.access_profile(): return redirect(url_for('bp_mqe.login', next='dashboard')) g.profile_page = 'dashboard' dbs = dashboards.OwnerDashboards(auth.logged_owner_id()) if dashboard_id_str is None: active_db_id = dbs.dashboards[0].dashboard_id else: try: active_db_id = uuid.UUID(dashboard_id_str) except ValueError: abort(404) if active_db_id not in dbs.dashboard_by_id: abort(404) layout = Layout.select(auth.logged_owner_id(), active_db_id) if not reports.owner_has_reports(auth.logged_owner_id()): onboarding = True else: onboarding = False return render_template('profile_dashboard.html', onboarding=onboarding, dashboards=dbs, active_db_id=active_db_id, active_db_layout_id=layout.layout_id, active_db_layout_dict=layout.layout_dict)
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 render_dashboard(owner_id, dashboard): print 'Rendering dashboard %r' % dashboard.dashboard_name layout = Layout.select(owner_id, dashboard.dashboard_id) for tile, visual_options in layout.tile_dict.items(): tile_data = tile.get_tile_data() print 'Rendering tile %r at position %s/%s' % ( tile_data['generated_tile_title'], visual_options['x'], visual_options['y'])
def test_detach_2_repack(self): tiles = self.test_place_multiple() detach_tile(tiles[0]) repack(tiles[0].owner_id, tiles[0].dashboard_id) detach_tile(tiles[1]) repack(tiles[0].owner_id, tiles[0].dashboard_id) del tiles[0] del tiles[0] layout = Layout.select(tiles[0].owner_id, tiles[0].dashboard_id) self.assertDictEqual( self.ld_from_vos( tiles, { u'width': 4, u'height': 4, u'x': 0, u'y': 0 }, { u'width': 5, u'height': 1, u'x': 0, u'y': 4 }, { u'width': 4, u'height': 4, u'x': 4, u'y': 0 }, ), layout.layout_dict)
def test_place(self): tile = call(tiles_test.TileTest.test_insert, dashboard_id=uuid.uuid1()) res = place_tile(tile) self.assertIsNotNone(res) vo = {'width': 4, 'height': 4, 'x': 0, 'y': 0} self.assertEqual(vo, res.new_tiles[tile]) layout = Layout.select(tile.owner_id, tile.dashboard_id) self.assertEqual(res.new_layout.layout_id, layout.layout_id) self.assertEqual({tile.tile_id: vo}, layout.layout_dict)
def test_place_wrong_id(self): dashboard_id = uuid.uuid1() tile = self.place(dashboard_id) layout = Layout.select(tile.owner_id, tile.dashboard_id) tile = self.place(dashboard_id) tile = call(tiles_test.TileTest.test_insert, dashboard_id=dashboard_id) res = place_tile(tile, for_layout_id=layout.layout_id) self.assertIsNone(res)
def test_set_new_layout(self): tiles = self.test_place_multiple() layout = Layout.select(tiles[0].owner_id, tiles[0].dashboard_id) layout.layout_dict = dict(layout.layout_dict.items()[:3]) res = layout.set() self.assertIsNotNone(res) layout2 = Layout.select(tiles[0].owner_id, tiles[0].dashboard_id) layout.layout_dict = dict(layout.layout_dict.items()[:2]) res = layout.set() self.assertIsNotNone(res) layout2_reselected = Layout.select(tiles[0].owner_id, tiles[0].dashboard_id) self.assertEqual(2, len(layout2_reselected.layout_dict)) # wrong id res = layout2_reselected.set(tiles[0].owner_id, tiles[0].dashboard_id, layout2.layout_id) self.assertIsNone(res)
def test_place_multiple(self): dashboard_id = uuid.uuid1() tiles = [] for kwargs in ({}, { 'initial_visual_options': { 'width': 12, 'height': 10 } }, {}, { 'initial_visual_options': { 'width': 5, 'height': 1 } }, {}): tiles.append(self.place(dashboard_id, **kwargs)) layout = Layout.select(tiles[0].owner_id, dashboard_id) self.assertEqual( self.ld_from_vos( tiles, { u'width': 4, u'height': 4, u'x': 0, u'y': 0 }, { u'width': 12, u'height': 10, u'x': 0, u'y': 4 }, { u'width': 4, u'height': 4, u'x': 4, u'y': 0 }, { u'width': 5, u'height': 1, u'x': 0, u'y': 14 }, { u'width': 4, u'height': 4, u'x': 8, u'y': 0 }, ), layout.layout_dict) return tiles
def render_dashboard(): dashboard_id = request.get_json()['dashboard_id'] check_access(lambda: auth.access_dashboard(dashboard_id)) db = dashboards.Dashboard.select(auth.logged_owner_id(), dashboard_id) if not db: return error('Invalid dashboard') layout = Layout.select(auth.logged_owner_id(), dashboard_id) html = get_template_attribute('m.html', 'dashboard')(db, layout.layout_id if layout else None, layout.layout_dict if layout else None) return success(result=dict(html=html))
def test_detach_all_and_attach(self): tiles = self.test_place_multiple() dashboard_id = tiles[0].dashboard_id for t in tiles: detach_tile(t) tile = call(tiles_test.TileTest.test_insert, dashboard_id=dashboard_id) res = place_tile(tile) vo = {'width': 4, 'height': 4, 'x': 0, 'y': 0} self.assertEqual(vo, res.new_tiles[tile]) layout = Layout.select(tile.owner_id, tile.dashboard_id) self.assertEqual(res.new_layout.layout_id, layout.layout_id) self.assertEqual({tile.tile_id: vo}, layout.layout_dict)
def test_deleting_layout_by_report_row(self): tile, report = self.test_sscs_virtual_column() report.process_input('3\n4\n5\n6') tile = Tile.select(tile.dashboard_id, Layout.select(tile.owner_id, tile.dashboard_id).layout_dict.keys()[0]) self.assertEqual(4, len(tile.series_specs())) layouts.detach_tile(tile) rows = c.dao.LayoutDAO.select_layout_by_report_multi(tile.owner_id, tile.report_id, [], 'sscs', 100) self.assertTrue(rows) report.process_input('3\n4\n5\n6') rows = c.dao.LayoutDAO.select_layout_by_report_multi(tile.owner_id, tile.report_id, [], 'sscs', 100) self.assertFalse(rows)
def test_tpcreator_as_mod_performance(self): owner_id = uuid.uuid4() dashboard_id = uuid.uuid4() tile_config = { 'tags': ['str:sample_string'], 'series_spec_list': [ dataseries.SeriesSpec(0, -1, dict(op='eq', args=['0'])), ], 'tile_options': { 'tpcreator_uispec': [{ 'tag': 'str:sample_string', 'prefix': 'str:' }], } } r = reports.Report.insert(owner_id, 'r') master_tile = Tile.insert(owner_id, r.report_id, dashboard_id, tile_config) layouts.place_tile(master_tile) strs = [random_string() for _ in xrange(199)] mods = [] layout_rows = c.dao.LayoutDAO.select_layout_by_report_multi( owner_id, r.report_id, [], 'tpcreator', 100) start = time() for str in strs: res = r.process_input('1', tags=['str:%s' % str], handle_tpcreator=False) mods.append( tpcreator.tpcreator_mod(res.report_instance, layout_rows[0], 200)) print 'Creating report instances took %.1f' % ((time() - start) * 1000) start = time() layouts.apply_mods(mods, owner_id, dashboard_id, None) print 'Applying tpcreator_mods took %.1f' % ((time() - start) * 1000) layout = Layout.select(owner_id, dashboard_id) self.assertEqual(200, len(layout.layout_dict)) tags_set = {tile.tags[0].split(':')[1] for tile in layout.tile_dict} self.assertEqual(200, len(tags_set)) self.assertEqual(tags_set, set(strs + ['sample_string']))
def test_synchronize_sizes_of_tpcreated(self): rd, master_tile = self.test_handle_tpcreator() layout = layouts.Layout.select(rd.owner_id, rd.dashboard_id) ld = layout.layout_dict ld[master_tile.tile_id]['width'] = 8 ld[master_tile.tile_id]['height'] = 3 ld = layouts.apply_mods_for_noninserted_layout( [layouts.repack_mod()], Layout(ld)).new_layout.layout_dict layout_id = layout.set(rd.owner_id, rd.dashboard_id) self.assertTrue(layout_id) self.assertTrue( tpcreator.synchronize_sizes_of_tpcreated(master_tile, layout_id)) layout = Layout.select(rd.owner_id, rd.dashboard_id) ld = layout.layout_dict for tile_id in tpcreator.select_tpcreated_tile_ids(master_tile): self.assertEqual(8, ld[tile_id]['width']) self.assertEqual(3, ld[tile_id]['height'])
def test_tpcreator_as_mod(self): owner_id = uuid.uuid4() dashboard_id = uuid.uuid4() tile_config = { 'tags': ['p1:10'], 'series_spec_list': [ dataseries.SeriesSpec(0, -1, dict(op='eq', args=['0'])), ], 'tile_options': { 'tpcreator_uispec': [{ 'tag': 'p1:10', 'prefix': 'p1:' }], } } r = reports.Report.insert(owner_id, 'r') master_tile = Tile.insert(owner_id, r.report_id, dashboard_id, tile_config) layouts.place_tile(master_tile) ri1 = r.process_input('0', tags=['p1:11'], handle_tpcreator=False).report_instance ri2 = r.process_input('0', tags=['p1:12'], handle_tpcreator=False).report_instance ri3 = r.process_input('0', tags=['p1:12'], handle_tpcreator=False).report_instance layout_rows = c.dao.LayoutDAO.select_layout_by_report_multi( owner_id, r.report_id, [], 'tpcreator', 100) mods = [ tpcreator.tpcreator_mod(ri1, layout_rows[0]), tpcreator.tpcreator_mod(ri2, layout_rows[0]), tpcreator.tpcreator_mod(ri3, layout_rows[0]) ] layouts.apply_mods(mods, owner_id, dashboard_id, None) layout = Layout.select(owner_id, dashboard_id) self.assertEqual(3, len(layout.layout_dict)) self.assertEqual([['p1:10'], ['p1:11'], ['p1:12']], sorted(tile.tags for tile in layout.tile_dict))
def test_deleting_layout_by_report_row_after_deleting_dashboard(self): tile, report = self.test_sscs_virtual_column() report.process_input('3\n4\n5\n6') tile = Tile.select( tile.dashboard_id, Layout.select(tile.owner_id, tile.dashboard_id).layout_dict.keys()[0]) self.assertEqual(4, len(tile.series_specs())) od = dashboards.OwnerDashboards(tile.owner_id) for db in od.dashboards: db.delete() rows = c.dao.LayoutDAO.select_layout_by_report_multi( tile.owner_id, tile.report_id, [], 'sscs', 100) self.assertTrue(rows) report.process_input('3\n4\n5\n6\n7\n8') rows = c.dao.LayoutDAO.select_layout_by_report_multi( tile.owner_id, tile.report_id, [], 'sscs', 100) self.assertFalse(rows)
def test_expire_tiles_without_data_optimize_check(self): owner_id = report_data('points').report.owner_id report_id = report_data('points').report.report_id dashboard_id = report_data('points').dashboard_id report_data('points').report.process_input( json.dumps([ OrderedDict([('user_name', 'xxx'), ('is_active', True), ('points', 1000)]), OrderedDict([('user_name', 'yy'), ('is_active', True), ('points', 2000)]), ]), created=datetime.datetime.utcnow() - datetime.timedelta(hours=8)) tile_config_1 = { 'tw_type': 'Range', 'series_spec_list': [ dataseries.SeriesSpec(2, 0, dict(op='eq', args=['monique'])), ], 'tile_options': { 'seconds_back': 86400, } } tile1 = tiles.Tile.insert(owner_id, report_id, dashboard_id, tile_config_1) self.assertTrue(tile1.get_tile_data()['series_data'][0]['data_points']) tile_config_2 = { 'tw_type': 'Range', 'series_spec_list': [ dataseries.SeriesSpec(2, 0, dict(op='eq', args=['john'])), ], 'tile_options': { 'seconds_back': 86400, } } tile2 = tiles.Tile.insert(owner_id, report_id, dashboard_id, tile_config_2) self.assertTrue(tile2.get_tile_data()['series_data'][0]['data_points']) tile_config_3 = { 'tw_type': 'Range', 'series_spec_list': [ dataseries.SeriesSpec(2, 0, dict(op='eq', args=['xxx'])), ], 'tile_options': { 'seconds_back': 86400, } } tile3 = tiles.Tile.insert(owner_id, report_id, dashboard_id, tile_config_3) self.assertTrue(tile3.get_tile_data()['series_data'][0]['data_points']) place_tile(tile1) place_tile(tile2) place_tile(tile3) res = tiles.expire_tiles_without_data([tile1, tile2, tile3], 3600, Layout.select( owner_id, dashboard_id).layout_id) self.assertTrue(res) tile1 = tiles.Tile.select(tile1.dashboard_id, tile1.tile_id) self.assertIsNotNone(tile1) tile2 = tiles.Tile.select(tile2.dashboard_id, tile2.tile_id) self.assertIsNotNone(tile2) tile3 = tiles.Tile.select(tile3.dashboard_id, tile3.tile_id) self.assertIsNone(tile3) res = tiles.expire_tiles_without_data([tile1, tile2], 3600, Layout.select( owner_id, dashboard_id).layout_id) self.assertFalse(res)
def main(): vars = tutorial.main() points_report = vars['points_report'] owner_id = vars['owner_id'] owner_dashboards = vars['owner_dashboards'] dashboard = vars['dashboard'] SECTION('Tile_config and tile_options') from mqe.dataseries import SeriesSpec from mqe.tiles import Tile tile_config = { 'series_spec_list': [ SeriesSpec(2, 0, { 'op': 'eq', 'args': ['john'] }), SeriesSpec(2, 0, { 'op': 'eq', 'args': ['monique'] }), ], 'tile_options': { 'tile_title': 'Points by user', } } tile = Tile.insert(owner_id, points_report.report_id, dashboard.dashboard_id, tile_config) pprint(tile.tile_options) tile_options2 = tile.tile_options.copy() tile_options2['owner_id'] = uuid.uuid4() tile2 = Tile.insert_with_tile_options(dashboard.dashboard_id, tile_options2) SECTION('Updating tile\'s config') from mqe.layouts import Layout, replace_tiles layout = Layout.select(owner_id, dashboard.dashboard_id) tile = layout.tile_dict.keys()[0] tile_config = tile.get_tile_config() tile_config['tile_options']['seconds_back'] = 3600 repl_tile = tile.insert_similar(tile_config) replace_tiles({tile: repl_tile}, for_layout_id=layout.layout_id) SECTION('Formatting tile data - tilewidgets and drawers') tile_config = { 'tw_type': 'Range', 'series_spec_list': [ SeriesSpec(2, 0, { 'op': 'eq', 'args': ['john'] }), SeriesSpec(2, 0, { 'op': 'eq', 'args': ['monique'] }), ], 'tile_options': { 'tile_title': 'Points by user', 'drawer_type': 'ChartRangeDrawer', 'colors': ['red', 'blue'], 'seconds_back': 3600, } } SECTION('Updating tile data') tile_data = tile.get_tile_data() input = """\ user_name is_active points john true 144 monique true 241 """ res = points_report.process_input(input) last_report_instance_id = tile_data['series_data'][0]['data_points'][ -1].rid new_tile_data = tile.get_new_tile_data(last_report_instance_id) SECTION('Managing colors') from mqe.dataseries import update_default_options tile_config = { 'series_spec_list': [ SeriesSpec(2, 0, { 'op': 'eq', 'args': ['john'] }), SeriesSpec(2, 0, { 'op': 'eq', 'args': ['monique'] }), ], 'tile_options': { 'colors': ['blue', 'red'], } } tile = Tile.insert(owner_id, points_report.report_id, dashboard.dashboard_id, tile_config) print tile.get_tile_data()['combined_colors'] update_default_options(tile) tile_config_2 = { 'series_spec_list': [ SeriesSpec(2, 0, { 'op': 'eq', 'args': ['monique'] }), ], } tile_2 = Tile.insert(owner_id, points_report.report_id, dashboard.dashboard_id, tile_config_2) print tile_2.get_tile_data()['combined_colors'] SECTION('Data series names') series_spec = SeriesSpec(2, 0, {'op': 'eq', 'args': ['monique']}) series_spec.set_name("monique's points") tile_config = {'series_spec_list': [series_spec]} tile = Tile.insert(owner_id, points_report.report_id, dashboard.dashboard_id, tile_config) print tile.get_tile_data()['series_data'][0]['name'] SECTION('Creating custom tilewidgets and drawers') from mqe.tilewidgets import register_drawer_class, Drawer @register_drawer_class class MaxNumberDrawer(Drawer): drawer_type = 'MaxNumberDrawer' def process_tile_data(self, tile_data): max_number = 0 for series_data in tile_data['series_data']: for point in series_data['data_points']: if int(point.value) > max_number: max_number = int(point.value) tile_data['max_number'] = max_number tile_config = { 'series_spec_list': [ SeriesSpec(2, 0, { 'op': 'eq', 'args': ['john'] }), SeriesSpec(2, 0, { 'op': 'eq', 'args': ['monique'] }), ], 'tile_options': { 'drawer_type': 'MaxNumberDrawer', } } tile = Tile.insert(owner_id, points_report.report_id, dashboard.dashboard_id, tile_config) print tile.get_tile_data()['max_number']
def main(): SECTION('Creating a report and report instances') import uuid from mqe.reports import Report owner_id = uuid.uuid4() simple_report = Report.insert(owner_id, 'simple') res = simple_report.process_input('10 20') print res.report_instance.table points_report = Report.insert(owner_id, 'points') input = """\ user_name is_active points john true 128 monique true 210 """ res = points_report.process_input(input) print res.report_instance.table SECTION('Creating a dashboard and a tile') from mqe.dashboards import OwnerDashboards owner_dashboards = OwnerDashboards(owner_id) dashboard = owner_dashboards.insert_dashboard('My Dashboard') from mqe.dataseries import SeriesSpec tile_config = { 'tw_type': 'Range', 'series_spec_list': [ SeriesSpec(2, 0, {'op': 'eq', 'args': ['john']}), SeriesSpec(2, 0, {'op': 'eq', 'args': ['monique']}), ], 'tile_options': { 'seconds_back': 86400, 'tile_title': 'Points by user', } } from mqe.tiles import Tile tile = Tile.insert(owner_id, points_report.report_id, dashboard.dashboard_id, tile_config) pprint(tile.get_tile_data()) SECTION('Placing a tile in a dashboard layout') from mqe.layouts import place_tile res = place_tile(tile) if not res: raise ValueError('Placing the tile unsuccessful') from mqe.layouts import Layout layout = Layout.select(owner_id, dashboard.dashboard_id) pprint(layout.layout_dict) def render_dashboard(owner_id, dashboard): print 'Rendering dashboard %r' % dashboard.dashboard_name layout = Layout.select(owner_id, dashboard.dashboard_id) for tile, visual_options in layout.tile_dict.items(): tile_data = tile.get_tile_data() print 'Rendering tile %r at position %s/%s' % ( tile_data['generated_tile_title'], visual_options['x'], visual_options['y']) # render tile_data['series_data'] render_dashboard(owner_id, dashboard) return locals()
def main(): vars = tutorial.main() points_report = vars['points_report'] tile = vars['tile'] owner_id = vars['owner_id'] owner_dashboards = vars['owner_dashboards'] SECTION('Auto-creating new data series') input = """\ user_name is_active points john true 128 monique true 210 alex true 12 """ points_report.process_input(input) series_names = [ series_data['name'] for series_data in tile.get_tile_data()['series_data'] ] print series_names new_dashboard = owner_dashboards.insert_dashboard('Points') tile_config = { 'tw_type': 'Range', 'series_spec_list': [ SeriesSpec(2, 0, { 'op': 'eq', 'args': ['john'] }), SeriesSpec(2, 0, { 'op': 'eq', 'args': ['monique'] }), ], 'tile_options': { 'seconds_back': 86400, 'tile_title': 'Points by user', 'sscs': SeriesSpec(2, 0, { 'op': 'eq', 'args': ['john'] }) } } new_tile = Tile.insert(owner_id, points_report.report_id, new_dashboard.dashboard_id, tile_config) place_tile(new_tile) input = """\ user_name is_active points john true 133 monique true 220 alex true 18 andrew true 6 """ points_report.process_input(input) layout = Layout.select(owner_id, new_dashboard.dashboard_id) tile_id = layout.layout_dict.keys()[0] tile = Tile.select(new_dashboard.dashboard_id, tile_id) series_names = [ series_data['name'] for series_data in tile.get_tile_data()['series_data'] ] print series_names
def test_sscs_set_layout_fails(self): tile, report = self.test_sscs_virtual_column() dashboard_id_1 = tile.dashboard_id dashboard_id_2 = uuid.uuid1() tile2 = tile.copy(dashboard_id_2) self.assertEqual(3, len(tile.series_specs())) self.assertTrue(layouts.place_tile(tile2)) report.process_input('3\n4\n5\n6') layout2 = Layout.select(tile.owner_id, dashboard_id_2) self.assertEqual(1, len(layout2.layout_dict)) self.assertEqual(4, len(layout2.tile_dict.keys()[0].series_specs())) layout1 = Layout.select(tile.owner_id, dashboard_id_1) self.assertEqual(1, len(layout1.layout_dict)) self.assertEqual(4, len(layout1.tile_dict.keys()[0].series_specs())) dashboard_id_3 = uuid.uuid1() tile3 = tile.copy(dashboard_id_3) self.assertEqual(3, len(tile.series_specs())) self.assertTrue(layouts.place_tile(tile3)) report.process_input('3\n4\n5\n6\n7') layout3 = Layout.select(tile.owner_id, dashboard_id_3) self.assertEqual(1, len(layout3.layout_dict)) self.assertEqual(5, len(layout3.tile_dict.keys()[0].series_specs())) layout2 = Layout.select(tile.owner_id, dashboard_id_2) self.assertEqual(1, len(layout2.layout_dict)) self.assertEqual(5, len(layout2.tile_dict.keys()[0].series_specs())) layout1 = Layout.select(tile.owner_id, dashboard_id_1) self.assertEqual(1, len(layout1.layout_dict)) self.assertEqual(5, len(layout1.tile_dict.keys()[0].series_specs())) mock_data = {'call': 0} def mock__set_new_layout(*args, **kwargs): mock_data['call'] += 1 if mock_data['call'] >= 2: return None return mock__set_new_layout.old_fun(*args, **kwargs) with patch(layouts.Layout, layouts.Layout.set, mock__set_new_layout): report.process_input('3\n4\n5\n6\n7\n8') layout3 = Layout.select(tile.owner_id, dashboard_id_3) self.assertEqual(1, len(layout3.layout_dict)) self.assertEqual(5, len(layout3.tile_dict.keys()[0].series_specs())) layout2 = Layout.select(tile.owner_id, dashboard_id_2) self.assertEqual(1, len(layout2.layout_dict)) self.assertEqual(5, len(layout2.tile_dict.keys()[0].series_specs())) layout1 = Layout.select(tile.owner_id, dashboard_id_1) self.assertEqual(1, len(layout1.layout_dict)) self.assertEqual(6, len(layout1.tile_dict.keys()[0].series_specs())) mock_data = {'call': 0} def mock__set_new_layout(*args, **kwargs): mock_data['call'] += 1 if mock_data['call'] in (2, 3, 4): return None mock_data['call'] = mock_data['call'] + 1 return mock__set_new_layout.old_fun(*args, **kwargs) with patch(layouts.Layout, layouts.Layout.set, mock__set_new_layout): report.process_input('3\n4\n5\n6\n7\n8\n9') layout3 = Layout.select(tile.owner_id, dashboard_id_3) self.assertEqual(1, len(layout3.layout_dict)) self.assertEqual(7, len(layout3.tile_dict.keys()[0].series_specs())) layout2 = Layout.select(tile.owner_id, dashboard_id_2) self.assertEqual(1, len(layout2.layout_dict)) self.assertEqual(7, len(layout2.tile_dict.keys()[0].series_specs())) layout1 = Layout.select(tile.owner_id, dashboard_id_1) self.assertEqual(1, len(layout1.layout_dict)) self.assertEqual(7, len(layout1.tile_dict.keys()[0].series_specs()))
def main(): vars = tutorial.main() owner_id = vars['owner_id'] owner_dashboards = vars['owner_dashboards'] dashboard = vars['dashboard'] SECTION('Using tags for identifying entities') from mqe.reports import Report cpu_report = Report.select_or_insert(owner_id, 'cpu_usage') metrics = [ ('user', 42.3), ('system', 13.4), ('io', 8.4), ] cpu_report.process_input(json.dumps(metrics), tags=['ip:192.168.1.18']) SECTION('Creating a master tile') from mqe.dataseries import SeriesSpec from mqe.tiles import Tile from mqe.layouts import place_tile, Layout, replace_tiles dashboard = owner_dashboards.insert_dashboard('CPU') master_tile_config = { 'tw_type': 'Range', 'tags': ['ip:192.168.1.18'], 'series_spec_list': [ SeriesSpec(1, 0, { 'op': 'eq', 'args': ['user'] }), SeriesSpec(1, 0, { 'op': 'eq', 'args': ['system'] }), ], 'tile_options': { 'tile_title': 'CPU usage', 'tpcreator_uispec': [{ 'tag': 'ip:192.168.1.18', 'prefix': 'ip:' }] } } master_tile = Tile.insert(owner_id, cpu_report.report_id, dashboard.dashboard_id, master_tile_config) print place_tile(master_tile) SECTION('Creating tiles from a master tile') metrics = json.dumps(metrics) cpu_report.process_input(metrics, tags=['ip:192.168.1.30']) cpu_report.process_input(metrics, tags=['ip:192.168.2.51']) cpu_report.process_input(metrics, tags=['ip:192.168.2.51']) layout = Layout.select(owner_id, dashboard.dashboard_id) for tile in layout.tile_dict: print tile.tags SECTION('Synchronizing options of tpcreated tiles') new_master_tile_config = { 'tw_type': 'Range', 'tags': ['ip:192.168.1.18'], 'series_spec_list': [ SeriesSpec(1, 0, { 'op': 'eq', 'args': ['user'] }), SeriesSpec(1, 0, { 'op': 'eq', 'args': ['system'] }), SeriesSpec(1, 0, { 'op': 'eq', 'args': ['io'] }), ], 'tile_options': { 'tile_title': 'CPU usage', 'tpcreator_uispec': [{ 'tag': 'ip:192.168.1.18', 'prefix': 'ip:' }] } } new_master_tile = Tile.insert(owner_id, cpu_report.report_id, dashboard.dashboard_id, new_master_tile_config) assert replace_tiles({master_tile: new_master_tile}, for_layout_id=None) layout = Layout.select(owner_id, dashboard.dashboard_id) for tile in layout.tile_dict: print len(tile.get_tile_data()['series_data']) SECTION('Expiring tiles and promoting new masters') from mqe.tpcreator import make_master_from_tpcreated old_master = [tile for tile in layout.tile_dict if tile.is_master_tile()][0] new_chosen_master = [ tile for tile in layout.tile_dict if tile.tags == ['ip:192.168.2.51'] ][0] assert not new_chosen_master.is_master_tile() new_master = make_master_from_tpcreated(old_master, new_chosen_master) res = replace_tiles({ old_master: new_master, new_chosen_master: None }, for_layout_id=None) print 'replaced %d tiles' % len(res.tile_replacement) layout = Layout.select(owner_id, dashboard.dashboard_id) tile = [ tile for tile in layout.tile_dict if tile.tags == ['ip:192.168.2.51'] ][0] print tile.is_master_tile()
def test_multiple_tags_order(self): tile_config = { 'tags': ['p1:10', 'p2:10', 'zzz'], 'series_spec_list': [ dataseries.SeriesSpec(0, -1, dict(op='eq', args=['0'])), ], 'tile_options': { 'tpcreator_uispec': [{ 'tag': 'p1:10', 'prefix': 'p1:' }, { 'tag': 'p1:20', 'prefix': 'p1:' }, { 'tag': 'zzz', 'prefix': 'z' }], } } owner_id = uuid.uuid1() dashboard_id_1 = uuid.uuid1() r = reports.Report.insert(owner_id, 'r') master_tile = Tile.insert(owner_id, r.report_id, dashboard_id_1, tile_config) layouts.place_tile(master_tile) r.process_input('1', tags=['p1:11', 'p1:12']) self.assertEqual( 1, len(Layout.select(owner_id, dashboard_id_1).layout_dict)) r.process_input('1', tags=['p1:11', 'p2:12', 'zz']) layout = Layout.select(owner_id, dashboard_id_1) self.assertEqual(2, len(layout.layout_dict)) self.assertIn(['p1:11', 'zz'], [t.tags for t in layout.tile_dict]) r.process_input('1', tags=[ 'p2:12', 'aaa', 'p1:11', ]) layout = Layout.select(owner_id, dashboard_id_1) self.assertEqual(2, len(layout.layout_dict)) tile_config_2 = { 'tags': ['p1:10', 'p2:10'], 'series_spec_list': [ dataseries.SeriesSpec(0, -1, dict(op='eq', args=['0'])), ], 'tile_options': { 'tpcreator_uispec': [{ 'tag': 'p1:10', 'prefix': 'p1:' }, { 'tag': 'p1:20', 'prefix': '' }] } } dashboard_id_2 = uuid.uuid1() master_tile_2 = Tile.insert(owner_id, r.report_id, dashboard_id_2, tile_config_2) layouts.place_tile(master_tile_2) r.process_input('1', tags=['p1:11', 'p2:12']) layout = Layout.select(owner_id, dashboard_id_2) self.assertEqual(2, len(layout.layout_dict)) self.assertIn(['p1:11', 'p2:12'], [t.tags for t in layout.tile_dict]) tile_config_3 = { 'tags': ['p2:10', 'p1:10'], 'series_spec_list': [ dataseries.SeriesSpec(0, -1, dict(op='eq', args=['0'])), ], 'tile_options': { 'tpcreator_uispec': [{ 'tag': 'p1:20', 'prefix': '' }, { 'tag': 'p1:10', 'prefix': 'p1:' }] } } dashboard_id_3 = uuid.uuid1() master_tile_3 = Tile.insert(owner_id, r.report_id, dashboard_id_3, tile_config_3) layouts.place_tile(master_tile_3) r.process_input('1', tags=['p1:10', 'p2:10']) layout = Layout.select(owner_id, dashboard_id_3) self.assertEqual(1, len(layout.layout_dict)) r.process_input('1', tags=['p2:11', 'p1:12']) layout = Layout.select(owner_id, dashboard_id_3) self.assertEqual(2, len(layout.layout_dict)) self.assertIn(['p1:12', 'p2:11'], [t.tags for t in layout.tile_dict])
def main(): vars = tutorial.main() points_report = vars['points_report'] tile = vars['tile'] owner_id = vars['owner_id'] owner_dashboards = vars['owner_dashboards'] dashboard = vars['dashboard'] SECTION('Placing, detaching, replacing tiles') from mqe.layouts import Layout, place_tile layout = Layout.select(owner_id, dashboard.dashboard_id) new_tile = tile.copy(dashboard.dashboard_id) # we decided that new_tile should be put in the current layout res = place_tile(new_tile, for_layout_id=layout.layout_id) if not res: raise ValueError('Placing the tile unsuccessful') else: print 'New tile placed with visual_options', res.new_tiles[new_tile] from mqe.layouts import replace_tiles from mqe.tiles import Tile layout = Layout.select(owner_id, dashboard.dashboard_id) tile = Tile.select(dashboard.dashboard_id, layout.layout_dict.keys()[0]) tile_config = tile.get_tile_config() tile_config['tile_options']['tile_title'] = 'New Title' repl_tile = tile.insert_similar(tile_config) res = replace_tiles({tile: repl_tile}, for_layout_id=layout.layout_id) if not res: raise ValueError('Replacement of tiles unsuccessful') else: print 'Tiles replaced:', res.tile_replacement SECTION('Setting a custom layout') layout = Layout.select(owner_id, dashboard.dashboard_id) for visual_options in layout.layout_dict.values(): visual_options['height'] += 1 new_layout_id = layout.set() if not new_layout_id: raise ValueError('Updating the layout failed') SECTION('Layout mods') from mqe.layouts import replace_tiles_mod, place_tile_mod, apply_mods tile = repl_tile tile1 = tile.copy(dashboard.dashboard_id) tile2 = tile.copy(dashboard.dashboard_id) tile3 = tile.copy(dashboard.dashboard_id) layout = Layout.select(owner_id, dashboard.dashboard_id) mods = [ replace_tiles_mod({tile: tile1}), place_tile_mod(tile2), place_tile_mod(tile3), ] res = apply_mods(mods, owner_id, dashboard.dashboard_id, for_layout_id=layout.layout_id) if not res: raise ValueError('Operation failed') else: print res from mqe.layouts import LayoutModificationImpossible def detach_top_tiles_mod(): def do(layout_mod): tile_ids = [ tile_id for tile_id, visual_options in layout_mod.layout.layout_dict.items() if visual_options['y'] == 0 ] if not tile_ids: raise LayoutModificationImpossible() for tile_id in tile_ids: del layout_mod.layout.layout_dict[tile_id] layout_mod.detached_tiles.append( Tile.select(layout_mod.layout.dashboard_id, tile_id)) return do res = apply_mods([detach_top_tiles_mod()], owner_id, dashboard.dashboard_id, None) if not res: raise ValueError('Operation failed') else: print res def detach_top_tiles_using_replacement_mod(): def do(layout_mod): tiles = [ tile for tile, visual_options in layout_mod.layout.tile_dict.items() if visual_options['y'] == 0 ] if not tiles: raise LayoutModificationImpossible() replace_tiles_mod({tile: None for tile in tiles})(layout_mod) return do
def test_set_layout_fails(self): owner_id = uuid.uuid1() dashboard_id_1 = uuid.uuid1() r = reports.Report.insert(owner_id, 'r') tile_config = { 'tw_type': 'Single', 'tags': ['p1:10'], 'series_spec_list': [ dataseries.SeriesSpec(0, -1, dict(op='eq', args=['0'])), ], 'tile_options': {} } tile_config['tile_options'][ 'tpcreator_uispec'] = tpcreator.suggested_tpcreator_uispec( ['p1:10']) master_tile_1 = Tile.insert(owner_id, r.report_id, dashboard_id_1, tile_config) layouts.place_tile(master_tile_1) r.process_input('1', tags=['p1:10']) self.assertEqual( 1, len( Layout.select(master_tile_1.owner_id, master_tile_1.dashboard_id).layout_dict)) master_tile_2 = master_tile_1.copy(dashboard_id_1) layouts.place_tile(master_tile_2) r.process_input('1', tags=['p1:11']) layout_1 = Layout.select(master_tile_1.owner_id, master_tile_1.dashboard_id) self.assertEqual(4, len(layout_1.layout_dict)) self.assertEqual( 1, len(layout_1.get_tpcreated_tile_ids(master_tile_1.tile_id))) self.assertEqual( 1, len(layout_1.get_tpcreated_tile_ids(master_tile_2.tile_id))) self.assertNotEqual( layout_1.get_tpcreated_tile_ids(master_tile_1.tile_id), layout_1.get_tpcreated_tile_ids(master_tile_2.tile_id)) dashboard_id_2 = uuid.uuid1() master_tile_3 = master_tile_1.copy(dashboard_id_2) layouts.place_tile(master_tile_3) dashboard_id_3 = uuid.uuid1() master_tile_4 = master_tile_1.copy(dashboard_id_3) layouts.place_tile(master_tile_4) r.process_input('1', tags=['p1:12']) layout_1 = Layout.select(master_tile_1.owner_id, dashboard_id_1) layout_2 = Layout.select(master_tile_1.owner_id, dashboard_id_2) layout_3 = Layout.select(master_tile_1.owner_id, dashboard_id_3) self.assertEqual(6, len(layout_1.layout_dict)) self.assertEqual(2, len(layout_2.layout_dict)) self.assertEqual(2, len(layout_3.layout_dict)) mock_data = {'call': 0} def mock__set_new_layout(*args, **kwargs): mock_data['call'] += 1 if mock_data['call'] >= 2: return None return mock__set_new_layout.old_fun(*args, **kwargs) with patch(layouts.Layout, layouts.Layout.set, mock__set_new_layout): r.process_input('1', tags=['p1:13']) layout_1 = Layout.select(master_tile_1.owner_id, dashboard_id_1) layout_2 = Layout.select(master_tile_1.owner_id, dashboard_id_2) layout_3 = Layout.select(master_tile_1.owner_id, dashboard_id_3) self.assertEqual(8, len(layout_1.layout_dict)) self.assertEqual(2, len(layout_2.layout_dict)) self.assertEqual(2, len(layout_3.layout_dict)) mock_data = {'call': 0} def mock__set_new_layout(*args, **kwargs): mock_data['call'] += 1 if mock_data['call'] % 5 != 0: return None return mock__set_new_layout.old_fun(*args, **kwargs) with patch(layouts.Layout, layouts.Layout.set, mock__set_new_layout): r.process_input('1', tags=['p1:14']) layout_1 = Layout.select(master_tile_1.owner_id, dashboard_id_1) layout_2 = Layout.select(master_tile_1.owner_id, dashboard_id_2) layout_3 = Layout.select(master_tile_1.owner_id, dashboard_id_3) self.assertEqual(10, len(layout_1.layout_dict)) self.assertEqual(3, len(layout_2.layout_dict)) self.assertEqual(3, len(layout_3.layout_dict))