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.')
parser.add_argument('--adb-path', help='Path to adb binary.')
parser.add_argument('--blacklist-file',
help='Path to device blacklist file.')
args = parser.parse_args(argv)
devil_dynamic_config = devil_env.EmptyConfig()
if args.adb_path:
devil_dynamic_config['dependencies'].update(
devil_env.LocalConfigItem('adb', devil_env.GetPlatform(),
args.adb_path))
devil_env.config.Initialize(configs=[devil_dynamic_config])
blacklist = (device_blacklist.Blacklist(args.blacklist_file)
if args.blacklist_file else None)
while True:
status_dict = get_all_status(blacklist)
with open(DEVICE_FILE, 'wb') as f:
json.dump(status_dict, f, indent=2, sort_keys=True)
time.sleep(60)
def InitializeEnvironment(args):
"""Initializes devil based on the args added by AddEnvironmentArguments().
This initializes devil, and configures it to use the adb binary specified by
the '--adb-path' flag (if provided by the user, otherwise this defaults to
devil's copy of adb). Although this is one possible way to initialize devil,
you should check if your project has prefered ways to initialize devil (ex.
the chromium project uses devil_chromium.Initialize() to have different
defaults for dependencies).
This method requires having previously called AddEnvironmentArguments() on the
relevant argparse.ArgumentParser.
Note: you should only initialize devil once, and subsequent calls to any
method wrapping devil_env.config.Initialize() will have no effect.
Args:
args: the parsed args returned by an argparse.ArgumentParser
"""
devil_dynamic_config = devil_env.EmptyConfig()
if args.adb_path:
devil_dynamic_config['dependencies'].update(
devil_env.LocalConfigItem('adb', devil_env.GetPlatform(),
args.adb_path))
devil_env.config.Initialize(configs=[devil_dynamic_config])
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--adb-path',
help='Absolute path to the adb binary to use.')
parser.add_argument('--blacklist-file', help='Device blacklist JSON file.')
parser.add_argument('--known-devices-file', action='append', default=[],
dest='known_devices_files',
help='Path to known device lists.')
parser.add_argument('-v', '--verbose', action='count', default=1,
help='Log more information.')
args = parser.parse_args()
run_tests_helper.SetLogLevel(args.verbose)
devil_dynamic_config = devil_env.EmptyConfig()
if args.adb_path:
devil_dynamic_config['dependencies'].update(
devil_env.LocalConfigItem(
'adb', devil_env.GetPlatform(), args.adb_path))
devil_env.config.Initialize(configs=[devil_dynamic_config])
blacklist = (device_blacklist.Blacklist(args.blacklist_file)
if args.blacklist_file
else None)
expected_devices = device_status.GetExpectedDevices(args.known_devices_files)
usb_devices = set(lsusb.get_android_devices())
devices = [device_utils.DeviceUtils(s)
for s in expected_devices.union(usb_devices)]
RecoverDevices(devices, blacklist)
def main(raw_args):
parser = argparse.ArgumentParser()
parser.add_argument('-v', '--verbose', action='count', help='Log more.')
parser.add_argument('-t', '--timeout', default=30, type=int,
help='Seconds to wait for the devices.')
parser.add_argument('--adb-path', help='ADB binary to use.')
parser.add_argument('device_serials', nargs='*', metavar='SERIAL',
help='Serials of the devices to wait for.')
args = parser.parse_args(raw_args)
run_tests_helper.SetLogLevel(args.verbose)
devil_dynamic_config = devil_env.EmptyConfig()
if args.adb_path:
devil_dynamic_config['dependencies'].update(
devil_env.LocalConfigItem(
'adb', devil_env.GetPlatform(), args.adb_path))
devil_env.config.Initialize(configs=[devil_dynamic_config])
devices = device_utils.DeviceUtils.HealthyDevices(
device_arg=args.device_serials)
parallel_devices = device_utils.DeviceUtils.parallel(devices)
parallel_devices.WaitUntilFullyBooted(timeout=args.timeout)
return 0
def main(raw_args):
parser = argparse.ArgumentParser()
subparsers = parser.add_subparsers()
def add_common_arguments(p):
script_common.AddDeviceArguments(p)
p.add_argument(
'--adb-path', help='Path to the adb binary.')
p.add_argument(
'-v', '--verbose', action='count', default=0,
help='Print more information.')
p.add_argument('command', nargs='*')
@contextlib.contextmanager
def remove_system_app(device, args):
RemoveSystemApps(device, args.packages)
yield
remove_parser = subparsers.add_parser('remove')
remove_parser.add_argument(
'--package', dest='packages', nargs='*', required=True,
help='The system package(s) to remove.')
add_common_arguments(remove_parser)
remove_parser.set_defaults(func=remove_system_app)
@contextlib.contextmanager
def replace_system_app(device, args):
with ReplaceSystemApp(device, args.package, args.replace_with):
yield
replace_parser = subparsers.add_parser('replace')
replace_parser.add_argument(
'--package', required=True,
help='The system package to replace.')
replace_parser.add_argument(
'--replace-with', metavar='APK', required=True,
help='The APK with which the existing system app should be replaced.')
add_common_arguments(replace_parser)
replace_parser.set_defaults(func=replace_system_app)
args = parser.parse_args(raw_args)
run_tests_helper.SetLogLevel(args.verbose)
devil_dynamic_config = devil_env.EmptyConfig()
if args.adb_path:
devil_dynamic_config['dependencies'].update(
devil_env.LocalConfigItem(
'adb', devil_env.GetPlatform(), args.adb_path))
devil_env.config.Initialize(configs=[devil_dynamic_config])
devices = script_common.GetDevices(args.devices, args.blacklist_file)
parallel_devices = parallelizer.SyncParallelizer(
[args.func(d, args) for d in devices])
with parallel_devices:
if args.command:
return cmd_helper.Call(args.command)
return 0
def InitializeEnvironment(args):
devil_dynamic_config = devil_env.EmptyConfig()
if args.adb_path:
devil_dynamic_config['dependencies'].update(
devil_env.LocalConfigItem('adb', devil_env.GetPlatform(),
args.adb_path))
devil_env.config.Initialize(configs=[devil_dynamic_config])
def main():
parser = argparse.ArgumentParser()
AddArguments(parser)
args = parser.parse_args()
run_tests_helper.SetLogLevel(args.verbose)
devil_dynamic_config = devil_env.EmptyConfig()
if args.adb_path:
devil_dynamic_config['dependencies'].update(
devil_env.LocalConfigItem('adb', devil_env.GetPlatform(),
args.adb_path))
devil_env.config.Initialize(configs=[devil_dynamic_config])
blacklist = (device_blacklist.Blacklist(args.blacklist_file)
if args.blacklist_file else None)
expected_devices = GetExpectedDevices(args.known_devices_files)
usb_devices = set(lsusb.get_android_devices())
devices = [
device_utils.DeviceUtils(s)
for s in expected_devices.union(usb_devices)
]
statuses = DeviceStatus(devices, blacklist)
# Log the state of all devices.
_LogStatuses(statuses)
# Update the last devices file(s).
if args.overwrite_known_devices_files:
for path in args.known_devices_files:
device_list.WritePersistentDeviceList(
path, [status['serial'] for status in statuses])
# Write device info to file for buildbot info display.
_WriteBuildbotFile(args.buildbot_path, statuses)
# Dump the device statuses to JSON.
if args.json_output:
with open(args.json_output, 'wb') as f:
f.write(
json.dumps(statuses,
indent=4,
sort_keys=True,
separators=(',', ': ')))
live_devices = [
status['serial'] for status in statuses
if (status['adb_status'] == 'device'
and not IsBlacklisted(status['serial'], blacklist))
]
# If all devices failed, or if there are no devices, it's an infra error.
if not live_devices:
logger.error('No available devices.')
return 0 if live_devices else exit_codes.INFRA
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.')
parser.add_argument('--adb-path', help='Path to adb binary.')
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)
devil_dynamic_config = devil_env.EmptyConfig()
if args.adb_path:
devil_dynamic_config['dependencies'].update(
devil_env.LocalConfigItem('adb', devil_env.GetPlatform(),
args.adb_path))
devil_env.config.Initialize(configs=[devil_dynamic_config])
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)
def main(raw_args):
parser = argparse.ArgumentParser()
parser.add_argument('--adb-path', help='ADB binary path.')
parser.add_argument(
'--device',
dest='devices',
action='append',
default=[],
help='Devices for which the governor should be set. Defaults to all.')
parser.add_argument('-v', '--verbose', action='count', help='Log more.')
subparsers = parser.add_subparsers()
set_governor = subparsers.add_parser('set-governor')
set_governor.add_argument('governor', help='Desired CPU governor.')
set_governor.set_defaults(func=SetScalingGovernor)
get_governor = subparsers.add_parser('get-governor')
get_governor.set_defaults(func=GetScalingGovernor)
list_governors = subparsers.add_parser('list-governors')
list_governors.set_defaults(func=ListAvailableGovernors)
args = parser.parse_args(raw_args)
run_tests_helper.SetLogLevel(args.verbose)
devil_dynamic_config = devil_env.EmptyConfig()
if args.adb_path:
devil_dynamic_config['dependencies'].update(
devil_env.LocalConfigItem('adb', devil_env.GetPlatform(),
args.adb_path))
devil_env.config.Initialize(configs=[devil_dynamic_config])
devices = device_utils.DeviceUtils.HealthyDevices(device_arg=args.devices)
parallel_devices = device_utils.DeviceUtils.parallel(devices)
parallel_devices.pMap(args.func, args)
return 0
def main():
logging.getLogger().setLevel(logging.INFO)
parser = argparse.ArgumentParser()
script_common.AddDeviceArguments(parser)
parser.add_argument('--adb-path',
help='Absolute path to the adb binary to use.')
args = parser.parse_args()
devil_dynamic_config = devil_env.EmptyConfig()
if args.adb_path:
devil_dynamic_config['dependencies'].update(
devil_env.LocalConfigItem(
'adb', devil_env.GetPlatform(), args.adb_path))
devil_env.config.Initialize(configs=[devil_dynamic_config])
reboot_into_bootloader(args.devices)
devices = [
d for d in fastboot.Fastboot.Devices() if not args.devices or
str(d) in args.devices]
parallel_devices = parallelizer.Parallelizer(devices)
parallel_devices.pMap(unlock_bootloader).pGet(None)
return 0
def main(raw_args):
# Recommended options on perf bots:
# --disable-network
# TODO(tonyg): We eventually want network on. However, currently radios
# can cause perfbots to drain faster than they charge.
# --min-battery-level 95
# Some perf bots run benchmarks with USB charging disabled which leads
# to gradual draining of the battery. We must wait for a full charge
# before starting a run in order to keep the devices online.
parser = argparse.ArgumentParser(
description='Provision Android devices with settings required for bots.'
)
parser.add_argument(
'-d',
'--device',
metavar='SERIAL',
action='append',
dest='devices',
help='the serial number of the device to be provisioned '
'(the default is to provision all devices attached)')
parser.add_argument('--adb-path',
help='Absolute path to the adb binary to use.')
parser.add_argument('--blacklist-file', help='Device blacklist JSON file.')
parser.add_argument('--skip-wipe',
action='store_true',
default=False,
help="don't wipe device data during provisioning")
parser.add_argument('--reboot-timeout',
metavar='SECS',
type=int,
help='when wiping the device, max number of seconds to'
' wait after each reboot '
'(default: %s)' % _DEFAULT_TIMEOUTS.HELP_TEXT)
parser.add_argument(
'--min-battery-level',
type=int,
metavar='NUM',
help='wait for the device to reach this minimum battery'
' level before trying to continue')
parser.add_argument('--disable-location',
action='store_true',
help='disable Google location services on devices')
parser.add_argument('--disable-mock-location',
action='store_true',
default=False,
help='Set ALLOW_MOCK_LOCATION to false')
parser.add_argument('--disable-network',
action='store_true',
help='disable network access on devices')
parser.add_argument('--disable-java-debug',
action='store_false',
dest='enable_java_debug',
default=True,
help='disable Java property asserts and JNI checking')
parser.add_argument('--disable-system-chrome',
action='store_true',
help='Disable the system chrome from devices.')
parser.add_argument('--remove-system-webview',
action='store_true',
help='Remove the system webview from devices.')
parser.add_argument('--adb-key-files',
type=str,
nargs='+',
help='list of adb keys to push to device')
parser.add_argument('-v',
'--verbose',
action='count',
default=1,
help='Log more information.')
parser.add_argument(
'--max-battery-temp',
type=int,
metavar='NUM',
help='Wait for the battery to have this temp or lower.')
parser.add_argument('--output-device-blacklist',
help='Json file to output the device blacklist.')
parser.add_argument('--emulators',
action='store_true',
help='provision only emulators and ignore usb devices')
args = parser.parse_args(raw_args)
run_tests_helper.SetLogLevel(args.verbose)
devil_dynamic_config = devil_env.EmptyConfig()
if args.adb_path:
devil_dynamic_config['dependencies'].update(
devil_env.LocalConfigItem('adb', devil_env.GetPlatform(),
args.adb_path))
devil_env.config.Initialize(configs=[devil_dynamic_config])
try:
return ProvisionDevices(
args.devices,
args.blacklist_file,
adb_key_files=args.adb_key_files,
disable_location=args.disable_location,
disable_mock_location=args.disable_mock_location,
disable_network=args.disable_network,
disable_system_chrome=args.disable_system_chrome,
emulators=args.emulators,
enable_java_debug=args.enable_java_debug,
max_battery_temp=args.max_battery_temp,
min_battery_level=args.min_battery_level,
output_device_blacklist=args.output_device_blacklist,
reboot_timeout=args.reboot_timeout,
remove_system_webview=args.remove_system_webview,
wipe=not args.skip_wipe)
except (device_errors.DeviceUnreachableError,
device_errors.NoDevicesError):
return exit_codes.INFRA
help=argparse.SUPPRESS)
parser.add_argument(
'--phase', action='append',
help=argparse.SUPPRESS)
parser.add_argument(
'-r', '--auto-reconnect', action='store_true',
help=argparse.SUPPRESS)
parser.add_argument(
'-t', '--target',
help=argparse.SUPPRESS)
args = parser.parse_args(raw_args)
run_tests_helper.SetLogLevel(args.verbose)
devil_dynamic_config = devil_env.EmptyConfig()
if args.adb_path:
devil_dynamic_config['dependencies'].update(
devil_env.LocalConfigItem(
'adb', devil_env.GetPlatform(), args.adb_path))
devil_env.config.Initialize(configs=[devil_dynamic_config])
try:
return ProvisionDevices(
args.devices,
args.blacklist_file,
adb_key_files=args.adb_key_files,
disable_location=args.disable_location,
disable_mock_location=args.disable_mock_location,
disable_network=args.disable_network,
