~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/ui/text.py

  • Committer: Tarmac
  • Author(s): Vincent Ladeuil
  • Date: 2017-01-30 14:42:05 UTC
  • mfrom: (6620.1.1 trunk)
  • Revision ID: tarmac-20170130144205-r8fh2xpmiuxyozpv
Merge  2.7 into trunk including fix for bug #1657238 [r=vila]

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005, 2008, 2009 Canonical Ltd
 
1
# Copyright (C) 2005-2011 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
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
 
 
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17
16
 
18
17
 
19
18
"""Text UI, write output to the console.
20
19
"""
21
20
 
 
21
from __future__ import absolute_import
 
22
 
 
23
import os
22
24
import sys
23
25
import time
24
 
import warnings
25
26
 
26
27
from bzrlib.lazy_import import lazy_import
27
28
lazy_import(globals(), """
 
29
import codecs
28
30
import getpass
 
31
import warnings
29
32
 
30
33
from bzrlib import (
 
34
    config,
 
35
    debug,
31
36
    progress,
32
37
    osutils,
33
 
    symbol_versioning,
 
38
    trace,
34
39
    )
35
40
 
36
41
""")
37
42
 
38
 
from bzrlib.ui import CLIUIFactory
39
 
 
40
 
 
41
 
class TextUIFactory(CLIUIFactory):
42
 
    """A UI factory for Text user interefaces."""
 
43
from bzrlib.ui import (
 
44
    UIFactory,
 
45
    NullProgressView,
 
46
    )
 
47
 
 
48
 
 
49
class _ChooseUI(object):
 
50
 
 
51
    """ Helper class for choose implementation.
 
52
    """
 
53
 
 
54
    def __init__(self, ui, msg, choices, default):
 
55
        self.ui = ui
 
56
        self._setup_mode()
 
57
        self._build_alternatives(msg, choices, default)
 
58
 
 
59
    def _setup_mode(self):
 
60
        """Setup input mode (line-based, char-based) and echo-back.
 
61
 
 
62
        Line-based input is used if the BZR_TEXTUI_INPUT environment
 
63
        variable is set to 'line-based', or if there is no controlling
 
64
        terminal.
 
65
        """
 
66
        if os.environ.get('BZR_TEXTUI_INPUT') != 'line-based' and \
 
67
           self.ui.stdin == sys.stdin and self.ui.stdin.isatty():
 
68
            self.line_based = False
 
69
            self.echo_back = True
 
70
        else:
 
71
            self.line_based = True
 
72
            self.echo_back = not self.ui.stdin.isatty()
 
73
 
 
74
    def _build_alternatives(self, msg, choices, default):
 
75
        """Parse choices string.
 
76
 
 
77
        Setup final prompt and the lists of choices and associated
 
78
        shortcuts.
 
79
        """
 
80
        index = 0
 
81
        help_list = []
 
82
        self.alternatives = {}
 
83
        choices = choices.split('\n')
 
84
        if default is not None and default not in range(0, len(choices)):
 
85
            raise ValueError("invalid default index")
 
86
        for c in choices:
 
87
            name = c.replace('&', '').lower()
 
88
            choice = (name, index)
 
89
            if name in self.alternatives:
 
90
                raise ValueError("duplicated choice: %s" % name)
 
91
            self.alternatives[name] = choice
 
92
            shortcut = c.find('&')
 
93
            if -1 != shortcut and (shortcut + 1) < len(c):
 
94
                help = c[:shortcut]
 
95
                help += '[' + c[shortcut + 1] + ']'
 
96
                help += c[(shortcut + 2):]
 
97
                shortcut = c[shortcut + 1]
 
98
            else:
 
99
                c = c.replace('&', '')
 
100
                shortcut = c[0]
 
101
                help = '[%s]%s' % (shortcut, c[1:])
 
102
            shortcut = shortcut.lower()
 
103
            if shortcut in self.alternatives:
 
104
                raise ValueError("duplicated shortcut: %s" % shortcut)
 
