/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/ui/text.py

  • Committer: Neil Martinsen-Burrell
  • Date: 2009-12-16 02:03:31 UTC
  • mto: This revision was merged to the branch mainline in revision 4908.
  • Revision ID: nmb@wartburg.edu-20091216020331-0rbid4b635r82z4d
completely rework the part about filesystem backups in light of JAMs comments about concurrent access

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/ui/text.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2008, 2009 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
18
18
"""Text UI, write output to the console.
19
19
"""
20
20
 
21
 
import codecs
22
21
import getpass
23
22
import os
24
23
import sys
32
31
    progress,
33
32
    osutils,
34
33
    symbol_versioning,
35
 
    trace,
36
34
    )
37
35
 
38
36
""")
39
37
 
40
 
from bzrlib.osutils import watch_sigwinch
41
 
 
42
38
from bzrlib.ui import (
43
39
    UIFactory,
44
40
    NullProgressView,
62
58
        self.stderr = stderr
63
59
        # paints progress, network activity, etc
64
60
        self._progress_view = self.make_progress_view()
65
 
        # hook up the signals to watch for terminal size changes
66
 
        watch_sigwinch()
67
 
 
68
 
    def be_quiet(self, state):
69
 
        if state and not self._quiet:
70
 
            self.clear_term()
71
 
        UIFactory.be_quiet(self, state)
72
 
        self._progress_view = self.make_progress_view()
73
 
 
 
61
        
74
62
    def clear_term(self):
75
63
        """Prepare the terminal for output.
76
64
 
94
82
                # end-of-file; possibly should raise an error here instead
95
83
                return None
96
84
 
97
 
    def get_integer(self, prompt):
98
 
        while True:
99
 
            self.prompt(prompt)
100
 
            line = self.stdin.readline()
101
 
            try:
102
 
                return int(line)
103
 
            except ValueError:
104
 
                pass
105
 
 
106
85
    def get_non_echoed_password(self):
107
86
        isatty = getattr(self.stdin, 'isatty', None)
108
87
        if isatty is not None and isatty():
156
135
    def make_progress_view(self):
157
136
        """Construct and return a new ProgressView subclass for this UI.
158
137
        """
159
 
        # with --quiet, never any progress view
160
 
        # <https://bugs.edge.launchpad.net/bzr/+bug/320035>.  Otherwise if the
161
 
        # user specifically requests either text or no progress bars, always
162
 
        # do that.  otherwise, guess based on $TERM and tty presence.
163
 
        if self.is_quiet():
164
 
            return NullProgressView()
165
 
        elif os.environ.get('BZR_PROGRESS_BAR') == 'text':
 
138
        # if the user specifically requests either text or no progress bars,
 
139
        # always do that.  otherwise, guess based on $TERM and tty presence.
 
140
        if os.environ.get('BZR_PROGRESS_BAR') == 'text':
166
141
            return TextProgressView(self.stderr)
167
142
        elif os.environ.get('BZR_PROGRESS_BAR') == 'none':
168
143
            return NullProgressView()
171
146
        else:
172
147
            return NullProgressView()
173
148
 
174
 
    def _make_output_stream_explicit(self, encoding, encoding_type):
175
 
        if encoding_type == 'exact':
176
 
            # force sys.stdout to be binary stream on win32; 
177
 
            # NB: this leaves the file set in that mode; may cause problems if
178
 
            # one process tries to do binary and then text output
179
 
            if sys.platform == 'win32':
180
 
                fileno = getattr(self.stdout, 'fileno', None)
181
 
                if fileno:
182
 
                    import msvcrt
183
 
                    msvcrt.setmode(fileno(), os.O_BINARY)
184
 
            return TextUIOutputStream(self, self.stdout)
185
 
        else:
186
 
            encoded_stdout = codecs.getwriter(encoding)(self.stdout,
187
 
                errors=encoding_type)
188
 
            # For whatever reason codecs.getwriter() does not advertise its encoding
189
 
            # it just returns the encoding of the wrapped file, which is completely
190
 
            # bogus. So set the attribute, so we can find the correct encoding later.
191
 
            encoded_stdout.encoding = encoding
192
 
            return TextUIOutputStream(self, encoded_stdout)
193
 
 
194
149
    def note(self, msg):
195
150
        """Write an already-formatted message, clearing the progress bar if necessary."""
196
151
        self.clear_term()
218
173
        self._progress_view.show_transport_activity(transport,
219
174
            direction, byte_count)
220
175
 
221
 
    def log_transport_activity(self, display=False):
222
 
        """See UIFactory.log_transport_activity()"""
223
 
        log = getattr(self._progress_view, 'log_transport_activity', None)
224
 
        if log is not None:
225
 
            log(display=display)
226
 
 
227
176
    def show_error(self, msg):
228
177
        self.clear_term()
229
178
        self.stderr.write("bzr: error: %s\n" % msg)
233
182
 
