/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/trace.py

  • Committer: Robert Collins
  • Date: 2010-05-06 23:41:35 UTC
  • mto: This revision was merged to the branch mainline in revision 5223.
  • Revision ID: robertc@robertcollins.net-20100506234135-yivbzczw1sejxnxc
Lock methods on ``Tree``, ``Branch`` and ``Repository`` are now
expected to return an object which can be used to unlock them. This reduces
duplicate code when using cleanups. The previous 'tokens's returned by
``Branch.lock_write`` and ``Repository.lock_write`` are now attributes
on the result of the lock_write. ``repository.RepositoryWriteLockResult``
and ``branch.BranchWriteLockResult`` document this. (Robert Collins)

``log._get_info_for_log_files`` now takes an add_cleanup callable.
(Robert Collins)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/trace.py
1
 
# Copyright (C) 2005-2011 Canonical Ltd
 
1
# Copyright (C) 2005-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
23
23
Messages are classified by severity levels: critical, error, warning, info,
24
24
and debug.
25
25
 
26
 
They can be sent to two places: stderr, and `$XDG_CACHE_HOME/breezy/brz.log`.
27
 
For purposes such as running the test suite, they can also be redirected away
28
 
from both of those two places to another location.
 
26
They can be sent to two places: to stderr, and to ~/.bzr.log.  For purposes
 
27
such as running the test suite, they can also be redirected away from both of
 
28
those two places to another location.
29
29
 
30
 
`brz.log` gets all messages, and full tracebacks for uncaught exceptions.
 
30
~/.bzr.log gets all messages, and full tracebacks for uncaught exceptions.
31
31
This trace file is always in UTF-8, regardless of the user's default encoding,
32
32
so that we can always rely on writing any message.
33
33
 
45
45
form.
46
46
"""
47
47
 
48
 
from __future__ import absolute_import
49
 
 
50
48
# FIXME: Unfortunately it turns out that python's logging module
51
49
# is quite expensive, even when the message is not printed by any handlers.
52
50
# We should perhaps change back to just simply doing it here.
56
54
# increased cost of logging.py is not so bad, and we could standardize on
57
55
# that.
58
56
 
59
 
import errno
 
57
import codecs
60
58
import logging
61
59
import os
62
60
import sys
63
61
import time
64
62
 
65
 
from .lazy_import import lazy_import
 
63
from bzrlib.lazy_import import lazy_import
66
64
lazy_import(globals(), """
67
 
import tempfile
 
65
from cStringIO import StringIO
 
66
import errno
 
67
import locale
68
68
import traceback
69
69
""")
70
70
 
71
 
import breezy
 
71
import bzrlib
 
72
 
 
73
from bzrlib.symbol_versioning import (
 
74
    deprecated_function,
 
75
    deprecated_in,
 
76
    )
72
77
 
73
78
lazy_import(globals(), """
74
 