105
            self.alternatives[shortcut] = choice
 
106
            # Add redirections for default.
 
107
            if index == default:
 
108
                self.alternatives[''] = choice
 
109
                self.alternatives['\r'] = choice
 
110
            help_list.append(help)
 
111
            index += 1
 
112
 
 
113
        self.prompt = u'%s (%s): ' % (msg, ', '.join(help_list))
 
114
 
 
115
    def _getline(self):
 
116
        line = self.ui.stdin.readline()
 
117
        if '' == line:
 
118
            raise EOFError
 
119
        return line.strip()
 
120
 
 
121
    def _getchar(self):
 
122
        char = osutils.getchar()
 
123
        if char == chr(3): # INTR
 
124
            raise KeyboardInterrupt
 
125
        if char == chr(4): # EOF (^d, C-d)
 
126
            raise EOFError
 
127
        return char
 
128
 
 
129
    def interact(self):
 
130
        """Keep asking the user until a valid choice is made.
 
131
        """
 
132
        if self.line_based:
 
133
            getchoice = self._getline
 
134
        else:
 
135
            getchoice = self._getchar
 
136
        iter = 0
 
137
        while True:
 
138
            iter += 1
 
139
            if 1 == iter or self.line_based:
 
140
                self.ui.prompt(self.prompt)
 
141
            try:
 
142
                choice = getchoice()
 
143
            except EOFError:
 
144
                self.ui.stderr.write('\n')
 
145
                return None
 
146
            except KeyboardInterrupt:
 
147
                self.ui.stderr.write('\n')
 
148
                raise KeyboardInterrupt
 
149
            choice = choice.lower()
 
150
            if choice not in self.alternatives:
 
151
                # Not a valid choice, keep on asking.
 
152
                continue
 
153
            name, index = self.alternatives[choice]
 
154
            if self.echo_back:
 
155
                self.ui.stderr.write(name + '\n')
 
156
            return index
 
157
 
 
158
 
 
159
opt_progress_bar = config.Option(
 
160
    'progress_bar', help='Progress bar type.',
 
161
    default_from_env=['BZR_PROGRESS_BAR'], default=None,
 
162
    invalid='error')
 
163
 
 
164
 
 
165
class TextUIFactory(UIFactory):
 
166
    """A UI factory for Text user interfaces."""
43
167
 
44
168
    def __init__(self,
45
 
                 bar_type=None,
46
169
                 stdin=None,
47
170
                 stdout=None,
48
171
                 stderr=None):
49
172
        """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
173
        """
55
 
        super(TextUIFactory, self).__init__(stdin=stdin,
56
 
                stdout=stdout, stderr=stderr)
57
 
        if bar_type:
58
 
            symbol_versioning.warn(symbol_versioning.deprecated_in((1, 11, 0))
59
 
                % "bar_type parameter")
 
174
        super(TextUIFactory, self).__init__()
 
175
        # TODO: there's no good reason not to pass all three streams, maybe we
 
176
        # should deprecate the default values...
 
177
        self.stdin = stdin
 
178
        self.stdout = stdout
 
179
        self.stderr = stderr
60
180
        # paints progress, network activity, etc
61
 
        self._progress_view = TextProgressView(self.stderr)
62
 
 
63
 
    def prompt(self, prompt):
64
 
        """Emit prompt on the CLI."""
65
 
        self.stdout.write(prompt)
66
 
        
 
181
        self._progress_view = self.make_progress_view()
 
182
 
 
183
    def choose(self, msg, choices, default=None):
 
184
        """Prompt the user for a list of alternatives.
 
185
 
 
186
        Support both line-based and char-based editing.
 
187
 
 
188
        In line-based mode, both the shortcut and full choice name are valid
 
189
        answers, e.g. for choose('prompt', '&yes\n&no'): 'y', ' Y ', ' yes',
 
190
        'YES ' are all valid input lines for choosing 'yes'.
 
191
 
 
192
        An empty line, when in line-based mode, or pressing enter in char-based
 
193
        mode will select the default choice (if any).
 
194
 
 
195
        Choice is echoed back if:
 
196
        - input is char-based; which means a controlling terminal is available,
 
197
          and osutils.getchar is used
 
198
        - input is line-based, and no controlling terminal is available
 
199
        """
 
