/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: Robert Collins
  • Date: 2010-05-06 11:08:10 UTC
  • mto: This revision was merged to the branch mainline in revision 5223.
  • Revision ID: robertc@robertcollins.net-20100506110810-h3j07fh5gmw54s25
Cleaner matcher matching revised unlocking protocol.

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