/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

build_tree_contents can create symlinks

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, 2010 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
37
36
 
38
37
""")
39
38
 
40
 
from bzrlib.osutils import watch_sigwinch
41
 
 
42
39
from bzrlib.ui import (
43
40
    UIFactory,
44
41
    NullProgressView,
53
50
                 stdout=None,
54
51
                 stderr=None):
55
52
        """Create a TextUIFactory.
 
53
 
 
54
        :param bar_type: The type of progress bar to create.  Deprecated
 
55
            and ignored; a TextProgressView is always used.
56
56
        """
57
57
        super(TextUIFactory, self).__init__()
58
58
        # TODO: there's no good reason not to pass all three streams, maybe we
62
62
        self.stderr = stderr
63
63
        # paints progress, network activity, etc
64
64
        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
 
 
 
65
        
74
66
    def clear_term(self):
75
67
        """Prepare the terminal for output.
76
68
 
94
86
                # end-of-file; possibly should raise an error here instead
95
87
                return None
96
88
 
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
89
    def get_non_echoed_password(self):
107
90
        isatty = getattr(self.stdin, 'isatty', None)
108
91
        if isatty is not None and isatty():
156
139
    def make_progress_view(self):
157
140
        """Construct and return a new ProgressView subclass for this UI.
158
141
        """
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':
 
142
        # if the user specifically requests either text or no progress bars,
 
143
        # always do that.  otherwise, guess based on $TERM and tty presence.
 
144
        if os.environ.get('BZR_PROGRESS_BAR') == 'text':
166
145
            return TextProgressView(self.stderr)
167
146
        elif os.environ.get('BZR_PROGRESS_BAR') == 'none':
168
147
            return NullProgressView()
171
150
        else:
172
151
            return NullProgressView()
173
152
 
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
153
    def note(self, msg):
195
154
        """Write an already-formatted message, clearing the progress bar if necessary."""
196
155
        self.clear_term()
218
177
        self._progress_view.show_transport_activity(transport,
219
178
            direction, byte_count)
220
179
 
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
 
    def show_error(self, msg):
228
 
        self.clear_term()
229
 
        self.stderr.write("bzr: error: %s\n" % msg)
230
 
 
231
 
    def show_message(self, msg):
232
 
        self.note(msg)
233
 
 
234
 
    def show_warning(self, msg):
235
 
        self.clear_term()
236
 
        self.stderr.write("bzr: warning: %s\n" % msg)
237
 
 
238
180
    def _progress_updated(self, task):
239
181
        """A task has been updated and wants to be displayed.
240
182
        """
242
184
            warnings.warn("%r updated but no tasks are active" %
243
185
                (task,))
244
186
        elif task != self._task_stack[-1]:
245
 
            # We used to check it was the top task, but it's hard to always
246
 
            # get this right and it's not necessarily useful: any actual
247
 
            # problems will be evident in use
248
 
            #warnings.warn("%r is not the top progress task %r" %
249
 
            #     (task, self._task_stack[-1]))
250
 
            pass
 
187
            warnings.warn("%r is not the top progress task %r" %
 
188
                (task, self._task_stack[-1]))
251
189
        self._progress_view.show_progress(task)
252
190
 
253
191
    def _progress_all_finished(self):
285
223
        self._term_file = term_file
286
224
        # true when there's output on the screen we may need to clear
287
225
        self._have_output = False
 
226
        # XXX: We could listen for SIGWINCH and update the terminal width...
 
227
        # https://launchpad.net/bugs/316357
 
228
        self._width = osutils.terminal_width()
288
229
        self._last_transport_msg = ''
289
230
        self._spin_pos = 0
290
231
        # time we last repainted the screen
294
235
        self._last_task = None
295
236
        self._total_byte_count = 0
296
237
        self._bytes_since_update = 0
297
 
        self._bytes_by_direction = {'unknown': 0, 'read': 0, 'write': 0}
298
 
        self._first_byte_time = None
299
238
        self._fraction = 0
300
 
        # force the progress bar to be off, as at the moment it doesn't 
301
 
        # correspond reliably to overall command progress
302
 
        self.enable_bar = False
303
239
 
304
240
    def _show_line(self, s):
305
241
        # sys.stderr.write("progress %r\n" % s)
306
 
        width = osutils.terminal_width()
307
 
        if width is not None:
308
 
            # we need one extra space for terminals that wrap on last char
309
 
            width = width - 1
310
 
            s = '%-*.*s' % (width, width, s)
311
 
        self._term_file.write('\r' + s + '\r')
 
242
        n = self._width - 1
 
243
        self._term_file.write('\r%-*.*s\r' % (n, n, s))
312
244
 
313
245
    def clear(self):
314
246
        if self._have_output:
317
249
 
318
250
    def _render_bar(self):
319
251
        # return a string for the progress bar itself
320
 
        if self.enable_bar and (
321
 
            (self._last_task is None) or self._last_task.show_bar):
 
252
        if (self._last_task is None) or self._last_task.show_bar:
322
253
            # If there's no task object, we show space for the bar anyhow.
323
254
            # That's because most invocations of bzr will end showing progress
324
255
            # at some point, though perhaps only after doing some initial IO.
340
271
            markers = int(round(float(cols) * completion_fraction)) - 1
341
272
            bar_str = '[' + ('#' * markers + spin_str).ljust(cols) + '] '
342
273
            return bar_str
343
 
        elif (self._last_task is None) or self._last_task.show_spinner:
 
274
        elif self._last_task.show_spinner:
344
275
            # The last task wanted just a spinner, no bar
345
276
            spin_str =  r'/-\|'[self._spin_pos % 4]
