~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/crash.py

  • Committer: Robert Collins
  • Date: 2010-04-08 04:34:03 UTC
  • mfrom: (5138 +trunk)
  • mto: This revision was merged to the branch mainline in revision 5139.
  • Revision ID: robertc@robertcollins.net-20100408043403-56z0d07vdqrx7f3t
Update bugfix for 528114 to trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
16
16
 
17
17
 
18
18
"""Handling and reporting crashes.
 
19
 
 
20
A crash is an exception propagated up almost to the top level of Bazaar.
 
21
 
 
22
If we have apport <https://launchpad.net/apport/>, we store a report of the
 
23
crash using apport into it's /var/crash spool directory, from where the user
 
24
can either manually send it to Launchpad.  In some cases (at least Ubuntu
 
25
development releases), Apport may pop up a window asking if they want
 
26
to send it.
 
27
 
 
28
Without apport, we just write a crash report to stderr and the user can report
 
29
this manually if the wish.
 
30
 
 
31
We never send crash data across the network without user opt-in.
 
32
 
 
33
In principle apport can run on any platform though as of Feb 2010 there seem
 
34
to be some portability bugs.
 
35
 
 
36
To force this off in bzr turn set APPORT_DISABLE in the environment or 
 
37
-Dno_apport.
19
38
"""
20
39
 
21
40
# for interactive testing, try the 'bzr assert-fail' command 
22
41
# or see http://code.launchpad.net/~mbp/bzr/bzr-fail
 
42
#
 
43
# to test with apport it's useful to set
 
44
# export APPORT_IGNORE_OBSOLETE_PACKAGES=1
23
45
 
24
46
import os
25
47
import platform
39
61
 
40
62
 
41
63
def report_bug(exc_info, stderr):
42
 
    if 'no_apport' not in debug.debug_flags:
43
 
        try:
44
 
            report_bug_to_apport(exc_info, stderr)
 
64
    if ('no_apport' in debug.debug_flags) or \
 
65
        os.environ.get('APPORT_DISABLE', None):
 
66
        return report_bug_legacy(exc_info, stderr)
 
67
    try:
 
68
        if report_bug_to_apport(exc_info, stderr):
 
69
            # wrote a file; if None then report the old way
45
70
            return
46
 
        except ImportError, e:
47
 
            trace.mutter("couldn't find apport bug-reporting library: %s" % e)
48
 
            pass
49
 
        except Exception, e:
50
 
            # this should only happen if apport is installed but it didn't
51
 
            # work, eg because of an io error writing the crash file
52
 
            sys.stderr.write("bzr: failed to report crash using apport:\n "
53
 
                "    %r\n" % e)
54
 
            pass
55
 
    report_bug_legacy(exc_info, stderr)
 
71
    except ImportError, e:
 
72
        trace.mutter("couldn't find apport bug-reporting library: %s" % e)
 
73
        pass
 
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
        stderr.write("bzr: failed to report crash using apport:\n "
 
78
            "    %r\n" % e)
 
79
        pass
 
80
    return report_bug_legacy(exc_info, stderr)
56
81
 
57
82
 
58
83
def report_bug_legacy(exc_info, err_file):
81
106
 
82
107
def report_bug_to_apport(exc_info, stderr):
83
108
    """Report a bug to apport for optional automatic filing.
 
109
 
 
110
    :returns: The name of the crash file, or None if we didn't write one.
84
111
    """
85
 
    # this is based on apport_package_hook.py, but omitting some of the
 
112
    # this function is based on apport_package_hook.py, but omitting some of the
86
113
    # Ubuntu-specific policy about what to report and when
87
114
 
88
 
    # if this fails its caught at a higher level; we don't want to open the
89
 
    # crash file unless apport can be loaded.
 
115
    # if the import fails, the exception will be caught at a higher level and
 
116
    # we'll report the error by other means
90
117
    import apport
91
118
 
92
 
    crash_file = _open_crash_file()
93
 
    try:
94
 
        _write_apport_report_to_file(exc_info, crash_file)
95
 
    finally:
96
 
        crash_file.close()
97
 
 
98
 
    stderr.write("bzr: ERROR: %s.%s: %s\n" 
99
 
        "\n"
100
 
        "*** Bazaar has encountered an internal error.  This probably indicates a\n"
101
 
        "    bug in Bazaar.  You can help us fix it by filing a bug report at\n"
102
 
        "        https://bugs.launchpad.net/bzr/+filebug\n"
103
 
        "    attaching the crash file\n"
104
 
        "        %s\n"
105
 
        "    and including a description of the problem.\n"
106
 
        "\n"
107
 
        "    The crash file is plain text and you can inspect or edit it to remove\n"
108
 
        "    private information.\n"
109
 
        % (exc_info[0].__module__, exc_info[0].__name__, exc_info[1],
110
 
           crash_file.name))
111
 
 
112
 
 
113
 
def _write_apport_report_to_file(exc_info, crash_file):
 
119
    crash_filename = _write_apport_report_to_file(exc_info)
 
120
 
 
121
    if crash_filename is None:
 
