Fixed #11134: signals recievers that disconnect during their processing no... (c935d7ff) · Commits · Dom Sekotill / django

django/dispatch/dispatcher.py

+98 −73

Original line number	Diff line number	Diff line
		@@ -14,15 +14,21 @@ def _make_id(target):
		return id(target)

		class Signal(object):
		"""Base class for all signals
		"""
		Base class for all signals

		Internal attributes:
		receivers -- { receriverkey (id) : weakref(receiver) }

		receivers
		{ receriverkey (id) : weakref(receiver) }
		"""

		def __init__(self, providing_args=None):
		"""providing_args -- A list of the arguments this signal can pass along in
		a send() call.
		"""
		Create a new signal.

		providing_args
		A list of the arguments this signal can pass along in a send() call.
		"""
		self.receivers = []
		if providing_args is None:
		@@ -30,15 +36,18 @@ class Signal(object):
		self.providing_args = set(providing_args)

		def connect(self, receiver, sender=None, weak=True, dispatch_uid=None):
		"""Connect receiver to sender for signal
		"""
		Connect receiver to sender for signal.

		Arguments:

		receiver -- a function or an instance method which is to
		receive signals. Receivers must be
		hashable objects.
		receiver
		A function or an instance method which is to receive signals.
		Receivers must be hashable objects.

		if weak is True, then receiver must be weak-referencable
		(more precisely saferef.safeRef() must be able to create
		a reference to the receiver).
		if weak is True, then receiver must be weak-referencable (more
		precisely saferef.safeRef() must be able to create a reference
		to the receiver).

		Receivers must be able to accept keyword arguments.

		@@ -46,20 +55,20 @@ class Signal(object):
		not be added if another receiver already exists with that
		dispatch_uid.

		sender -- the sender to which the receiver should respond
		Must either be of type Signal, or None to receive events
		from any sender.
		sender
		The sender to which the receiver should respond Must either be
		of type Signal, or None to receive events from any sender.

		weak -- whether to use weak references to the receiver
		By default, the module will attempt to use weak
		references to the receiver objects. If this parameter
		is false, then strong references will be used.
		weak
		Whether to use weak references to the receiver By default, the
		module will attempt to use weak references to the receiver
		objects. If this parameter is false, then strong references will
		be used.

		dispatch_uid -- an identifier used to uniquely identify a particular
		instance of a receiver. This will usually be a string, though it
		may be anything hashable.

		returns None
		dispatch_uid
		An identifier used to uniquely identify a particular instance of
		a receiver. This will usually be a string, though it may be
		anything hashable.
		"""
		from django.conf import settings

		@@ -99,22 +108,27 @@ class Signal(object):
		self.receivers.append((lookup_key, receiver))

		def disconnect(self, receiver=None, sender=None, weak=True, dispatch_uid=None):
		"""Disconnect receiver from sender for signal
		"""
		Disconnect receiver from sender for signal.

		If weak references are used, disconnect need not be called. The receiver
		will be remove from dispatch automatically.

		receiver -- the registered receiver to disconnect. May be none if
		Arguments:

		receiver
		The registered receiver to disconnect. May be none if
		dispatch_uid is specified.
		sender -- the registered sender to disconnect
		weak -- the weakref state to disconnect
		dispatch_uid -- the unique identifier of the receiver to disconnect

		disconnect reverses the process of connect.
		sender
		The registered sender to disconnect

		If weak references are used, disconnect need not be called.
		The receiver will be remove from dispatch automatically.
		weak
		The weakref state to disconnect

		returns None
		dispatch_uid
		the unique identifier of the receiver to disconnect
		"""

		if dispatch_uid:
		lookup_key = (dispatch_uid, _make_id(sender))
		else:
		@@ -127,21 +141,23 @@ class Signal(object):
		break

		def send(self, sender, **named):
		"""Send signal from sender to all connected receivers.
		"""
		Send signal from sender to all connected receivers.

		sender -- the sender of the signal
		Either a specific object or None.
		If any receiver raises an error, the error propagates back through send,
		terminating the dispatch loop, so it is quite possible to not have all
		receivers called if a raises an error.

		named -- named arguments which will be passed to receivers.
		Arguments:

		Returns a list of tuple pairs [(receiver, response), ... ].
		sender
		The sender of the signal Either a specific object or None.

		If any receiver raises an error, the error propagates back
		through send, terminating the dispatch loop, so it is quite
		possible to not have all receivers called if a raises an
		error.
		"""
		named
		Named arguments which will be passed to receivers.

		Returns a list of tuple pairs [(receiver, response), ... ].
		"""
		responses = []
		if not self.receivers:
		return responses
		@@ -152,23 +168,28 @@ class Signal(object):
		return responses

		def send_robust(self, sender, **named):
		"""Send signal from sender to all connected receivers catching errors
		"""
		Send signal from sender to all connected receivers catching errors.

		sender -- the sender of the signal
		Can be any python object (normally one registered with
		a connect if you actually want something to occur).
		Arguments:

		named -- named arguments which will be passed to receivers.
		These arguments must be a subset of the argument names
		defined in providing_args.
		sender
		The sender of the signal Can be any python object (normally one
		registered with a connect if you actually want something to
		occur).

		Return a list of tuple pairs [(receiver, response), ... ],
		may raise DispatcherKeyError
		named
		Named arguments which will be passed to receivers. These
		arguments must be a subset of the argument names defined in
		providing_args.

		if any receiver raises an error (specifically any subclass of Exception),
		the error instance is returned as the result for that receiver.
		"""
		Return a list of tuple pairs [(receiver, response), ... ]. May raise
		DispatcherKeyError.

		if any receiver raises an error (specifically any subclass of
		Exception), the error instance is returned as the result for that
		receiver.
		"""
		responses = []
		if not self.receivers:
		return responses
		@@ -185,13 +206,14 @@ class Signal(object):
		return responses

		def _live_receivers(self, senderkey):
		"""Filter sequence of receivers to get resolved, live receivers
		"""
		Filter sequence of receivers to get resolved, live receivers.

		This checks for weak references
		and resolves them, then returning only live
		receivers.
		This checks for weak references and resolves them, then returning only
		live receivers.
		"""
		none_senderkey = _make_id(None)
		receivers = []

		for (receiverkey, r_senderkey), receiver in self.receivers:
		if r_senderkey == none_senderkey or r_senderkey == senderkey:
		@@ -199,12 +221,15 @@ class Signal(object):
		# Dereference the weak reference.
		receiver = receiver()
		if receiver is not None:
		yield receiver
		receivers.append(receiver)
		else:
		yield receiver
		receivers.append(receiver)
		return receivers

		def _remove_receiver(self, receiver):
		"""Remove dead receivers from connections."""
		"""
		Remove dead receivers from connections.
		"""

		to_remove = []
		for key, connected_receiver in self.receivers:

tests/modeltests/signals/tests.py

0 → 100644

+28 −0

Original line number	Diff line number	Diff line
		from django.db.models import signals
		from django.test import TestCase
		from modeltests.signals.models import Person

		class MyReceiver(object):
		def __init__(self, param):
		self.param = param
		self._run = False

		def __call__(self, signal, sender, **kwargs):
		self._run = True
		signal.disconnect(receiver=self, sender=sender)

		class SignalTests(TestCase):
		def test_disconnect_in_dispatch(self):
		"""
		Test that signals that disconnect when being called don't mess future
		dispatching.
		"""
		a, b = MyReceiver(1), MyReceiver(2)
		signals.post_save.connect(sender=Person, receiver=a)
		signals.post_save.connect(sender=Person, receiver=b)
		p = Person.objects.create(first_name='John', last_name='Smith')

		self.failUnless(a._run)
		self.failUnless(b._run)
		self.assertEqual(signals.post_save.receivers, [])