blob: 025a50cd2b1302bcd0f122f157d09edb8f2188d4 [file] [log] [blame]
#!/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.
from __future__ import print_function
import argparse
import json
import logging
import os
import re
import shutil
import subprocess
import sys
import tempfile
import threading
import time
from collections import namedtuple
from hooks import install
from py_utils import binary_manager
from py_utils import dependency_util
from py_utils import xvfb
# Path to dependency manager config containing chrome binary data.
CHROME_BINARIES_CONFIG = dependency_util.ChromeBinariesConfigPath()
CHROME_CONFIG_URL = (
'https://code.google.com/p/chromium/codesearch#chromium/src/third_party/'
'catapult/py_utils/py_utils/chrome_binaries.json')
# Default port to run on if not auto-assigning from OS
DEFAULT_PORT = '8111'
_TIMEOUT_RETURNCODE = 124
# Mapping of sys.platform -> platform-specific names and paths.
PLATFORM_MAPPING = {
'linux2': {
'omaha': 'linux',
'prefix': 'Linux_x64',
'zip_prefix': 'linux',
'chromepath': 'chrome-linux/chrome'
},
'win32': {
'omaha': 'win',
'prefix': 'Win',
'zip_prefix': 'win32',
'chromepath': 'chrome-win32\\chrome.exe',
},
'darwin': {
'omaha': 'mac',
'prefix': 'Mac',
'zip_prefix': 'mac',
'chromepath': ('chrome-mac/Chrome.app/Contents/MacOS/Chrome'),
'version_path': 'chrome-mac/Chrome.app/Contents/Versions/',
'additional_paths': [
('chrome-mac/Chrome.app/Contents/Versions/%VERSION%/'
'Chrome Helper.app/Contents/MacOS/Chrome Helper'),
],
},
}
class ChromeNotFound(Exception):
pass
def IsDepotToolsPath(path):
return os.path.isfile(os.path.join(path, 'gclient'))
def FindDepotTools():
# Check if depot_tools is already in PYTHONPATH
for path in sys.path:
if path.rstrip(os.sep).endswith('depot_tools') and IsDepotToolsPath(path):
return path
# Check if depot_tools is in the path
for path in os.environ['PATH'].split(os.pathsep):
if IsDepotToolsPath(path):
return path.rstrip(os.sep)
return None
def GetLocalChromePath(path_from_command_line):
if path_from_command_line:
return path_from_command_line
if sys.platform == 'darwin': # Mac
chrome_path = (
'/Applications/Google Chrome.app/Contents/MacOS/Google Chrome')
if os.path.isfile(chrome_path):
return chrome_path
elif sys.platform.startswith('linux'):
found = False
try:
with open(os.devnull, 'w') as devnull:
found = subprocess.call(['google-chrome', '--version'],
stdout=devnull, stderr=devnull) == 0
except OSError:
pass
if found:
return 'google-chrome'
elif sys.platform == 'win32':
search_paths = [os.getenv('PROGRAMFILES(X86)'),
os.getenv('PROGRAMFILES'),
os.getenv('LOCALAPPDATA')]
chrome_path = os.path.join('Google', 'Chrome', 'Application', 'chrome.exe')
for search_path in search_paths:
test_path = os.path.join(search_path, chrome_path)
if os.path.isfile(test_path):
return test_path
return None
ChromeInfo = namedtuple('ChromeInfo', 'path, version')
def GetChromeInfo(args):
"""Finds chrome either locally or remotely and returns path and version info.
Version is not reported if local chrome is used.
"""
if args.use_local_chrome:
chrome_path = GetLocalChromePath(args.chrome_path)
if not chrome_path:
raise ChromeNotFound('Could not find chrome locally. You can supply it '
'manually using --chrome_path')
return ChromeInfo(path=chrome_path, version=None)
channel = args.channel
if sys.version_info.major == 3:
target = 'linux'
else:
target = 'linux2'
if sys.platform == target and channel == 'canary':
channel = 'dev'
assert channel in ['stable', 'beta', 'dev', 'canary']
binary = 'chrome'
print('Fetching the', channel, binary, 'binary via the binary_manager.')
chrome_manager = binary_manager.BinaryManager([CHROME_BINARIES_CONFIG])
os_name, arch = dependency_util.GetOSAndArchForCurrentDesktopPlatform()
chrome_path, version = chrome_manager.FetchPathWithVersion(
'%s_%s' % (binary, channel), os_name, arch)
print('Finished fetching the', binary, 'binary to', chrome_path)
return ChromeInfo(path=chrome_path, version=version)
def KillProcess(process):
"""Kills process on all platform, including windows."""
if sys.platform == 'win32':
# Use taskkill on Windows to make sure process and all its subprocesses are
# killed.
subprocess.call(['taskkill', '/F', '/T', '/PID', str(process.pid)])
else:
process.kill()
def RunTests(args, chrome_path):
"""Runs tests and returns dev server return code.
Returns _TIMEOUT_RETURNCODE if tests exceed args.timeout_sec.
"""
user_data_dir = None
xvfb_process = None
chrome_process = None
server_process = None
timer = None
test_start_time = time.time()
try:
user_data_dir = tempfile.mkdtemp()
server_path = os.path.join(os.path.dirname(
os.path.abspath(__file__)), os.pardir, 'bin', 'run_dev_server')
# TODO(anniesullie): Make OS selection of port work on Windows. See #1235.
if sys.platform == 'win32':
port = DEFAULT_PORT
else:
port = '0'
server_command = [server_path, '--no-install-hooks', '--port', port]
if sys.platform.startswith('win'):
server_command = ['python.exe'] + server_command
print('Starting dev_server...')
server_process = subprocess.Popen(
server_command, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
bufsize=1)
time.sleep(1)
if sys.platform != 'win32':
output = server_process.stderr.readline()
port = re.search(
r'Now running on http://127.0.0.1:([\d]+)',
output.decode('utf-8')).group(1)
if xvfb.ShouldStartXvfb():
print('Starting xvfb...')
xvfb_process = xvfb.StartXvfb()
chrome_command = [
chrome_path,
'--user-data-dir=%s' % user_data_dir,
'--no-sandbox',
'--no-experiments',
'--no-first-run',
'--noerrdialogs',
'--window-size=1280,1024',
'--enable-logging', '--v=1',
'--enable-features=ForceWebRequestProxyForTest',
'--force-device-scale-factor=1',
'--use-mock-keychain',
]
if args.extra_chrome_args:
chrome_command.extend(args.extra_chrome_args.strip('"').split(' '))
chrome_command.append(
('http://localhost:%s/%s/tests.html?' % (port, args.tests)) +
'headless=true&testTypeToRun=all')
print('Starting Chrome at path %s...' % chrome_path)
chrome_process = subprocess.Popen(
chrome_command, stdout=sys.stdout, stderr=sys.stderr)
print('Chrome process command:', ' '.join(chrome_command))
print('Waiting for tests to finish...')
def KillServer():
print('Timeout reached. Killing dev server...')
KillProcess(server_process)
timer = threading.Timer(args.timeout_sec, KillServer)
timer.start()
server_out, server_err = server_process.communicate()
timed_out = not timer.is_alive()
timer.cancel()
# There is a very unlikely case where you see server saying "ALL_PASSED"
# but the test still saying "timed out". This usually happens because the
# server takes about a second to exit after printing "ALL_PASSED", and it
# can time out within that time. Looking at the server returncode can help
# here. The timeout should be increased if we're hitting this case.
print("Server return code:", server_process.returncode)
logging.error('Server stdout:\n%s', server_out)
logging.error('Server stderr:\n%s', server_err)
if timed_out:
print('Tests did not finish before', args.timeout_sec, 'seconds')
return _TIMEOUT_RETURNCODE
if server_process.returncode == 0:
print("Tests passed in %.2f seconds." % (time.time() - test_start_time))
else:
logging.error('Tests failed!')
return server_process.returncode
finally:
if timer:
timer.cancel()
if server_process and server_process.poll is None:
# Dev server is still running. Kill it.
print('Killing dev server...')
KillProcess(server_process)
if chrome_process:
print('Killing Chrome...')
KillProcess(chrome_process)
# Wait for Chrome to be killed before deleting temp Chrome dir. Only have
# this timing issue on Windows.
if sys.platform == 'win32':
time.sleep(5)
if user_data_dir:
chrome_debug_logs = os.path.join(user_data_dir, 'chrome_debug.log')
if os.path.exists(chrome_debug_logs):
with open(chrome_debug_logs) as f:
print('-------- chrome_debug.log --------')
sys.stdout.write(f.read())
print('-------- ---------------- --------')
print('Chrome debug logs printed from', chrome_debug_logs)
try:
shutil.rmtree(user_data_dir)
except OSError as e:
logging.error('Error cleaning up temp dirs %s: %s', user_data_dir, e)
if xvfb_process:
KillProcess(xvfb_process)
def Main(argv):
parser = argparse.ArgumentParser(
description='Run dev_server tests for a project.')
parser.add_argument('--chrome_path', type=str,
help='Path to Chrome browser binary.')
parser.add_argument('--no-use-local-chrome',
dest='use_local_chrome', action='store_false',
help='Use chrome binary fetched from cloud storage '
'instead of chrome available on the system.')
parser.add_argument(
'--no-install-hooks', dest='install_hooks', action='store_false')
parser.add_argument('--tests', type=str,
help='Set of tests to run (tracing or perf_insights)')
parser.add_argument('--channel', type=str, default='stable',
help='Chrome channel to run (stable or canary)')
parser.add_argument('--presentation-json', type=str,
help='Recipe presentation-json output file path')
parser.add_argument('--timeout-sec', type=float, default=float('inf'),
help='Timeout for running all tests, in seconds')
parser.add_argument('--timeout-retries', type=int, default=0,
help='Number of times to retry if tests time out.'
'Default 0 (no retries)')
parser.add_argument('--extra-chrome-args', type=str,
help='Extra args to pass to chrome.')
parser.set_defaults(install_hooks=True)
parser.set_defaults(use_local_chrome=True)
args = parser.parse_args(argv[1:])
# TODO(crbug.com/1132884) Test consistently fails with canary channel on Mac.
if args.channel == 'canary' and sys.platform == 'darwin':
print ('Skipping canary channel tests on MacOS')
sys.exit(0)
if args.install_hooks:
install.InstallHooks()
chrome_info = GetChromeInfo(args)
print('Using chrome at path', chrome_info.path)
if not args.use_local_chrome:
print ('Chrome version', chrome_info.version, '| channel ', args.channel)
attempts_left = max(0, args.timeout_retries) + 1
return_code = None
while attempts_left:
print(attempts_left, 'attempts left. Running tests...')
return_code = RunTests(args, chrome_info.path)
if return_code == _TIMEOUT_RETURNCODE:
attempts_left -= 1
continue
break
else:
logging.error('Tests timed out every time. Retried %d times.',
args.timeout_retries)
return_code = 1
if args.presentation_json:
with open(args.presentation_json, 'w') as recipe_out:
# Add a link to the buildbot status for the step saying which version
# of Chrome the test ran on. The actual linking feature is not used,
# but there isn't a way to just add text.
link_name = 'Chrome Version %s' % chrome_info.version
presentation_info = {'links': {link_name: CHROME_CONFIG_URL}}
json.dump(presentation_info, recipe_out)
sys.exit(return_code)