Пример #1
0
    def insert_dashboard(self, dashboard_name, dashboard_options={}):
        """Insert a dashboard having the passed ``dashboard_name`` and ``dashboard_options`` (a JSON-serializable value).
        """
        from mqe import layouts

        row = c.dao.DashboardDAO.insert(self.owner_id, dashboard_name,
                                        serialize.mjson(dashboard_options))
        if not row:
            return None
        dashboard = Dashboard(row)

        change_dashboards_ordering(
            self.owner_id,
            self.dashboard_id_ordering + [dashboard.dashboard_id])

        empty_layout = layouts.Layout()
        empty_layout.set(self.owner_id, row['dashboard_id'], None)

        log.info('Inserted new dashboard dashboard_id=%s name=%r',
                 dashboard.dashboard_id, dashboard.dashboard_name)

        self.reload()

        fire_signal(new_dashboard, dashboard=dashboard)

        return Dashboard(row)
Пример #2
0
def handle_tpcreator(owner_id, report_id, report_instance):
    """The method calls the TPCreator (see :ref:`guide_tpcreator`) for the given report instance,
    possibly creating new tiles from a master tile and altering dashboards'
    layouts. The signal :attr:`~mqe.signals.layout_modified` is issued for each
    modification."""
    layout_rows = c.dao.LayoutDAO.select_layout_by_report_multi(
        owner_id, report_id, [], 'tpcreator',
        mqeconfig.MAX_TPCREATORS_PER_REPORT)
    if not layout_rows:
        log.debug('No layout_by_report tpcreator rows')
        return

    log.info(
        'tpcreator is processing %s rows for owner_id=%s report_id=%s report_instance_id=%s',
        len(layout_rows), owner_id, report_id,
        report_instance.report_instance_id)
    for row in layout_rows:
        mods = [
            tpcreator_mod(report_instance, row),
            layouts.if_mod(lambda layout_mod: layout_mod.new_tiles,
                           layouts.repack_mod())
        ]
        lmr = layouts.apply_mods(mods,
                                 owner_id,
                                 row['dashboard_id'],
                                 for_layout_id=None,
                                 max_tries=MAX_TPCREATE_TRIES)
        if lmr and lmr.new_layout.layout_id != lmr.old_layout.layout_id:
            fire_signal(layout_modified,
                        reason='tpcreator',
                        layout_modification_result=lmr)
Пример #3
0
def handle_tpcreator_row(row, report_instance):
    log.debug('Processing row %s', row)

    layout = layouts.Layout.select(row['owner_id'], row['dashboard_id'])
    if not layout:
        log.warn('No layout')
        return True

    layout_id = layout.layout_id

    tpcreator_spec_by_master_id, tpcreated_tags_by_master_id = _get_tpcreator_data(layout, row['report_id'])
    log.debug('tpcreator data: %s, %s', tpcreator_spec_by_master_id, tpcreated_tags_by_master_id)

    if not tpcreator_spec_by_master_id:
        log.info('Deleting obsoleted layout_by_report tpcreator row')
        c.dao.LayoutDAO.delete_layout_by_report(row['owner_id'], row['report_id'], row['tags'],
                                                row['label'], row['dashboard_id'], row['layout_id'])
        return True

    for master_id, tpcreator_spec in tpcreator_spec_by_master_id.items():
        log.debug('Processing master_id=%s tpcreator_spec=%s', master_id, tpcreator_spec)
        tpcreated_tags = tpcreated_tags_by_master_id[master_id]
        if len(tpcreated_tags) >= mqeconfig.MAX_TPCREATED:
            log.warn('Too many tpcreated for master_id=%s', master_id)
            continue

        matching_tags = tags_matching_tpcreator_spec(tpcreator_spec, report_instance.all_tags)
        if not matching_tags:
            log.debug('No tags match the tpcreator_spec')
            continue
        if tuple(matching_tags) in tpcreated_tags:
            log.debug('A tpcreated tile already exists for the matched tags %s', matching_tags)
            continue

        master_tile = Tile.select(row['dashboard_id'], master_id)
        if not master_tile:
            log.warn('No master_tile')
            continue

        new_tile_options = _tile_options_of_tpcreated(master_tile, tpcreator_spec, matching_tags)
        new_tile = Tile.insert_with_tile_options(master_tile.dashboard_id, new_tile_options)
        log.info('tpcreator created new tile with tags %s for report_id=%s', matching_tags,
                 row['report_id'])
        mres = layouts.place_tile(new_tile, size_of=master_tile.tile_id,
                                  for_layout_id=layout_id)
        if not mres:
            log.debug('Placing new tile failed')
            return False

        fire_signal(layout_modified,
                    reason='tpcreator',
                    layout_modification_result=mres)

        layout_id = mres.new_layout.layout_id

    return True
