Add live output for blimp integration script {run} func

blimp/tools/client_engine_integration.py

 #!/usr/bin/env python
 # Copyright 2016 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Blimp Client + Engine integration test system
 
    Set up Client and Engine
    Set up Forward to connect machine host with client device.
    Start Engine and run blimp on Android Client.
 """
 
 import argparse
 import json
 import logging
 import posixpath
 import os
 import re
 import signal
 import subprocess
 import sys
-import time
 
 SRC_PATH = os.path.abspath(
     os.path.join(os.path.dirname(__file__), '..', '..'))
 
 DEVIL_PATH = os.path.join(SRC_PATH, 'third_party', 'catapult',
                           'devil')
 
 if DEVIL_PATH not in sys.path:
   sys.path.append(DEVIL_PATH)
 
@@ skipping 62 matching lines @@
       ' --android-fonts-path=' + blimp_fonts_path +
       ' --blimp-client-token-path=' + token_file_path +
       ' --enable-logging=stderr' +
       ' -v=0' +
       ' --vmodule="blimp*=1"']
   p = subprocess.Popen(run_engine_cmd, shell=True,
                        stdout=subprocess.PIPE,
                        stderr=subprocess.STDOUT)
 
   for line in iter(p.stdout.readline, ''):
+    sys.stdout.write(line)
     l = line.rstrip()
     match = re.match(PORT_PATTERN, l)
     if match:
       port = match.group(1)
       break
 
   return port, p
 
 
 def SetCommandFlag(device, engine_ip, engine_port):
@@ skipping 51 matching lines @@
       setattr(json_args, k, args.__dict__[k])
   json_object = {'args': json_args}
   device.EnableRoot()
   host_device_tuples = [(_TOKEN_FILE_PATH, _CLIENT_TOKEN_PATH)]
   device.PushChangedFiles(host_device_tuples)
 
   port_number, engine_process = RunEngine(
       args.output_linux_directory, _TOKEN_FILE_PATH)
   json_object['port_number'] = port_number
   json_object['pid'] = engine_process.pid
-  logging.info("Engine port number: %s", port_number)
-  logging.info("Engine running PID: %d", engine_process.pid)
+  logging.info('Engine port number: %s', port_number)
+  logging.info('Engine running PID: %d', engine_process.pid)
 
-  if engine_process.poll() is None:
+  if engine_process.poll() is not None:
+    logging.error('Engine failed to start. Return code: %d',
+                  engine_process.poll())

[nyquist, 2016/08/12 03:45:25]

Is this guaranteed to return the same result across invocations?

+  else:
     try:
       port_pairs = [(port_number, port_number)]
       forwarder.Forwarder.Map(port_pairs, device)
       SetCommandFlag(device, args.engine_ip, port_number)
       print "Blimp engine started"
       return engine_process
 
     finally:
       with open(json_file_path, 'w') as f:
         json.dump(json_object, f, default=_JsonEncodeDefault)
 
 
 def _Run(args, json_file_path, device):
   """Start engine and forwarder and keep runnning.
 
   Args:
     args: parsed command line arguments.
     json_file_path: json file path which keeps the script variables.
     device: (DeviceUtils) device to run the tests on.
   """
   try:
     engine_process = _Start(args, json_file_path, device)
     while True:
-      time.sleep(1)
-      return_code = engine_process.poll()
-      if return_code is not None:
+      nextline = engine_process.stdout.readline()
+      if nextline == '' and engine_process.poll() is not None:
         # The engine died.
         sys.exit(1)
+      sys.stdout.write(nextline)
+      sys.stdout.flush()
+
   except KeyboardInterrupt:
     sys.exit(0)
   finally:
     _Stop(args, json_file_path, device)
 
 
 def _Load(args, json_file_path, device): # pylint: disable=unused-argument
   """Start client and load the url
 
   Args:
@@ skipping 91 matching lines @@
                else None)
   device = device_utils.DeviceUtils.HealthyDevices(
       blacklist=blacklist, device_arg=serial)[0]
 
   args.func(args, json_file_path, device)
 
 
 if __name__ == '__main__':
   main()