/brz/remove-bazaar

# Copyright (C) 2005-2011 Canonical Ltd

They can be sent to two places: to stderr, and to ~/.brz.log.  For purposes

~/.brz.log gets all messages, and full tracebacks for uncaught exceptions.

from __future__ import absolute_import

 

import errno

from .lazy_import import lazy_import

import tempfile

import breezy

from breezy import (

from .sixish import (

    BytesIO,

    PY3,

    StringIO,

    text_type,

    )

 

 

# global verbosity for breezy; controls the log level for stderr; 0=normal; <0

# Absolute path for ~/.brz.log.  Not changed even if the log/trace output is

_brz_log_filename = None

_brz_log_start_time = breezy._start_time

_brz_logger = logging.getLogger('brz')

    ui.ui_factory.clear_term()

    _brz_logger.info(*args, **kwargs)

    ui.ui_factory.clear_term()

    _brz_logger.warning(*args, **kwargs)

    _brz_logger.error(*args, **kwargs)

 

 

class _Bytes(str):

    """Compat class for displaying bytes on Python 2."""

 

    def __repr__(self):

        return 'b' + str.__repr__(self)

 

    def __unicode__(self):

        return self.decode('ascii', 'replace')

    # Let format strings be specified as ascii bytes to help Python 2

    if isinstance(fmt, bytes):

        fmt = fmt.decode('ascii', 'replace')

    if args:

        if not PY3:

            args = tuple(

                _Bytes(arg) if isinstance(arg, bytes) else arg for arg in args)

        out = fmt % args

    out = '%0.3f  %s\n' % (now - _brz_log_start_time, out)

    _trace_file.write(out.encode('utf-8'))

def _get_brz_log_filename():

    brz_log = osutils.path_from_environ('BRZ_LOG')

    if brz_log:

        return brz_log

    home = osutils.path_from_environ('BRZ_HOME')

        # GZ 2012-02-01: Logging to the home dir is bad, but XDG is unclear

        #                over what would be better. On windows, bug 240550

        #                suggests LOCALAPPDATA be used instead.

        home = osutils._get_home_dir()

    return os.path.join(home, '.brz.log')

 

 

def _open_brz_log():

    """Open the .brz.log trace file.

    .brz.log.old and a new file is started.  Otherwise, we append to the

    This sets the global _brz_log_filename.

    global _brz_log_filename

            except OSError as e:

                fd = os.open(filename, flags | os.O_CREAT | os.O_EXCL, 0o666)

            except OSError as e:

        return os.fdopen(fd, 'ab', 0) # unbuffered

 

 

    _brz_log_filename = _get_brz_log_filename()

    _rollover_trace_maybe(_brz_log_filename)

        brz_log_file = _open_or_create_log_file(_brz_log_filename)

        brz_log_file.write(b'\n')

        if brz_log_file.tell() <= 2:

            brz_log_file.write(b"this is a debug log for diagnosing/reporting problems in brz\n")

            brz_log_file.write(b"you can delete or truncate this file, or include sections in\n")

            brz_log_file.write(b"bug reports to https://bugs.launchpad.net/brz/+filebug\n\n")

 

        return brz_log_file

 

    except EnvironmentError as e:

        # handlers registered for "brz"' when something goes wrong on the

    """Configure default logging: messages to stderr and debug to .brz.log

    Non-command-line programs embedding breezy do not need to call this.  They

    logging.getLogger("brz").

 

    :return: A memento from push_log_file for restoring the log state.

    start_time = osutils.format_local_date(_brz_log_start_time,

    brz_log_file = _open_brz_log()

    if brz_log_file is not None:

        brz_log_file.write(start_time.encode('utf-8') + b'\n')

    memento = push_log_file(brz_log_file,

    # after hooking output into brz_log, we also need to attach a stderr

    if sys.version_info[0] == 2:

        stderr_handler = EncodedStreamHandler(sys.stderr,

            osutils.get_terminal_encoding(), 'replace', level=logging.INFO)

    else:

        stderr_handler = logging.StreamHandler(stream=sys.stderr)

    logging.getLogger('brz').addHandler(stderr_handler)

    return memento

        previously active logging.

    new_handler = EncodedStreamHandler(to_file, "utf-8", level=logging.DEBUG)

    brz_logger = logging.getLogger('brz')

    old_handlers = brz_logger.handlers[:]

    del brz_logger.handlers[:]

    brz_logger.addHandler(new_handler)

    brz_logger.setLevel(logging.DEBUG)

    # TODO: also probably need to save and restore the level on brz_logger.

def pop_log_file(entry):

    This flushes, but does not close the trace file (so that anything that was

    in it is output.

    (magic, old_handlers, new_handler, old_trace_file, new_trace_file) = entry

    brz_logger = logging.getLogger('brz')

    brz_logger.removeHandler(new_handler)

    # must be closed, otherwise logging will try to close it at exit, and the

    brz_logger.handlers = old_handlers

    if new_trace_file is not None:

        new_trace_file.flush()

        _brz_logger.setLevel(logging.WARNING)

        _brz_logger.setLevel(logging.INFO)

        from breezy import win32utils

        status_file = open('/proc/%s/status' % os.getpid(), 'rb')

def _dump_memory_usage(err_file):

    try:

        try:

            fd, name = tempfile.mkstemp(prefix="brz_memdump", suffix=".json")

            dump_file = os.fdopen(fd, 'w')

            from meliae import scanner

            scanner.dump_gc_objects(dump_file)

            err_file.write("Memory dumped to %s\n" % name)

        except ImportError:

            err_file.write("Dumping memory requires meliae module.\n")

            log_exception_quietly()

        except:

            err_file.write("Exception while dumping memory.\n")

            log_exception_quietly()

    finally:

        if dump_file is not None:

            dump_file.close()

        elif fd is not None:

            os.close(fd)

 

 

def _qualified_exception_name(eclass, unqualified_breezy_errors=False):

    """Give name of error class including module for non-builtin exceptions

 

    If `unqualified_breezy_errors` is True, errors specific to breezy will

    also omit the module prefix.

    """

    class_name = eclass.__name__

    module_name = eclass.__module__

    if module_name in ("builtins", "exceptions", "__main__") or (

            unqualified_breezy_errors and module_name == "breezy.errors"):

        return class_name

    return "%s.%s" % (module_name, class_name)

 

    """Report an exception to err_file (typically stderr) and to .brz.log.

    # Log the full traceback to ~/.brz.log

    if isinstance(exc_object, KeyboardInterrupt):

        err_file.write("brz: interrupted\n")

        err_file.write("brz: out of memory\n")

        if 'mem_dump' in debug.debug_flags:

            _dump_memory_usage(err_file)

        else:

            err_file.write("Use -Dmem_dump to dump memory to a file.\n")

    elif osutils.is_environment_error(exc_object):

        if getattr(exc_object, 'errno', None) == errno.EPIPE:

            err_file.write("brz: broken pipe\n")

            return errors.EXIT_ERROR

    err_file.write("brz: ERROR: %s: %s\n" % (

        _qualified_exception_name(exc_type), exc_object))

    err_file.write(("brz: ERROR: %s\n" % (str(exc_info[1]),)))

        err_file.write(("%s\n" % advice))

    """Report an exception that probably indicates a bug in brz"""

    from breezy.crash import report_bug

    # called from the breezy library finalizer returned by breezy.initialize()

    except ValueError as e:

        # On Windows, I get ValueError calling stdout.flush() on a closed

        # handle

        pass

    except IOError as e:

    # called from the breezy library finalizer returned by breezy.initialize()

 

 

class EncodedStreamHandler(logging.Handler):

    """Robustly write logging events to a stream using the specified encoding

 

    Messages are expected to be formatted to unicode, but UTF-8 byte strings

    are also accepted. An error during formatting or a str message in another

    encoding will be quitely noted as an error in the Bazaar log file.

 

    The stream is not closed so sys.stdout or sys.stderr may be passed.

    """

 

    def __init__(self, stream, encoding=None, errors='strict', level=0):

        logging.Handler.__init__(self, level)

        self.stream = stream

        if encoding is None:

            encoding = getattr(stream, "encoding", "ascii")

        self.encoding = encoding

        self.errors = errors

 

    def flush(self):

        flush = getattr(self.stream, "flush", None)

        if flush is not None:

            flush()

 

    def emit(self, record):