200
 
 
201
        choose_ui = _ChooseUI(self, msg, choices, default)
 
202
        return choose_ui.interact()
 
203
 
 
204
    def be_quiet(self, state):
 
205
        if state and not self._quiet:
 
206
            self.clear_term()
 
207
        UIFactory.be_quiet(self, state)
 
208
        self._progress_view = self.make_progress_view()
 
209
 
67
210
    def clear_term(self):
68
211
        """Prepare the terminal for output.
69
212
 
72
215
        # XXX: If this is preparing to write to stdout, but that's for example
73
216
        # directed into a file rather than to the terminal, and the progress
74
217
        # bar _is_ going to the terminal, we shouldn't need
75
 
        # to clear it.  We might need to separately check for the case of 
 
218
        # to clear it.  We might need to separately check for the case of
76
219
        self._progress_view.clear()
77
220
 
 
221
    def get_integer(self, prompt):
 
222
        while True:
 
223
            self.prompt(prompt)
 
224
            line = self.stdin.readline()
 
225
            try:
 
226
                return int(line)
 
227
            except ValueError:
 
228
                pass
 
229
 
 
230
    def get_non_echoed_password(self):
 
231
        isatty = getattr(self.stdin, 'isatty', None)
 
232
        if isatty is not None and isatty():
 
233
            # getpass() ensure the password is not echoed and other
 
234
            # cross-platform niceties
 
235
            password = getpass.getpass('')
 
236
        else:
 
237
            # echo doesn't make sense without a terminal
 
238
            password = self.stdin.readline()
 
239
            if not password:
 
240
                password = None
 
241
            else:
 
242
                password = password.decode(self.stdin.encoding)
 
243
 
 
244
                if password[-1] == '\n':
 
245
                    password = password[:-1]
 
246
        return password
 
247
 
 
248
    def get_password(self, prompt=u'', **kwargs):
 
249
        """Prompt the user for a password.
 
250
 
 
251
        :param prompt: The prompt to present the user
 
252
        :param kwargs: Arguments which will be expanded into the prompt.
 
253
                       This lets front ends display different things if
 
254
                       they so choose.
 
255
        :return: The password string, return None if the user
 
256
                 canceled the request.
 
257
        """
 
258
        prompt += ': '
 
259
        self.prompt(prompt, **kwargs)
 
260
        # There's currently no way to say 'i decline to enter a password'
 
261
        # as opposed to 'my password is empty' -- does it matter?
 
262
        return self.get_non_echoed_password()
 
263
 
 
264
    def get_username(self, prompt, **kwargs):
 
265
        """Prompt the user for a username.
 
266
 
 
267
        :param prompt: The prompt to present the user
 
268
        :param kwargs: Arguments which will be expanded into the prompt.
 
269
                       This lets front ends display different things if
 
270
                       they so choose.
 
271
        :return: The username string, return None if the user
 
272
                 canceled the request.
 
273
        """
 
274
        prompt += ': '
 
275
        self.prompt(prompt, **kwargs)
 
276
        username = self.stdin.readline()
 
277
        if not username:
 
278
            username = None
 
279
        else:
 
280
            username = username.decode(self.stdin.encoding)
 
281
            if username[-1] == '\n':
 
282
                username = username[:-1]
 
283
        return username
 
284
 
 
285
    def make_progress_view(self):
 
286
        """Construct and return a new ProgressView subclass for this UI.
 
