← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/ui/text.py

  • Committer: Vincent Ladeuil
  • Date: 2010-02-09 17:27:46 UTC
  • mto: (5029.1.1 integration)
  • mto: This revision was merged to the branch mainline in revision 5030.
  • Revision ID: v.ladeuil+lp@free.fr-20100209172746-6f4mvlnr2mac807j
Move NoSmartTransportServer to bzrlib.tests.test_server

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, 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
21
22
import getpass
22
23
import os
23
24
import sys
31
32
    progress,
32
33
    osutils,
33
34
    symbol_versioning,
 
35
    trace,
34
36
    )
35
37
 
36
38
""")
49
51
                 stdout=None,
50
52
                 stderr=None):
51
53
        """Create a TextUIFactory.
52
 
 
53
 
        :param bar_type: The type of progress bar to create.  Deprecated
54
 
            and ignored; a TextProgressView is always used.
55
54
        """
56
55
        super(TextUIFactory, self).__init__()
57
56
        # TODO: there's no good reason not to pass all three streams, maybe we
62
61
        # paints progress, network activity, etc
63
62
        self._progress_view = self.make_progress_view()
64
63
        
 
64
    def be_quiet(self, state):
 
65
        if state and not self._quiet:
 
66
            self.clear_term()
 
67
        UIFactory.be_quiet(self, state)
 
68
        self._progress_view = self.make_progress_view()
 
69
 
65
70
    def clear_term(self):
66
71
        """Prepare the terminal for output.
67
72
 
85
90
                # end-of-file; possibly should raise an error here instead
86
91
                return None
87
92
 
 
93
    def get_integer(self, prompt):
 
94
        while True:
 
95
            self.prompt(prompt)
 
96
            line = self.stdin.readline()
 
97
            try:
 
98
                return int(line)
 
99
            except ValueError:
 
100
                pass
 
101
 
88
102
    def get_non_echoed_password(self):
89
103
        isatty = getattr(self.stdin, 'isatty', None)
90
104
        if isatty is not None and isatty():
138
152
    def make_progress_view(self):
139
153
        """Construct and return a new ProgressView subclass for this UI.
140
154
        """
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':
 
155
        # with --quiet, never any progress view
 
156
        # <https://bugs.edge.launchpad.net/bzr/+bug/320035>.  Otherwise if the
 
157
        # user specifically requests either text or no progress bars, always
 
158
        # do that.  otherwise, guess based on $TERM and tty presence.
 
159
        if self.is_quiet():
 
160
            return NullProgressView()
 
161
        elif os.environ.get('BZR_PROGRESS_BAR') == 'text':
144
162
            return TextProgressView(self.stderr)
145
163
        elif os.environ.get('BZR_PROGRESS_BAR') == 'none':
146
164
            return NullProgressView()
149
167
        else:
150
168
            return NullProgressView()
151
169
 
 
170
    def _make_output_stream_explicit(self, encoding, encoding_type):
 
171
        if encoding_type == 'exact':
 
172
            # force sys.stdout to be binary stream on win32; 
 
173
            # NB: this leaves the file set in that mode; may cause problems if
 
174
            # one process tries to do binary and then text output
 
175
            if sys.platform == 'win32':
 
176
                fileno = getattr(self.stdout, 'fileno', None)
 
177
                if fileno:
 
178
                    import msvcrt
 
179
                    msvcrt.setmode(fileno(), os.O_BINARY)
 
180
            return TextUIOutputStream(self, self.stdout)
 
181
        else:
 
182
            encoded_stdout = codecs.getwriter(encoding)(self.stdout,
 
183
                errors=encoding_type)
 
184
            # For whatever reason codecs.getwriter() does not advertise its encoding
 
185
            # it just returns the encoding of the wrapped file, which is completely
 
186
            # bogus. So set the attribute, so we can find the correct encoding later.
 
187
            encoded_stdout.encoding = encoding
 
188
            return TextUIOutputStream(self, encoded_stdout)
 
189
 
152
190
    def note(self, msg):
153
191
        """Write an already-formatted message, clearing the progress bar if necessary."""
154
192
        self.clear_term()
176
214
        self._progress_view.show_transport_activity(transport,
177
215
            direction, byte_count)
178
216
 
 
217
    def log_transport_activity(self, display=False):
 
