← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/cethread.py

  • Committer: Robert Collins
  • Date: 2006-05-04 13:26:31 UTC
  • mto: (1697.1.1 integration)
  • mto: This revision was merged to the branch mainline in revision 1701.
  • Revision ID: robertc@robertcollins.net-20060504132631-ab199c12d7427f82
Branch.break_lock should handle bound branches too

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/cethread.py
1
 
# Copyright (C) 2011 Canonical Ltd
2
 
#
3
 
# This program is free software; you can redistribute it and/or modify
4
 
# it under the terms of the GNU General Public License as published by
5
 
# the Free Software Foundation; either version 2 of the License, or
6
 
# (at your option) any later version.
7
 
#
8
 
# This program is distributed in the hope that it will be useful,
9
 
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
 
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
 
# GNU General Public License for more details.
12
 
#
13
 
# You should have received a copy of the GNU General Public License
14
 
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
 
 
17
 
import sys
18
 
import threading
19
 
 
20
 
 
21
 
class CatchingExceptionThread(threading.Thread):
22
 
    """A thread that keeps track of exceptions.
23
 
 
24
 
    If an exception occurs during the thread execution, it's caught and
25
 
    re-raised when the thread is joined().
26
 
    """
27
 
 
28
 
    def __init__(self, *args, **kwargs):
29
 
        # There are cases where the calling thread must wait, yet, if an
30
 
        # exception occurs, the event should be set so the caller is not
31
 
        # blocked. The main example is a calling thread that want to wait for
32
 
        # the called thread to be in a given state before continuing.
33
 
        try:
34
 
            sync_event = kwargs.pop('sync_event')
35
 
        except KeyError:
36
 
            # If the caller didn't pass a specific event, create our own
37
 
            sync_event = threading.Event()
38
 
        super(CatchingExceptionThread, self).__init__(*args, **kwargs)
39
 
        self.set_sync_event(sync_event)
40
 
        self.exception = None
41
 
        self.ignored_exceptions = None # see set_ignored_exceptions
42
 
        self.lock = threading.Lock()
43
 
 
44
 
    # compatibility thunk for python-2.4 and python-2.5...
45
 
    if sys.version_info < (2, 6):
46
 
        name = property(threading.Thread.getName, threading.Thread.setName)
47
 
 
48
 
    def set_sync_event(self, event):
49
 
        """Set the ``sync_event`` event used to synchronize exception catching.
50
 
 
51
 
        When the thread uses an event to synchronize itself with another thread
52
 
        (setting it when the other thread can wake up from a ``wait`` call),
53
 
        the event must be set after catching an exception or the other thread
54
 
        will hang.
55
 
 
56
 
        Some threads require multiple events and should set the relevant one
57
 
        when appropriate.
58
 
 
59
 
        Note that the event should be initially cleared so the caller can
60
 
        wait() on him and be released when the thread set the event.
61
 
 
62
 
        Also note that the thread can use multiple events, setting them as it
63
 
        progress, while the caller can chose to wait on any of them. What
64
 
        matters is that there is always one event set so that the caller is
65
 
        always released when an exception is caught. Re-using the same event is
66
 
        therefore risky as the thread itself has no idea about which event the
67
 
        caller is waiting on. If the caller has already been released then a
68
 
        cleared event won't guarantee that the caller is still waiting on it.
69
 
        """
70
 
        self.sync_event = event
71
 
 
72
 
    def switch_and_set(self, new):
73
 
        """Switch to a new ``sync_event`` and set the current one.
74
 
 
75
 
        Using this method protects against race conditions while setting a new
76
 
        ``sync_event``.
77
 
 
78
 
        Note that this allows a caller to wait either on the old or the new
79
 
        event depending on whether it wants a fine control on what is happening
80
 
        inside a thread.
81
 
 
82
 
        :param new: The event that will become ``sync_event``
83
 
        """
84
 
        cur = self.sync_event
85
 
        self.lock.acquire()
86
 
        try: # Always release the lock
87
 
            try:
88
 
                self.set_sync_event(new)
89
 
                # From now on, any exception will be synced with the new event
90
 
            except:
91
 
                # Unlucky, we couldn't set the new sync event, try restoring a
92
 
                # safe state
93
 
                self.set_sync_event(cur)
94
 
                raise
95
 
            # Setting the current ``sync_event`` will release callers waiting
96
 
            # on it, note that it will also be set in run() if an exception is
97
 
            # raised
98
 
            cur.set()
99
 
        finally:
100
 
            self.lock.release()
101
 
 
102
 
    def set_ignored_exceptions(self, ignored):
103
 
        """Declare which exceptions will be ignored.
104
 
 
105
 
        :param ignored: Can be either:
106
 
        
107
 
           - None: all exceptions will be raised,
108
 
           - an exception class: the instances of this class will be ignored,
109
 
           - a tuple of exception classes: the instances of any class of the
110
 
             list will be ignored,
111
 
           - a callable: that will be passed the exception object
112
 
             and should return True if the exception should be ignored
113
 
        """
114
 
        if ignored is None:
115
 
            self.ignored_exceptions = None
116
 
        elif isinstance(ignored, (Exception, tuple)):
117
 
            self.ignored_exceptions = lambda e: isinstance(e, ignored)
118
 
        else:
119
 
            self.ignored_exceptions = ignored
120
 
 
121
 
    def run(self):
122
 
        """Overrides Thread.run to capture any exception."""
123
 
        self.sync_event.clear()
124
 
        try:
125
 
            try:
126
 
                super(CatchingExceptionThread, self).run()
127
 
            except:
128
 
                self.exception = sys.exc_info()
129
 
        finally:
130
 
            # Make sure the calling thread is released
131
 
            self.sync_event.set()
132
 
 
133
 
 
134
 
    def join(self, timeout=None):
135
 
        """Overrides Thread.join to raise any exception caught.
136
 
 
137
 
        Calling join(timeout=0) will raise the caught exception or return None
138
 
        if the thread is still alive.
139
 
        """
140
 
        super(CatchingExceptionThread, self).join(timeout)
141
 
        if self.exception is not None:
142
 
            exc_class, exc_value, exc_tb = self.exception
143
 
            self.exception = None # The exception should be raised only once
144
 
            if (self.ignored_exceptions is None
145
 
                or not self.ignored_exceptions(exc_value)):
146
 
                # Raise non ignored exceptions
147
 
                raise exc_class, exc_value, exc_tb
148
 
 
149
 
    def pending_exception(self):
150
 
        """Raise the caught exception.
151
 
 
152
 
        This does nothing if no exception occurred.
153
 
        """
154
 
        self.join(timeout=0)