← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/crash.py

- stub for revision properties

Show diffs side-by-side

added added

removed removed

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