Revert "Plumb in crprocess instead of RunCommand to allow quiet operation."

lib/operation.py

 # Copyright (c) 2011 The Chromium OS Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Operation, including output and progress display
 
 This module implements the concept of an operation, which has regular progress
 updates, verbose text display and perhaps some errors.
 """
 
@@ skipping 15 matching lines @@
   it looking for errors and progress information. Optionally it can output the
   stderr and stdout to the terminal, but it is normally supressed.
 
   Progress information is garnered from the subprocess output based on
   knowledge of the legacy scripts, but at some point will move over to using
   real progress information reported through new python methods which will
   replace the scripts.
 
   Each operation has a name, and this class handles displaying this name
   as it reports progress.
-
-
-  Operation Objects
-  =================
-
-  verbose: True / False
-    In verbose mode all output from subprocesses is displayed, otherwise
-    this output is normally supressed, unless we think it indicates an error.
-
-  progress: True / False
-    The output from subprocesses can be analysed in a very basic manner to
-    try to present progress information to the user.
   """
   # Force color on/off, or use color only if stdout is a terminal.
   COLOR_OFF, COLOR_ON, COLOR_IF_TERMINAL = range(3)
 
   def __init__(self, name, color=COLOR_IF_TERMINAL):
     """Create a new operation.
 
     Args:
       name: Operation name in a form to be displayed for the user.
       color: Determines policy for sending color to stdout:
         COLOR_OFF: never send color.
         COLOR_ON: always send color.
         COLOR_IF_TERMINAL: send color if output apperas to be a terminal.
     """
     self._name = name   # Operation name.
-    self.verbose = False   # True to echo subprocess output.
-    self.progress = True   # True to report progress of the operation
+    self._verbose = False   # True to echo subprocess output.
+    self._progress = True   # True to report progress of the operation
     self._column = 0    # Current output column (always 0 unless verbose).
     self._update_len = 0    # Length of last progress update message.
     self._line = ''   # text of current line, so far
 
     # By default, we display ANSI colors unless output is redirected.
     want_color = (color == self.COLOR_ON or
       (color == self.COLOR_IF_TERMINAL and os.isatty(sys.stdout.fileno())))
     self._color = Color(want_color)
 
     # -1 = no newline pending
@@ skipping 10 matching lines @@
   def __del__(self):
     """Object is about to be destroyed, so finish out output cleanly."""
     self.FinishOutput()
 
   def FinishOutput(self):
     """Finish off any pending output.
 
     This finishes any output line currently in progress and resets the color
     back to normal.
     """
-    self._FinishLine(self.verbose, final=True)
-    if self._column and self.verbose:
+    self._FinishLine(self._verbose, final=True)
+    if self._column and self._verbose:
       print self._color.Stop()
       self._column = 0
 
   def WereErrorsDetected(self):
     """Returns whether any errors have been detected.
 
     Returns:
       True if any errors have been detected in subprocess output so far.
       False otherwise
     """
     return self._error_count > 0
 
+  def SetVerbose(self, verbose):
+    """Enable / disable verbose mode.
+
+    In verbose mode all output from subprocesses is displayed, otherwise
+    this output is normally supressed, unless we think it indicates an error.
+
+    Args:
+      verbose: True to display all subprocess output, False to supress.
+    """
+    self._verbose = verbose
+
+  def SetProgress(self, progress):
+    """Enable / disable progress display.
+
+    The output from subprocesses can be analysed in a very basic manner to
+    try to present progress information to the user.
+
+    Args:
+      progress: True to enable progress display, False to disable.
+    """
+    self._progress = progress
+
   def SetName(self, name):
     """Set the name of the operation as displayed to the user.
 
     Args:
       name: Operation name.
     """
     self._name = name
 
   def _FilterOutputForErrors(self, line, print_error):
     """Filter a line of output to look for and display errors.
 
     This uses a few regular expression searches to spot common error reports
     from subprocesses. A count of these is kept so we know how many occurred.
     Optionally they are displayed in red on the terminal.
 
     Args:
       line: the output line to filter, as a string.
-      print_error: True to print the error, False to just record it.
+      print_it: True to print the error, False to just record it.
     """
     bad_things = ['Cannot GET', 'ERROR', '!!!', 'FAILED']
     for bad_thing in bad_things:
       if re.search(bad_thing, line, flags=re.IGNORECASE):
         self._error_count += 1
         if print_error:
           print self._color.Color(self._color.RED, line)
           break
 
   def _FilterOutputForProgress(self, line):
