/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/crash.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2010-04-06 06:59:03 UTC
  • mfrom: (5051.5.1 subunit)
  • Revision ID: pqm@pqm.ubuntu.com-20100406065903-y9dxgwmog1pmw7dz
Use subunit when running tests in PQM.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/crash.py
1
 
# Copyright (C) 2009-2011 Canonical Ltd
 
1
# Copyright (C) 2009, 2010 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
 
17
 
17
18
"""Handling and reporting crashes.
18
19
 
19
20
A crash is an exception propagated up almost to the top level of Bazaar.
20
21
 
21
22
If we have apport <https://launchpad.net/apport/>, we store a report of the
22
 
crash using apport into its /var/crash spool directory, from where the user
 
23
crash using apport into it's /var/crash spool directory, from where the user
23
24
can either manually send it to Launchpad.  In some cases (at least Ubuntu
24
25
development releases), Apport may pop up a window asking if they want
25
26
to send it.
32
33
In principle apport can run on any platform though as of Feb 2010 there seem
33
34
to be some portability bugs.
34
35
 
35
 
To force this off in brz turn set APPORT_DISABLE in the environment or
 
36
To force this off in bzr turn set APPORT_DISBLE in the environment or 
36
37
-Dno_apport.
37
38
"""
38
39
 
39
 
from __future__ import absolute_import
40
 
 
41
 
# for interactive testing, try the 'brz assert-fail' command
 
40
# for interactive testing, try the 'bzr assert-fail' command 
42
41
# or see http://code.launchpad.net/~mbp/bzr/bzr-fail
43
42
#
44
43
# to test with apport it's useful to set
49
48
import pprint
50
49
import sys
51
50
import time
 
51
from StringIO import StringIO
52
52
 
53
 
import breezy
54
 
from . import (
55
 
    bedding,
 
53
import bzrlib
 
54
from bzrlib import (
 
55
    config,
56
56
    debug,
57
57
    osutils,
58
58
    plugin,
59
59
    trace,
60
60
    )
61
 
from .sixish import (
62
 
    StringIO,
63
 
    )
64
61
 
65
62
 
66
63
def report_bug(exc_info, stderr):
67
64
    if ('no_apport' in debug.debug_flags) or \
68
 
            os.environ.get('APPORT_DISABLE', None):
 
65
        os.environ.get('APPORT_DISABLE', None):
69
66
        return report_bug_legacy(exc_info, stderr)
70
67
    try:
71
68
        if report_bug_to_apport(exc_info, stderr):
72
69
            # wrote a file; if None then report the old way
73
70
            return
74
 
    except ImportError as e:
 
71
    except ImportError, e:
75
72
        trace.mutter("couldn't find apport bug-reporting library: %s" % e)
76
 
    except Exception as e:
 
73
        pass
 
74
    except Exception, e:
77
75
        # this should only happen if apport is installed but it didn't
78
76
        # work, eg because of an io error writing the crash file
79
 
        trace.mutter("brz: failed to report crash using apport: %r" % e)
80
 
        trace.log_exception_quietly()
 
77
        stderr.write("bzr: failed to report crash using apport:\n "
 
78
            "    %r\n" % e)
 
79
        pass
81
80
    return report_bug_legacy(exc_info, stderr)
82
81
 
83
82
 
85
84
    """Report a bug by just printing a message to the user."""
86
85
    trace.print_exception(exc_info, err_file)
87
86
    err_file.write('\n')
88
 
    import textwrap
89
 
 
90
 
    def print_wrapped(l):
91
 
        err_file.write(textwrap.fill(
92
 
            l, width=78, subsequent_indent='    ') + '\n')
93
 
    print_wrapped('brz %s on python %s (%s)\n' %
94
 
                  (breezy.__version__,
95
 
                   breezy._format_version_tuple(sys.version_info),
96
 
                   platform.platform(aliased=1)))
97
 
    print_wrapped('arguments: %r\n' % sys.argv)
98
 
    print_wrapped(textwrap.fill(
99
 
        'plugins: ' + plugin.format_concise_plugin_list(),
100
 
        width=78,
101
 
        subsequent_indent='    ',
102
 
        ) + '\n')
103
 
    print_wrapped(
 
87
    err_file.write('bzr %s on python %s (%s)\n' % \
 
88
                       (bzrlib.__version__,
 
89
                        bzrlib._format_version_tuple(sys.version_info),
 
90
                        platform.platform(aliased=1)))
 
91
    err_file.write('arguments: %r\n' % sys.argv)
 
92
    err_file.write(
104
93
        'encoding: %r, fsenc: %r, lang: %r\n' % (
105
94
            osutils.get_user_encoding(), sys.getfilesystemencoding(),
106
95
            os.environ.get('LANG')))
107
 
    # We used to show all the plugins here, but it's too verbose.
 
96
    err_file.write("plugins:\n")
 
97
    err_file.write(_format_plugin_list())
108
98
    err_file.write(
109
 
        "\n"
 
99
        "\n\n"
110
100
        "*** Bazaar has encountered an internal error.  This probably indicates a\n"
111
101
        "    bug in Bazaar.  You can help us fix it by filing a bug report at\n"
112
 
        "        https://bugs.launchpad.net/brz/+filebug\n"
 
102
        "        https://bugs.launchpad.net/bzr/+filebug\n"
113
103
        "    including this traceback and a description of the problem.\n"
114
104
        )
115
105
 
122
112
    # this function is based on apport_package_hook.py, but omitting some of the
123
113
    # Ubuntu-specific policy about what to report and when
124
114
 
125
 
    # This import is apparently not used, but we're doing it so that if the
126
 
    # import fails, the exception will be caught at a higher level and we'll
127
 
    # report the error by other means.
128
 
    import apport  # noqa: F401
 
115
    # if the import fails, the exception will be caught at a higher level and
 
116
    # we'll report the error by other means
 
117
    import apport
129
118
 
130
119
    crash_filename = _write_apport_report_to_file(exc_info)
131
120
 
132
121
    if crash_filename is None:
133
122
        stderr.write("\n"
134
 
                     "apport is set to ignore crashes in this version of brz.\n"
135
 
                     )
 
123
            "apport is set to ignore crashes in this version of bzr.\n"
 
124
            )
136
125
    else:
137
126
        trace.print_exception(exc_info, stderr)
138
127
        stderr.write("\n"
139
 
                     "You can report this problem to Bazaar's developers by running\n"
140
 
                     "    apport-bug %s\n"
141
 
                     "if a bug-reporting window does not automatically appear.\n"
142
 
                     % (crash_filename))
 
128
            "You can report this problem to Bazaar's developers by running\n"
 
129
            "    apport-bug %s\n"
 
130
            "if a bug-reporting window does not automatically appear.\n"
 
131
            % (crash_filename))