218
        """See UIFactory.log_transport_activity()"""
 
219
        log = getattr(self._progress_view, 'log_transport_activity', None)
 
220
        if log is not None:
 
221
            log(display=display)
 
222
 
 
223
    def show_error(self, msg):
 
224
        self.clear_term()
 
225
        self.stderr.write("bzr: error: %s\n" % msg)
 
226
 
 
227
    def show_message(self, msg):
 
228
        self.note(msg)
 
229
 
 
230
    def show_warning(self, msg):
 
231
        self.clear_term()
 
232
        self.stderr.write("bzr: warning: %s\n" % msg)
 
233
 
179
234
    def _progress_updated(self, task):
180
235
        """A task has been updated and wants to be displayed.
181
236
        """
210
265
        self._term_file = term_file
211
266
        # true when there's output on the screen we may need to clear
212
267
        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
268
        self._last_transport_msg = ''
217
269
        self._spin_pos = 0
218
270
        # time we last repainted the screen
222
274
        self._last_task = None
223
275
        self._total_byte_count = 0
224
276
        self._bytes_since_update = 0
 
277
        self._bytes_by_direction = {'unknown': 0, 'read': 0, 'write': 0}
 
278
        self._first_byte_time = None
225
279
        self._fraction = 0
 
280
        # force the progress bar to be off, as at the moment it doesn't 
 
281
        # correspond reliably to overall command progress
 
282
        self.enable_bar = False
226
283
 
227
284
    def _show_line(self, s):
228
285
        # sys.stderr.write("progress %r\n" % s)
229
 
        n = self._width - 1
230
 
        self._term_file.write('\r%-*.*s\r' % (n, n, s))
 
286
        width = osutils.terminal_width()
 
287
        if width is not None:
 
288
            # we need one extra space for terminals that wrap on last char
 
289
            width = width - 1
 
290
            s = '%-*.*s' % (width, width, s)
 
291
        self._term_file.write('\r' + s + '\r')
231
292
 
232
293
    def clear(self):
233
294
        if self._have_output:
236
297
 
237
298
    def _render_bar(self):
238
299
        # return a string for the progress bar itself
239
 
        if (self._last_task is None) or self._last_task.show_bar:
 
300
        if self.enable_bar and (
 
301
            (self._last_task is None) or self._last_task.show_bar):
240
302
            # If there's no task object, we show space for the bar anyhow.
241
303
            # That's because most invocations of bzr will end showing progress
242
304
            # at some point, though perhaps only after doing some initial IO.
258
320
            markers = int(round(float(cols) * completion_fraction)) - 1
259
321
            bar_str = '[' + ('#' * markers + spin_str).ljust(cols) + '] '
260
322
            return bar_str
261
 
        elif self._last_task.show_spinner:
 
323
        elif (self._last_task is None) or self._last_task.show_spinner:
262
324
            # The last task wanted just a spinner, no bar
263
325
            spin_str =  r'/-\|'[self._spin_pos % 4]
264
326
            self._spin_pos += 1
326
388
        This may update a progress bar, spinner, or similar display.
327
389
        By default it does nothing.