346
277
            self._spin_pos += 1
408
339
        This may update a progress bar, spinner, or similar display.
409
340
        By default it does nothing.
410
341
        """
411
 
        # XXX: there should be a transport activity model, and that too should
412
 
        #      be seen by the progress view, rather than being poked in here.
 
342
        # XXX: Probably there should be a transport activity model, and that
 
343
        # too should be seen by the progress view, rather than being poked in
 
344
        # here.
 
345
        if not self._have_output:
 
346
            # As a workaround for <https://launchpad.net/bugs/321935> we only
 
347
            # show transport activity when there's already a progress bar
 
348
            # shown, which time the application code is expected to know to
 
349
            # clear off the progress bar when it's going to send some other
 
350
            # output.  Eventually it would be nice to have that automatically
 
351
            # synchronized.
 
352
            return
413
353
        self._total_byte_count += byte_count
414
354
        self._bytes_since_update += byte_count
415
 
        if self._first_byte_time is None:
416
 
            # Note that this isn't great, as technically it should be the time
417
 
            # when the bytes started transferring, not when they completed.
418
 
            # However, we usually start with a small request anyway.
419
 
            self._first_byte_time = time.time()
420
 
        if direction in self._bytes_by_direction:
421
 
            self._bytes_by_direction[direction] += byte_count
422
 
        else:
423
 
            self._bytes_by_direction['unknown'] += byte_count
424
 
        if 'no_activity' in debug.debug_flags:
425
 
            # Can be used as a workaround if
426
 
            # <https://launchpad.net/bugs/321935> reappears and transport
427
 
            # activity is cluttering other output.  However, thanks to
428
 
            # TextUIOutputStream this shouldn't be a problem any more.
429
 
            return
430
355
        now = time.time()
431
356
        if self._total_byte_count < 2000:
432
357
            # a little resistance at first, so it doesn't stay stuck at 0
437
362
        elif now >= (self._transport_update_time + 0.5):
438
363
            # guard against clock stepping backwards, and don't update too
439
364
            # often
440
 
            rate = (self._bytes_since_update
441
 
                    / (now - self._transport_update_time))
442
 
            # using base-10 units (see HACKING.txt).
443
 
            msg = ("%6dkB %5dkB/s" %
444
 
                    (self._total_byte_count / 1000, int(rate) / 1000,))
 
365
            rate = self._bytes_since_update / (now - self._transport_update_time)
 
366
            msg = ("%6dKB %5dKB/s" %
 
367
                    (self._total_byte_count>>10, int(rate)>>10,))
445
368
            self._transport_update_time = now
446
369
            self._last_repaint = now
447
370
            self._bytes_since_update = 0
448
371
            self._last_transport_msg = msg
449
372
            self._repaint()
450
 
 
451
 
    def _format_bytes_by_direction(self):
452
 
        if self._first_byte_time is None:
453
 
            bps = 0.0
454
 
        else:
455
 
            transfer_time = time.time() - self._first_byte_time
456
 
            if transfer_time < 0.001:
457
 
                transfer_time = 0.001
458
 
            bps = self._total_byte_count / transfer_time
459
 
 
460
 
        # using base-10 units (see HACKING.txt).
461
 
        msg = ('Transferred: %.0fkB'
462
 
               ' (%.1fkB/s r:%.0fkB w:%.0fkB'
463
 
               % (self._total_byte_count / 1000.,
464
 
                  bps / 1000.,
465
 
                  self._bytes_by_direction['read'] / 1000.,
466
 
                  self._bytes_by_direction['write'] / 1000.,
467
 
                 ))
468
 
        if self._bytes_by_direction['unknown'] > 0:
469
 
            msg += ' u:%.0fkB)' % (
470
 
                self._bytes_by_direction['unknown'] / 1000.
471
 
                )
472
 
        else:
473
 
            msg += ')'
474
 
        return msg
475
 
 
476
 
    def log_transport_activity(self, display=False):
477
 
        msg = self._format_bytes_by_direction()
478
 
        trace.mutter(msg)
479
 
        if display and self._total_byte_count > 0:
480
 
            self.clear()
481
 
            self._term_file.write(msg + '\n')
482
 
 
483
 
 
484
 
class TextUIOutputStream(object):
485
 
    """Decorates an output stream so that the terminal is cleared before writing.
486
 
 
487
 
    This is supposed to ensure that the progress bar does not conflict with bulk
488
 
    text output.
489
 
    """
490
 
    # XXX: this does not handle the case of writing part of a line, then doing
491
 
    # progress bar output: the progress bar will probably write over it.
492
 
    # one option is just to buffer that text until we have a full line;
493
 
    # another is to save and restore it
494
 
 
495
 
    # XXX: might need to wrap more methods
496
 
 
497
 
    def __init__(self, ui_factory, wrapped_stream):
498
 
        self.ui_factory = ui_factory
499
 
        self.wrapped_stream = wrapped_stream
500
 
        # this does no transcoding, but it must expose the underlying encoding
501
 
        # because some callers need to know what can be written - see for
502
 
        # example unescape_for_display.
503
 
        self.encoding = getattr(wrapped_stream, 'encoding', None)
504
 
 
505
 
    def flush(self):
506
 
        self.ui_factory.clear_term()
507
 
        self.wrapped_stream.flush()
508
 
 
509
 
    def write(self, to_write):
510
 
        self.ui_factory.clear_term()
511
 
        self.wrapped_stream.write(to_write)
512
 
 
513
 
    def writelines(self, lines):
514
 
        self.ui_factory.clear_term()
515
 
        self.wrapped_stream.writelines(lines)