1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
|
#!/usr/bin/env python
# Copyright 2015 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.
"""Launches a daemon to monitor android device temperatures & status.
This script will repeatedly poll the given devices for their temperatures and
status every 60 seconds and dump the stats to file on the host.
"""
import argparse
import collections
import json
import logging
import logging.handlers
import os
import re
import socket
import sys
import time
if __name__ == '__main__':
sys.path.append(
os.path.abspath(os.path.join(os.path.dirname(__file__),
'..', '..', '..')))
from devil.android import battery_utils
from devil.android import device_blacklist
from devil.android import device_errors
from devil.android import device_utils
from devil.android.tools import script_common
# Various names of sensors used to measure cpu temp
CPU_TEMP_SENSORS = [
# most nexus devices
'tsens_tz_sensor0',
# android one
'mtktscpu',
# nexus 9
'CPU-therm',
]
DEVICE_FILE_VERSION = 1
DEVICE_FILE = os.path.join(
os.path.expanduser('~'), '.android',
'%s__android_device_status.json' % socket.gethostname().split('.')[0])
MEM_INFO_REGEX = re.compile(r'.*?\:\s*(\d+)\s*kB') # ex: 'MemTotal: 185735 kB'
def get_device_status_unsafe(device):
"""Polls the given device for various info.
Returns: A dict of the following format:
{
'battery': {
'level': 100,
'temperature': 123
},
'build': {
'build.id': 'ABC12D',
'product.device': 'chickenofthesea'
},
'imei': 123456789,
'mem': {
'avail': 1000000,
'total': 1234567,
},
'processes': 123,
'state': 'good',
'temp': {
'some_sensor': 30
},
'uptime': 1234.56,
}
"""
status = collections.defaultdict(dict)
# Battery
battery = battery_utils.BatteryUtils(device)
battery_info = battery.GetBatteryInfo()
try:
level = int(battery_info.get('level'))
except (KeyError, TypeError, ValueError):
level = None
if level and level >= 0 and level <= 100:
status['battery']['level'] = level
try:
temperature = int(battery_info.get('temperature'))
except (KeyError, TypeError, ValueError):
temperature = None
if temperature:
status['battery']['temperature'] = temperature
# Build
status['build']['build.id'] = device.build_id
status['build']['product.device'] = device.build_product
# Memory
mem_info = ''
try:
mem_info = device.ReadFile('/proc/meminfo')
except device_errors.AdbShellCommandFailedError:
logging.exception('Unable to read /proc/meminfo')
for line in mem_info.splitlines():
match = MEM_INFO_REGEX.match(line)
if match:
try:
value = int(match.group(1))
except ValueError:
continue
key = line.split(':')[0].strip()
if 'MemTotal' == key:
status['mem']['total'] = value
elif 'MemFree' == key:
status['mem']['free'] = value
# Process
try:
status['processes'] = len(device.ListProcesses())
except device_errors.AdbCommandFailedError:
logging.exception('Unable to count process list.')
# CPU Temps
# Find a thermal sensor that matches one in CPU_TEMP_SENSORS and read its
# temperature.
files = []
try:
files = device.RunShellCommand(
'grep -lE "%s" /sys/class/thermal/thermal_zone*/type' % '|'.join(
CPU_TEMP_SENSORS), shell=True, check_return=True)
except device_errors.AdbShellCommandFailedError:
logging.exception('Unable to list thermal sensors.')
for f in files:
try:
sensor_name = device.ReadFile(f).strip()
temp = float(device.ReadFile(f[:-4] + 'temp').strip()) # s/type^/temp
status['temp'][sensor_name] = temp
except (device_errors.AdbShellCommandFailedError, ValueError):
logging.exception('Unable to read thermal sensor %s', f)
# Uptime
try:
uptimes = device.ReadFile('/proc/uptime').split()
status['uptime'] = float(uptimes[0]) # Take the first field (actual uptime)
except (device_errors.AdbShellCommandFailedError, ValueError):
logging.exception('Unable to read /proc/uptime')
try:
status['imei'] = device.GetIMEI()
except device_errors.CommandFailedError:
logging.exception('Unable to read IMEI')
status['imei'] = 'unknown'
status['state'] = 'available'
return status
def get_device_status(device):
try:
status = get_device_status_unsafe(device)
except device_errors.DeviceUnreachableError:
status = {'state': 'offline'}
return status
def get_all_status(blacklist):
status_dict = {
'version': DEVICE_FILE_VERSION,
'devices': {},
}
healthy_devices = device_utils.DeviceUtils.HealthyDevices(blacklist)
parallel_devices = device_utils.DeviceUtils.parallel(healthy_devices)
results = parallel_devices.pMap(get_device_status).pGet(None)
status_dict['devices'] = {
device.serial: result for device, result in zip(healthy_devices, results)
}
if blacklist:
for device, reason in blacklist.Read().iteritems():
status_dict['devices'][device] = {
'state': reason.get('reason', 'blacklisted')}
status_dict['timestamp'] = time.time()
return status_dict
def main(argv):
"""Launches the device monitor.
Polls the devices for their battery and cpu temperatures and scans the
blacklist file every 60 seconds and dumps the data to DEVICE_FILE.
"""
parser = argparse.ArgumentParser(
description='Launches the device monitor.')
script_common.AddEnvironmentArguments(parser)
parser.add_argument('--blacklist-file', help='Path to device blacklist file.')
args = parser.parse_args(argv)
logger = logging.getLogger()
logger.setLevel(logging.DEBUG)
handler = logging.handlers.RotatingFileHandler(
'/tmp/device_monitor.log', maxBytes=10 * 1024 * 1024, backupCount=5)
fmt = logging.Formatter('%(asctime)s %(levelname)s %(message)s',
datefmt='%y%m%d %H:%M:%S')
handler.setFormatter(fmt)
logger.addHandler(handler)
script_common.InitializeEnvironment(args)
blacklist = (device_blacklist.Blacklist(args.blacklist_file)
if args.blacklist_file else None)
logging.info('Device monitor running with pid %d, adb: %s, blacklist: %s',
os.getpid(), args.adb_path, args.blacklist_file)
while True:
start = time.time()
status_dict = get_all_status(blacklist)
with open(DEVICE_FILE, 'wb') as f:
json.dump(status_dict, f, indent=2, sort_keys=True)
logging.info('Got status of all devices in %.2fs.', time.time() - start)
time.sleep(60)
if __name__ == '__main__':
sys.exit(main(sys.argv[1:]))
|
