Android: capture logcat for all devices on bb_run_sharded_steps.py

build/android/bb_run_sharded_steps.py

 #!/usr/bin/env python
 #
 # Copyright (c) 2012 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.
 
 """Helper script to shard build bot steps and save results to disk.
 
 Our buildbot infrastructure requires each slave to run steps serially.
 This is sub-optimal for android, where these steps can run independently on
@@ skipping 27 matching lines @@
 import datetime
 import json
 import logging
 import multiprocessing
 import optparse
 import pexpect
 import pickle
 import os
 import signal
 import shutil
+import subprocess
 import sys
 
 from pylib import android_commands
 from pylib import cmd_helper
 from pylib import constants
 from pylib import ports
 
 
 _OUTPUT_DIR = os.path.join(constants.CHROME_DIR, 'out', 'step_results')
 
@@ skipping 19 matching lines @@
     result = {'name': step['name'],
               'output': output,
               'exit_code': exit_code or 0,
               'total_time': (end_time - start_time).seconds,
               'device': step['device']}
     _SaveResult(result)
     results += [result]
   return results
 
 
+class _LogCatMonitor(object):
+  def __init__(self):
+    self._monitor = None
+    self._logcat_dir = os.path.join(constants.CHROME_DIR, 'out',
+                                    'sharded_steps_logcat_monitor')
+
+  def __enter__(self):
+    cmd = [os.path.join(constants.CHROME_DIR, 'build', 'android',
+                        'adb_logcat_monitor.py'), self._logcat_dir]
+    self._monitor = subprocess.Popen(cmd, cwd=constants.CHROME_DIR)
+
+  def __exit__(self, *args):
+    if self._monitor:
+      # adb_logcat_printer will kill the monitor.
+      self._monitor = None
+      cmd = [os.path.join(constants.CHROME_DIR, 'build', 'android',
+                          'adb_logcat_printer.py'), self._logcat_dir]
+      cmd = subprocess.Popen(cmd, cwd=constants.CHROME_DIR)
+      cmd.wait()
+
+
 def _RunShardedSteps(steps, devices):
   assert steps
   assert devices, 'No devices connected?'
   if os.path.exists(_OUTPUT_DIR):
     assert '/step_results' in _OUTPUT_DIR
     shutil.rmtree(_OUTPUT_DIR)
   if not os.path.exists(_OUTPUT_DIR):
     os.makedirs(_OUTPUT_DIR)
   step_names = sorted(steps.keys())
   all_params = []
   num_devices = len(devices)
   shard_size = (len(steps) + num_devices - 1) / num_devices
   for i, device in enumerate(devices):
     steps_per_device = []
     for s in steps.keys()[i * shard_size:(i + 1) * shard_size]:
       steps_per_device += [{'name': s,
                             'device': device,
                             'cmd': steps[s] + ' --device ' + device +
                             ' --keep_test_server_ports'}]
     all_params += [steps_per_device]
   print 'Start sharding (note: output is not synchronized...)'
   print '*' * 80
   start_time = datetime.datetime.now()
-  pool = multiprocessing.Pool(processes=num_devices)
-  async_results = pool.map_async(_RunStepsPerDevice, all_params)
-  results_per_device = async_results.get(999999)
+
+  with _LogCatMonitor() as logcat_monitor:
+    pool = multiprocessing.Pool(processes=num_devices)
+    async_results = pool.map_async(_RunStepsPerDevice, all_params)
+    results_per_device = async_results.get(999999)
+
   end_time = datetime.datetime.now()
   print '*' * 80
   print 'Finished sharding.'
   print 'Summary'
   total_time = 0
   for results in results_per_device:
     for result in results:
       print('%s : exit_code=%d in %d secs at %s' %
             (result['name'], result['exit_code'], result['total_time'],
              result['device']))
@@ skipping 56 matching lines @@
     print 'You must attach a device'
     return 1
 
   with file(options.steps, 'r') as f:
     steps = json.load(f)
   return _RunShardedSteps(steps, devices)
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv))