Example #1
0
def after_execute(conn, elt, multiparams, params, result):
    duration = 1000 * (time.time() - conn.info['query_start_time'].pop(-1))
    action = elt.__class__.__name__

    if action == 'Select':
        name = 'unknown'
        try:
            name = _table_name_from_select_element(elt)
        except Exception:
            logging.exception('Failed finding table name.')
    elif action in ['Update', 'Insert', 'Delete']:
        name = elt.table.name
    else:
        # create/drop tables, sqlalchemy internal schema queries, etc
        return

    action = action.lower()

    statsd_client.timing('db.{}.{}'.format(name, action), duration)
    metrics_logger.debug("table=%s query=%s duration=%.2f", name, action,
                         duration)

    if has_request_context():
        g.setdefault('queries_count', 0)
        g.setdefault('queries_duration', 0)
        g.queries_count += 1
        g.queries_duration += duration

    return result
Example #2
0
 def decorator(*args, **kwargs):
     token = _token_extractor()
     user = _user_decode(token)
     g.setdefault('user', user)
     auth_func = auth_kwargs.pop('auth_func', None)
     auth_cls = auth_kwargs.pop('auth_cls', None)
     callback = _get_authorization_callback(auth_func, auth_cls, args)
     # jwt_authorize params take preference to Flask route params in case of name collision.
     kwargs.update(auth_kwargs)
     _check_authorization(user, callback, **kwargs)
     return fn(*args, **kwargs)
Example #3
0
    def allocate_friendly_ids(cls, event, n):
        """Allocate n Contribution friendly_ids.

        This is needed so that we can allocate all IDs in one go. Not doing
        so could result in DB deadlocks. All operations that create more than
        one contribution should use this method.

        :param event: the :class:`Event` in question
        :param n: the number of ids to pre-allocate
        """
        from indico.modules.events import Event
        fid = increment_and_get(Event._last_friendly_contribution_id, Event.id == event.id, n)
        friendly_ids = g.setdefault('friendly_ids', {})
        friendly_ids.setdefault(cls, {})[event.id] = range(fid - n + 1, fid + 1)
Example #4
0
def preload_events(ids, lightweight=True, persons=False):
    """Preload events so they are in SA's identity cache

    This is useful for legacy pages where we have to show large
    numbers of events without being able to query them from the
    db cleanly.

    :param ids: An iterable of IDs or Conference objects
    :param lightweight: Only load dates and title
    :param persons: Also load the person links
    """
    cache = g.setdefault('_event_cache', {})
    ids = {int(getattr(id_, 'id', id_)) for id_ in ids} - cache.viewkeys()
    query = Event.find(Event.id.in_(ids))
    if lightweight:
        query = query.options(load_only('id', 'title', 'start_dt', 'end_dt', 'timezone'))
    if persons:
        query = query.options(joinedload('person_links'))
    cache.update((e.id, e) for e in query)
Example #5
0
    def preload_relationships(cls, query, *relationships, **kwargs):
        """Preload relationships for all objects from a query.

        :param query: A SQLAlchemy query object.
        :param relationships: The names of relationships to preload.
        :param strategy: The loading strategy to use for the
                         relationships.  Defaults to `joinedload` and
                         can be any callable that takes a relationship
                         name and returns a query option.
        """
        assert cls.allow_relationship_preloading
        strategy = kwargs.pop('strategy', joinedload)
        assert not kwargs  # no other kwargs allowed
        cache = g.setdefault('relationship_cache', {}).setdefault(cls, {'data': {}, 'relationships': set()})
        missing_relationships = set(relationships) - cache['relationships']
        if not missing_relationships:
            return
        query = query.options(*map(strategy, missing_relationships))
        data_cache = cache['data']
        for obj in query:
            obj_cache = data_cache.setdefault(obj, {})
            for rel in missing_relationships:
                obj_cache[rel] = getattr(obj, rel)
        cache['relationships'] |= missing_relationships
Example #6
0
def _init_livesync_g():
    g.setdefault('livesync_changes', defaultdict(set))
Example #7
0
def _event_moved(conf, old_parent, new_parent, **kwargs):
    if new_parent.getCategoryPath()[0] != '0':
        g.setdefault('detached_events_moved', set()).add(conf.as_event)
        return
    event = conf.as_event
    event.category_id = int(new_parent.id)
Example #8
0
def init_email_queue():
    """Enable email queueing for the current context."""
    g.setdefault('email_queue', [])