build/android/adb_logcat_monitor.py

   1 #!/usr/bin/env python
   2 #
   3 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
   4 # Use of this source code is governed by a BSD-style license that can be
   5 # found in the LICENSE file.
   6
   7 """Saves logcats from all connected devices.
   8
   9 Usage: adb_logcat_monitor.py <base_dir> [<adb_binary_path>]
  10
  11 This script will repeatedly poll adb for new devices and save logcats
  12 inside the <base_dir> directory, which it attempts to create.  The
  13 script will run until killed by an external signal.  To test, run the
  14 script in a shell and <Ctrl>-C it after a while.  It should be
  15 resilient across phone disconnects and reconnects and start the logcat
  16 early enough to not miss anything.
  17 """
  18
  19 import logging
  20 import os
  21 import re
  22 import shutil
  23 import signal
  24 import subprocess
  25 import sys
  26 import time
  27
  28 # Map from device_id -> (process, logcat_num)
  29 devices = {}
  30
  31
  32 class TimeoutException(Exception):
  33   """Exception used to signal a timeout."""
  34   pass
  35
  36
  37 class SigtermError(Exception):
  38   """Exception used to catch a sigterm."""
  39   pass
  40
  41
  42 def StartLogcatIfNecessary(device_id, adb_cmd, base_dir):
  43   """Spawns a adb logcat process if one is not currently running."""
  44   process, logcat_num = devices[device_id]
  45   if process:
  46     if process.poll() is None:
  47       # Logcat process is still happily running
  48       return
  49     else:
  50       logging.info('Logcat for device %s has died', device_id)
  51       error_filter = re.compile('- waiting for device -')
  52       for line in process.stderr:
  53         if not error_filter.match(line):
  54           logging.error(device_id + ':   ' + line)
  55
  56   logging.info('Starting logcat %d for device %s', logcat_num,
  57                device_id)
  58   logcat_filename = 'logcat_%s_%03d' % (device_id, logcat_num)
  59   logcat_file = open(os.path.join(base_dir, logcat_filename), 'w')
  60   process = subprocess.Popen([adb_cmd, '-s', device_id,
  61                               'logcat', '-v', 'threadtime'],
  62                              stdout=logcat_file,
  63                              stderr=subprocess.PIPE)
  64   devices[device_id] = (process, logcat_num + 1)
  65
  66
  67 def GetAttachedDevices(adb_cmd):
  68   """Gets the device list from adb.
  69
  70   We use an alarm in this function to avoid deadlocking from an external
  71   dependency.
  72
  73   Args:
  74     adb_cmd: binary to run adb
  75
  76   Returns:
  77     list of devices or an empty list on timeout
  78   """
  79   signal.alarm(2)
  80   try:
  81     out, err = subprocess.Popen([adb_cmd, 'devices'],
  82                                 stdout=subprocess.PIPE,
  83                                 stderr=subprocess.PIPE).communicate()
  84     if err:
  85       logging.warning('adb device error %s', err.strip())
  86     return re.findall('^(\\S+)\tdevice$', out, re.MULTILINE)
  87   except TimeoutException:
  88     logging.warning('"adb devices" command timed out')
  89     return []
  90   except (IOError, OSError):
  91     logging.exception('Exception from "adb devices"')
  92     return []
  93   finally:
  94     signal.alarm(0)
  95
  96
  97 def main(base_dir, adb_cmd='adb'):
  98   """Monitor adb forever.  Expects a SIGINT (Ctrl-C) to kill."""
  99   # We create the directory to ensure 'run once' semantics
 100   if os.path.exists(base_dir):
 101     print 'adb_logcat_monitor: %s already exists? Cleaning' % base_dir
 102     shutil.rmtree(base_dir, ignore_errors=True)
 103
 104   os.makedirs(base_dir)
 105   logging.basicConfig(filename=os.path.join(base_dir, 'eventlog'),
 106                       level=logging.INFO,
 107                       format='%(asctime)-2s %(levelname)-8s %(message)s')
 108
 109   # Set up the alarm for calling 'adb devices'. This is to ensure
 110   # our script doesn't get stuck waiting for a process response
 111   def TimeoutHandler(_signum, _unused_frame):
 112     raise TimeoutException()
 113   signal.signal(signal.SIGALRM, TimeoutHandler)
 114
 115   # Handle SIGTERMs to ensure clean shutdown
 116   def SigtermHandler(_signum, _unused_frame):
 117     raise SigtermError()
 118   signal.signal(signal.SIGTERM, SigtermHandler)
 119
 120   logging.info('Started with pid %d', os.getpid())
 121   pid_file_path = os.path.join(base_dir, 'LOGCAT_MONITOR_PID')
 122
 123   try:
 124     with open(pid_file_path, 'w') as f:
 125       f.write(str(os.getpid()))
 126     while True:
 127       for device_id in GetAttachedDevices(adb_cmd):
 128         if not device_id in devices:
 129           subprocess.call([adb_cmd, '-s', device_id, 'logcat', '-c'])
 130           devices[device_id] = (None, 0)
 131
 132       for device in devices:
 133         # This will spawn logcat watchers for any device ever detected
 134         StartLogcatIfNecessary(device, adb_cmd, base_dir)
 135
 136       time.sleep(5)
 137   except SigtermError:
 138     logging.info('Received SIGTERM, shutting down')
 139   except: # pylint: disable=bare-except
 140     logging.exception('Unexpected exception in main.')
 141   finally:
 142     for process, _ in devices.itervalues():
 143       if process:
 144         try:
 145           process.terminate()
 146         except OSError:
 147           pass
 148     os.remove(pid_file_path)
 149
 150
 151 if __name__ == '__main__':
 152   if 2 <= len(sys.argv) <= 3:
 153     print 'adb_logcat_monitor: Initializing'
 154     sys.exit(main(*sys.argv[1:3]))
 155
 156   print 'Usage: %s <base_dir> [<adb_binary_path>]' % sys.argv[0]