← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/trace.py

Deprecate compare_trees and move its body to InterTree.changes_from.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/trace.py
1
 
#! /usr/bin/env python
2
 
# -*- coding: UTF-8 -*-
3
 
 
 
1
# Copyright (C) 2005, 2006 by Canonical Ltd
 
2
#
4
3
# This program is free software; you can redistribute it and/or modify
5
4
# it under the terms of the GNU General Public License as published by
6
5
# the Free Software Foundation; either version 2 of the License, or
7
6
# (at your option) any later version.
8
 
 
 
7
#
9
8
# This program is distributed in the hope that it will be useful,
10
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
11
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12
11
# GNU General Public License for more details.
13
 
 
 
12
#
14
13
# You should have received a copy of the GNU General Public License
15
14
# along with this program; if not, write to the Free Software
16
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17
16
 
18
 
 
19
 
__copyright__ = "Copyright (C) 2005 Canonical Ltd."
20
 
__author__ = "Martin Pool <mbp@canonical.com>"
21
 
 
22
 
 
23
 
import sys, os, time, socket, stat, codecs
 
17
"""Messages and logging for bazaar-ng.
 
18
 
 
19
Messages are supplied by callers as a string-formatting template, plus values
 
20
to be inserted into it.  The actual %-formatting is deferred to the log
 
21
library so that it doesn't need to be done for messages that won't be emitted.
 
22
 
 
23
Messages are classified by severity levels: critical, error, warning, info,
 
24
and debug.
 
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.
 
29
 
 
30
~/.bzr.log gets all messages, and full tracebacks for uncaught exceptions.
 
31
This trace file is always in UTF-8, regardless of the user's default encoding,
 
32
so that we can always rely on writing any message.
 
33
 
 
34
Output to stderr depends on the mode chosen by the user.  By default, messages
 
35
of info and above are sent out, which results in progress messages such as the
 
36
list of files processed by add and commit.  In quiet mode, only warnings and
 
37
above are shown.  In debug mode, stderr gets debug messages too.
 
38
 
 
39
Errors that terminate an operation are generally passed back as exceptions;
 
40
others may be just emitted as messages.
 
41
 
 
42
Exceptions are reported in a brief form to stderr so as not to look scary.
 
43
BzrErrors are required to be able to format themselves into a properly
 
44
explanatory message.  This is not true for builtin exceptions such as
 
45
KeyError, which typically just str to "0".  They're printed in a different
 
46
form.
 
47
"""
 
48
 
 
49
# FIXME: Unfortunately it turns out that python's logging module
 
50
# is quite expensive, even when the message is not printed by any handlers.
 
51
# We should perhaps change back to just simply doing it here.
 
52
 
 
53
 
 
54
import errno
 
55
import os
 
56
import sys
 
57
import logging
 
58
 
24
59
import bzrlib
25
 
 
26
 
######################################################################
27
 
# messages and logging
28
 
 
29
 
global _tracefile, _starttime
30
 
_tracefile = None
31
 
 
32
 
# used to have % (os.environ['USER'], time.time(), os.getpid()), 'w')
33
 
_starttime = None
34
 
 
35
 
# If false, notes also go to stdout; should replace this with --silent
36
 
# at some point.
37
 
silent = False
38
 
 
39
 
 
40
 
# fix this if we ever fork within python
41
 
_mypid = os.getpid()
42
 
_logprefix = '[%d] ' % _mypid
43
 
 
44
 
 
45
 
def _write_trace(msg):
46
 
    _tracefile.write(_logprefix + msg + '\n')
47
 
 
48
 
 
49
 
def warning(msg):
50
 
    sys.stderr.write('bzr: warning: ' + msg + '\n')
51
 
    _write_trace('warning: ' + msg)
52
 
 
53
 
 
54
 
mutter = _write_trace
55
 
 
56
 
 
57
 
def note(msg):
58
 
    b = '* ' + str(msg) + '\n'
59
 
    if not silent:
60
 
        sys.stderr.write(b)
61
 
    _write_trace('note: ' + msg)
62
 
 
63
 
 
64
 
def log_error(msg):
65
 
    sys.stderr.write(msg + '\n')
66
 
    _write_trace(msg)
 