287
        """
 
288
        # with --quiet, never any progress view
 
289
        # <https://bugs.launchpad.net/bzr/+bug/320035>.  Otherwise if the
 
290
        # user specifically requests either text or no progress bars, always
 
291
        # do that.  otherwise, guess based on $TERM and tty presence.
 
292
        if self.is_quiet():
 
293
            return NullProgressView()
 
294
        pb_type = config.GlobalStack().get('progress_bar')
 
295
        if pb_type == 'none': # Explicit requirement
 
296
            return NullProgressView()
 
297
        if (pb_type == 'text' # Explicit requirement
 
298
            or progress._supports_progress(self.stderr)): # Guess
 
299
            return TextProgressView(self.stderr)
 
300
        # No explicit requirement and no successful guess
 
301
        return NullProgressView()
 
302
 
 
303
    def _make_output_stream_explicit(self, encoding, encoding_type):
 
304
        if encoding_type == 'exact':
 
305
            # force sys.stdout to be binary stream on win32; 
 
306
            # NB: this leaves the file set in that mode; may cause problems if
 
307
            # one process tries to do binary and then text output
 
308
            if sys.platform == 'win32':
 
309
                fileno = getattr(self.stdout, 'fileno', None)
 
310
                if fileno:
 
311
                    import msvcrt
 
312
                    msvcrt.setmode(fileno(), os.O_BINARY)
 
313
            return TextUIOutputStream(self, self.stdout)
 
314
        else:
 
315
            encoded_stdout = codecs.getwriter(encoding)(self.stdout,
 
316
                errors=encoding_type)
 
317
            # For whatever reason codecs.getwriter() does not advertise its encoding
 
318
            # it just returns the encoding of the wrapped file, which is completely
 
319
            # bogus. So set the attribute, so we can find the correct encoding later.
 
320
            encoded_stdout.encoding = encoding
 
321
            return TextUIOutputStream(self, encoded_stdout)
 
322
 
78
323
    def note(self, msg):
79
324
        """Write an already-formatted message, clearing the progress bar if necessary."""
80
325
        self.clear_term()
81
326
        self.stdout.write(msg + '\n')
82
327
 
 
328
    def prompt(self, prompt, **kwargs):
 
329
        """Emit prompt on the CLI.
 
330
        
 
331
        :param kwargs: Dictionary of arguments to insert into the prompt,
 
332
            to allow UIs to reformat the prompt.
 
333
        """
 
334
        if type(prompt) != unicode:
 
335
            raise ValueError("prompt %r not a unicode string" % prompt)
 
336
        if kwargs:
 
337
            # See <https://launchpad.net/bugs/365891>
 
338
            prompt = prompt % kwargs
 
339
        try:
 
340
            prompt = prompt.encode(self.stderr.encoding)
 
341
        except (UnicodeError, AttributeError):
 
342
            # If stderr has no encoding attribute or can't properly encode,
 
343
            # fallback to terminal encoding for robustness (better display
 
344
            # something to the user than aborting with a traceback).
 
345
            prompt = prompt.encode(osutils.get_terminal_encoding(), 'replace')
 
346
        self.clear_term()
 
347
        self.stdout.flush()
 
348
        self.stderr.write(prompt)
 
349
 
83
350
    def report_transport_activity(self, transport, byte_count, direction):
84
351
        """Called by transports as they do IO.
85
 
        
 
352
 
86
353
        This may update a progress bar, spinner, or similar display.
87
354
        By default it does nothing.
88
355
        """
89
 
        self._progress_view.show_transport_activity(byte_count)
 
356
        self._progress_view.show_transport_activity(transport,
 
357
            direction, byte_count)
 
358
 
 
359
    def log_transport_activity(self, display=False):
 
360
        """See UIFactory.log_transport_activity()"""
 
361
        log = getattr(self._progress_view, 'log_transport_activity', None)
 
362
        if log is not None:
 
363
            log(display=display)
 
364
 
 
365
    def show_error(self, msg):
 
366
        self.clear_term()
 
367
        self.stderr.write("bzr: error: %s\n" % msg)
 
368
 
 
369
    def show_message(self, msg):
 
370
        self.note(msg)
 
371
 
 
372
    def show_warning(self, msg):
 
373
        self.clear_term()
 
374
        if isinstance(msg, unicode):
 
375
            te = osutils.get_terminal_encoding()
 
376
            msg = msg.encode(te, 'replace')
 
377
        self.stderr.write("bzr: warning: %s\n" % msg)
90
378
 
91
379
    def _progress_updated(self, task):
92
380
        """A task has been updated and wants to be displayed.