Пример #4
0
    def select_or_insert(owner_id, report_name):
        """Returns a :class:`Report` having the passed name - either an existing row or a newly
        created"""
        inserted, row = c.dao.ReportDAO.select_or_insert(owner_id, report_name)
        if not row:
            return
        report = Report(row)

        if inserted:
            fire_signal(new_report, report=report)
        return report
Пример #5
0
def init_dao_modules(database_type):
    for module_path in DAO_MODULE_PATHS_BY_DATABASE_TYPE[mqeconfig.DATABASE_TYPE]:
        module = importlib.import_module(module_path)
        fire_signal(dao_module_loaded, database_type=database_type,
                    module_path=module_path, module=module)
        if hasattr(module, 'initialize'):
            module.initialize()
        for v in vars(module).values():
            if inspect.isclass(v) and issubclass(v, BaseDAO):
                register_dao_class(database_type, v)
    DAO_MODULE_PATHS_BY_DATABASE_TYPE[mqeconfig.DATABASE_TYPE] = []
Пример #6
0
    def insert(owner_id, report_name):
        """Insert and return a new :class:`Report` having the passed name. Returns ``None``
        if it already exists."""
        row = c.dao.ReportDAO.insert(owner_id, report_name)
        if not row:
            return None

        report = Report(row)

        fire_signal(new_report, report=report)

        return report
Пример #7
0
def handle_sscreator(owner_id, report_id, report_instance):
    """The method calls the SSCS (see :ref:`guide_sscreator`) for the given report instance,
    possibly creating new series definitions for tiles and altering dashboards'
    layouts. The signal :attr:`~mqe.signals.layout_modified` is issued for each
    modification."""
    layout_rows = c.dao.LayoutDAO.select_layout_by_report_multi(owner_id, report_id, [], 'sscs',
                                            mqeconfig.MAX_DASHBOARDS_WITH_SSCS_PER_REPORT)
    if not layout_rows:
        log.debug('No layout_by_report sscs rows')
        return

    log.info('sscreator is processing %s rows for owner_id=%s report_id=%s report_instance_id=%s',
             len(layout_rows), owner_id, report_id, report_instance.report_instance_id)
    for row in layout_rows:
        mods = [sscreator_mod(report_instance, row)]
        lmr = layouts.apply_mods(mods, owner_id, row['dashboard_id'], for_layout_id=None,
                                 max_tries=MAX_SSCS_TRIES)
        if lmr and lmr.new_layout.layout_id != lmr.old_layout.layout_id:
            fire_signal(layout_modified, reason='sscreator', layout_modification_result=lmr)
Пример #8
0
def handle_tpcreator(owner_id, report_id, report_instance, make_first_master=False):
    """The method calls the TPCreator (see :ref:`guide_tpcreator`) for the given report instance,
    possibly creating new tiles from a master tile and altering dashboards'
    layouts. The signal :attr:`~mqe.signals.layout_modified` is issued for each
    modification.

    :param bool make_first_master: whether to promote the first tile wrt. ordering
        of tag values to a master tile. The default is ``False``, which means that
        a new master tile will not be promoted.

    """
    layout_rows = c.dao.LayoutDAO.select_layout_by_report_multi(owner_id, report_id, [], 'tpcreator',
                                                         mqeconfig.MAX_TPCREATORS_PER_REPORT)
    if not layout_rows:
        log.debug('No layout_by_report tpcreator rows')
        return

    log.info('tpcreator is processing %s rows for owner_id=%s report_id=%s report_instance_id=%s',
             len(layout_rows), owner_id, report_id, report_instance.report_instance_id)
    for row in layout_rows:
        mods = [tpcreator_mod(report_instance, row),
                # run the repacking only if tpcreator created a new tile
                layouts.if_mod(lambda layout_mod: layout_mod.new_tiles,
                               layouts.repack_mod(put_master_first=(not make_first_master)))]
        if make_first_master:
            mods.extend([
                # run the promote_first... mod only if tpcreator created a new tile
                layouts.if_mod(lambda layout_mod: layout_mod.new_tiles,
                               layouts.promote_first_as_master_mod()),
                # another repacking is needed if the promote_first... mod made replacements,
                # because the mod doesn't preserve ordering
                layouts.if_mod(lambda layout_mod: layout_mod.tile_replacement,
                               layouts.repack_mod()),
            ])

        lmr = layouts.apply_mods(mods, owner_id, row['dashboard_id'], for_layout_id=None,
                                 max_tries=MAX_TPCREATE_TRIES)
        if lmr and lmr.new_layout.layout_id != lmr.old_layout.layout_id:
            fire_signal(layout_modified, reason='tpcreator', layout_modification_result=lmr)