60
from bzrlib.errors import BzrError, BzrNewError
 
61
from bzrlib.symbol_versioning import (deprecated_function,
 
62
        zero_nine,
 
63
        )
 
64
 
 
65
_file_handler = None
 
66
_stderr_handler = None
 
67
_stderr_quiet = False
 
68
_trace_file = None
 
69
_trace_depth = 0
 
70
_bzr_log_file = None
 
71
 
 
72
 
 
73
# configure convenient aliases for output routines
 
74
 
 
75
_bzr_logger = logging.getLogger('bzr')
 
76
 
 
77
def note(*args, **kwargs):
 
78
    # FIXME note always emits utf-8, regardless of the terminal encoding
 
79
    import bzrlib.ui
 
80
    bzrlib.ui.ui_factory.clear_term()
 
81
    _bzr_logger.info(*args, **kwargs)
 
82
 
 
83
def warning(*args, **kwargs):
 
84
    import bzrlib.ui
 
85
    bzrlib.ui.ui_factory.clear_term()
 
86
    _bzr_logger.warning(*args, **kwargs)
 
87
 
 
88
info = note
 
89
log_error = _bzr_logger.error
 
90
error =     _bzr_logger.error
 
91
 
 
92
 
 
93
def mutter(fmt, *args):
 
94
    if _trace_file is None:
 
95
        return
 
96
    if hasattr(_trace_file, 'closed') and _trace_file.closed:
 
97
        return
 
98
    if len(args) > 0:
 
99
        # It seems that if we do ascii % (unicode, ascii) we can
 
100
        # get a unicode cannot encode ascii error, so make sure that "fmt"
 
101
        # is a unicode string
 
102
        out = unicode(fmt) % args
 
103
    else:
 
104
        out = fmt
 
105
    out += '\n'
 
106
    try:
 
107
        _trace_file.write(out)
 
108
    except UnicodeError, e:
 
109
        warning('UnicodeError: %s', e)
 
110
        _trace_file.write(repr(out))
 
111
    # TODO: jam 20051227 Consider flushing the trace file to help debugging
 
112
    #_trace_file.flush()
 
113
debug = mutter
67
114
 
68
115
 
69
116
def _rollover_trace_maybe(trace_fname):
 
117
    import stat
70
118
    try:
71
119
        size = os.stat(trace_fname)[stat.ST_SIZE]
72
120
        if size <= 4 << 20:
73
121
            return
74
122
        old_fname = trace_fname + '.old'
75
 
 
76
 
        try:
77
 
            # must remove before rename on windows
78
 
            os.remove(old_fname)
79
 
        except OSError:
80
 
            pass
81
 
 
82
 
        try:
83
 
            # might fail if in use on windows
84
 
            os.rename(trace_fname, old_fname)
85
 
        except OSError:
86
 
            pass
 
123
        from osutils import rename
 
124
        rename(trace_fname, old_fname)
87
125
    except OSError:
88
126
        return
89
127
 
90
128
 
91
 
 
92
 
def create_tracefile(argv):
 
129
def open_tracefile(tracefilename='~/.bzr.log'):
93
130
    # Messages are always written to here, so that we have some
94
131
    # information if something goes wrong.  In a future version this
95
132
    # file will be removed on successful completion.
96
 
    global _starttime, _tracefile
97
 
 
98
 
    _starttime = os.times()[4]
99
 
 
100
 
    trace_fname = os.path.join(os.path.expanduser('~/.bzr.log'))
 
133
    global _file_handler, _bzr_log_file
 
134
    import codecs
 
135
 
 
136
    trace_fname = os.path.join(os.path.expanduser(tracefilename))
101
137
    _rollover_trace_maybe(trace_fname)
102
 
 
103
 
    # buffering=1 means line buffered
104
 
    _tracefile = codecs.open(trace_fname, 'at', 'utf8', buffering=1)
105
 
    t = _tracefile
106
 
 
107
 
    if os.fstat(t.fileno())[stat.ST_SIZE] == 0:
108
 
        t.write("\nthis is a debug log for diagnosing/reporting problems in bzr\n")
109
 
        t.write("you can delete or truncate this file, or include sections in\n")
110
 
        t.write("bug reports to bazaar-ng@lists.canonical.com\n\n")