328
390
        """
329
 
        # XXX: Probably there should be a transport activity model, and that
330
 
        # too should be seen by the progress view, rather than being poked in
331
 
        # here.
332
 
        if not self._have_output:
333
 
            # As a workaround for <https://launchpad.net/bugs/321935> we only
334
 
            # show transport activity when there's already a progress bar
335
 
            # shown, which time the application code is expected to know to
336
 
            # clear off the progress bar when it's going to send some other
337
 
            # output.  Eventually it would be nice to have that automatically
338
 
            # synchronized.
339
 
            return
 
391
        # XXX: there should be a transport activity model, and that too should
 
392
        #      be seen by the progress view, rather than being poked in here.
340
393
        self._total_byte_count += byte_count
341
394
        self._bytes_since_update += byte_count
 
395
        if self._first_byte_time is None:
 
396
            # Note that this isn't great, as technically it should be the time
 
397
            # when the bytes started transferring, not when they completed.
 
398
            # However, we usually start with a small request anyway.
 
399
            self._first_byte_time = time.time()
 
400
        if direction in self._bytes_by_direction:
 
401
            self._bytes_by_direction[direction] += byte_count
 
402
        else:
 
403
            self._bytes_by_direction['unknown'] += byte_count
 
404
        if 'no_activity' in debug.debug_flags:
 
405
            # Can be used as a workaround if
 
406
            # <https://launchpad.net/bugs/321935> reappears and transport
 
407
            # activity is cluttering other output.  However, thanks to
 
408
            # TextUIOutputStream this shouldn't be a problem any more.
 
409
            return
342
410
        now = time.time()
343
411
        if self._total_byte_count < 2000:
344
412
            # a little resistance at first, so it doesn't stay stuck at 0
349
417
        elif now >= (self._transport_update_time + 0.5):
350
418
            # guard against clock stepping backwards, and don't update too
351
419
            # often
352
 
            rate = self._bytes_since_update / (now - self._transport_update_time)
353
 
            msg = ("%6dKB %5dKB/s" %
354
 
                    (self._total_byte_count>>10, int(rate)>>10,))
 
420
            rate = (self._bytes_since_update
 
421
                    / (now - self._transport_update_time))
 
422
            # using base-10 units (see HACKING.txt).
 
423
            msg = ("%6dkB %5dkB/s" %
 
424
                    (self._total_byte_count / 1000, int(rate) / 1000,))
355
425
            self._transport_update_time = now
356
426
            self._last_repaint = now
357
427
            self._bytes_since_update = 0
358
428
            self._last_transport_msg = msg
359
429
            self._repaint()
 
430
 
 
431
    def _format_bytes_by_direction(self):
 
432
        if self._first_byte_time is None:
 
433
            bps = 0.0
 
434
        else:
 
435
            transfer_time = time.time() - self._first_byte_time
 
436
            if transfer_time < 0.001:
 
437
                transfer_time = 0.001
 
438
            bps = self._total_byte_count / transfer_time
 
439
 
 
440
        # using base-10 units (see HACKING.txt).
 
441
        msg = ('Transferred: %.0fkB'
 
442
               ' (%.1fkB/s r:%.0fkB w:%.0fkB'
 
443
               % (self._total_byte_count / 1000.,
 
444
                  bps / 1000.,
 
445
                  self._bytes_by_direction['read'] / 1000.,
 
446
                  self._bytes_by_direction['write'] / 1000.,
 
447
                 ))
 
448
        if self._bytes_by_direction['unknown'] > 0:
 
449
            msg += ' u:%.0fkB)' % (
 
450
                self._bytes_by_direction['unknown'] / 1000.
 
451
                )
 
452
        else:
 
453
            msg += ')'
 
454
        return msg
 
455
 
 
456
    def log_transport_activity(self, display=False):
 
457
        msg = self._format_bytes_by_direction()
 
458
        trace.mutter(msg)
 
459
        if display and self._total_byte_count > 0:
 
460
            self.clear()
 
461
            self._term_file.write(msg + '\n')
 
462
 
 
463
 
 
464
class TextUIOutputStream(object):
 
465
    """Decorates an output stream so that the terminal is cleared before writing.
 
466
 
 
467
    This is supposed to ensure that the progress bar does not conflict with bulk
 
468
    text output.
 
469
    """
 
470
    # XXX: this does not handle the case of writing part of a line, then doing
 
471
    # progress bar output: the progress bar will probably write over it.
 
472
    # one option is just to buffer that text until we have a full line;
 
473
    # another is to save and restore it
 
474
 
 
475
    # XXX: might need to wrap more methods
 
476
 
 
477
    def __init__(self, ui_factory, wrapped_stream):
 
478
        self.ui_factory = ui_factory
 
479
        self.wrapped_stream = wrapped_stream
 
480
        # this does no transcoding, but it must expose the underlying encoding
 
481
        # because some callers need to know what can be written - see for
 
482
        # example unescape_for_display.
 
483
        self.encoding = getattr(wrapped_stream, 'encoding', None)
 
484
 
 
485
    def flush(self):
 
486
        self.ui_factory.clear_term()
 
487
        self.wrapped_stream.flush()
 
488
 
 
489
    def write(self, to_write):
 
490
        self.ui_factory.clear_term()
 
491
        self.wrapped_stream.write(to_write)
 
492
 
 
493
    def writelines(self, lines):
 
494
        self.ui_factory.clear_term()
 
495
        self.wrapped_stream.writelines(lines)