def ProvisionDevices(options): if options.device is not None: devices = [options.device] else: devices = android_commands.GetAttachedDevices() for device_serial in devices: device = device_utils.DeviceUtils(device_serial) device.old_interface.EnableAdbRoot() install_output = GetCmdOutput( ['%s/build/android/adb_install_apk.py' % constants.DIR_SOURCE_ROOT, '--apk', '%s/build/android/CheckInstallApk-debug.apk' % constants.DIR_SOURCE_ROOT ]) failure_string = 'Failure [INSTALL_FAILED_INSUFFICIENT_STORAGE]' if failure_string in install_output: WipeDeviceData(device) _ConfigureLocalProperties(device) device_settings.ConfigureContentSettingsDict( device, device_settings.DETERMINISTIC_DEVICE_SETTINGS) # TODO(tonyg): We eventually want network on. However, currently radios # can cause perfbots to drain faster than they charge. if 'perf' in os.environ.get('BUILDBOT_BUILDERNAME', '').lower(): device_settings.ConfigureContentSettingsDict( device, device_settings.NETWORK_DISABLED_SETTINGS) device.old_interface.RunShellCommandWithSU('date -u %f' % time.time()) (_, props) = device.old_interface.GetShellCommandStatusAndOutput('getprop') for prop in props: print prop if options.auto_reconnect: PushAndLaunchAdbReboot(devices, options.target)
def main(argv): option_parser = optparse.OptionParser() option_parser.add_option( '--enable_asserts', dest='set_asserts', action='store_true', default=None, help='Sets the dalvik.vm.enableassertions property to "all"') option_parser.add_option( '--disable_asserts', dest='set_asserts', action='store_false', default=None, help='Removes the dalvik.vm.enableassertions property') options, _ = option_parser.parse_args(argv) # TODO(jbudorick): Accept optional serial number and run only for the # specified device when present. devices = android_commands.GetAttachedDevices() for device in [device_utils.DeviceUtils(serial) for serial in devices]: if options.set_asserts != None: if device.old_interface.SetJavaAssertsEnabled(options.set_asserts): # TODO(jbudorick) How to best do shell restarts after the # android_commands refactor? device.RunShellCommand('stop') device.RunShellCommand('start')
def RunJavaTest(fname, suite, test, ports_to_forward): device = android_commands.GetAttachedDevices()[0] package_name = _GetPackageName(fname) test = package_name + '.' + suite + '#' + test java_test_runner = TestRunner(False, device, [test], False, False, False, False, 0, ports_to_forward) return java_test_runner.Run()
def DispatchPythonTests(options): """Dispatches the Monkey tests, sharding it if there multiple devices.""" logger = logging.getLogger() logger.setLevel(logging.DEBUG) attached_devices = android_commands.GetAttachedDevices() if not attached_devices: raise Exception('You have no devices attached or visible!') # Actually run the tests. logging.debug('Running monkey tests.') # TODO(frankf): This is a stop-gap solution. Come up with a # general way for running tests on every devices. available_tests = [] for k in range(len(attached_devices)): new_method = 'testMonkey%d' % k setattr(MonkeyTest, new_method, MonkeyTest.testMonkey) available_tests.append(MonkeyTest(new_method)) options.ensure_value('shard_retries', 1) sharder = python_test_sharder.PythonTestSharder( attached_devices, available_tests, options) results = sharder.RunShardedTests() report_results.LogFull( results=results, test_type='Monkey', test_package='Monkey', build_type=options.build_type) report_results.PrintAnnotation(results)
def main(): parser = optparse.OptionParser() parser.add_option('', '--out-dir', help='Directory where the device path is stored', default=os.path.join(os.path.dirname(__file__), '..', '..', 'out')) options, args = parser.parse_args() if args: parser.error('Unknown options %s' % args) buildbot_report.PrintNamedStep('Device Status Check') devices = android_commands.GetAttachedDevices() types, builds, reports, errors = [], [], [], [] if devices: types, builds, reports, errors = zip( *[DeviceInfo(dev) for dev in devices]) unique_types = list(set(types)) unique_builds = list(set(builds)) buildbot_report.PrintMsg('Online devices: %d. Device types %s, builds %s' % (len(devices), unique_types, unique_builds)) print '\n'.join(reports) full_errors = [] for serial, device_errors in zip(devices, errors): full_errors.extend('%s: %s' % (serial, error) for error in device_errors) if full_errors: buildbot_report.PrintWarning() print '\n'.join(full_errors) CheckForMissingDevices(options, devices)
def ProvisionDevices(options): is_perf = 'perf' in os.environ.get('BUILDBOT_BUILDERNAME', '').lower() # TODO(jbudorick): Parallelize provisioning of all attached devices after # switching from AndroidCommands. if options.device is not None: devices = [options.device] else: devices = android_commands.GetAttachedDevices() # Wipe devices (unless --skip-wipe was specified) if not options.skip_wipe: WipeDevicesIfPossible(devices) bad_devices = [] # Provision devices for device_serial in devices: try: ProvisionDevice(device_serial, is_perf, options.disable_location) except errors.WaitForResponseTimedOutError: logging.info( 'Timed out waiting for device %s. Adding to blacklist.', device_serial) bad_devices.append(device_serial) # Device black list is reset by bb_device_status_check.py per build. device_blacklist.ExtendBlacklist([device_serial]) devices = [device for device in devices if device not in bad_devices] # If there are no good devices if not devices: raise device_errors.NoDevicesError try: device_utils.DeviceUtils.parallel(devices).Reboot(True) except errors.DeviceUnresponsiveError: pass bad_devices = [] for device_serial in devices: device = device_utils.DeviceUtils(device_serial) try: device.WaitUntilFullyBooted(timeout=90) (_, prop ) = device.old_interface.GetShellCommandStatusAndOutput('getprop') for p in prop: print p except errors.WaitForResponseTimedOutError: logging.info( 'Timed out waiting for device %s. Adding to blacklist.', device_serial) bad_devices.append(device_serial) # Device black list is reset by bb_device_status_check.py per build. device_blacklist.ExtendBlacklist([device_serial]) devices = [device for device in devices if device not in bad_devices] # If there are no good devices if not devices: raise device_errors.NoDevicesError if options.auto_reconnect: PushAndLaunchAdbReboot(devices, options.target)
def PrepareShellRun(config): """ Returns a context allowing a shell to be run. This will start an internal http server to serve mojo applications, forward a local port on the device to this http server and install the current version of the mojo shell. """ build_dir = Paths(config).build_dir constants.SetOutputDirectort(build_dir) httpd = _SilentTCPServer(('127.0.0.1', 0), _GetHandlerClassForPath(build_dir)) atexit.register(httpd.shutdown) host_port = httpd.server_address[1] http_thread = threading.Thread(target=httpd.serve_forever) http_thread.daemon = True http_thread.start() device = android_commands.AndroidCommands( android_commands.GetAttachedDevices()[0]) device.EnableAdbRoot() device.ManagedInstall(os.path.join(build_dir, 'apks', 'MojoShell.apk'), keep_data=True, package_name=MOJO_SHELL_PACKAGE_NAME) atexit.register(forwarder.Forwarder.UnmapAllDevicePorts, device) forwarder.Forwarder.Map([(0, host_port)], device) context = Context(device, forwarder.Forwarder.DevicePortForHostPort(host_port)) atexit.register(StopShell, context) return context
def testDeviceManagement(self): self._drivers = [ self.CreateDriver() for x in android_commands.GetAttachedDevices() ] self.assertRaises(chromedriver.UnknownError, self.CreateDriver) self._drivers[0].Quit() self._drivers[0] = self.CreateDriver()
def main(argv): logging.basicConfig(level=logging.INFO) parser = optparse.OptionParser() parser.add_option('-w', '--wipe', action='store_true', help='Wipe device data from all attached devices.') parser.add_option('-d', '--device', help='The serial number of the device to be provisioned') parser.add_option('-t', '--target', default='Debug', help='The build target') parser.add_option( '-r', '--auto-reconnect', action='store_true', help='Push binary which will reboot the device on adb disconnections.') options, args = parser.parse_args(argv[1:]) constants.SetBuildType(options.target) if args: print >> sys.stderr, 'Unused args %s' % args return 1 if options.wipe: devices = android_commands.GetAttachedDevices() for device_serial in devices: device = device_utils.DeviceUtils(device_serial) WipeDeviceData(device) device_utils.RebootDevices() else: ProvisionDevices(options)
def main(argv): parser = optparse.OptionParser() AddInstallAPKOption(parser) options, args = parser.parse_args(argv) constants.SetBuildType(options.build_type) ValidateInstallAPKOption(parser, options) if len(args) > 1: raise Exception('Error: Unknown argument:', args[1:]) retry_times = 5 retry_interval = 15 while retry_times > 0: devices = android_commands.GetAttachedDevices() if not devices: print 'No connected devices found, '\ 'kill adb server and retry in %d seconds...' % retry_interval android_commands.AndroidCommands().KillAdbServer() time.sleep(retry_interval) retry_interval *= 2 retry_times -= 1 else: break if not devices: raise Exception('Error: no connected devices') if not options.apk_package: options.apk_package = apk_helper.GetPackageName(options.apk) pool = multiprocessing.Pool(len(devices)) # Send a tuple (apk_path, apk_package, device) per device. pool.map(_InstallApk, zip([options.apk] * len(devices), [options.apk_package] * len(devices), [options.keep_data] * len(devices), devices))
def _GetAttachedDevices(wait_for_debugger=False, test_device=None): """Get all attached devices. If we are using a debugger, limit to only one device. Args: wait_for_debugger: True if this run will use a debugger. test_device: Name of a specific device to use. Returns: A list of attached devices. """ attached_devices = [] attached_devices = android_commands.GetAttachedDevices() if test_device: assert test_device in attached_devices, ( 'Did not find device %s among attached device. Attached devices: %s' % (test_device, ', '.join(attached_devices))) attached_devices = [test_device] if len(attached_devices) > 1 and wait_for_debugger: logging.warning( 'Debugger can not be sharded, using first available device') attached_devices = attached_devices[:1] return attached_devices
def main(): parser = optparse.OptionParser() parser.add_option('--device', help='The serial number of the device. If not specified ' 'will use all devices.') parser.add_option('-a', '--all-tombstones', action='store_true', help="""Resolve symbols for all tombstones, rather than just the most recent""") parser.add_option('-s', '--stack', action='store_true', help='Also include symbols for stack data') parser.add_option('-w', '--wipe-tombstones', action='store_true', help='Erase all tombstones from device after processing') parser.add_option('-j', '--jobs', type='int', default=4, help='Number of jobs to use when processing multiple ' 'crash stacks.') options, _ = parser.parse_args() if options.device: devices = [options.device] else: devices = android_commands.GetAttachedDevices() tombstones = [] for device_serial in devices: device = device_utils.DeviceUtils(device_serial) tombstones += _GetTombstonesForDevice(device, options) _ResolveTombstones(options.jobs, tombstones)
def main(argv): parser = optparse.OptionParser() parser.set_usage("usage: %prog [options] target") AddInstallAPKOption(parser) options, args = parser.parse_args(argv) if len(args) > 1 and options.apk: parser.error("Appending the apk as argument can't be used with --apk.") elif len(args) > 2: parser.error("Too many arguments.") constants.SetBuildType(options.build_type) ValidateInstallAPKOption(parser, options, args) devices = android_commands.GetAttachedDevices() if options.device: if options.device not in devices: raise Exception('Error: %s not in attached devices %s' % (options.device, ','.join(devices))) devices = [options.device] if not devices: raise Exception('Error: no connected devices') device_utils.DeviceUtils.parallel(devices).Install( options.apk, reinstall=options.keep_data)
def setUp(self): if not os.getenv('BUILDTYPE'): os.environ['BUILDTYPE'] = 'Debug' devices = android_commands.GetAttachedDevices() self.assertGreater(len(devices), 0, 'No device attached!') self.ac = android_commands.AndroidCommands(device=devices[0])
def main(argv): parser = optparse.OptionParser() parser.add_option('-s', '--steps', help='A JSON file containing all the steps to be ' 'sharded.') parser.add_option('-p', '--print_results', help='Only prints the results for the previously ' 'executed step, do not run it again.') options, urls = parser.parse_args(argv) if options.print_results: return _PrintStepOutput(options.print_results) # At this point, we should kill everything that may have been left over from # previous runs. _KillPendingServers() # Reset the test port allocation. It's important to do it before starting # to dispatch any step. if not ports.ResetTestServerPortAllocation(): raise Exception('Failed to reset test server port.') # Sort the devices so that we'll try to always run a step in the same device. devices = sorted(android_commands.GetAttachedDevices()) if not devices: print 'You must attach a device' return 1 with file(options.steps, 'r') as f: steps = json.load(f) return _RunShardedSteps(steps, devices)
def _KillPendingServers(): for retry in range(5): for server in ['lighttpd', 'web-page-replay']: pids = [p.pid for p in psutil.process_iter() if server in p.name] for pid in pids: try: logging.warning('Killing %s %s', server, pid) os.kill(pid, signal.SIGQUIT) except Exception as e: logging.warning('Failed killing %s %s %s', server, pid, e) # Restart the adb server with taskset to set a single CPU affinity. cmd_helper.RunCmd(['adb', 'kill-server']) cmd_helper.RunCmd(['taskset', '-c', '0', 'adb', 'start-server']) cmd_helper.RunCmd(['taskset', '-c', '0', 'adb', 'root']) i = 1 while not android_commands.GetAttachedDevices(): time.sleep(i) i *= 2 if i > 10: break # Reset the test port allocation. It's important to do it before starting # to dispatch any step. if not ports.ResetTestServerPortAllocation(): raise Exception('Failed to reset test server port.') forwarder.Forwarder.UseMultiprocessing()
def _KillAllEmulators(): """Kill all running emulators that look like ones we started. There are odd 'sticky' cases where there can be no emulator process running but a device slot is taken. A little bot trouble and and we're out of room forever. """ emulators = android_commands.GetAttachedDevices(hardware=False) if not emulators: return for emu_name in emulators: cmd_helper.RunCmd(['adb', '-s', emu_name, 'emu', 'kill']) logging.info('Emulator killing is async; give a few seconds for all to die.') for i in range(5): if not android_commands.GetAttachedDevices(hardware=False): return time.sleep(1)
def _RunATestSuite(options, suite_name): """Run a single test suite. Helper for Dispatch() to allow stop/restart of the emulator across test bundles. If using the emulator, we start it on entry and stop it on exit. Args: options: options for running the tests. suite_name: name of the test suite being run. Returns: 0 if successful, number of failing tests otherwise. """ step_name = os.path.basename(options.test_suite).replace('-debug.apk', '') attached_devices = [] buildbot_emulators = [] if options.use_emulator: buildbot_emulators = emulator.LaunchEmulators(options.emulator_count, wait_for_boot=True) attached_devices = [e.device for e in buildbot_emulators] elif options.test_device: attached_devices = [options.test_device] else: attached_devices = android_commands.GetAttachedDevices() if not attached_devices: logging.critical('A device must be attached and online.') return 1 # Reset the test port allocation. It's important to do it before starting # to dispatch any tests. if not ports.ResetTestServerPortAllocation(): raise Exception('Failed to reset test server port.') if options.gtest_filter: logging.warning('Sharding is not possible with these configurations.') attached_devices = [attached_devices[0]] sharder = test_sharder.TestSharder(attached_devices, options.test_suite, options.gtest_filter, options.test_arguments, options.timeout, options.cleanup_test_files, options.tool, options.build_type, options.webkit) test_results = sharder.RunShardedTests() test_results.LogFull(test_type='Unit test', test_package=suite_name, build_type=options.build_type, flakiness_server=options.flakiness_dashboard_server) test_results.PrintAnnotation() for buildbot_emulator in buildbot_emulators: buildbot_emulator.Shutdown() return len(test_results.GetAllBroken())
def main(): logger = logging.getLogger() logger.setLevel(logging.DEBUG) desc = ( 'Performs semi-automated application update verification testing. ' 'When given --save, it takes a snapshot of the application data ' 'on the device. (A dialog on the device will prompt the user to grant ' 'permission to backup the data.) Otherwise, it performs the update ' 'testing as follows: ' '1. Installs the |from-apk| (optional). ' '2. Restores the previously stored snapshot of application data ' 'given by |app-data| ' '(A dialog on the device will prompt the user to grant permission to ' 'restore the data.) ' '3. Verifies that |to-apk| cannot be installed side-by-side. ' '4. Verifies that |to-apk| can replace |from-apk|.') parser = optparse.OptionParser(description=desc) parser.add_option('--package-name', help='Package name for the application.') parser.add_option('--save', action='store_true', help=('Save a snapshot of application data. ' 'This will be saved as backup.db in the ' 'current directory if |app-data| directory ' 'is not specifid.')) parser.add_option('--from-apk', help=('APK to update from. This is optional if you already ' 'have the app installed.')) parser.add_option('--to-apk', help='APK to update to.') parser.add_option('--app-data', help=('Path to the application data to be restored or the ' 'directory where the data should be saved.')) (options, args) = parser.parse_args() if args: parser.print_help(sys.stderr) parser.error('Unknown arguments: %s.' % args) devices = android_commands.GetAttachedDevices() if len(devices) != 1: parser.error('Exactly 1 device must be attached.') device = device_utils.DeviceUtils(devices[0]) if options.from_apk: assert os.path.isfile(options.from_apk) if options.save: if not options.package_name: parser.print_help(sys.stderr) parser.error('Missing --package-name.') _SaveAppData(device, options.package_name, from_apk=options.from_apk, data_dir=options.app_data) else: if not options.to_apk or not options.app_data: parser.print_help(sys.stderr) parser.error('Missing --to-apk or --app-data.') assert os.path.isfile(options.to_apk) assert os.path.isfile(options.app_data) _VerifyAppUpdate(device, options.to_apk, options.app_data, from_apk=options.from_apk)
def _GetAllDevices(): devices_path = os.path.join(os.environ.get('CHROMIUM_OUT_DIR', 'out'), device_list.LAST_DEVICES_FILENAME) try: devices = device_list.GetPersistentDeviceList(devices_path) except IOError as e: logging.error('Unable to find %s [%s]', devices_path, e) devices = android_commands.GetAttachedDevices() return sorted(devices)
def Dispatch(options): attached_devices = [] if options.test_device: attached_devices = [options.test_device] else: attached_devices = android_commands.GetAttachedDevices() if not attached_devices: logging.critical('A device must be attached and online.') return 1 # Reset the test port allocation. It's important to do it before starting # to dispatch any tests. if not ports.ResetTestServerPortAllocation(): raise Exception('Failed to reset test server port.') test_suite_dir = os.path.join(cmd_helper.OutDirectory.get(), options.build_type) options.test_suite = os.path.join( test_suite_dir, 'apks', constants.BROWSERTEST_SUITE_NAME + '.apk') # Constructs a new TestRunner with the current options. def RunnerFactory(device, shard_index): return test_runner.TestRunner(device, options.test_suite, options.test_arguments, options.timeout, options.cleanup_test_files, options.tool, options.build_type, options.webkit, constants.BROWSERTEST_TEST_PACKAGE_NAME, constants.BROWSERTEST_TEST_ACTIVITY_NAME, constants.BROWSERTEST_COMMAND_LINE_FILE) # Get tests and split them up based on the number of devices. if options.gtest_filter: all_tests = [t for t in options.gtest_filter.split(':') if t] else: all_enabled = gtest_dispatch.GetAllEnabledTests( RunnerFactory, attached_devices) all_tests = _FilterTests(all_enabled) # Run tests. # TODO(nileshagrawal): remove this abnormally long setup timeout once fewer # files are pushed to the devices for content_browsertests: crbug.com/138275 setup_timeout = 20 * 60 # 20 minutes test_results = shard.ShardAndRunTests(RunnerFactory, attached_devices, all_tests, options.build_type, setup_timeout=setup_timeout, test_timeout=None, num_retries=options.num_retries) report_results.LogFull(results=test_results, test_type='Unit test', test_package=constants.BROWSERTEST_SUITE_NAME, build_type=options.build_type, flakiness_server=options.flakiness_dashboard_server) report_results.PrintAnnotation(test_results)
def _GetAvailablePort(): """Returns an available TCP port for the console.""" used_ports = [] emulators = android_commands.GetAttachedDevices(hardware=False) for emulator in emulators: used_ports.append(emulator.split('-')[1]) for port in PortPool.port_range(): if str(port) not in used_ports: return port
def DispatchPythonTests(options): """Dispatches the Python tests. If there are multiple devices, use sharding. Args: options: command line options. Returns: A list of test results. """ attached_devices = android_commands.GetAttachedDevices() if not attached_devices: raise Exception('You have no devices attached or visible!') if options.device: attached_devices = [options.device] test_collection = TestInfoCollection() all_tests = _GetAllTests(options.python_test_root, options.official_build) test_collection.AddTests(all_tests) test_names = [t.qualified_name for t in all_tests] logging.debug('All available tests: ' + str(test_names)) available_tests = test_collection.GetAvailableTests( options.annotations, options.exclude_annotations, options.test_filter) if not available_tests: logging.warning('No Python tests to run with current args.') return base_test_result.TestRunResults() test_names = [t.qualified_name for t in available_tests] logging.debug('Final list of tests to run: ' + str(test_names)) # Copy files to each device before running any tests. for device_id in attached_devices: logging.debug('Pushing files to device %s', device_id) test_pkg = test_package.TestPackage(options.test_apk_path, options.test_apk_jar_path) test_files_copier = test_runner.TestRunner(options, device_id, 0, test_pkg, []) test_files_copier.InstallTestPackage() if options.push_deps: logging.info('Pushing data deps to device.') test_files_copier.PushDataDeps() else: logging.warning('Skipping pushing data deps to device.') # Actually run the tests. if len(attached_devices) > 1 and options.wait_for_debugger: logging.warning('Debugger can not be sharded, ' 'using first available device') attached_devices = attached_devices[:1] logging.debug('Running Python tests') sharder = PythonTestSharder(attached_devices, available_tests, options) test_results = sharder.RunShardedTests() return test_results
def ProvisionDevices(options): if options.device is not None: devices = [options.device] else: devices = android_commands.GetAttachedDevices() for device in devices: android_cmd = android_commands.AndroidCommands(device) android_cmd.RunShellCommand('su -c date -u %f' % time.time()) if options.auto_reconnect: PushAndLaunchAdbReboot(devices, options.target)
def setUp(self): devices = android_commands.GetAttachedDevices() self.browser = 'stable' self.package_info = profiler.GetSupportedBrowsers()[self.browser] self.device = device_utils.DeviceUtils(devices[0]) adb = android_commands.AndroidCommands(devices[0]) adb.StartActivity(self.package_info.package, self.package_info.activity, wait_for_completion=True)
def EnumerateDevices(self): # If a custom adb_path has been setup through settings, prepend that to the # PATH. The android_commands module will use that to locate adb. if (self.settings['adb_path'] and not os.environ['PATH'].startswith(self.settings['adb_path'])): os.environ['PATH'] = os.pathsep.join([self.settings['adb_path'], os.environ['PATH']]) for device in android_commands.GetAttachedDevices(): yield AndroidDevice( self, android_commands.AndroidCommands(device, api_strict_mode=True))
def setUp(self): devices = android_commands.GetAttachedDevices() self.browser = 'stable' self.package_info = profiler.GetSupportedBrowsers()[self.browser] self.device = device_utils.DeviceUtils(devices[0]) self.device.StartActivity(intent.Intent( activity=self.package_info.activity, package=self.package_info.package), blocking=True)
def main(): while True: try: devices = android_commands.GetAttachedDevices() for device in devices: android_cmd = android_commands.AndroidCommands(device) android_cmd.RunShellCommand('touch /sdcard/host_heartbeat') except: # Keep the heatbeat running bypassing all errors. pass time.sleep(PULSE_PERIOD)
def GlobalSetUp(): ChromeDriverTest._http_server = webserver.WebServer( chrome_paths.GetTestData()) ChromeDriverTest._sync_server = webserver.SyncWebServer() if _ANDROID_PACKAGE_KEY: ChromeDriverTest._device = device_utils.DeviceUtils( android_commands.GetAttachedDevices()[0]) http_host_port = ChromeDriverTest._http_server._server.server_port sync_host_port = ChromeDriverTest._sync_server._server.server_port forwarder.Forwarder.Map( [(http_host_port, http_host_port), (sync_host_port, sync_host_port)], ChromeDriverTest._device)
def main(): while True: try: devices = android_commands.GetAttachedDevices() for device_serial in devices: device_utils.DeviceUtils( device_serial).old_interface.RunShellCommand( 'touch /sdcard/host_heartbeat') except: # Keep the heatbeat running bypassing all errors. pass time.sleep(PULSE_PERIOD)