234
183
    def show_warning(self, msg):
235
184
        self.clear_term()
236
 
        if isinstance(msg, unicode):
237
 
            te = osutils.get_terminal_encoding()
238
 
            msg = msg.encode(te, 'replace')
239
185
        self.stderr.write("bzr: warning: %s\n" % msg)
240
186
 
241
187
    def _progress_updated(self, task):
245
191
            warnings.warn("%r updated but no tasks are active" %
246
192
                (task,))
247
193
        elif task != self._task_stack[-1]:
248
 
            # We used to check it was the top task, but it's hard to always
249
 
            # get this right and it's not necessarily useful: any actual
250
 
            # problems will be evident in use
251
 
            #warnings.warn("%r is not the top progress task %r" %
252
 
            #     (task, self._task_stack[-1]))
253
 
            pass
 
194
            warnings.warn("%r is not the top progress task %r" %
 
195
                (task, self._task_stack[-1]))
254
196
        self._progress_view.show_progress(task)
255
197
 
256
198
    def _progress_all_finished(self):
257
199
        self._progress_view.clear()
258
200
 
259
 
    def show_user_warning(self, warning_id, **message_args):
260
 
        """Show a text message to the user.
261
 
 
262
 
        Explicitly not for warnings about bzr apis, deprecations or internals.
263
 
        """
264
 
        # eventually trace.warning should migrate here, to avoid logging and
265
 
        # be easier to test; that has a lot of test fallout so for now just
266
 
        # new code can call this
267
 
        if warning_id not in self.suppressed_warnings:
268
 
            self.stderr.write(self.format_user_warning(warning_id, message_args) +
269
 
                '\n')
270
 
 
271
201
 
272
202
class TextProgressView(object):
273
203
    """Display of progress bar and other information on a tty.
288
218
        self._term_file = term_file
289
219
        # true when there's output on the screen we may need to clear
290
220
        self._have_output = False
 
221
        # XXX: We could listen for SIGWINCH and update the terminal width...
 
222
        # https://launchpad.net/bugs/316357
 
223
        self._width = osutils.terminal_width()
291
224
        self._last_transport_msg = ''
292
225
        self._spin_pos = 0
293
226
        # time we last repainted the screen
297
230
        self._last_task = None
298
231
        self._total_byte_count = 0
299
232
        self._bytes_since_update = 0
300
 
        self._bytes_by_direction = {'unknown': 0, 'read': 0, 'write': 0}
301
 
        self._first_byte_time = None
302
233
        self._fraction = 0
303
 
        # force the progress bar to be off, as at the moment it doesn't 
304
 
        # correspond reliably to overall command progress
305
 
        self.enable_bar = False
306
234
 
307
235
    def _show_line(self, s):
308
236
        # sys.stderr.write("progress %r\n" % s)
309
 
        width = osutils.terminal_width()
310
 
        if width is not None:
311
 
            # we need one extra space for terminals that wrap on last char
312
 
            width = width - 1
313
 
            s = '%-*.*s' % (width, width, s)
 
237
        if self._width is not None:
 
238
            n = self._width - 1
 
239
            s = '%-*.*s' % (n, n, s)
314
240
        self._term_file.write('\r' + s + '\r')
315
241
 
316
242
    def clear(self):
320
246
 
321
247
    def _render_bar(self):
322
248
        # return a string for the progress bar itself
323
 
        if self.enable_bar and (
324
 
            (self._last_task is None) or self._last_task.show_bar):
 
249
        if (self._last_task is None) or self._last_task.show_bar:
325
250
            # If there's no task object, we show space for the bar anyhow.
326
251
            # That's because most invocations of bzr will end showing progress
327
252
            # at some point, though perhaps only after doing some initial IO.
343
268
            markers = int(round(float(cols) * completion_fraction)) - 1
344
269
            bar_str = '[' + ('#' * markers + spin_str).ljust(cols) + '] '
345
270
            return bar_str
346
 
        elif (self._last_task is None) or self._last_task.show_spinner:
 
271
        elif self._last_task.show_spinner:
347
272
            # The last task wanted just a spinner, no bar
348
273
            spin_str =  r'/-\|'[self._spin_pos % 4]
349
274
            self._spin_pos += 1
411
336
        This may update a progress bar, spinner, or similar display.
412
337
        By default it does nothing.
413
338
        """
414
 
        # XXX: there should be a transport activity model, and that too should
415
 
        #      be seen by the progress view, rather than being poked in here.
 
339
        # XXX: Probably there should be a transport activity model, and that
 
340
        # too should be seen by the progress view, rather than being poked in
 
341
        # here.
 
342
        if not self._have_output:
 
343
            # As a workaround for <https://launchpad.net/bugs/321935> we only
 
344
            # show transport activity when there's already a progress bar
 
345
            # shown, which time the application code is expected to know to
 
346
            # clear off the progress bar when it's going to send some other
 