93
381
        """
94
 
        if task != self._task_stack[-1]:
95
 
            warnings.warn("%r is not the top progress task %r" %
96
 
                (task, self._task_stack[-1]))
 
382
        if not self._task_stack:
 
383
            warnings.warn("%r updated but no tasks are active" %
 
384
                (task,))
 
385
        elif task != self._task_stack[-1]:
 
386
            # We used to check it was the top task, but it's hard to always
 
387
            # get this right and it's not necessarily useful: any actual
 
388
            # problems will be evident in use
 
389
            #warnings.warn("%r is not the top progress task %r" %
 
390
            #     (task, self._task_stack[-1]))
 
391
            pass
97
392
        self._progress_view.show_progress(task)
98
393
 
99
394
    def _progress_all_finished(self):
100
395
        self._progress_view.clear()
101
396
 
 
397
    def show_user_warning(self, warning_id, **message_args):
 
398
        """Show a text message to the user.
 
399
 
 
400
        Explicitly not for warnings about bzr apis, deprecations or internals.
 
401
        """
 
402
        # eventually trace.warning should migrate here, to avoid logging and
 
403
        # be easier to test; that has a lot of test fallout so for now just
 
404
        # new code can call this
 
405
        if warning_id not in self.suppressed_warnings:
 
406
            self.stderr.write(self.format_user_warning(warning_id, message_args) +
 
407
                '\n')
 
408
 
102
409
 
103
410
class TextProgressView(object):
104
411
    """Display of progress bar and other information on a tty.
105
 
    
106
 
    This shows one line of text, including possibly a network indicator, spinner, 
 
412
 
 
413
    This shows one line of text, including possibly a network indicator, spinner,
107
414
    progress bar, message, etc.
108
415
 
109
416
    One instance of this is created and held by the UI, and fed updates when a
115
422
    this only prints the stack from the nominated current task up to the root.
