← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/ui/text.py

Merge previous attempt into current trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/ui/text.py
1
 
# Copyright (C) 2005, 2008, 2009 Canonical Ltd
 
1
# Copyright (C) 2005-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
import getpass
21
23
import os
22
24
import sys
23
25
import time
26
28
from bzrlib.lazy_import import lazy_import
27
29
lazy_import(globals(), """
28
30
from bzrlib import (
 
31
    debug,
29
32
    progress,
30
33
    osutils,
31
34
    symbol_versioning,
 
35
    trace,
32
36
    )
33
37
 
34
38
""")
35
39
 
 
40
from bzrlib.osutils import watch_sigwinch
 
41
 
36
42
from bzrlib.ui import (
37
43
    UIFactory,
38
44
    NullProgressView,
47
53
                 stdout=None,
48
54
                 stderr=None):
49
55
        """Create a TextUIFactory.
50
 
 
51
 
        :param bar_type: The type of progress bar to create. It defaults to
52
 
                         letting the bzrlib.progress.ProgressBar factory auto
53
 
                         select.   Deprecated.
54
56
        """
55
57
        super(TextUIFactory, self).__init__()
56
58
        # TODO: there's no good reason not to pass all three streams, maybe we
60
62
        self.stderr = stderr
61
63
        # paints progress, network activity, etc
62
64
        self._progress_view = self.make_progress_view()
63
 
        
 
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
 
64
74
    def clear_term(self):
65
75
        """Prepare the terminal for output.
66
76
 
84
94
                # end-of-file; possibly should raise an error here instead
85
95
                return None
86
96
 
 
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
 
87
106
    def get_non_echoed_password(self):
88
107
        isatty = getattr(self.stdin, 'isatty', None)
89
108
        if isatty is not None and isatty():
137
156
    def make_progress_view(self):
138
157
        """Construct and return a new ProgressView subclass for this UI.
139
158
        """
140
 
        # if the user specifically requests either text or no progress bars,
141
 
        # always do that.  otherwise, guess based on $TERM and tty presence.
142
 
        if os.environ.get('BZR_PROGRESS_BAR') == 'text':
 
159
        # with --quiet, never any progress view
 
160
        # <https://bugs.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':
143
166
            return TextProgressView(self.stderr)
144
167
        elif os.environ.get('BZR_PROGRESS_BAR') == 'none':
145
168
            return NullProgressView()
148
171
        else:
149
172
            return NullProgressView()
150
173
 
 
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
 
151
194
    def note(self, msg):
152
195
        """Write an already-formatted message, clearing the progress bar if necessary."""
153
196
        self.clear_term()
175
218
        self._progress_view.show_transport_activity(transport,
176
219
            direction, byte_count)
177
220
 
 
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
        if isinstance(msg, unicode):
 
237
            te = osutils.get_terminal_encoding()
 
238
            msg = msg.encode(te, 'replace')
 
239
        self.stderr.write("bzr: warning: %s\n" % msg)
 
240
 
178
241
    def _progress_updated(self, task):
179
242
        """A task has been updated and wants to be displayed.
180
243
        """
182
245
            warnings.warn("%r updated but no tasks are active" %
183
246
                (task,))
184
247
        elif task != self._task_stack[-1]:
185
 
            warnings.warn("%r is not the top progress task %r" %
186
 
                (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
187
254
        self._progress_view.show_progress(task)
188
255
 
189
256
    def _progress_all_finished(self):
190
257
        self._progress_view.clear()
191
258
 
 
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
 
192
271
 
193
272
class TextProgressView(object):
194
273
    """Display of progress bar and other information on a tty.
209
288
        self._term_file = term_file
210
289
        # true when there's output on the screen we may need to clear
211
290
        self._have_output = False
212
 
        # XXX: We could listen for SIGWINCH and update the terminal width...
213
 
        # https://launchpad.net/bugs/316357
214
 
        self._width = osutils.terminal_width()
215
291
        self._last_transport_msg = ''
216
292
        self._spin_pos = 0
217
293
        # time we last repainted the screen
221
297
        self._last_task = None
222
298
        self._total_byte_count = 0
223
299
        self._bytes_since_update = 0
 
300
        self._bytes_by_direction = {'unknown': 0, 'read': 0, 'write': 0}
 
301
        self._first_byte_time = None
 