347
            # output.  Eventually it would be nice to have that automatically
 
348
            # synchronized.
 
349
            return
416
350
        self._total_byte_count += byte_count
417
351
        self._bytes_since_update += byte_count
418
 
        if self._first_byte_time is None:
419
 
            # Note that this isn't great, as technically it should be the time
420
 
            # when the bytes started transferring, not when they completed.
421
 
            # However, we usually start with a small request anyway.
422
 
            self._first_byte_time = time.time()
423
 
        if direction in self._bytes_by_direction:
424
 
            self._bytes_by_direction[direction] += byte_count
425
 
        else:
426
 
            self._bytes_by_direction['unknown'] += byte_count
427
 
        if 'no_activity' in debug.debug_flags:
428
 
            # Can be used as a workaround if
429
 
            # <https://launchpad.net/bugs/321935> reappears and transport
430
 
            # activity is cluttering other output.  However, thanks to
431
 
            # TextUIOutputStream this shouldn't be a problem any more.
432
 
            return
433
352
        now = time.time()
434
353
        if self._total_byte_count < 2000:
435
354
            # a little resistance at first, so it doesn't stay stuck at 0
440
359
        elif now >= (self._transport_update_time + 0.5):
441
360
            # guard against clock stepping backwards, and don't update too
442
361
            # often
443
 
            rate = (self._bytes_since_update
444
 
                    / (now - self._transport_update_time))
445
 
            # using base-10 units (see HACKING.txt).
446
 
            msg = ("%6dkB %5dkB/s" %
447
 
                    (self._total_byte_count / 1000, int(rate) / 1000,))
 
362
            rate = self._bytes_since_update / (now - self._transport_update_time)
 
363
            msg = ("%6dKB %5dKB/s" %
 
364
                    (self._total_byte_count>>10, int(rate)>>10,))
448
365
            self._transport_update_time = now
449
366
            self._last_repaint = now
450
367
            self._bytes_since_update = 0
451
368
            self._last_transport_msg = msg
452
369
            self._repaint()
453
 
 
454
 
    def _format_bytes_by_direction(self):
455
 
        if self._first_byte_time is None:
456
 
            bps = 0.0
457
 
        else:
458
 
            transfer_time = time.time() - self._first_byte_time
459
 
            if transfer_time < 0.001:
460
 
                transfer_time = 0.001
461
 
            bps = self._total_byte_count / transfer_time
462
 
 
463
 
        # using base-10 units (see HACKING.txt).
464
 
        msg = ('Transferred: %.0fkB'
465
 
               ' (%.1fkB/s r:%.0fkB w:%.0fkB'
466
 
               % (self._total_byte_count / 1000.,
467
 
                  bps / 1000.,
468
 
                  self._bytes_by_direction['read'] / 1000.,
469
 
                  self._bytes_by_direction['write'] / 1000.,
470
 
                 ))
471
 
        if self._bytes_by_direction['unknown'] > 0:
472
 
            msg += ' u:%.0fkB)' % (
473
 
                self._bytes_by_direction['unknown'] / 1000.
474
 
                )
475
 
        else:
476
 
            msg += ')'
477
 
        return msg
478
 
 
479
 
    def log_transport_activity(self, display=False):
480
 
        msg = self._format_bytes_by_direction()
481
 
        trace.mutter(msg)
482
 
        if display and self._total_byte_count > 0:
483
 
            self.clear()
484
 
            self._term_file.write(msg + '\n')
485
 
 
486
 
 
487
 
class TextUIOutputStream(object):
488
 
    """Decorates an output stream so that the terminal is cleared before writing.
489
 
 
490
 
    This is supposed to ensure that the progress bar does not conflict with bulk
491
 
    text output.
492
 
    """
493
 
    # XXX: this does not handle the case of writing part of a line, then doing
494
 
    # progress bar output: the progress bar will probably write over it.
495
 
    # one option is just to buffer that text until we have a full line;
496
 
    # another is to save and restore it
497
 
 
498
 
    # XXX: might need to wrap more methods
499
 
 
500
 
    def __init__(self, ui_factory, wrapped_stream):
501
 
        self.ui_factory = ui_factory
502
 
        self.wrapped_stream = wrapped_stream
503
 
        # this does no transcoding, but it must expose the underlying encoding
504
 
        # because some callers need to know what can be written - see for
505
 
        # example unescape_for_display.
506
 
        self.encoding = getattr(wrapped_stream, 'encoding', None)
507
 
 
508
 
    def flush(self):
509
 
        self.ui_factory.clear_term()
510
 
        self.wrapped_stream.flush()
511
 
 
512
 
    def write(self, to_write):
513
 
        self.ui_factory.clear_term()
514
 
        self.wrapped_stream.write(to_write)
515
 
 
516
 
    def writelines(self, lines):
517
 
        self.ui_factory.clear_term()
518
 
        self.wrapped_stream.writelines(lines)