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

  • Committer: Martin
  • Date: 2018-08-21 00:53:34 UTC
  • mto: This revision was merged to the branch mainline in revision 7074.
  • Revision ID: gzlist@googlemail.com-20180821005334-e1ogxakojyybpwib
Fix recursion check in C bencode implementation

Hard to get Cython to do the right thing but by inverting the
return code can use the standard except handling.

Avoid going through a Python call when encoding, which requires
the encode recursion check to work too.

Adjust tests to use a smaller limit to be more managable.

Show diffs side-by-side

added added

removed removed

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