302
        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
224
306
 
225
307
    def _show_line(self, s):
226
 
        n = self._width - 1
227
 
        self._term_file.write('\r%-*.*s\r' % (n, n, s))
 
308
        # 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)
 
314
        self._term_file.write('\r' + s + '\r')
228
315
 
229
316
    def clear(self):
230
317
        if self._have_output:
233
320
 
234
321
    def _render_bar(self):
235
322
        # return a string for the progress bar itself
236
 
        if (self._last_task is None) or self._last_task.show_bar:
 
323
        if self.enable_bar and (
 
324
            (self._last_task is None) or self._last_task.show_bar):
237
325
            # If there's no task object, we show space for the bar anyhow.
238
326
            # That's because most invocations of bzr will end showing progress
239
327
            # at some point, though perhaps only after doing some initial IO.
244
332
            cols = 20
245
333
            if self._last_task is None:
246
334
                completion_fraction = 0
 
335
                self._fraction = 0
247
336
            else:
248
337
                completion_fraction = \
249
338
                    self._last_task._overall_completion_fraction() or 0
 
339
            if (completion_fraction < self._fraction and 'progress' in
 
340
                debug.debug_flags):
 
341
                import pdb;pdb.set_trace()
 
342
            self._fraction = completion_fraction
250
343
            markers = int(round(float(cols) * completion_fraction)) - 1
251
344
            bar_str = '[' + ('#' * markers + spin_str).ljust(cols) + '] '
252
345
            return bar_str
253
 
        elif self._last_task.show_spinner:
 
346
        elif (self._last_task is None) or self._last_task.show_spinner:
254
347
            # The last task wanted just a spinner, no bar
255
348
            spin_str =  r'/-\|'[self._spin_pos % 4]
256
349
            self._spin_pos += 1
282
375
            task_msg = self._format_task(self._last_task)
283
376
        else:
284
377
            task_msg = ''
285
 
        trans = self._last_transport_msg
286
 
        if trans:
287
 
            trans += ' | '
 
378
        if self._last_task and not self._last_task.show_transport_activity:
 
379
            trans = ''
 
380
        else:
 
381
            trans = self._last_transport_msg
 
382
            if trans:
 
383
                trans += ' | '
288
384
        return (bar_string + trans + task_msg)
289
385
 
290
386
    def _repaint(self):
301
397
        must_update = task is not self._last_task
302
398
        self._last_task = task
303
399
        now = time.time()
304
 
        if (not must_update) and (now < self._last_repaint + 0.1):
 
400
        if (not must_update) and (now < self._last_repaint + task.update_latency):
305
401
            return
306
402
        if now > self._transport_update_time + 10:
307
403
            # no recent activity; expire it
315
411
        This may update a progress bar, spinner, or similar display.
316
412
        By default it does nothing.
317
413
        """
318
 
        # XXX: Probably there should be a transport activity model, and that
319
 
        # too should be seen by the progress view, rather than being poked in
320
 
        # here.
321
 
        if not self._have_output:
322
 
            # As a workaround for <https://launchpad.net/bugs/321935> we only
323
 
            # show transport activity when there's already a progress bar
324
 
            # shown, which time the application code is expected to know to
325
 
            # clear off the progress bar when it's going to send some other
326
 
            # output.  Eventually it would be nice to have that automatically
327
 
            # synchronized.
328
 
            return
 
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.
329
416
        self._total_byte_count += byte_count
330
417
        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
331
433
        now = time.time()
 
434
        if self._total_byte_count < 2000:
 
435
            # a little resistance at first, so it doesn't stay stuck at 0
 
436
            # while connecting...
 
437
            return
332
438
        if self._transport_update_time is None:
333
439
            self._transport_update_time = now
334
440
        elif now >= (self._transport_update_time + 0.5):
335
441
            # guard against clock stepping backwards, and don't update too
336
442
            # often
337
 
            rate = self._bytes_since_update / (now - self._transport_update_time)
338
 
            msg = ("%6dKB %5dKB/s" %
339
 
                    (self._total_byte_count>>10, int(rate)>>10,))
 
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,))
340
448
            self._transport_update_time = now
341
449
            self._last_repaint = now
342
450
            self._bytes_since_update = 0
343
451
            self._last_transport_msg = msg
344
452
            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)