/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 breezy/crash.py

  • Committer: Jelmer Vernooij
  • Date: 2019-10-28 01:38:39 UTC
  • mto: This revision was merged to the branch mainline in revision 7412.
  • Revision ID: jelmer@jelmer.uk-20191028013839-q63zzm4yr0id9b3o
Allow unknown extras in git commits when just inspecting revisions, rather than importing.

Show diffs side-by-side

added added

removed removed

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