116
423
    """
117
424
 
118
 
    def __init__(self, term_file):
 
425
    def __init__(self, term_file, encoding=None, errors="replace"):
119
426
        self._term_file = term_file
 
427
        if encoding is None:
 
428
            self._encoding = getattr(term_file, "encoding", None) or "ascii"
 
429
        else:
 
430
            self._encoding = encoding
 
431
        self._encoding_errors = errors
120
432
        # true when there's output on the screen we may need to clear
121
433
        self._have_output = False
122
 
        # XXX: We could listen for SIGWINCH and update the terminal width...
123
 
        self._width = osutils.terminal_width()
124
434
        self._last_transport_msg = ''
125
435
        self._spin_pos = 0
126
436
        # time we last repainted the screen
127
437
        self._last_repaint = 0
128
438
        # time we last got information about transport activity
129
439
        self._transport_update_time = 0
130
 
        self._task_fraction = None
131
440
        self._last_task = None
132
441
        self._total_byte_count = 0
133
442
        self._bytes_since_update = 0
134
 
 
135
 
    def _show_line(self, s):
136
 
        n = self._width - 1
137
 
        self._term_file.write('\r%-*.*s\r' % (n, n, s))
 
443
        self._bytes_by_direction = {'unknown': 0, 'read': 0, 'write': 0}
 
444
        self._first_byte_time = None
 
445
        self._fraction = 0
 
446
        # force the progress bar to be off, as at the moment it doesn't 
 
447
        # correspond reliably to overall command progress
 
448
        self.enable_bar = False
 
449
 
 
450
    def _avail_width(self):
 
451
        # we need one extra space for terminals that wrap on last char
 
452
        w = osutils.terminal_width() 
 
453
        if w is None:
 
454
            return None
 
455
        else:
 
456
            return w - 1
 
457
 
 
458
    def _show_line(self, u):
 
459
        s = u.encode(self._encoding, self._encoding_errors)
 
460
        width = self._avail_width()
 
461
        if width is not None:
 
462
            # GZ 2012-03-28: Counting bytes is wrong for calculating width of
 
463
            #                text but better than counting codepoints.
 
464
            s = '%-*.*s' % (width, width, s)
 
465
        self._term_file.write('\r' + s + '\r')
138
466
 
139
467
    def clear(self):
140
468
        if self._have_output:
143
471
 
144
472
    def _render_bar(self):
145
473
        # return a string for the progress bar itself
146
 
        if (self._last_task is not None) and self._last_task.show_bar:
 
474
        if self.enable_bar and (
 
475
            (self._last_task is None) or self._last_task.show_bar):
 
476
            # If there's no task object, we show space for the bar anyhow.
 
477
            # That's because most invocations of bzr will end showing progress
 
478
            # at some point, though perhaps only after doing some initial IO.
 
479
            # It looks better to draw the progress bar initially rather than
 
480
            # to have what looks like an incomplete progress bar.
147
481
            spin_str =  r'/-\|'[self._spin_pos % 4]
148
482
            self._spin_pos += 1
149
 
            f = self._task_fraction or 0
150
483
            cols = 20
151
 
            # number of markers highlighted in bar
152
 
            markers = int(round(float(cols) * f)) - 1
 
484
            if self._last_task is None:
 
485
                completion_fraction = 0
 
486
                self._fraction = 0
 
487
            else:
 
488
                completion_fraction = \
 
489
                    self._last_task._overall_completion_fraction() or 0
 
490
            if (completion_fraction < self._fraction and 'progress' in
 
491
                debug.debug_flags):
 
492
                import pdb;pdb.set_trace()
 
493
            self._fraction = completion_fraction
 
494
            markers = int(round(float(cols) * completion_fraction)) - 1
153
495
            bar_str = '[' + ('#' * markers + spin_str).ljust(cols) + '] '
154
496
            return bar_str
155
497
        elif (self._last_task is None) or self._last_task.show_spinner:
 
498
            # The last task wanted just a spinner, no bar
156
499
            spin_str =  r'/-\|'[self._spin_pos % 4]
157
500
            self._spin_pos += 1
158
501
            return spin_str + ' '
160
503
            return ''
161
504
 
162
505
    def _format_task(self, task):
 
506
        """Format task-specific parts of progress bar.
 
507
 
 
508
        :returns: (text_part, counter_part) both unicode strings.
 
