← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/crash.py

  • Committer: John Arbash Meinel
  • Date: 2009-06-02 19:56:24 UTC
  • mto: This revision was merged to the branch mainline in revision 4469.
  • Revision ID: john@arbash-meinel.com-20090602195624-utljsyz0qgmq63lg
Add a chunks_to_gzip function.
This allows the _record_to_data code to build up a list of chunks,
rather than requiring a single string.
It should be ~ the same performance when using a single string, since
we are only adding a for() loop over the chunks and an if check.
We could possibly just remove the if check and not worry about adding
some empty strings in there.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/crash.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
 
 
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.
38
 
"""
39
 
 
40
 
# for interactive testing, try the 'bzr assert-fail' command 
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
45
 
 
46
 
import os
47
 
import platform
48
 
import pprint
49
 
import sys
50
 
import time
51
 
from StringIO import StringIO
52
 
 
53
 
import bzrlib
54
 
from bzrlib import (
55
 
    config,
56
 
    debug,
57
 
    osutils,
58
 
    plugin,
59
 
    trace,
60
 
    )
61
 
 
62
 
 
63
 
def report_bug(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
70
 
            return
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)
81
 
 
82
 
 
83
 
def report_bug_legacy(exc_info, err_file):
84
 
    """Report a bug by just printing a message to the user."""
85
 
    trace.print_exception(exc_info, err_file)
86
 
    err_file.write('\n')
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(
93
 
        'encoding: %r, fsenc: %r, lang: %r\n' % (
94
 
            osutils.get_user_encoding(), sys.getfilesystemencoding(),
95
 
            os.environ.get('LANG')))
96
 
    err_file.write("plugins:\n")
97
 
    err_file.write(_format_plugin_list())
98
 
    err_file.write(
99
 
        "\n\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
 
        "    including this traceback and a description of the problem.\n"
104
 
        )
105
 
 
106
 
 
107
 
def report_bug_to_apport(exc_info, stderr):
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.
111
 
    """
112
 
    # this function is based on apport_package_hook.py, but omitting some of the
113
 
    # Ubuntu-specific policy about what to report and when
114
 
 
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
118
 
 
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):
140
 
    import traceback
141
 
    from apport.report import Report
142
 
 
143
 
    exc_type, exc_object, exc_tb = exc_info
144
 
 
145
 
    pr = Report()
146
 
    # add_proc_info gives you the memory map of the process, which is not so
147
 
    # useful for Bazaar but does tell you what binary libraries are loaded.
148
 
    # More importantly it sets the ExecutablePath, InterpreterPath, etc.
149
 
    pr.add_proc_info()
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
 
 
158
 
    pr['CommandLine'] = pprint.pformat(sys.argv)
159
 
    pr['BzrVersion'] = bzrlib.__version__
160
 
    pr['PythonVersion'] = bzrlib._format_version_tuple(sys.version_info)
161
 
    pr['Platform'] = platform.platform(aliased=1)
162
 
    pr['UserEncoding'] = osutils.get_user_encoding()
163
 
    pr['FileSystemEncoding'] = sys.getfilesystemencoding()
164
 
    pr['Locale'] = os.environ.get('LANG')
165
 
    pr['BzrPlugins'] = _format_plugin_list()
166
 
    pr['PythonLoadedModules'] = _format_module_list()
167
 
    pr['BzrDebugFlags'] = pprint.pformat(debug.debug_flags)
168
 
 
169
 
    # actually we'd rather file directly against the upstream product, but
170
 
    # apport does seem to count on there being one in there; we might need to
171
 
    # redirect it elsewhere anyhow
172
 
    pr['SourcePackage'] = 'bzr'
173
 
    pr['Package'] = 'bzr'
174
 
 
175
 
    # tell apport to file directly against the bzr package using 
176
 
    # <https://bugs.launchpad.net/bzr/+bug/391015>
177
 
    #
178
 
    # XXX: unfortunately apport may crash later if the crashdb definition
179
 
    # file isn't present
180
 
    pr['CrashDb'] = 'bzr'
181
 
 
182
 
    tb_file = StringIO()
183
 
    traceback.print_exception(exc_type, exc_object, exc_tb, file=tb_file)
184
 
    pr['Traceback'] = tb_file.getvalue()
185
 
 
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()
227
 
 
228
 
 
229
 
def _open_crash_file():
230
 
    crash_dir = config.crash_dir()
231
 
    if not osutils.isdir(crash_dir):
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')
254
 
 
255
 
 
256
 
def _format_plugin_list():
257
 
    plugin_lines = []
258
 
    for name, a_plugin in sorted(plugin.plugins().items()):
259
 
        plugin_lines.append("  %-20s %s [%s]" %
260
 
            (name, a_plugin.path(), a_plugin.__version__))
261
 
    return '\n'.join(plugin_lines)
262
 
 
263
 
 
264
 
def _format_module_list():
265
 
    return pprint.pformat(sys.modules)