111
 
 
112
 
    # TODO: If we failed to create the file, perhaps give a warning
113
 
    # but don't abort; send things to /dev/null instead?
114
 
 
115
 
    _write_trace('bzr %s invoked on python %s (%s)'
116
 
                 % (bzrlib.__version__,
117
 
                    '.'.join(map(str, sys.version_info)),
118
 
                    sys.platform))
119
 
 
120
 
    _write_trace('  arguments: %r' % argv)
121
 
    _write_trace('  working dir: ' + os.getcwdu())
122
 
 
123
 
 
124
 
def close_trace():
125
 
    times = os.times()
126
 
    mutter("finished, %.3fu/%.3fs cpu, %.3fu/%.3fs cum, %.3f elapsed"
127
 
           % (times[:4] + ((times[4] - _starttime),)))
128
 
 
129
 
 
130
 
 
131
 
def log_exception(e):
132
 
    import traceback, cStringIO
133
 
    s = cStringIO.StringIO()
134
 
    traceback.print_exc(None, s)
135
 
    for l in s.getvalue().split('\n'):
136
 
        _write_trace(l)
137
 
        
138
 
    
 
138
    try:
 
139
        LINE_BUFFERED = 1
 
140
        tf = codecs.open(trace_fname, 'at', 'utf8', buffering=LINE_BUFFERED)
 
141
        _bzr_log_file = tf
 
142
        if tf.tell() == 0:
 
143
            tf.write("\nthis is a debug log for diagnosing/reporting problems in bzr\n")
 
144
            tf.write("you can delete or truncate this file, or include sections in\n")
 
145
            tf.write("bug reports to bazaar-ng@lists.canonical.com\n\n")
 
146
        _file_handler = logging.StreamHandler(tf)
 
147
        fmt = r'[%(process)5d] %(asctime)s.%(msecs)03d %(levelname)s: %(message)s'
 
148
        datefmt = r'%a %H:%M:%S'
 
149
        _file_handler.setFormatter(logging.Formatter(fmt, datefmt))
 
150
        _file_handler.setLevel(logging.DEBUG)
 
151
        logging.getLogger('').addHandler(_file_handler)
 
152
    except IOError, e:
 
153
        warning("failed to open trace file: %s" % (e))
 
154
 
 
155
 
 
156
@deprecated_function(zero_nine)
 
157
def log_exception(msg=None):
 
158
    """Log the last exception to stderr and the trace file.
 
159
 
 
160
    The exception string representation is used as the error
 
161
    summary, unless msg is given.
 
162
    """
 
163
    if msg:
 
164
        error(msg)
 
165
    else:
 
166
        exc_str = format_exception_short(sys.exc_info())
 
167
        error(exc_str)
 
168
    log_exception_quietly()
 
169
 
 
170
 
 
171
def log_exception_quietly():
 
172
    """Log the last exception to the trace file only.
 
173
 
 
174
    Used for exceptions that occur internally and that may be 
 
175
    interesting to developers but not to users.  For example, 
 
176
    errors loading plugins.
 
177
    """
 
178
    import traceback
 
179
    debug(traceback.format_exc())
 
180
 
 
181
 
 
182
def enable_default_logging():
 
183
    """Configure default logging to stderr and .bzr.log"""
 
184
    # FIXME: if this is run twice, things get confused
 
185
    global _stderr_handler, _file_handler, _trace_file, _bzr_log_file
 
186
    _stderr_handler = logging.StreamHandler()
 
187
    logging.getLogger('').addHandler(_stderr_handler)
 
188
    _stderr_handler.setLevel(logging.INFO)
 
189
    if not _file_handler:
 
190
        open_tracefile()
 
191
    _trace_file = _bzr_log_file
 
192
    if _file_handler:
 
193
        _file_handler.setLevel(logging.DEBUG)
 
194
    _bzr_logger.setLevel(logging.DEBUG)
 
195
 
 
196
 
 
197
def be_quiet(quiet=True):
 
198
    global _stderr_handler, _stderr_quiet
 
199
    
 
200
    _stderr_quiet = quiet
 
201
    if quiet:
 
202
        _stderr_handler.setLevel(logging.WARNING)
 