122
        stderr.write("\n"
 
123
            "apport is set to ignore crashes in this version of bzr.\n"
 
124
            )
 
125
    else:
 
126
        trace.print_exception(exc_info, stderr)
 
127
        stderr.write("\n"
 
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))
 
132
        # XXX: on Windows, Mac, and other platforms where we might have the
 
133
        # apport libraries but not have an apport always running, we could
 
134
        # synchronously file now
 
135
 
 
136
    return crash_filename
 
137
 
 
138
 
 
139
def _write_apport_report_to_file(exc_info):
114
140
    import traceback
115
141
    from apport.report import Report
116
142
 
122
148
    # More importantly it sets the ExecutablePath, InterpreterPath, etc.
123
149
    pr.add_proc_info()
124
150
    pr.add_user_info()
 
151
 
 
152
    # Package and SourcePackage are needed so that apport will report about even
 
153
    # non-packaged versions of bzr; also this reports on their packaged
 
154
    # dependencies which is useful.
 
155
    pr['SourcePackage'] = 'bzr'
 
156
    pr['Package'] = 'bzr'
 
157
 
125
158
    pr['CommandLine'] = pprint.pformat(sys.argv)
126
159
    pr['BzrVersion'] = bzrlib.__version__
127
160
    pr['PythonVersion'] = bzrlib._format_version_tuple(sys.version_info)
150
183
    traceback.print_exception(exc_type, exc_object, exc_tb, file=tb_file)
151
184
    pr['Traceback'] = tb_file.getvalue()
152
185
 
153
 
    pr.write(crash_file)
 
186
    _attach_log_tail(pr)
 
187
 
 
188
    # We want to use the 'bzr' crashdb so that it gets sent directly upstream,
 
189
    # which is a reasonable default for most internal errors.  However, if we
 
190
    # set it here then apport will crash later if it doesn't know about that
 
191
    # crashdb.  Instead, we rely on the bzr package installing both a
 
192
    # source hook telling crashes to go to this crashdb, and a crashdb
 
193
    # configuration describing it.
 
194
 
 
195
    # these may contain some sensitive info (smtp_passwords)
 
196
    # TODO: strip that out and attach the rest
 
197
    #
 
198
    #attach_file_if_exists(report,
 
199
    #   os.path.join(dot_bzr, 'bazaar.conf', 'BzrConfig')
 
200
    #attach_file_if_exists(report,
 
201
    #   os.path.join(dot_bzr, 'locations.conf', 'BzrLocations')
 
202
    
 
203
    # strip username, hostname, etc
 
204
    pr.anonymize()
 
205
 
 
206
    if pr.check_ignored():
 
207
        # eg configured off in ~/.apport-ignore.xml
 
208
        return None
 
209
    else:
 
210
        crash_file_name, crash_file = _open_crash_file()
 
211
        pr.write(crash_file)
 
212
        crash_file.close()
 
213
        return crash_file_name
 
214
 
 
215
 
 
216
def _attach_log_tail(pr):
 
217
    try:
 
218
        bzr_log = open(trace._get_bzr_log_filename(), 'rt')
 
219
    except (IOError, OSError), e:
 
220
        pr['BzrLogTail'] = repr(e)
 
221
        return
 
222
    try:
 
223
        lines = bzr_log.readlines()
 
224
        pr['BzrLogTail'] = ''.join(lines[-40:])
 
225
    finally:
 
226
        bzr_log.close()
154
227
 
155
228
 
156
229
def _open_crash_file():
157
230
    crash_dir = config.crash_dir()
158
 
    # user-readable only, just in case the contents are sensitive.
159
231
    if not osutils.isdir(crash_dir):
160
 
        os.makedirs(crash_dir, mode=0700)
161
 
    filename = 'bzr-%s-%s.crash' % (
162
 
        osutils.compact_date(time.time()),
163
 
        os.getpid(),)
164
 
    return open(osutils.pathjoin(crash_dir, filename), 'wt')
 
232
        # on unix this should be /var/crash and should already exist; on
 
233
        # Windows or if it's manually configured it might need to be created,
 
234
        # and then it should be private
 
235
        os.makedirs(crash_dir, mode=0600)
 
236
    date_string = time.strftime('%Y-%m-%dT%H:%M', time.gmtime())
 
237
    # XXX: getuid doesn't work on win32, but the crash directory is per-user
 
238
    if sys.platform == 'win32':
 
239
        user_part = ''
 
240
    else:
 
241
        user_part = '.%d' % os.getuid()
 
242
    filename = osutils.pathjoin(
 
243
        crash_dir,
 
244
        'bzr%s.%s.crash' % (
 
245
            user_part,
 
246
            date_string))
 
247
    # be careful here that people can't play tmp-type symlink mischief in the
 
248
    # world-writable directory
 
249
    return filename, os.fdopen(
 
250
        os.open(filename, 
 
251
            os.O_WRONLY|os.O_CREAT|os.O_EXCL,
 
252
            0600),
 
253
        'w')
165
254
 
166
255
 
167
256
def _format_plugin_list():