mirror of
https://git.anonymousland.org/anonymousland/synapse.git
synced 2024-12-26 22:49:23 -05:00
8c69b735e3
This is more involved than it might otherwise be, because the current implementation just drops its logcontexts and runs everything in the sentinel context. It turns out that we aren't actually using a bunch of the functionality here (notably suppress_failures and the fact that Distributor.fire returns a deferred), so the easiest way to fix this is actually by simplifying a bunch of code.
139 lines
4.5 KiB
Python
139 lines
4.5 KiB
Python
# -*- coding: utf-8 -*-
|
|
# Copyright 2014-2016 OpenMarket Ltd
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
|
|
import logging
|
|
|
|
from twisted.internet import defer
|
|
|
|
from synapse.metrics.background_process_metrics import run_as_background_process
|
|
from synapse.util.logcontext import make_deferred_yieldable, run_in_background
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
def user_left_room(distributor, user, room_id):
|
|
distributor.fire("user_left_room", user=user, room_id=room_id)
|
|
|
|
|
|
def user_joined_room(distributor, user, room_id):
|
|
distributor.fire("user_joined_room", user=user, room_id=room_id)
|
|
|
|
|
|
class Distributor(object):
|
|
"""A central dispatch point for loosely-connected pieces of code to
|
|
register, observe, and fire signals.
|
|
|
|
Signals are named simply by strings.
|
|
|
|
TODO(paul): It would be nice to give signals stronger object identities,
|
|
so we can attach metadata, docstrings, detect typoes, etc... But this
|
|
model will do for today.
|
|
"""
|
|
|
|
def __init__(self):
|
|
self.signals = {}
|
|
self.pre_registration = {}
|
|
|
|
def declare(self, name):
|
|
if name in self.signals:
|
|
raise KeyError("%r already has a signal named %s" % (self, name))
|
|
|
|
self.signals[name] = Signal(
|
|
name,
|
|
)
|
|
|
|
if name in self.pre_registration:
|
|
signal = self.signals[name]
|
|
for observer in self.pre_registration[name]:
|
|
signal.observe(observer)
|
|
|
|
def observe(self, name, observer):
|
|
if name in self.signals:
|
|
self.signals[name].observe(observer)
|
|
else:
|
|
# TODO: Avoid strong ordering dependency by allowing people to
|
|
# pre-register observations on signals that don't exist yet.
|
|
if name not in self.pre_registration:
|
|
self.pre_registration[name] = []
|
|
self.pre_registration[name].append(observer)
|
|
|
|
def fire(self, name, *args, **kwargs):
|
|
"""Dispatches the given signal to the registered observers.
|
|
|
|
Runs the observers as a background process. Does not return a deferred.
|
|
"""
|
|
if name not in self.signals:
|
|
raise KeyError("%r does not have a signal named %s" % (self, name))
|
|
|
|
run_as_background_process(
|
|
name,
|
|
self.signals[name].fire,
|
|
*args, **kwargs
|
|
)
|
|
|
|
|
|
class Signal(object):
|
|
"""A Signal is a dispatch point that stores a list of callables as
|
|
observers of it.
|
|
|
|
Signals can be "fired", meaning that every callable observing it is
|
|
invoked. Firing a signal does not change its state; it can be fired again
|
|
at any later point. Firing a signal passes any arguments from the fire
|
|
method into all of the observers.
|
|
"""
|
|
|
|
def __init__(self, name):
|
|
self.name = name
|
|
self.observers = []
|
|
|
|
def observe(self, observer):
|
|
"""Adds a new callable to the observer list which will be invoked by
|
|
the 'fire' method.
|
|
|
|
Each observer callable may return a Deferred."""
|
|
self.observers.append(observer)
|
|
|
|
def fire(self, *args, **kwargs):
|
|
"""Invokes every callable in the observer list, passing in the args and
|
|
kwargs. Exceptions thrown by observers are logged but ignored. It is
|
|
not an error to fire a signal with no observers.
|
|
|
|
Returns a Deferred that will complete when all the observers have
|
|
completed."""
|
|
|
|
def do(observer):
|
|
def eb(failure):
|
|
logger.warning(
|
|
"%s signal observer %s failed: %r",
|
|
self.name, observer, failure,
|
|
exc_info=(
|
|
failure.type,
|
|
failure.value,
|
|
failure.getTracebackObject()))
|
|
|
|
return defer.maybeDeferred(observer, *args, **kwargs).addErrback(eb)
|
|
|
|
deferreds = [
|
|
run_in_background(do, o)
|
|
for o in self.observers
|
|
]
|
|
|
|
return make_deferred_yieldable(defer.gatherResults(
|
|
deferreds, consumeErrors=True,
|
|
))
|
|
|
|
def __repr__(self):
|
|
return "<Signal name=%r>" % (self.name,)
|