509
        """
163
510
        if not task.show_count:
164
511
            s = ''
165
 
        elif task.total_cnt is not None:
 
512
        elif task.current_cnt is not None and task.total_cnt is not None:
166
513
            s = ' %d/%d' % (task.current_cnt, task.total_cnt)
167
514
        elif task.current_cnt is not None:
168
515
            s = ' %d' % (task.current_cnt)
169
516
        else:
170
517
            s = ''
171
 
        self._task_fraction = task._overall_completion_fraction()
172
518
        # compose all the parent messages
173
519
        t = task
174
520
        m = task.msg
176
522
            t = t._parent_task
177
523
            if t.msg:
178
524
                m = t.msg + ':' + m
179
 
        return m + s
 
525
        return m, s
180
526
 
181
 
    def _repaint(self):
 
527
    def _render_line(self):
182
528
        bar_string = self._render_bar()
183
529
        if self._last_task:
184
 
            task_msg = self._format_task(self._last_task)
185
 
        else:
186
 
            task_msg = ''
187
 
        trans = self._last_transport_msg
188
 
        if trans and task_msg:
189
 
            trans += ' | '
190
 
        s = (bar_string
191
 
             + trans
192
 
             + task_msg
193
 
             )
 
530
            task_part, counter_part = self._format_task(self._last_task)
 
531
        else:
 
532
            task_part = counter_part = ''
 
533
        if self._last_task and not self._last_task.show_transport_activity:
 
534
            trans = ''
 
535
        else:
 
536
            trans = self._last_transport_msg
 
537
        # the bar separates the transport activity from the message, so even
 
538
        # if there's no bar or spinner, we must show something if both those
 
539
        # fields are present
 
540
        if (task_part or trans) and not bar_string:
 
541
            bar_string = '| '
 
542
        # preferentially truncate the task message if we don't have enough
 
543
        # space
 
544
        avail_width = self._avail_width()
 
545
        if avail_width is not None:
 
546
            # if terminal avail_width is unknown, don't truncate
 
547
            current_len = len(bar_string) + len(trans) + len(task_part) + len(counter_part)
 
548
            gap = current_len - avail_width
 
549
            if gap > 0:
 
550
                task_part = task_part[:-gap-2] + '..'
 
551
        s = trans + bar_string + task_part + counter_part
 
552
        if avail_width is not None:
 
553
            if len(s) < avail_width:
 
554
                s = s.ljust(avail_width)
 
555
            elif len(s) > avail_width:
 
556
                s = s[:avail_width]
 
557
        return s
 
558
 
 
559
    def _repaint(self):
 
560
        s = self._render_line()
194
561
        self._show_line(s)
195
562
        self._have_output = True
196
563
 
197
564
    def show_progress(self, task):
 
565
        """Called by the task object when it has changed.
 
566
        
 
567
        :param task: The top task object; its parents are also included 
 
568
            by following links.
 
569
        """
 
570
        must_update = task is not self._last_task
198
571
        self._last_task = task
199
572
        now = time.time()
200
 
        if now < self._last_repaint + 0.1:
 
573
        if (not must_update) and (now < self._last_repaint + task.update_latency):
201
574
            return
202
 
        if now > self._transport_update_time + 5:
 
575
        if now > self._transport_update_time + 10:
203
576
            # no recent activity; expire it
204
577
            self._last_transport_msg = ''
205
578
        self._last_repaint = now
206
579
        self._repaint()
207
580
 
208
 
    def show_transport_activity(self, byte_count):
209
 
        """Called by transports as they do IO.
210
 
        
 
581
    def show_transport_activity(self, transport, direction, byte_count):
 
582
        """Called by transports via the ui_factory, as they do IO.
 
583
 
211
584
        This may update a progress bar, spinner, or similar display.
212
585
        By default it does nothing.
213
586
        """
214
 
        # XXX: Probably there should be a transport activity model, and that
215
 
        # too should be seen by the progress view, rather than being poked in
216
 
        # here.
 
587
        # XXX: there should be a transport activity model, and that too should
 
588
        #      be seen by the progress view, rather than being poked in here.
217
589
        self._total_byte_count += byte_count
218
590
        self._bytes_since_update += byte_count
 
591
        if self._first_byte_time is None:
 
592
            # Note that this isn't great, as technically it should be the time
 
593
            # when the bytes started transferring, not when they completed.
 
594
            # However, we usually start with a small request anyway.
 
595
            self._first_byte_time = time.time()
 
596
        if direction in self._bytes_by_direction:
 
597
            self._bytes_by_direction[direction] += byte_count
 
598
        else:
 
599
            self._bytes_by_direction['unknown'] += byte_count
 
600
        if 'no_activity' in debug.debug_flags:
 
601
            # Can be used as a workaround if
 
602
            # <https://launchpad.net/bugs/321935> reappears and transport
 
603
            # activity is cluttering other output.  However, thanks to
 
604
            # TextUIOutputStream this shouldn't be a problem any more.
 
605
            return
219
606
        now = time.time()
 
607
        if self._total_byte_count < 2000:
 
608
            # a little resistance at first, so it doesn't stay stuck at 0
 
