/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: Gustav Hartvigsson
  • Date: 2021-01-09 21:36:27 UTC
  • Revision ID: gustav.hartvigsson@gmail.com-20210109213627-h1xwcutzy9m7a99b
Added 'Case Preserving Working Tree Use Cases' from Canonical Wiki

* Addod a page from the Canonical Bazaar wiki
  with information on the scmeatics of case
  perserving filesystems an a case insensitive
  filesystem works.
  
  * Needs re-work, but this will do as it is the
    same inforamoton as what was on the linked
    page in the currint documentation.

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