@@ skipping 14 matching lines @@
   def _Progress(self, upto, total):
     """Record and optionally display progress information.
 
     Args:
       upto: which step we are up to in the operation (integer, from 0).
       total: total number of steps in operation,
     """
     if total > 0:
       update_str = '%s...%d%% (%d of %d)' % (self._name,
           upto * 100 // total, upto, total)
-      if self.progress:
+      if self._progress:
         # Finish the current line, print progress, and remember its length.
-        self._FinishLine(self.verbose)
+        self._FinishLine(self._verbose)
 
         # Sometimes the progress string shrinks and in this case we need to
         # blank out the characters at the end of the line that will not be
         # overwritten by the new line
         pad = max(self._update_len - len(update_str), 0)
         sys.stdout.write(update_str + (' ' * pad) + '\r')
         self._update_len = len(update_str)
 
   def _FinishLine(self, display, final=False):
     """Finish off the current line and prepare to start a new one.
@@ skipping 103 matching lines @@
       self._column += len(text)
       # If a newline is required, remember to output it later.
       if newline:
         self._pending_nl = self._column
         self._column = 0
 
     self._line += text
 
     # If we now have a whole line, check it for errors and progress.
     if newline:
-      self._FilterOutputForErrors(self._line, print_error=not display)
+      self._FilterOutputForErrors(self._line, print_it=not display)
       self._FilterOutputForProgress(self._line)
       self._line = ''
 
   def Output(self, stream, data):
     """Handle the output of a block of text from the subprocess.
 
     All subprocess output should be sent through this method. It is split into
     lines which are processed separately using the _Out() method.
 
     Args:
       stream: Which file the output come in on:
         sys.stdout: stdout
         sys.stderr: stderr
         None: Our own internal output
       data: Output data as a big string, potentially containing many lines of
         text. Each line should end with \r\n. There is no requirement to send
         whole lines - this method happily handles fragments and tries to
         present then to the user as early as possible
 
     #TODO(sjg): Just use a list as the input parameter to avoid the split.
     """
-    # We cannot use splitlines() here as we need this exact behavior
-    lines = data.split('\r\n')
+    lines = data.splitlines()
 
     # Output each full line, with a \n after it.
     for line in lines[:-1]:
-      self._Out(stream, line, display=self.verbose, newline=True)
+      self._Out(stream, line, display=self._verbose, newline=True)
 
     # If we have a partial line at the end, output what we have.
     # We will continue it later.
     if lines[-1]:
-      self._Out(stream, lines[-1], display=self.verbose)
+      self._Out(stream, lines[-1], display=self._verbose)
 
     # Flush so that the terminal will receive partial line output (now!)
     sys.stdout.flush()
 
   def Outline(self, line):
     """Output a line of text to the display.
 
     This outputs text generated internally, such as a warning message or error
     summary. It ensures that our message plays nicely with child output if
     any.
 
     Args:
       line: text to output (without \n on the end)
     """
     self._Out(None, line, display=True, newline=True)
     self._FinishLine(display=True)
-
-  def Info(self, line):
-    """Output a line of information text to the display in verbose mode.
-
-    Args:
-      line: text to output (without \n on the end)
-    """
-    self._Out(None, self._color.Color(self._color.BLUE, line),
-        display=self.verbose, newline=True)
-    self._FinishLine(display=True)