609
            # while connecting...
 
610
            return
220
611
        if self._transport_update_time is None:
221
612
            self._transport_update_time = now
222
 
        elif now >= (self._transport_update_time + 0.2):
 
613
        elif now >= (self._transport_update_time + 0.5):
223
614
            # guard against clock stepping backwards, and don't update too
224
615
            # often
225
 
            rate = self._bytes_since_update / (now - self._transport_update_time)
226
 
            msg = ("%6dkB @ %4dkB/s" %
227
 
                (self._total_byte_count>>10, int(rate)>>10,))
 
616
            rate = (self._bytes_since_update
 
617
                    / (now - self._transport_update_time))
 
618
            # using base-10 units (see HACKING.txt).
 
619
            msg = ("%6dkB %5dkB/s " %
 
620
                    (self._total_byte_count / 1000, int(rate) / 1000,))
228
621
            self._transport_update_time = now
229
622
            self._last_repaint = now
230
623
            self._bytes_since_update = 0
231
624
            self._last_transport_msg = msg
232
625
            self._repaint()
233
626
 
234
 
 
 
627
    def _format_bytes_by_direction(self):
 
628
        if self._first_byte_time is None:
 
629
            bps = 0.0
 
630
        else:
 
631
            transfer_time = time.time() - self._first_byte_time
 
632
            if transfer_time < 0.001:
 
633
                transfer_time = 0.001
 
634
            bps = self._total_byte_count / transfer_time
 
635
 
 
636
        # using base-10 units (see HACKING.txt).
 
637
        msg = ('Transferred: %.0fkB'
 
638
               ' (%.1fkB/s r:%.0fkB w:%.0fkB'
 
639
               % (self._total_byte_count / 1000.,
 
640
                  bps / 1000.,
 
641
                  self._bytes_by_direction['read'] / 1000.,
 
642
                  self._bytes_by_direction['write'] / 1000.,
 
643
                 ))
 
644
        if self._bytes_by_direction['unknown'] > 0:
 
645
            msg += ' u:%.0fkB)' % (
 
646
                self._bytes_by_direction['unknown'] / 1000.
 
647
                )
 
648
        else:
 
649
            msg += ')'
 
650
        return msg
 
651
 
 
652
    def log_transport_activity(self, display=False):
 
653
        msg = self._format_bytes_by_direction()
 
654
        trace.mutter(msg)
 
655
        if display and self._total_byte_count > 0:
 
656
            self.clear()
 
657
            self._term_file.write(msg + '\n')
 
658
 
 
659
 
 
660
class TextUIOutputStream(object):
 
661
    """Decorates an output stream so that the terminal is cleared before writing.
 
662
 
 
663
    This is supposed to ensure that the progress bar does not conflict with bulk
 
664
    text output.
 
665
    """
 
666
    # XXX: this does not handle the case of writing part of a line, then doing
 
667
    # progress bar output: the progress bar will probably write over it.
 
668
    # one option is just to buffer that text until we have a full line;
 
669
    # another is to save and restore it
 
670
 
 
671
    # XXX: might need to wrap more methods
 
672
 
 
673
    def __init__(self, ui_factory, wrapped_stream):
 
674
        self.ui_factory = ui_factory
 
675
        self.wrapped_stream = wrapped_stream
 
676
        # this does no transcoding, but it must expose the underlying encoding
 
677
        # because some callers need to know what can be written - see for
 
678
        # example unescape_for_display.
 
679
        self.encoding = getattr(wrapped_stream, 'encoding', None)
 
680
 
 
681
    def flush(self):
 
682
        self.ui_factory.clear_term()
 
683
        self.wrapped_stream.flush()
 
684
 
 
685
    def write(self, to_write):
 
686
        self.ui_factory.clear_term()
 
687
        self.wrapped_stream.write(to_write)
 
688
 
 
689
    def writelines(self, lines):
 
690
        self.ui_factory.clear_term()
 
691
        self.wrapped_stream.writelines(lines)