← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/cleanup.py

  • Committer: Martin Pool
  • Date: 2005-08-29 05:06:32 UTC
  • Revision ID: mbp@sourcefrog.net-20050829050632-a26baaf6a0efbf25
- cope with plugin modules without a __path__ attribute

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/cleanup.py
1
 
# Copyright (C) 2009, 2010 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
 
"""Helpers for managing cleanup functions and the errors they might raise.
18
 
 
19
 
The usual way to run cleanup code in Python is::
20
 
 
21
 
    try:
22
 
        do_something()
23
 
    finally:
24
 
        cleanup_something()
25
 
 
26
 
However if both `do_something` and `cleanup_something` raise an exception
27
 
Python will forget the original exception and propagate the one from
28
 
cleanup_something.  Unfortunately, this is almost always much less useful than
29
 
the original exception.
30
 
 
31
 
If you want to be certain that the first, and only the first, error is raised,
32
 
then use::
33
 
 
34
 
    operation = OperationWithCleanups(do_something)
35
 
    operation.add_cleanup(cleanup_something)
36
 
    operation.run_simple()
37
 
 
38
 
This is more inconvenient (because you need to make every try block a
39
 
function), but will ensure that the first error encountered is the one raised,
40
 
while also ensuring all cleanups are run.  See OperationWithCleanups for more
41
 
details.
42
 
"""
43
 
 
44
 
from __future__ import absolute_import
45
 
 
46
 
from collections import deque
47
 
import sys
48
 
from bzrlib import (
49
 
    debug,
50
 
    trace,
51
 
    )
52
 
 
53
 
def _log_cleanup_error(exc):
54
 
    trace.mutter('Cleanup failed:')
55
 
    trace.log_exception_quietly()
56
 
    if 'cleanup' in debug.debug_flags:
57
 
        trace.warning('bzr: warning: Cleanup failed: %s', exc)
58
 
 
59
 
 
60
 
def _run_cleanup(func, *args, **kwargs):
61
 
    """Run func(*args, **kwargs), logging but not propagating any error it
62
 
    raises.
63
 
 
64
 
    :returns: True if func raised no errors, else False.
65
 
    """
66
 
    try:
67
 
        func(*args, **kwargs)
68
 
    except KeyboardInterrupt:
69
 
        raise
70
 
    except Exception, exc:
71
 
        _log_cleanup_error(exc)
72
 
        return False
73
 
    return True
74
 
 
75
 
 
76
 
def _run_cleanups(funcs):
77
 
    """Run a series of cleanup functions."""
78
 
    for func, args, kwargs in funcs:
79
 
        _run_cleanup(func, *args, **kwargs)
80
 
 
81
 
 
82
 
class ObjectWithCleanups(object):
83
 
    """A mixin for objects that hold a cleanup list.
84
 
 
85
 
    Subclass or client code can call add_cleanup and then later `cleanup_now`.
86
 
    """
87
 
    def __init__(self):
88
 
        self.cleanups = deque()
89
 
 
90
 
    def add_cleanup(self, cleanup_func, *args, **kwargs):
91
 
        """Add a cleanup to run.
92
 
 
93
 
        Cleanups may be added at any time.  
94
 
        Cleanups will be executed in LIFO order.
95
 
        """
96
 
        self.cleanups.appendleft((cleanup_func, args, kwargs))
97
 
 
98
 
    def cleanup_now(self):
99
 
        _run_cleanups(self.cleanups)
100
 
        self.cleanups.clear()
101
 
 
102
 
 
103
 
class OperationWithCleanups(ObjectWithCleanups):
104
 
    """A way to run some code with a dynamic cleanup list.
105
 
 
106
 
    This provides a way to add cleanups while the function-with-cleanups is
107
 
    running.
108
 
 
109
 
    Typical use::
110
 
 
111
 
        operation = OperationWithCleanups(some_func)
112
 
        operation.run(args...)
113
 
 
114
 
    where `some_func` is::
115
 
 
116
 
        def some_func(operation, args, ...):
117
 
            do_something()
118
 
            operation.add_cleanup(something)
119
 
            # etc
120
 
 
121
 
    Note that the first argument passed to `some_func` will be the
122
 
    OperationWithCleanups object.  To invoke `some_func` without that, use
123
 
    `run_simple` instead of `run`.
124
 
    """
125
 
 
126
 
    def __init__(self, func):
127
 
        super(OperationWithCleanups, self).__init__()
128
 
        self.func = func
129
 
 
130
 
    def run(self, *args, **kwargs):
131
 
        return _do_with_cleanups(
132
 
            self.cleanups, self.func, self, *args, **kwargs)
133
 
 
134
 
    def run_simple(self, *args, **kwargs):
135
 
        return _do_with_cleanups(
136
 
            self.cleanups, self.func, *args, **kwargs)
137
 
 
138
 
 
139
 
def _do_with_cleanups(cleanup_funcs, func, *args, **kwargs):
140
 
    """Run `func`, then call all the cleanup_funcs.
141
 
 
142
 
    All the cleanup_funcs are guaranteed to be run.  The first exception raised
143
 
    by func or any of the cleanup_funcs is the one that will be propagted by
144
 
    this function (subsequent errors are caught and logged).
145
 
 
146
 
    Conceptually similar to::
147
 
 
148
 
        try:
149
 
            return func(*args, **kwargs)
150
 
        finally:
151
 
            for cleanup, cargs, ckwargs in cleanup_funcs:
152
 
                cleanup(*cargs, **ckwargs)
153
 
 
154
 
    It avoids several problems with using try/finally directly:
155
 
     * an exception from func will not be obscured by a subsequent exception
156
 
       from a cleanup.
157
 
     * an exception from a cleanup will not prevent other cleanups from
158
 
       running (but the first exception encountered is still the one
159
 
       propagated).
160
 
 
161
 
    Unike `_run_cleanup`, `_do_with_cleanups` can propagate an exception from a
162
 
    cleanup, but only if there is no exception from func.
163
 
    """
164
 
    # As correct as Python 2.4 allows.
165
 
    try:
166
 
        result = func(*args, **kwargs)
167
 
    except:
168
 
        # We have an exception from func already, so suppress cleanup errors.
169
 
        _run_cleanups(cleanup_funcs)
170
 
        raise
171
 
    else:
172
 
        # No exception from func, so allow the first exception from
173
 
        # cleanup_funcs to propagate if one occurs (but only after running all
174
 
        # of them).
175
 
        exc_info = None
176
 
        for cleanup, c_args, c_kwargs in cleanup_funcs:
177
 
            # XXX: Hmm, if KeyboardInterrupt arrives at exactly this line, we
178
 
            # won't run all cleanups... perhaps we should temporarily install a
179
 
            # SIGINT handler?
180
 
            if exc_info is None:
181
 
                try:
182
 
                    cleanup(*c_args, **c_kwargs)
183
 
                except:
184
 
                    # This is the first cleanup to fail, so remember its
185
 
                    # details.
186
 
                    exc_info = sys.exc_info()
187
 
            else:
188
 
                # We already have an exception to propagate, so log any errors
189
 
                # but don't propagate them.
190
 
                _run_cleanup(cleanup, *c_args, **kwargs)
191
 
        if exc_info is not None:
192
 
            try:
193
 
                raise exc_info[0], exc_info[1], exc_info[2]
194
 
            finally:
195
 
                del exc_info
196
 
        # No error, so we can return the result
197
 
        return result
198
 
 
199