203
    else:
 
204
        _stderr_handler.setLevel(logging.INFO)
 
205
 
 
206
 
 
207
def is_quiet():
 
208
    global _stderr_quiet
 
209
    return _stderr_quiet
 
210
 
 
211
 
 
212
def disable_default_logging():
 
213
    """Turn off default log handlers.
 
214
 
 
215
    This is intended to be used by the test framework, which doesn't
 
216
    want leakage from the code-under-test into the main logs.
 
217
    """
 
218
 
 
219
    l = logging.getLogger('')
 
220
    l.removeHandler(_stderr_handler)
 
221
    if _file_handler:
 
222
        l.removeHandler(_file_handler)
 
223
    _trace_file = None
 
224
 
 
225
 
 
226
def enable_test_log(to_file):
 
227
    """Redirect logging to a temporary file for a test
 
228
    
 
229
    returns an opaque reference that should be passed to disable_test_log
 
230
    after the test completes.
 
231
    """
 
232
    disable_default_logging()
 
233
    global _trace_file
 
234
    global _trace_depth
 
235
    hdlr = logging.StreamHandler(to_file)
 
236
    hdlr.setLevel(logging.DEBUG)
 
237
    hdlr.setFormatter(logging.Formatter('%(levelname)8s  %(message)s'))
 
238
    _bzr_logger.addHandler(hdlr)
 
239
    _bzr_logger.setLevel(logging.DEBUG)
 
240
    result = hdlr, _trace_file, _trace_depth
 
241
    _trace_file = to_file
 
242
    _trace_depth += 1
 
243
    return result
 
244
 
 
245
 
 
246
def disable_test_log((test_log_hdlr, old_trace_file, old_trace_depth)):
 
247
    _bzr_logger.removeHandler(test_log_hdlr)
 
248
    test_log_hdlr.close()
 
249
    global _trace_file
 
250
    global _trace_depth
 
251
    _trace_file = old_trace_file
 
252
    _trace_depth = old_trace_depth
 
253
    if not _trace_depth:
 
254
        enable_default_logging()
 
255
 
 
256
 
 
257
def report_exception(exc_info, err_file):
 
258
    exc_type, exc_object, exc_tb = exc_info
 
259
    # Log the full traceback to ~/.bzr.log
 
260
    log_exception_quietly()
 
261
    if (isinstance(exc_object, IOError)
 
262
        and getattr(exc_object, 'errno', None) == errno.EPIPE):
 
263
        print >>err_file, "bzr: broken pipe"
 
264
    elif isinstance(exc_object, KeyboardInterrupt):
 
265
        print >>err_file, "bzr: interrupted"
 
266
    elif getattr(exc_object, 'is_user_error', False):
 
267
        report_user_error(exc_info, err_file)
 
268
    elif isinstance(exc_object, (OSError, IOError)):
 
269
        # Might be nice to catch all of these and show them as something more
 
270
        # specific, but there are too many cases at the moment.
 
271
        report_user_error(exc_info, err_file)
 
272
    else:
 
273
        report_bug(exc_info, err_file)
 
274
 
 
275
 
 
276
# TODO: Should these be specially encoding the output?
 
277
def report_user_error(exc_info, err_file):
 
278
    print >>err_file, "bzr: ERROR:", str(exc_info[1])
 
279
 
 
280
 
 
281
def report_bug(exc_info, err_file):
 
282
    """Report an exception that probably indicates a bug in bzr"""
 
283
    import traceback
 
284
    exc_type, exc_object, exc_tb = exc_info
 
285
    print >>err_file, "bzr: ERROR: %s: %s" % (exc_type, exc_object)
 
286
    print >>err_file
 
287
    traceback.print_exception(exc_type, exc_object, exc_tb, file=err_file)
 
288
    print >>err_file
 
289
    print >>err_file, 'bzr %s on python %s (%s)' % \
 
290
                       (bzrlib.__version__,
 
291
                        '.'.join(map(str, sys.version_info)),
 
292
                        sys.platform)
 
293
    print >>err_file, 'arguments: %r' % sys.argv
 
294
    print >>err_file
 
295
    print >>err_file, "** please send this report to bazaar-ng@lists.ubuntu.com"