1
# Copyright (C) 2009, 2010 Canonical Ltd
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.
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.
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
17
"""Helpers for managing cleanup functions and the errors they might raise.
19
The usual way to run cleanup code in Python is::
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.
31
If you want to be certain that the first, and only the first, error is raised,
34
operation = OperationWithCleanups(do_something)
35
operation.add_cleanup(cleanup_something)
36
operation.run_simple()
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
44
from __future__ import absolute_import
46
from collections import deque
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('brz: warning: Cleanup failed: %s', exc)
60
def _run_cleanup(func, *args, **kwargs):
61
"""Run func(*args, **kwargs), logging but not propagating any error it
64
:returns: True if func raised no errors, else False.
68
except KeyboardInterrupt:
70
except Exception as exc:
71
_log_cleanup_error(exc)
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)
82
class ObjectWithCleanups(object):
83
"""A mixin for objects that hold a cleanup list.
85
Subclass or client code can call add_cleanup and then later `cleanup_now`.
88
self.cleanups = deque()
90
def add_cleanup(self, cleanup_func, *args, **kwargs):
91
"""Add a cleanup to run.
93
Cleanups may be added at any time.
94
Cleanups will be executed in LIFO order.
96
self.cleanups.appendleft((cleanup_func, args, kwargs))
98
def cleanup_now(self):
99
_run_cleanups(self.cleanups)
100
self.cleanups.clear()
103
class OperationWithCleanups(ObjectWithCleanups):
104
"""A way to run some code with a dynamic cleanup list.
106
This provides a way to add cleanups while the function-with-cleanups is
111
operation = OperationWithCleanups(some_func)
112
operation.run(args...)
114
where `some_func` is::
116
def some_func(operation, args, ...):
118
operation.add_cleanup(something)
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`.
126
def __init__(self, func):
127
super(OperationWithCleanups, self).__init__()
130
def run(self, *args, **kwargs):
131
return _do_with_cleanups(
132
self.cleanups, self.func, self, *args, **kwargs)
134
def run_simple(self, *args, **kwargs):
135
return _do_with_cleanups(
136
self.cleanups, self.func, *args, **kwargs)
139
def _do_with_cleanups(cleanup_funcs, func, *args, **kwargs):
140
"""Run `func`, then call all the cleanup_funcs.
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).
146
Conceptually similar to::
149
return func(*args, **kwargs)
151
for cleanup, cargs, ckwargs in cleanup_funcs:
152
cleanup(*cargs, **ckwargs)
154
It avoids several problems with using try/finally directly:
155
* an exception from func will not be obscured by a subsequent exception
157
* an exception from a cleanup will not prevent other cleanups from
158
running (but the first exception encountered is still the one
161
Unike `_run_cleanup`, `_do_with_cleanups` can propagate an exception from a
162
cleanup, but only if there is no exception from func.
165
result = func(*args, **kwargs)
167
# We have an exception from func already, so suppress cleanup errors.
168
_run_cleanups(cleanup_funcs)
170
# No exception from func, so allow first cleanup error to propgate.
171
pending_cleanups = iter(cleanup_funcs)
173
for cleanup, c_args, c_kwargs in pending_cleanups:
174
cleanup(*c_args, **c_kwargs)
176
# Still run the remaining cleanups but suppress any further errors.
177
_run_cleanups(pending_cleanups)
179
# No error, so we can return the result
added
removed
breezy/cleanup.py
