156 строки
4.7 KiB
Python
Executable File
156 строки
4.7 KiB
Python
Executable File
#!/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.
|
|
|
|
"""Saves logcats from all connected devices.
|
|
|
|
Usage: adb_logcat_monitor.py <base_dir> [<adb_binary_path>]
|
|
|
|
This script will repeatedly poll adb for new devices and save logcats
|
|
inside the <base_dir> directory, which it attempts to create. The
|
|
script will run until killed by an external signal. To test, run the
|
|
script in a shell and <Ctrl>-C it after a while. It should be
|
|
resilient across phone disconnects and reconnects and start the logcat
|
|
early enough to not miss anything.
|
|
"""
|
|
|
|
import logging
|
|
import os
|
|
import re
|
|
import shutil
|
|
import signal
|
|
import subprocess
|
|
import sys
|
|
import time
|
|
|
|
# Map from device_id -> (process, logcat_num)
|
|
devices = {}
|
|
|
|
|
|
class TimeoutException(Exception):
|
|
"""Exception used to signal a timeout."""
|
|
pass
|
|
|
|
|
|
class SigtermError(Exception):
|
|
"""Exception used to catch a sigterm."""
|
|
pass
|
|
|
|
|
|
def StartLogcatIfNecessary(device_id, adb_cmd, base_dir):
|
|
"""Spawns a adb logcat process if one is not currently running."""
|
|
process, logcat_num = devices[device_id]
|
|
if process:
|
|
if process.poll() is None:
|
|
# Logcat process is still happily running
|
|
return
|
|
else:
|
|
logging.info('Logcat for device %s has died', device_id)
|
|
error_filter = re.compile('- waiting for device -')
|
|
for line in process.stderr:
|
|
if not error_filter.match(line):
|
|
logging.error(device_id + ': ' + line)
|
|
|
|
logging.info('Starting logcat %d for device %s', logcat_num,
|
|
device_id)
|
|
logcat_filename = 'logcat_%s_%03d' % (device_id, logcat_num)
|
|
logcat_file = open(os.path.join(base_dir, logcat_filename), 'w')
|
|
process = subprocess.Popen([adb_cmd, '-s', device_id,
|
|
'logcat', '-v', 'threadtime'],
|
|
stdout=logcat_file,
|
|
stderr=subprocess.PIPE)
|
|
devices[device_id] = (process, logcat_num + 1)
|
|
|
|
|
|
def GetAttachedDevices(adb_cmd):
|
|
"""Gets the device list from adb.
|
|
|
|
We use an alarm in this function to avoid deadlocking from an external
|
|
dependency.
|
|
|
|
Args:
|
|
adb_cmd: binary to run adb
|
|
|
|
Returns:
|
|
list of devices or an empty list on timeout
|
|
"""
|
|
signal.alarm(2)
|
|
try:
|
|
out, err = subprocess.Popen([adb_cmd, 'devices'],
|
|
stdout=subprocess.PIPE,
|
|
stderr=subprocess.PIPE).communicate()
|
|
if err:
|
|
logging.warning('adb device error %s', err.strip())
|
|
return re.findall('^(\w+)\tdevice$', out, re.MULTILINE)
|
|
except TimeoutException:
|
|
logging.warning('"adb devices" command timed out')
|
|
return []
|
|
except (IOError, OSError):
|
|
logging.exception('Exception from "adb devices"')
|
|
return []
|
|
finally:
|
|
signal.alarm(0)
|
|
|
|
|
|
def main(base_dir, adb_cmd='adb'):
|
|
"""Monitor adb forever. Expects a SIGINT (Ctrl-C) to kill."""
|
|
# We create the directory to ensure 'run once' semantics
|
|
if os.path.exists(base_dir):
|
|
print 'adb_logcat_monitor: %s already exists? Cleaning' % base_dir
|
|
shutil.rmtree(base_dir, ignore_errors=True)
|
|
|
|
os.makedirs(base_dir)
|
|
logging.basicConfig(filename=os.path.join(base_dir, 'eventlog'),
|
|
level=logging.INFO,
|
|
format='%(asctime)-2s %(levelname)-8s %(message)s')
|
|
|
|
# Set up the alarm for calling 'adb devices'. This is to ensure
|
|
# our script doesn't get stuck waiting for a process response
|
|
def TimeoutHandler(_, unused_frame):
|
|
raise TimeoutException()
|
|
signal.signal(signal.SIGALRM, TimeoutHandler)
|
|
|
|
# Handle SIGTERMs to ensure clean shutdown
|
|
def SigtermHandler(_, unused_frame):
|
|
raise SigtermError()
|
|
signal.signal(signal.SIGTERM, SigtermHandler)
|
|
|
|
logging.info('Started with pid %d', os.getpid())
|
|
pid_file_path = os.path.join(base_dir, 'LOGCAT_MONITOR_PID')
|
|
|
|
try:
|
|
with open(pid_file_path, 'w') as f:
|
|
f.write(str(os.getpid()))
|
|
while True:
|
|
for device_id in GetAttachedDevices(adb_cmd):
|
|
if not device_id in devices:
|
|
devices[device_id] = (None, 0)
|
|
|
|
for device in devices:
|
|
# This will spawn logcat watchers for any device ever detected
|
|
StartLogcatIfNecessary(device, adb_cmd, base_dir)
|
|
|
|
time.sleep(5)
|
|
except SigtermError:
|
|
logging.info('Received SIGTERM, shutting down')
|
|
except:
|
|
logging.exception('Unexpected exception in main.')
|
|
finally:
|
|
for process, _ in devices.itervalues():
|
|
if process:
|
|
try:
|
|
process.terminate()
|
|
except OSError:
|
|
pass
|
|
os.remove(pid_file_path)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
if 2 <= len(sys.argv) <= 3:
|
|
print 'adb_logcat_monitor: Initializing'
|
|
sys.exit(main(*sys.argv[1:3]))
|
|
|
|
print 'Usage: %s <base_dir> [<adb_binary_path>]' % sys.argv[0]
|