from breezy import (
75
 
    bedding,
 
79
from bzrlib import (
76
80
    debug,
 
81
    errors,
77
82
    osutils,
 
83
    plugin,
 
84
    symbol_versioning,
78
85
    ui,
79
86
    )
80
87
""")
81
 
from . import (
82
 
    errors,
83
 
    )
84
 
 
85
 
from .sixish import (
86
 
    PY3,
87
 
    StringIO,
88
 
    text_type,
89
 
    )
90
 
 
91
 
 
92
 
# global verbosity for breezy; controls the log level for stderr; 0=normal; <0
 
88
 
 
89
 
 
90
# global verbosity for bzrlib; controls the log level for stderr; 0=normal; <0
93
91
# is quiet; >0 is verbose.
94
92
_verbosity_level = 0
95
93
 
99
97
# than push/pop_log_file.
100
98
_trace_file = None
101
99
 
102
 
# Absolute path for brz.log.  Not changed even if the log/trace output is
 
100
# Absolute path for ~/.bzr.log.  Not changed even if the log/trace output is
103
101
# redirected elsewhere.  Used to show the location in --version.
104
 
_brz_log_filename = None
 
102
_bzr_log_filename = None
105
103
 
106
104
# The time the first message was written to the trace file, so that we can
107
105
# show relative times since startup.
108
 
_brz_log_start_time = breezy._start_time
 
106
_bzr_log_start_time = bzrlib._start_time
109
107
 
110
108
 
111
109
# held in a global for quick reference
112
 
_brz_logger = logging.getLogger('brz')
 
110
_bzr_logger = logging.getLogger('bzr')
113
111
 
114
112
 
115
113
def note(*args, **kwargs):
116
 
    """Output a note to the user.
117
 
 
118
 
    Takes the same parameters as logging.info.
119
 
 
120
 
    :return: None
121
 
    """
 
114
    # FIXME note always emits utf-8, regardless of the terminal encoding
 
115
    #
122
116
    # FIXME: clearing the ui and then going through the abstract logging
123
117
    # framework is whack; we should probably have a logging Handler that
124
118
    # deals with terminal output if needed.
125
 
    ui.ui_factory.clear_term()
126
 
    _brz_logger.info(*args, **kwargs)
 
119
    import bzrlib.ui
 
120
    bzrlib.ui.ui_factory.clear_term()
 
121
    _bzr_logger.info(*args, **kwargs)
127
122
 
128
123
 
129
124
def warning(*args, **kwargs):
130
 
    ui.ui_factory.clear_term()
131
 
    _brz_logger.warning(*args, **kwargs)
 
125
    import bzrlib.ui
 
126
    bzrlib.ui.ui_factory.clear_term()
 
127
    _bzr_logger.warning(*args, **kwargs)
 
128
 
 
129
 
 
130
@deprecated_function(deprecated_in((2, 1, 0)))
 
131
def info(*args, **kwargs):
 
132
    """Deprecated: use trace.note instead."""
 
133
    note(*args, **kwargs)
 
134
 
 
135
 
 
136
@deprecated_function(deprecated_in((2, 1, 0)))
 
137
def log_error(*args, **kwargs):
 
138
    """Deprecated: use bzrlib.trace.show_error instead"""
 
139
    _bzr_logger.error(*args, **kwargs)
 
140
 
 
141
 
 
142
@deprecated_function(deprecated_in((2, 1, 0)))
 
143
def error(*args, **kwargs):
 
144
    """Deprecated: use bzrlib.trace.show_error instead"""
 
145
    _bzr_logger.error(*args, **kwargs)
132
146
 
133
147
 
134
148
def show_error(*args, **kwargs):
136
150
 
137
151
    Don't use this for exceptions, use report_exception instead.
138
152
    """
139
 
    _brz_logger.error(*args, **kwargs)
140
 
 
141
 
 
142
 
class _Bytes(str):
143
 
    """Compat class for displaying bytes on Python 2."""
144
 
 
145
 
    def __repr__(self):
146
 
        return 'b' + str.__repr__(self)
147
 
 
148
 
    def __unicode__(self):
149
 
        return self.decode('ascii', 'replace')
 
153
    _bzr_logger.error(*args, **kwargs)
150
154
 
151
155
 
152
156
def mutter(fmt, *args):
157
161
    if (getattr(_trace_file, 'closed', None) is not None) and _trace_file.closed:
158
162
        return
159
163
 
160
 
    # Let format strings be specified as ascii bytes to help Python 2
161
 
    if isinstance(fmt, bytes):
162
 
        fmt = fmt.decode('ascii', 'replace')
 
164
    if isinstance(fmt, unicode):
 
165
        fmt = fmt.encode('utf8')
163
166
 
164
 
    if args:
165
 
        if not PY3:
166
 
            args = tuple(
167
 
                _Bytes(arg) if isinstance(arg, bytes) else arg for arg in args)
168
 
        out = fmt % args
 
167
    if len(args) > 0:
 
168
        # It seems that if we do ascii % (unicode, ascii) we can
 
169
        # get a unicode cannot encode ascii error, so make sure that "fmt"
 
170
        # is a unicode string
 
171
        real_args = []
 
172
        for arg in args:
 
173
            if isinstance(arg, unicode):
 
174
                arg = arg.encode('utf8')
 
175
            real_args.append(arg)
 
176
        out = fmt % tuple(real_args)
169
177
    else:
170
178
        out = fmt
171
179
    now = time.time()
172
 
    out = '%0.3f  %s\n' % (now - _brz_log_start_time, out)
173
 
    _trace_file.write(out.encode('utf-8'))
 
180
    timestamp = '%0.3f  ' % (now - _bzr_log_start_time,)
 
181
    out = timestamp + out + '\n'
 
182
    _trace_file.write(out)
174
183
    # there's no explicit flushing; the file is typically line buffered.
175
184
 
176
185
 
205
214
        return
206
215
 
207
216
 
208
 
def _get_brz_log_filename():
209
 
    """Return the brz log filename.
210
 
 
211
 
    :return: A path to the log file
212
 
    :raise EnvironmentError: If the cache directory could not be created
213
 
    """
214
 
    brz_log = osutils.path_from_environ('BRZ_LOG')
215
 
    if brz_log:
216
 
        return brz_log
217
 
    return os.path.join(bedding.cache_dir(), 'brz.log')
218
 
 
219
 
 
220
 
def _open_brz_log():
221
 
    """Open the brz.log trace file.
 
217
def _get_bzr_log_filename():
 
218
    bzr_log = os.environ.get('BZR_LOG')
 
219
    if bzr_log:
 
220
        return bzr_log
 
221
    home = os.environ.get('BZR_HOME')
 
222
    if home is None:
 
223
        if sys.platform == 'win32':
 
224
            from bzrlib import win32utils
 
225
            home = win32utils.get_home_location()
 
226
        else:
 
227
            home = os.path.expanduser('~')
 
228
    return os.path.join(home, '.bzr.log')
 
229
 
 
230
 
 
231
def _open_bzr_log():
 
232
    """Open the .bzr.log trace file.
222
233
 
223
234
    If the log is more than a particular length, the old file is renamed to
224
 
    brz.log.old and a new file is started.  Otherwise, we append to the
 
235
    .bzr.log.old and a new file is started.  Otherwise, we append to the
225
236
    existing file.
226
237
 
227
 
    This sets the global _brz_log_filename.
 
238
    This sets the global _bzr_log_filename.
228
239
    """
229
 
    global _brz_log_filename
 
240
    global _bzr_log_filename
230
241
 
231
242
    def _open_or_create_log_file(filename):
232
243
        """Open existing log file, or create with ownership and permissions
240
251
            try:
241
252
                fd = os.open(filename, flags)
242
253
                break
243
 
            except OSError as e:
 
254
            except OSError, e:
244
255
                if e.errno != errno.ENOENT:
245
256
                    raise
246
257
            try:
247
 
                fd = os.open(filename, flags | os.O_CREAT | os.O_EXCL, 0o666)
248
 
            except OSError as e:
 
258
                fd = os.open(filename, flags | os.O_CREAT | os.O_EXCL, 0666)
 
259
            except OSError, e:
249
260
                if e.errno != errno.EEXIST:
250
261
                    raise
251
262
            else:
252
263
                osutils.copy_ownership_from_path(filename)
253
264
                break
254
 
        return os.fdopen(fd, 'ab', 0)  # unbuffered
255
 
 
 
265
        return os.fdopen(fd, 'at', 0) # unbuffered
 
266
 
 
267
 
 
268
    _bzr_log_filename = _get_bzr_log_filename()
 
269
    _rollover_trace_maybe(_bzr_log_filename)
256
270
    try:
257
 
        _brz_log_filename = _get_brz_log_filename()
258
 
        _rollover_trace_maybe(_brz_log_filename)
259
 
 
260
 
        brz_log_file = _open_or_create_log_file(_brz_log_filename)
261
 
        brz_log_file.write(b'\n')
262
 
        if brz_log_file.tell() <= 2:
263
 
            brz_log_file.write(
264
 
                b"this is a debug log for diagnosing/reporting problems in brz\n")
265
 
            brz_log_file.write(
266
 
                b"you can delete or truncate this file, or include sections in\n")
267
 
            brz_log_file.write(
268
 
                b"bug reports to https://bugs.launchpad.net/brz/+filebug\n\n")
269
 
 
270
 
        return brz_log_file
271
 
 
272
 
    except EnvironmentError as e:
 
271
        bzr_log_file = _open_or_create_log_file(_bzr_log_filename)
 
272
        bzr_log_file.write('\n')
 
273
        if bzr_log_file.tell() <= 2:
 
274
            bzr_log_file.write("this is a debug log for diagnosing/reporting problems in bzr\n")
 
275
            bzr_log_file.write("you can delete or truncate this file, or include sections in\n")
 
276
            bzr_log_file.write("bug reports to https://bugs.launchpad.net/bzr/+filebug\n\n")
 
277
 
 
278
        return bzr_log_file
 
279
 
 
280
    except EnvironmentError, e:
273
281
        # If we are failing to open the log, then most likely logging has not
274
282
        # been set up yet. So we just write to stderr rather than using
275
283
        # 'warning()'. If we using warning(), users get the unhelpful 'no
276
 
        # handlers registered for "brz"' when something goes wrong on the
 
284
        # handlers registered for "bzr"' when something goes wrong on the
277
285
        # server. (bug #503886)
278
286
        sys.stderr.write("failed to open trace file: %s\n" % (e,))
279
287
    # TODO: What should happen if we fail to open the trace file?  Maybe the
283
291
 
284
292
 
285
293
def enable_default_logging():
286
 
    """Configure default logging: messages to stderr and debug to brz.log
 
294
    """Configure default logging: messages to stderr and debug to .bzr.log
287
295
 
288
296
    This should only be called once per process.
289
297
 
290
 
    Non-command-line programs embedding breezy do not need to call this.  They
 
298
    Non-command-line programs embedding bzrlib do not need to call this.  They
291
299
    can instead either pass a file to _push_log_file, or act directly on
292
 
    logging.getLogger("brz").
 
300
    logging.getLogger("bzr").
293
301
 
294
302
    Output can be redirected away by calling _push_log_file.
295
 
 
296
 
    :return: A memento from push_log_file for restoring the log state.
297
303
    """
298
 
    start_time = osutils.format_local_date(_brz_log_start_time,
 
304
    # Do this before we open the log file, so we prevent
 
305
    # get_terminal_encoding() from mutter()ing multiple times
 
306
    term_encoding = osutils.get_terminal_encoding()
 
307
    start_time = osutils.format_local_date(_bzr_log_start_time,
299
308
                                           timezone='local')
300
 
    brz_log_file = _open_brz_log()
301
 
    if brz_log_file is not None:
302
 
        brz_log_file.write(start_time.encode('utf-8') + b'\n')
303
 
    memento = push_log_file(
304
 
        brz_log_file,
 
309
    # create encoded wrapper around stderr
 
310
    bzr_log_file = _open_bzr_log()
 
311
    if bzr_log_file is not None:
 
312
        bzr_log_file.write(start_time.encode('utf-8') + '\n')
 
313
    push_log_file(bzr_log_file,
305
314
        r'[%(process)5d] %(asctime)s.%(msecs)03d %(levelname)s: %(message)s',
306
315
        r'%Y-%m-%d %H:%M:%S')
307
 
    # after hooking output into brz_log, we also need to attach a stderr
 
316
    # after hooking output into bzr_log, we also need to attach a stderr
308
317
    # handler, writing only at level info and with encoding
309
 
    if sys.version_info[0] == 2:
310
 
        stderr_handler = EncodedStreamHandler(
311
 
            sys.stderr, osutils.get_terminal_encoding(), 'replace',
312
 
            level=logging.INFO)
313
 
    else:
314
 
        stderr_handler = logging.StreamHandler(stream=sys.stderr)
315
 
    logging.getLogger('brz').addHandler(stderr_handler)
316
 
    return memento
 
318
    writer_factory = codecs.getwriter(term_encoding)
 
319
    encoded_stderr = writer_factory(sys.stderr, errors='replace')
 
320
    stderr_handler = logging.StreamHandler(encoded_stderr)
 
321
    stderr_handler.setLevel(logging.INFO)
 
322
    logging.getLogger('bzr').addHandler(stderr_handler)
317
323
 
318
324
 
319
325
def push_log_file(to_file, log_format=None, date_format=None):
322
328
    :param to_file: A file-like object to which messages will be sent.
323
329
 
324
330
    :returns: A memento that should be passed to _pop_log_file to restore the
325
 
        previously active logging.
 
331
    previously active logging.
326
332
    """
327
333
    global _trace_file
328
334
    # make a new handler
329
 
    new_handler = EncodedStreamHandler(to_file, "utf-8", level=logging.DEBUG)
 
335
    new_handler = logging.StreamHandler(to_file)
 
336
    new_handler.setLevel(logging.DEBUG)
330
337
    if log_format is None:
331
338
        log_format = '%(levelname)8s  %(message)s'
332
339
    new_handler.setFormatter(logging.Formatter(log_format, date_format))
333
340
    # save and remove any existing log handlers
334
 
    brz_logger = logging.getLogger('brz')
335
 
    old_handlers = brz_logger.handlers[:]
336
 
    del brz_logger.handlers[:]
 
341
    bzr_logger = logging.getLogger('bzr')
 
342
    old_handlers = bzr_logger.handlers[:]
 
343
    del bzr_logger.handlers[:]
337
344
    # set that as the default logger
338
 
    brz_logger.addHandler(new_handler)
339
 
    brz_logger.setLevel(logging.DEBUG)
 
345
    bzr_logger.addHandler(new_handler)
 
346
    bzr_logger.setLevel(logging.DEBUG)
340
347
    # TODO: check if any changes are needed to the root logger
341
348
    #
342
 
    # TODO: also probably need to save and restore the level on brz_logger.
 
349
    # TODO: also probably need to save and restore the level on bzr_logger.
343
350
    # but maybe we can avoid setting the logger level altogether, and just set
344
351
    # the level on the handler?
345
352
    #
347
354
    old_trace_file = _trace_file
348
355
    # send traces to the new one
349
356
    _trace_file = to_file
 
357
    result = new_handler, _trace_file
350
358
    return ('log_memento', old_handlers, new_handler, old_trace_file, to_file)
351
359
 
352
360
 
353
 
def pop_log_file(entry):
 
361
def pop_log_file((magic, old_handlers, new_handler, old_trace_file, new_trace_file)):
354
362
    """Undo changes to logging/tracing done by _push_log_file.
355
363
 
356
 
    This flushes, but does not close the trace file (so that anything that was
357
 
    in it is output.
 
364
    This flushes, but does not close the trace file.
358
365
 
359
366
    Takes the memento returned from _push_log_file."""
360
 
    (magic, old_handlers, new_handler, old_trace_file, new_trace_file) = entry
361
367
    global _trace_file
362
368
    _trace_file = old_trace_file
363
 
    brz_logger = logging.getLogger('brz')
364
 
    brz_logger.removeHandler(new_handler)
365
 
    # must be closed, otherwise logging will try to close it at exit, and the
 
369
    bzr_logger = logging.getLogger('bzr')
 
370
    bzr_logger.removeHandler(new_handler)
 
371
    # must be closed, otherwise logging will try to close it atexit, and the
366
372
    # file will likely already be closed underneath.
367
373
    new_handler.close()
368
 
    brz_logger.handlers = old_handlers
369
 
    if new_trace_file is not None:
370
 
        new_trace_file.flush()
 
374
    bzr_logger.handlers = old_handlers
 
375
    new_trace_file.flush()
371
376
 
372
377
 
373
378
def log_exception_quietly():
409
414
def _update_logging_level(quiet=True):
410
415
    """Hide INFO messages if quiet."""
411
416
    if quiet:
412
 
        _brz_logger.setLevel(logging.WARNING)
 
417
        _bzr_logger.setLevel(logging.WARNING)
413
418
    else:
414
 
        _brz_logger.setLevel(logging.INFO)
 
419
        _bzr_logger.setLevel(logging.INFO)
415
420
 
416
421
 
417
422
def is_quiet():
427
432
def debug_memory(message='', short=True):
428
433
    """Write out a memory dump."""
429
434
    if sys.platform == 'win32':
430
 
        from breezy import win32utils
 
435
        from bzrlib import win32utils
431
436
        win32utils.debug_memory_win32api(message=message, short=short)
432
437
    else:
433
438
        _debug_memory_proc(message=message, short=short)
435
440
 
436
441
_short_fields = ('VmPeak', 'VmSize', 'VmRSS')
437
442
 
438
 
 
439
443
def _debug_memory_proc(message='', short=True):
440
444
    try:
441
 
        status_file = open('/proc/%s/status' % os.getpid(), 'rb')
 
445
        status_file = file('/proc/%s/status' % os.getpid(), 'rb')
442
446
    except IOError:
443
447
        return
444
448
    try:
457
461
                    break
458
462
 
459
463
 
460
 
def _dump_memory_usage(err_file):
461
 
    try:
462
 
        try:
463
 
            fd, name = tempfile.mkstemp(prefix="brz_memdump", suffix=".json")
464
 
            dump_file = os.fdopen(fd, 'w')
465
 
            from meliae import scanner
466
 
            scanner.dump_gc_objects(dump_file)
467
 
            err_file.write("Memory dumped to %s\n" % name)
468
 
        except ImportError:
469
 
            err_file.write("Dumping memory requires meliae module.\n")
470
 
            log_exception_quietly()
471
 
        except BaseException:
472
 
            err_file.write("Exception while dumping memory.\n")
473
 
            log_exception_quietly()
474
 
    finally:
475
 
        if dump_file is not None:
476
 
            dump_file.close()
477
 
        elif fd is not None:
478
 
            os.close(fd)
479
 
 
480
 
 
481
 
def _qualified_exception_name(eclass, unqualified_breezy_errors=False):
482
 
    """Give name of error class including module for non-builtin exceptions
483
 
 
484
 
    If `unqualified_breezy_errors` is True, errors specific to breezy will
485
 
    also omit the module prefix.
486
 
    """
487
 
    class_name = eclass.__name__
488
 
    module_name = eclass.__module__
489
 
    if module_name in ("builtins", "exceptions", "__main__") or (
490
 
            unqualified_breezy_errors and module_name == "breezy.errors"):
491
 
        return class_name
492
 
    return "%s.%s" % (module_name, class_name)
493
 
 
494
 
 
495
464
def report_exception(exc_info, err_file):
496
 
    """Report an exception to err_file (typically stderr) and to brz.log.
 
465
    """Report an exception to err_file (typically stderr) and to .bzr.log.
497
466
 
498
467
    This will show either a full traceback or a short message as appropriate.
499
468
 
500
469
    :return: The appropriate exit code for this error.
501
470
    """
502
 
    # Log the full traceback to brz.log
 
471
    # Log the full traceback to ~/.bzr.log
503
472
    log_exception_quietly()
504
473
    if 'error' in debug.debug_flags:
505
474
        print_exception(exc_info, err_file)
506
475
        return errors.EXIT_ERROR
507
476
    exc_type, exc_object, exc_tb = exc_info
508
 
    if isinstance(exc_object, KeyboardInterrupt):
509
 
        err_file.write("brz: interrupted\n")
 
477
    if (isinstance(exc_object, IOError)
 
478
        and getattr(exc_object, 'errno', None) == errno.EPIPE):
 
479
        err_file.write("bzr: broken pipe\n")
 
480
        return errors.EXIT_ERROR
 
481
    elif isinstance(exc_object, KeyboardInterrupt):
 
482
        err_file.write("bzr: interrupted\n")
510
483
        return errors.EXIT_ERROR
511
484
    elif isinstance(exc_object, MemoryError):
512
 
        err_file.write("brz: out of memory\n")
513
 
        if 'mem_dump' in debug.debug_flags:
514
 
            _dump_memory_usage(err_file)
515
 
        else:
516
 
            err_file.write("Use -Dmem_dump to dump memory to a file.\n")
 
485
        err_file.write("bzr: out of memory\n")
517
486
        return errors.EXIT_ERROR
518
487
    elif isinstance(exc_object, ImportError) \
519
 
            and str(exc_object).startswith("No module named "):
520
 
        report_user_error(
521
 
            exc_info, err_file,
 
488
        and str(exc_object).startswith("No module named "):
 
489
        report_user_error(exc_info, err_file,
522
490
            'You may need to install this Python library separately.')
523
491
        return errors.EXIT_ERROR
524
492
    elif not getattr(exc_object, 'internal_error', True):
525
493
        report_user_error(exc_info, err_file)
526
494
        return errors.EXIT_ERROR
527
 
    elif osutils.is_environment_error(exc_object):
528
 
        if getattr(exc_object, 'errno', None) == errno.EPIPE:
529
 
            err_file.write("brz: broken pipe\n")
530
 
            return errors.EXIT_ERROR
 
495
    elif isinstance(exc_object, (OSError, IOError)):
531
496
        # Might be nice to catch all of these and show them as something more
532
497
        # specific, but there are too many cases at the moment.
533
498
        report_user_error(exc_info, err_file)
539
504
 
540
505
def print_exception(exc_info, err_file):
541
506
    exc_type, exc_object, exc_tb = exc_info
542
 
    err_file.write("brz: ERROR: %s: %s\n" % (
543
 
        _qualified_exception_name(exc_type), exc_object))
 
507
    err_file.write("bzr: ERROR: %s.%s: %s\n" % (
 
508
        exc_type.__module__, exc_type.__name__, exc_object))
544
509
    err_file.write('\n')
545
510
    traceback.print_exception(exc_type, exc_object, exc_tb, file=err_file)
546
511
 
555
520
    :param advice: Extra advice to the user to be printed following the
556
521
        exception.
557
522
    """
558
 
    err_file.write(("brz: ERROR: %s\n" % (str(exc_info[1]),)))
 
523
    err_file.write("bzr: ERROR: %s\n" % (exc_info[1],))
559
524
    if advice:
560
 
        err_file.write(("%s\n" % advice))
 
525
        err_file.write("%s\n" % (advice,))
561
526
 
562
527
 
563
528
def report_bug(exc_info, err_file):
564
 
    """Report an exception that probably indicates a bug in brz"""
565
 
    from breezy.crash import report_bug
 
529
    """Report an exception that probably indicates a bug in bzr"""
 
530
    from bzrlib.crash import report_bug
566
531
    report_bug(exc_info, err_file)
567
532
 
568
533
 
569
534
def _flush_stdout_stderr():
570
 
    # called from the breezy library finalizer returned by breezy.initialize()
 
535
    # installed into an atexit hook by bzrlib.initialize()
571
536
    try:
572
537
        sys.stdout.flush()
573
538
        sys.stderr.flush()
574
 
    except ValueError:
575
 
        # On Windows, I get ValueError calling stdout.flush() on a closed
576
 
        # handle
577
 
        pass
578
 
    except IOError as e:
 
539
    except IOError, e:
579
540
        import errno
580
541
        if e.errno in [errno.EINVAL, errno.EPIPE]:
581
542
            pass
584
545
 
585
546
 
586
547
def _flush_trace():
587
 
    # called from the breezy library finalizer returned by breezy.initialize()
 
548
    # run from atexit hook
588
549
    global _trace_file
589
550
    if _trace_file:
590
551
        _trace_file.flush()
591
 
 
592
 
 
593
 
class EncodedStreamHandler(logging.Handler):
594
 
    """Robustly write logging events to a stream using the specified encoding
595
 
 
596
 
    Messages are expected to be formatted to unicode, but UTF-8 byte strings
597
 
    are also accepted. An error during formatting or a str message in another
598
 
    encoding will be quitely noted as an error in the Bazaar log file.
599
 
 
600
 
    The stream is not closed so sys.stdout or sys.stderr may be passed.
601
 
    """
602
 
 
603
 
    def __init__(self, stream, encoding=None, errors='strict', level=0):
604
 
        logging.Handler.__init__(self, level)
605
 
        self.stream = stream
606
 
        if encoding is None:
607
 
            encoding = getattr(stream, "encoding", "ascii")
608
 
        self.encoding = encoding
609
 
        self.errors = errors
610
 
 
611
 
    def flush(self):
612
 
        flush = getattr(self.stream, "flush", None)
613
 
        if flush is not None:
614
 
            flush()
615
 
 
616
 
    def emit(self, record):
617
 
        try:
618
 
            if not isinstance(record.msg, text_type):
619
 
                msg = record.msg.decode("utf-8")
620
 
                if PY3:
621
 
                    record.msg = msg
622
 
            line = self.format(record)
623
 
            if not isinstance(line, text_type):
624
 
                line = line.decode("utf-8")
625
 
            self.stream.write(line.encode(self.encoding, self.errors) + b"\n")
626
 
        except Exception:
627
 
            log_exception_quietly()
628
 
            # Try saving the details that would have been logged in some form
629
 
            msg = args = "<Unformattable>"
630
 
            try:
631
 
                msg = repr(record.msg)
632
 
                args = repr(record.args)
633
 
            except Exception:
634
 
                pass
635
 
            # Using mutter() bypasses the logging module and writes directly
636
 
            # to the file so there's no danger of getting into a loop here.
637
 
            mutter("Logging record unformattable: %s %% %s", msg, args)
638
 
 
639
 
 
640
 
class Config(object):
641
 
    """Configuration of message tracing in breezy.
642
 
 
643
 
    This implements the context manager protocol and should manage any global
644
 
    variables still used. The default config used is DefaultConfig, but
645
 
    embedded uses of breezy may wish to use a custom manager.
646
 
    """
647
 
 
648
 
    def __enter__(self):
649
 
        return self  # This is bound to the 'as' clause in a with statement.
650
 
 
651
 
    def __exit__(self, exc_type, exc_val, exc_tb):
652
 
        return False  # propogate exceptions.
653
 
 
654
 
 
655
 
class DefaultConfig(Config):
656
 
    """A default configuration for tracing of messages in breezy.
657
 
 
658
 
    This implements the context manager protocol.
659
 
    """
660
 
 
661
 
    def __enter__(self):
662
 
        self._original_filename = _brz_log_filename
663
 
        self._original_state = enable_default_logging()
664
 
        return self  # This is bound to the 'as' clause in a with statement.
665
 
 
666
 
    def __exit__(self, exc_type, exc_val, exc_tb):
667
 
        pop_log_file(self._original_state)
668
 
        global _brz_log_filename
669
 
        _brz_log_filename = self._original_filename
670
 
        return False  # propogate exceptions.