143
132
        # XXX: on Windows, Mac, and other platforms where we might have the
144
133
        # apport libraries but not have an apport always running, we could
145
134
        # synchronously file now
154
143
    exc_type, exc_object, exc_tb = exc_info
155
144
 
156
145
    pr = Report()
157
 
    # add_proc_info sets the ExecutablePath, InterpreterPath, etc.
 
146
    # add_proc_info gets the executable and interpreter path, which is needed,
 
147
    # plus some less useful stuff like the memory map
158
148
    pr.add_proc_info()
159
 
    # It also adds ProcMaps which for us is rarely useful and mostly noise, so
160
 
    # let's remove it.
161
 
    del pr['ProcMaps']
162
149
    pr.add_user_info()
163
150
 
164
151
    # Package and SourcePackage are needed so that apport will report about even
165
 
    # non-packaged versions of brz; also this reports on their packaged
 
152
    # non-packaged versions of bzr; also this reports on their packaged
166
153
    # dependencies which is useful.
167
 
    pr['SourcePackage'] = 'brz'
168
 
    pr['Package'] = 'brz'
 
154
    pr['SourcePackage'] = 'bzr'
 
155
    pr['Package'] = 'bzr'
169
156
 
170
157
    pr['CommandLine'] = pprint.pformat(sys.argv)
171
 
    pr['BrzVersion'] = breezy.__version__
172
 
    pr['PythonVersion'] = breezy._format_version_tuple(sys.version_info)
 
158
    pr['BzrVersion'] = bzrlib.__version__
 
159
    pr['PythonVersion'] = bzrlib._format_version_tuple(sys.version_info)
173
160
    pr['Platform'] = platform.platform(aliased=1)
174
161
    pr['UserEncoding'] = osutils.get_user_encoding()
175
162
    pr['FileSystemEncoding'] = sys.getfilesystemencoding()
176
 
    pr['Locale'] = os.environ.get('LANG', 'C')
177
 
    pr['BrzPlugins'] = _format_plugin_list()
 
163
    pr['Locale'] = os.environ.get('LANG')
 
164
    pr['BzrPlugins'] = _format_plugin_list()
178
165
    pr['PythonLoadedModules'] = _format_module_list()
179
 
    pr['BrzDebugFlags'] = pprint.pformat(debug.debug_flags)
180
 
 
181
 
    # actually we'd rather file directly against the upstream product, but
182
 
    # apport does seem to count on there being one in there; we might need to
183
 
    # redirect it elsewhere anyhow
184
 
    pr['SourcePackage'] = 'brz'
185
 
    pr['Package'] = 'brz'
186
 
 
187
 
    # tell apport to file directly against the brz package using
188
 
    # <https://bugs.launchpad.net/bzr/+bug/391015>
