зеркало из https://github.com/mozilla/gecko-dev.git
692 строки
23 KiB
Python
692 строки
23 KiB
Python
# This Source Code Form is subject to the terms of the Mozilla Public
|
|
# License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
|
|
r"""Make it easy to install and run [browsertime](https://github.com/sitespeedio/browsertime).
|
|
|
|
Browsertime is a harness for running performance tests, similar to
|
|
Mozilla's Raptor testing framework. Browsertime is written in Node.js
|
|
and uses Selenium WebDriver to drive multiple browsers including
|
|
Chrome, Chrome for Android, Firefox, and (pending the resolution of
|
|
[Bug 1525126](https://bugzilla.mozilla.org/show_bug.cgi?id=1525126)
|
|
and similar tickets) Firefox for Android and GeckoView-based vehicles.
|
|
|
|
Right now a custom version of browsertime and the underlying
|
|
geckodriver binary are needed to support GeckoView-based vehicles;
|
|
this module accommodates those in-progress custom versions.
|
|
|
|
To get started, run
|
|
```
|
|
./mach browsertime --setup [--clobber]
|
|
```
|
|
This will populate `tools/browsertime/node_modules`.
|
|
|
|
To invoke browsertime, run
|
|
```
|
|
./mach browsertime [ARGS]
|
|
```
|
|
All arguments are passed through to browsertime.
|
|
"""
|
|
|
|
from __future__ import absolute_import, print_function, unicode_literals
|
|
|
|
import argparse
|
|
import collections
|
|
import contextlib
|
|
import json
|
|
import logging
|
|
import os
|
|
import platform
|
|
import re
|
|
import stat
|
|
import subprocess
|
|
import sys
|
|
import time
|
|
|
|
import mozpack.path as mozpath
|
|
from mach.decorators import Command, CommandArgument
|
|
from mozbuild.base import BinaryNotFoundException, MachCommandBase
|
|
from mozbuild.util import mkdir
|
|
from six import StringIO
|
|
|
|
AUTOMATION = "MOZ_AUTOMATION" in os.environ
|
|
BROWSERTIME_ROOT = os.path.dirname(__file__)
|
|
|
|
PILLOW_VERSION = "8.4.0" # version 8.4.0 currently supports python 3.6 to 3.10
|
|
PYSSIM_VERSION = "0.4"
|
|
SCIPY_VERSION = "1.2.3"
|
|
NUMPY_VERSION = "1.16.1"
|
|
OPENCV_VERSION = "4.5.4.60"
|
|
|
|
py3_minor = sys.version_info.minor
|
|
if py3_minor > 7:
|
|
SCIPY_VERSION = "1.7.3"
|
|
NUMPY_VERSION = "1.22.0"
|
|
PILLOW_VERSION = "9.0.0"
|
|
|
|
MIN_NODE_VERSION = "16.0.0"
|
|
|
|
IS_APPLE_SILICON = sys.platform.startswith(
|
|
"darwin"
|
|
) and platform.processor().startswith("arm")
|
|
|
|
|
|
@contextlib.contextmanager
|
|
def silence():
|
|
oldout, olderr = sys.stdout, sys.stderr
|
|
try:
|
|
sys.stdout, sys.stderr = StringIO(), StringIO()
|
|
yield
|
|
finally:
|
|
sys.stdout, sys.stderr = oldout, olderr
|
|
|
|
|
|
def node_path(command_context):
|
|
import platform
|
|
from distutils.version import StrictVersion
|
|
|
|
from mozbuild.nodeutil import find_node_executable
|
|
|
|
state_dir = command_context._mach_context.state_dir
|
|
cache_path = os.path.join(state_dir, "browsertime", "node-16")
|
|
|
|
NODE_FAILURE_MSG = (
|
|
"Could not locate a node binary that is at least version {}. ".format(
|
|
MIN_NODE_VERSION
|
|
)
|
|
+ "Please run `./mach raptor --browsertime -t amazon` to install it "
|
|
+ "from the Taskcluster Toolchain artifacts."
|
|
)
|
|
|
|
# Check standard locations first
|
|
node_exe = find_node_executable(min_version=StrictVersion(MIN_NODE_VERSION))
|
|
if node_exe and (node_exe[0] is not None):
|
|
return os.path.abspath(node_exe[0])
|
|
if not os.path.exists(cache_path):
|
|
raise Exception(NODE_FAILURE_MSG)
|
|
|
|
# Check the browsertime-specific node location next
|
|
node_name = "node"
|
|
if platform.system() == "Windows":
|
|
node_name = "node.exe"
|
|
node_exe_path = os.path.join(
|
|
state_dir,
|
|
"browsertime",
|
|
"node-16",
|
|
"node",
|
|
)
|
|
else:
|
|
node_exe_path = os.path.join(
|
|
state_dir,
|
|
"browsertime",
|
|
"node-16",
|
|
"node",
|
|
"bin",
|
|
)
|
|
|
|
node_exe = os.path.join(node_exe_path, node_name)
|
|
if not os.path.exists(node_exe):
|
|
raise Exception(NODE_FAILURE_MSG)
|
|
|
|
return os.path.abspath(node_exe)
|
|
|
|
|
|
def package_path():
|
|
"""The path to the `browsertime` directory.
|
|
|
|
Override the default with the `BROWSERTIME` environment variable."""
|
|
override = os.environ.get("BROWSERTIME", None)
|
|
if override:
|
|
return override
|
|
|
|
return mozpath.join(BROWSERTIME_ROOT, "node_modules", "browsertime")
|
|
|
|
|
|
def browsertime_path():
|
|
"""The path to the `browsertime.js` script."""
|
|
# On Windows, invoking `node_modules/.bin/browsertime{.cmd}`
|
|
# doesn't work when invoked as an argument to our specific
|
|
# binary. Since we want our version of node, invoke the
|
|
# actual script directly.
|
|
return mozpath.join(package_path(), "bin", "browsertime.js")
|
|
|
|
|
|
def visualmetrics_path():
|
|
"""The path to the `visualmetrics.py` script."""
|
|
return mozpath.join(package_path(), "browsertime", "visualmetrics-portable.py")
|
|
|
|
|
|
def host_platform():
|
|
is_64bits = sys.maxsize > 2 ** 32
|
|
|
|
if sys.platform.startswith("win"):
|
|
if is_64bits:
|
|
return "win64"
|
|
elif sys.platform.startswith("linux"):
|
|
if is_64bits:
|
|
return "linux64"
|
|
elif sys.platform.startswith("darwin"):
|
|
return "darwin"
|
|
|
|
raise ValueError("sys.platform is not yet supported: {}".format(sys.platform))
|
|
|
|
|
|
# Map from `host_platform()` to a `fetch`-like syntax.
|
|
host_fetches = {
|
|
"darwin": {
|
|
"ffmpeg": {
|
|
"type": "static-url",
|
|
"url": "https://github.com/mozilla/perf-automation/releases/download/FFMPEG-v4.4.1/ffmpeg-macos.zip", # noqa
|
|
# An extension to `fetch` syntax.
|
|
"path": "ffmpeg-macos",
|
|
},
|
|
},
|
|
"linux64": {
|
|
"ffmpeg": {
|
|
"type": "static-url",
|
|
"url": "https://github.com/mozilla/perf-automation/releases/download/FFMPEG-v4.4.1/ffmpeg-4.4.1-i686-static.tar.xz", # noqa
|
|
# An extension to `fetch` syntax.
|
|
"path": "ffmpeg-4.4.1-i686-static",
|
|
},
|
|
},
|
|
"win64": {
|
|
"ffmpeg": {
|
|
"type": "static-url",
|
|
"url": "https://github.com/mozilla/perf-automation/releases/download/FFMPEG-v4.4.1/ffmpeg-4.4.1-full_build.zip", # noqa
|
|
# An extension to `fetch` syntax.
|
|
"path": "ffmpeg-4.4.1-full_build",
|
|
},
|
|
},
|
|
}
|
|
|
|
|
|
def artifact_cache_path(command_context):
|
|
r"""Downloaded artifacts will be kept here."""
|
|
# The convention is $MOZBUILD_STATE_PATH/cache/$FEATURE.
|
|
return mozpath.join(command_context._mach_context.state_dir, "cache", "browsertime")
|
|
|
|
|
|
def state_path(command_context):
|
|
r"""Unpacked artifacts will be kept here."""
|
|
# The convention is $MOZBUILD_STATE_PATH/$FEATURE.
|
|
return mozpath.join(command_context._mach_context.state_dir, "browsertime")
|
|
|
|
|
|
def setup_prerequisites(command_context):
|
|
r"""Install browsertime and visualmetrics.py prerequisites."""
|
|
|
|
from mozbuild.action.tooltool import unpack_file
|
|
from mozbuild.artifact_cache import ArtifactCache
|
|
|
|
# Download the visualmetrics-portable.py requirements.
|
|
artifact_cache = ArtifactCache(
|
|
artifact_cache_path(command_context),
|
|
log=command_context.log,
|
|
skip_cache=False,
|
|
)
|
|
|
|
fetches = host_fetches[host_platform()]
|
|
for tool, fetch in sorted(fetches.items()):
|
|
archive = artifact_cache.fetch(fetch["url"])
|
|
# TODO: assert type, verify sha256 (and size?).
|
|
|
|
if fetch.get("unpack", True):
|
|
cwd = os.getcwd()
|
|
try:
|
|
mkdir(state_path(command_context))
|
|
os.chdir(state_path(command_context))
|
|
command_context.log(
|
|
logging.INFO,
|
|
"browsertime",
|
|
{"path": archive},
|
|
"Unpacking temporary location {path}",
|
|
)
|
|
|
|
unpack_file(archive)
|
|
|
|
# Make sure the expected path exists after extraction
|
|
path = os.path.join(state_path(command_context), fetch.get("path"))
|
|
if not os.path.exists(path):
|
|
raise Exception("Cannot find an extracted directory: %s" % path)
|
|
|
|
try:
|
|
# Some archives provide binaries that don't have the
|
|
# executable bit set so we need to set it here
|
|
for root, dirs, files in os.walk(path):
|
|
for edir in dirs:
|
|
loc_to_change = os.path.join(root, edir)
|
|
st = os.stat(loc_to_change)
|
|
os.chmod(loc_to_change, st.st_mode | stat.S_IEXEC)
|
|
for efile in files:
|
|
loc_to_change = os.path.join(root, efile)
|
|
st = os.stat(loc_to_change)
|
|
os.chmod(loc_to_change, st.st_mode | stat.S_IEXEC)
|
|
except Exception as e:
|
|
raise Exception(
|
|
"Could not set executable bit in %s, error: %s" % (path, str(e))
|
|
)
|
|
finally:
|
|
os.chdir(cwd)
|
|
|
|
|
|
def setup_browsertime(
|
|
command_context,
|
|
should_clobber=False,
|
|
new_upstream_url="",
|
|
install_vismet_reqs=False,
|
|
):
|
|
r"""Install browsertime and visualmetrics.py prerequisites and the Node.js package."""
|
|
|
|
sys.path.append(mozpath.join(command_context.topsrcdir, "tools", "lint", "eslint"))
|
|
import setup_helper
|
|
|
|
if not new_upstream_url:
|
|
setup_prerequisites(command_context)
|
|
|
|
if new_upstream_url:
|
|
package_json_path = os.path.join(BROWSERTIME_ROOT, "package.json")
|
|
|
|
command_context.log(
|
|
logging.INFO,
|
|
"browsertime",
|
|
{
|
|
"new_upstream_url": new_upstream_url,
|
|
"package_json_path": package_json_path,
|
|
},
|
|
"Updating browsertime node module version in {package_json_path} "
|
|
"to {new_upstream_url}",
|
|
)
|
|
|
|
if not re.search("/tarball/[a-f0-9]{40}$", new_upstream_url):
|
|
raise ValueError(
|
|
"New upstream URL does not end with /tarball/[a-f0-9]{40}: '%s'"
|
|
% new_upstream_url
|
|
)
|
|
|
|
with open(package_json_path) as f:
|
|
existing_body = json.loads(
|
|
f.read(), object_pairs_hook=collections.OrderedDict
|
|
)
|
|
|
|
existing_body["devDependencies"]["browsertime"] = new_upstream_url
|
|
|
|
updated_body = json.dumps(existing_body)
|
|
|
|
with open(package_json_path, "w") as f:
|
|
f.write(updated_body)
|
|
|
|
# Install the browsertime Node.js requirements.
|
|
if not setup_helper.check_node_executables_valid():
|
|
return 1
|
|
|
|
# To use a custom `geckodriver`, set
|
|
# os.environ[b"GECKODRIVER_BASE_URL"] = bytes(url)
|
|
# to an endpoint with binaries named like
|
|
# https://github.com/sitespeedio/geckodriver/blob/master/install.js#L31.
|
|
if AUTOMATION:
|
|
os.environ["CHROMEDRIVER_SKIP_DOWNLOAD"] = "true"
|
|
os.environ["GECKODRIVER_SKIP_DOWNLOAD"] = "true"
|
|
|
|
if install_vismet_reqs:
|
|
# Hide this behind a flag so we don't install them by default in Raptor
|
|
command_context.log(
|
|
logging.INFO, "browsertime", {}, "Installing python requirements"
|
|
)
|
|
activate_browsertime_virtualenv(command_context)
|
|
|
|
command_context.log(
|
|
logging.INFO,
|
|
"browsertime",
|
|
{"package_json": mozpath.join(BROWSERTIME_ROOT, "package.json")},
|
|
"Installing browsertime node module from {package_json}",
|
|
)
|
|
|
|
# Add the mozbuild Node binary path to the OS environment in Apple Silicon.
|
|
# During the browesertime installation, it seems installation of sitespeed.io
|
|
# sub dependencies look for a global Node rather than the mozbuild Node binary.
|
|
# Normally `--scripts-prepend-node-path` should prevent this but it seems to still
|
|
# look for a system Node in the environment. This logic ensures the same Node is used.
|
|
node_dir = os.path.dirname(node_path(command_context))
|
|
if IS_APPLE_SILICON and node_dir not in os.environ["PATH"]:
|
|
os.environ["PATH"] += os.pathsep + node_dir
|
|
|
|
status = setup_helper.package_setup(
|
|
BROWSERTIME_ROOT,
|
|
"browsertime",
|
|
should_update=new_upstream_url != "",
|
|
should_clobber=should_clobber,
|
|
no_optional=new_upstream_url or AUTOMATION,
|
|
)
|
|
|
|
if status:
|
|
return status
|
|
if new_upstream_url or AUTOMATION:
|
|
return 0
|
|
if install_vismet_reqs:
|
|
return check(command_context)
|
|
|
|
return 0
|
|
|
|
|
|
def node(command_context, args):
|
|
r"""Invoke node (interactively) with the given arguments."""
|
|
return command_context.run_process(
|
|
[node_path(command_context)] + args,
|
|
append_env=append_env(command_context),
|
|
pass_thru=True, # Allow user to run Node interactively.
|
|
ensure_exit_code=False, # Don't throw on non-zero exit code.
|
|
cwd=mozpath.join(command_context.topsrcdir),
|
|
)
|
|
|
|
|
|
def append_env(command_context, append_path=True):
|
|
fetches = host_fetches[host_platform()]
|
|
|
|
# Ensure that `ffmpeg` is found and added to the environment
|
|
path = os.environ.get("PATH", "").split(os.pathsep) if append_path else []
|
|
path_to_ffmpeg = mozpath.join(
|
|
state_path(command_context), fetches["ffmpeg"]["path"]
|
|
)
|
|
|
|
path.insert(
|
|
0,
|
|
path_to_ffmpeg
|
|
if host_platform().startswith("linux")
|
|
else mozpath.join(path_to_ffmpeg, "bin"),
|
|
) # noqa
|
|
|
|
# Ensure that bare `node` and `npm` in scripts, including post-install
|
|
# scripts, finds the binary we're invoking with. Without this, it's
|
|
# easy for compiled extensions to get mismatched versions of the Node.js
|
|
# extension API.
|
|
node_dir = os.path.dirname(node_path(command_context))
|
|
path = [node_dir] + path
|
|
|
|
append_env = {
|
|
"PATH": os.pathsep.join(path),
|
|
# Bug 1560193: The JS library browsertime uses to execute commands
|
|
# (execa) will muck up the PATH variable and put the directory that
|
|
# node is in first in path. If this is globally-installed node,
|
|
# that means `/usr/bin` will be inserted first which means that we
|
|
# will get `/usr/bin/python` for `python`.
|
|
#
|
|
# Our fork of browsertime supports a `PYTHON` environment variable
|
|
# that points to the exact python executable to use.
|
|
"PYTHON": command_context.virtualenv_manager.python_path,
|
|
}
|
|
|
|
return append_env
|
|
|
|
|
|
def _need_install(command_context, package):
|
|
from pip._internal.req.constructors import install_req_from_line
|
|
|
|
req = install_req_from_line(package)
|
|
req.check_if_exists(use_user_site=False)
|
|
if req.satisfied_by is None:
|
|
return True
|
|
venv_site_lib = os.path.abspath(
|
|
os.path.join(command_context.virtualenv_manager.bin_path, "..", "lib")
|
|
)
|
|
site_packages = os.path.abspath(req.satisfied_by.location)
|
|
return not site_packages.startswith(venv_site_lib)
|
|
|
|
|
|
def activate_browsertime_virtualenv(command_context, *args, **kwargs):
|
|
r"""Activates virtualenv.
|
|
|
|
This function will also install Pillow and pyssim if needed.
|
|
It will raise an error in case the install failed.
|
|
"""
|
|
# TODO: Remove `./mach browsertime` completely, as a follow up to Bug 1758990
|
|
MachCommandBase.activate_virtualenv(command_context, *args, **kwargs)
|
|
|
|
# installing Python deps on the fly
|
|
for dep in (
|
|
"Pillow==%s" % PILLOW_VERSION,
|
|
"pyssim==%s" % PYSSIM_VERSION,
|
|
"scipy==%s" % SCIPY_VERSION,
|
|
"numpy==%s" % NUMPY_VERSION,
|
|
"opencv-python==%s" % OPENCV_VERSION,
|
|
):
|
|
if _need_install(command_context, dep):
|
|
subprocess.check_call(
|
|
[
|
|
command_context.virtualenv_manager.python_path,
|
|
"-m",
|
|
"pip",
|
|
"install",
|
|
dep,
|
|
]
|
|
)
|
|
|
|
|
|
def check(command_context):
|
|
r"""Run `visualmetrics.py --check`."""
|
|
command_context.activate_virtualenv()
|
|
|
|
args = ["--check"]
|
|
status = command_context.run_process(
|
|
[command_context.virtualenv_manager.python_path, visualmetrics_path()] + args,
|
|
# For --check, don't allow user's path to interfere with path testing except on Linux
|
|
append_env=append_env(
|
|
command_context, append_path=host_platform().startswith("linux")
|
|
),
|
|
pass_thru=True,
|
|
ensure_exit_code=False, # Don't throw on non-zero exit code.
|
|
cwd=mozpath.join(command_context.topsrcdir),
|
|
)
|
|
|
|
sys.stdout.flush()
|
|
sys.stderr.flush()
|
|
|
|
if status:
|
|
return status
|
|
|
|
# Avoid logging the command (and, on Windows, the environment).
|
|
command_context.log_manager.terminal_handler.setLevel(logging.CRITICAL)
|
|
print("browsertime version:", end=" ")
|
|
|
|
sys.stdout.flush()
|
|
sys.stderr.flush()
|
|
|
|
return node(command_context, [browsertime_path()] + ["--version"])
|
|
|
|
|
|
def extra_default_args(command_context, args=[]):
|
|
# Add Mozilla-specific default arguments. This is tricky because browsertime is quite
|
|
# loose about arguments; repeat arguments are generally accepted but then produce
|
|
# difficult to interpret type errors.
|
|
|
|
def extract_browser_name(args):
|
|
"Extracts the browser name if any"
|
|
# These are BT arguments, it's BT job to check them
|
|
# here we just want to extract the browser name
|
|
res = re.findall("(--browser|-b)[= ]([\w]+)", " ".join(args))
|
|
if res == []:
|
|
return None
|
|
return res[0][-1]
|
|
|
|
def matches(args, *flags):
|
|
"Return True if any argument matches any of the given flags (maybe with an argument)."
|
|
for flag in flags:
|
|
if flag in args or any(arg.startswith(flag + "=") for arg in args):
|
|
return True
|
|
return False
|
|
|
|
extra_args = []
|
|
|
|
# Default to Firefox. Override with `-b ...` or `--browser=...`.
|
|
specifies_browser = matches(args, "-b", "--browser")
|
|
if not specifies_browser:
|
|
extra_args.extend(("-b", "firefox"))
|
|
|
|
# Default to not collect HAR. Override with `--skipHar=false`.
|
|
specifies_har = matches(args, "--har", "--skipHar", "--gzipHar")
|
|
if not specifies_har:
|
|
extra_args.append("--skipHar")
|
|
|
|
if not matches(args, "--android"):
|
|
# If --firefox.binaryPath is not specified, default to the objdir binary
|
|
# Note: --firefox.release is not a real browsertime option, but it will
|
|
# silently ignore it instead and default to a release installation.
|
|
specifies_binaryPath = matches(
|
|
args,
|
|
"--firefox.binaryPath",
|
|
"--firefox.release",
|
|
"--firefox.nightly",
|
|
"--firefox.beta",
|
|
"--firefox.developer",
|
|
)
|
|
|
|
if not specifies_binaryPath:
|
|
specifies_binaryPath = extract_browser_name(args) == "chrome"
|
|
|
|
if not specifies_binaryPath:
|
|
try:
|
|
extra_args.extend(
|
|
("--firefox.binaryPath", command_context.get_binary_path())
|
|
)
|
|
except BinaryNotFoundException as e:
|
|
command_context.log(
|
|
logging.ERROR,
|
|
"browsertime",
|
|
{"error": str(e)},
|
|
"ERROR: {error}",
|
|
)
|
|
command_context.log(
|
|
logging.INFO,
|
|
"browsertime",
|
|
{},
|
|
"Please run |./mach build| "
|
|
"or specify a Firefox binary with --firefox.binaryPath.",
|
|
)
|
|
return 1
|
|
|
|
if extra_args:
|
|
command_context.log(
|
|
logging.DEBUG,
|
|
"browsertime",
|
|
{"extra_args": extra_args},
|
|
"Running browsertime with extra default arguments: {extra_args}",
|
|
)
|
|
|
|
return extra_args
|
|
|
|
|
|
def _verify_node_install(command_context):
|
|
# check if Node is installed
|
|
sys.path.append(mozpath.join(command_context.topsrcdir, "tools", "lint", "eslint"))
|
|
import setup_helper
|
|
|
|
with silence():
|
|
node_valid = setup_helper.check_node_executables_valid()
|
|
if not node_valid:
|
|
print("Can't find Node. did you run ./mach bootstrap ?")
|
|
return False
|
|
|
|
# check if the browsertime package has been deployed correctly
|
|
# for this we just check for the browsertime directory presence
|
|
if not os.path.exists(browsertime_path()):
|
|
print("Could not find browsertime.js, try ./mach browsertime --setup")
|
|
print("If that still fails, try ./mach browsertime --setup --clobber")
|
|
return False
|
|
|
|
return True
|
|
|
|
|
|
@Command(
|
|
"browsertime",
|
|
category="testing",
|
|
description="Run [browsertime](https://github.com/sitespeedio/browsertime) "
|
|
"performance tests.",
|
|
)
|
|
@CommandArgument(
|
|
"--verbose",
|
|
action="store_true",
|
|
help="Verbose output for what commands the build is running.",
|
|
)
|
|
@CommandArgument("--update-upstream-url", default="")
|
|
@CommandArgument("--setup", default=False, action="store_true")
|
|
@CommandArgument("--clobber", default=False, action="store_true")
|
|
@CommandArgument(
|
|
"--skip-cache",
|
|
default=False,
|
|
action="store_true",
|
|
help="Skip all local caches to force re-fetching remote artifacts.",
|
|
)
|
|
@CommandArgument("--check-browsertime", default=False, action="store_true")
|
|
@CommandArgument(
|
|
"--install-vismet-reqs",
|
|
default=False,
|
|
action="store_true",
|
|
help="Add this flag to get the visual metrics requirements installed.",
|
|
)
|
|
@CommandArgument(
|
|
"--browsertime-help",
|
|
default=False,
|
|
action="store_true",
|
|
help="Show the browsertime help message.",
|
|
)
|
|
@CommandArgument("args", nargs=argparse.REMAINDER)
|
|
def browsertime(
|
|
command_context,
|
|
args,
|
|
verbose=False,
|
|
update_upstream_url="",
|
|
setup=False,
|
|
clobber=False,
|
|
skip_cache=False,
|
|
check_browsertime=False,
|
|
browsertime_help=False,
|
|
install_vismet_reqs=False,
|
|
):
|
|
command_context._set_log_level(verbose)
|
|
|
|
# Output a message before going further to make sure the
|
|
# user knows that this tool is unsupported by the perftest
|
|
# team and point them to our supported tools. Pause a bit to
|
|
# make sure the user sees this message.
|
|
command_context.log(
|
|
logging.INFO,
|
|
"browsertime",
|
|
{},
|
|
"[INFO] This command should be used for browsertime setup only.\n"
|
|
"If you are looking to run performance tests on your patch, use "
|
|
"`./mach raptor --browsertime` instead.\n\nYou can get visual-metrics "
|
|
"by using the --browsertime-video and --browsertime-visualmetrics. "
|
|
"Here is a sample command for raptor-browsertime: \n\t`./mach raptor "
|
|
"--browsertime -t amazon --browsertime-video --browsertime-visualmetrics`\n\n"
|
|
"See this wiki page for more information if needed: "
|
|
"https://wiki.mozilla.org/TestEngineering/Performance/Raptor/Browsertime\n\n",
|
|
)
|
|
time.sleep(5)
|
|
|
|
if update_upstream_url:
|
|
return setup_browsertime(
|
|
command_context,
|
|
new_upstream_url=update_upstream_url,
|
|
install_vismet_reqs=install_vismet_reqs,
|
|
)
|
|
elif setup:
|
|
return setup_browsertime(
|
|
command_context,
|
|
should_clobber=clobber,
|
|
install_vismet_reqs=install_vismet_reqs,
|
|
)
|
|
else:
|
|
if not _verify_node_install(command_context):
|
|
return 1
|
|
|
|
if check_browsertime:
|
|
return check(command_context)
|
|
|
|
if browsertime_help:
|
|
args.append("--help")
|
|
|
|
activate_browsertime_virtualenv(command_context)
|
|
default_args = extra_default_args(command_context, args)
|
|
if default_args == 1:
|
|
return 1
|
|
return node(command_context, [browsertime_path()] + default_args + args)
|