distributor.py 4.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154
  1. # -*- coding: utf-8 -*-
  2. # Copyright 2014-2016 OpenMarket Ltd
  3. #
  4. # Licensed under the Apache License, Version 2.0 (the "License");
  5. # you may not use this file except in compliance with the License.
  6. # You may obtain a copy of the License at
  7. #
  8. # http://www.apache.org/licenses/LICENSE-2.0
  9. #
  10. # Unless required by applicable law or agreed to in writing, software
  11. # distributed under the License is distributed on an "AS IS" BASIS,
  12. # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13. # See the License for the specific language governing permissions and
  14. # limitations under the License.
  15. from twisted.internet import defer
  16. from synapse.util.logcontext import (
  17. PreserveLoggingContext, preserve_context_over_fn
  18. )
  19. from synapse.util import unwrapFirstError
  20. import logging
  21. logger = logging.getLogger(__name__)
  22. def registered_user(distributor, user):
  23. return distributor.fire("registered_user", user)
  24. def user_left_room(distributor, user, room_id):
  25. return preserve_context_over_fn(
  26. distributor.fire,
  27. "user_left_room", user=user, room_id=room_id
  28. )
  29. def user_joined_room(distributor, user, room_id):
  30. return preserve_context_over_fn(
  31. distributor.fire,
  32. "user_joined_room", user=user, room_id=room_id
  33. )
  34. class Distributor(object):
  35. """A central dispatch point for loosely-connected pieces of code to
  36. register, observe, and fire signals.
  37. Signals are named simply by strings.
  38. TODO(paul): It would be nice to give signals stronger object identities,
  39. so we can attach metadata, docstrings, detect typoes, etc... But this
  40. model will do for today.
  41. """
  42. def __init__(self, suppress_failures=True):
  43. self.suppress_failures = suppress_failures
  44. self.signals = {}
  45. self.pre_registration = {}
  46. def declare(self, name):
  47. if name in self.signals:
  48. raise KeyError("%r already has a signal named %s" % (self, name))
  49. self.signals[name] = Signal(
  50. name,
  51. suppress_failures=self.suppress_failures,
  52. )
  53. if name in self.pre_registration:
  54. signal = self.signals[name]
  55. for observer in self.pre_registration[name]:
  56. signal.observe(observer)
  57. def observe(self, name, observer):
  58. if name in self.signals:
  59. self.signals[name].observe(observer)
  60. else:
  61. # TODO: Avoid strong ordering dependency by allowing people to
  62. # pre-register observations on signals that don't exist yet.
  63. if name not in self.pre_registration:
  64. self.pre_registration[name] = []
  65. self.pre_registration[name].append(observer)
  66. def fire(self, name, *args, **kwargs):
  67. if name not in self.signals:
  68. raise KeyError("%r does not have a signal named %s" % (self, name))
  69. return self.signals[name].fire(*args, **kwargs)
  70. class Signal(object):
  71. """A Signal is a dispatch point that stores a list of callables as
  72. observers of it.
  73. Signals can be "fired", meaning that every callable observing it is
  74. invoked. Firing a signal does not change its state; it can be fired again
  75. at any later point. Firing a signal passes any arguments from the fire
  76. method into all of the observers.
  77. """
  78. def __init__(self, name, suppress_failures):
  79. self.name = name
  80. self.suppress_failures = suppress_failures
  81. self.observers = []
  82. def observe(self, observer):
  83. """Adds a new callable to the observer list which will be invoked by
  84. the 'fire' method.
  85. Each observer callable may return a Deferred."""
  86. self.observers.append(observer)
  87. @defer.inlineCallbacks
  88. def fire(self, *args, **kwargs):
  89. """Invokes every callable in the observer list, passing in the args and
  90. kwargs. Exceptions thrown by observers are logged but ignored. It is
  91. not an error to fire a signal with no observers.
  92. Returns a Deferred that will complete when all the observers have
  93. completed."""
  94. def do(observer):
  95. def eb(failure):
  96. logger.warning(
  97. "%s signal observer %s failed: %r",
  98. self.name, observer, failure,
  99. exc_info=(
  100. failure.type,
  101. failure.value,
  102. failure.getTracebackObject()))
  103. if not self.suppress_failures:
  104. return failure
  105. return defer.maybeDeferred(observer, *args, **kwargs).addErrback(eb)
  106. with PreserveLoggingContext():
  107. deferreds = [
  108. do(observer)
  109. for observer in self.observers
  110. ]
  111. res = yield defer.gatherResults(
  112. deferreds, consumeErrors=True
  113. ).addErrback(unwrapFirstError)
  114. defer.returnValue(res)
  115. def __repr__(self):
  116. return "<Signal name=%r>" % (self.name,)