189
 
    #
190
 
    # XXX: unfortunately apport may crash later if the crashdb definition
191
 
    # file isn't present
192
 
    pr['CrashDb'] = 'brz'
 
166
    pr['BzrDebugFlags'] = pprint.pformat(debug.debug_flags)
193
167
 
194
168
    tb_file = StringIO()
195
169
    traceback.print_exception(exc_type, exc_object, exc_tb, file=tb_file)
197
171
 
198
172
    _attach_log_tail(pr)
199
173
 
200
 
    # We want to use the 'brz' crashdb so that it gets sent directly upstream,
 
174
    # We want to use the 'bzr' crashdb so that it gets sent directly upstream,
201
175
    # which is a reasonable default for most internal errors.  However, if we
202
176
    # set it here then apport will crash later if it doesn't know about that
203
 
    # crashdb.  Instead, we rely on the brz package installing both a
 
177
    # crashdb.  Instead, we rely on the bzr package installing both a
204
178
    # source hook telling crashes to go to this crashdb, and a crashdb
205
179
    # configuration describing it.
206
180
 
207
181
    # these may contain some sensitive info (smtp_passwords)
208
182
    # TODO: strip that out and attach the rest
209
183
    #
210
 
    # attach_file_if_exists(report,
211
 
    #   os.path.join(dot_brz, 'breezy.conf', 'BrzConfig')
212
 
    # attach_file_if_exists(report,
213
 
    #   os.path.join(dot_brz, 'locations.conf', 'BrzLocations')
214
 
 
 
184
    #attach_file_if_exists(report,
 
185
    #   os.path.join(dot_bzr, 'bazaar.conf', 'BzrConfig')
 
186
    #attach_file_if_exists(report,
 
187
    #   os.path.join(dot_bzr, 'locations.conf', 'BzrLocations')
 
188
    
215
189
    # strip username, hostname, etc
216
190
    pr.anonymize()
217
191
 
227
201
 
228
202
def _attach_log_tail(pr):
229
203
    try:
230
 
        brz_log = open(trace._get_brz_log_filename(), 'rt')
231
 
    except (IOError, OSError) as e:
232
 
        pr['BrzLogTail'] = repr(e)
 
204
        bzr_log = open(trace._get_bzr_log_filename(), 'rt')
 
205
    except (IOError, OSError), e:
 
206
        pr['BzrLogTail'] = repr(e)
233
207
        return
234
208
    try:
235
 
        lines = brz_log.readlines()
236
 
        pr['BrzLogTail'] = ''.join(lines[-40:])
 
209
        lines = bzr_log.readlines()
 
210
        pr['BzrLogTail'] = ''.join(lines[-40:])
237
211
    finally:
238
 
        brz_log.close()
 
212
        bzr_log.close()
239
213
 
240
214
 
241
215
def _open_crash_file():
242
 
    crash_dir = bedding.crash_dir()
 
216
    crash_dir = config.crash_dir()
243
217
    if not osutils.isdir(crash_dir):
244
218
        # on unix this should be /var/crash and should already exist; on
245
219
        # Windows or if it's manually configured it might need to be created,
246
220
        # and then it should be private
247
 
        os.makedirs(crash_dir, mode=0o600)
 
221
        os.makedirs(crash_dir, mode=0600)
248
222
    date_string = time.strftime('%Y-%m-%dT%H:%M', time.gmtime())
249
223
    # XXX: getuid doesn't work on win32, but the crash directory is per-user
250
224
    if sys.platform == 'win32':
253
227
        user_part = '.%d' % os.getuid()
254
228
    filename = osutils.pathjoin(
255
229
        crash_dir,
256
 
        'brz%s.%s.crash' % (
 
230
        'bzr%s.%s.crash' % (
257
231
            user_part,
258
232
            date_string))
259
233
    # be careful here that people can't play tmp-type symlink mischief in the
260
234
    # world-writable directory
261
235
    return filename, os.fdopen(
262
 
        os.open(filename,
263
 
                os.O_WRONLY | os.O_CREAT | os.O_EXCL,
264
 
                0o600),
265
 
        'wb')
 
236
        os.open(filename, 
 
237
            os.O_WRONLY|os.O_CREAT|os.O_EXCL,
 
238
            0600),
 
239
        'w')
266
240
 
267
241
 
268
242
def _format_plugin_list():
269
 
    return ''.join(plugin.describe_plugins(show_paths=True))
 
243
    plugin_lines = []
 
244
    for name, a_plugin in sorted(plugin.plugins().items()):
 
245
        plugin_lines.append("  %-20s %s [%s]" %
 
246
            (name, a_plugin.path(), a_plugin.__version__))
 
247
    return '\n'.join(plugin_lines)
270
248
 
271
249
 
272
250
def _format_module_list():