# 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/.
import argparse
import logging
import subprocess
import sys
from datetime
import datetime, timedelta
from operator
import itemgetter
from mach.decorators
import Command, CommandArgument, SubCommand
from mozbuild.base
import MozbuildObject
def _get_busted_bugs(payload):
import requests
payload = dict(payload)
payload[
"include_fields"] =
"id,summary,last_change_time,resolution"
payload[
"blocks"] = 1543241
response = requests.get(
"https://bugzilla.mozilla.org/rest/bug", payload)
response.raise_for_status()
return response.json().get(
"bugs", [])
@Command(
"busted",
category=
"misc",
description=
"Query known bugs in our tooling, and file new ones.",
)
def busted_default(command_context):
unresolved = _get_busted_bugs({
"resolution":
"---"})
creation_time = datetime.now() - timedelta(days=15)
creation_time = creation_time.strftime(
"%Y-%m-%dT%H-%M-%SZ")
resolved = _get_busted_bugs({
"creation_time": creation_time})
resolved = [bug
for bug
in resolved
if bug[
"resolution"]]
all_bugs = sorted(
unresolved + resolved, key=itemgetter(
"last_change_time"), reverse=
True
)
if all_bugs:
for bug
in all_bugs:
print(
"[%s] Bug %s - %s"
% (
(
"UNRESOLVED"
if not bug[
"resolution"]
else "RESOLVED - %s" % bug[
"resolution"]
),
bug[
"id"],
bug[
"summary"],
)
)
else:
print(
"No known tooling issues found.")
@SubCommand(
"busted",
"file", description=
"File a bug for busted tooling.")
@CommandArgument(
"against",
help=(
"The specific mach command that is busted (i.e. if you encountered "
"an error with `mach build`, run `mach busted file build`). If "
"the issue is not connected to any particular mach command, you "
"can also run `mach busted file general`."
),
)
def busted_file(command_context, against):
import webbrowser
if (
against !=
"general"
and against
not in command_context._mach_context.commands.command_handlers
):
print(
"%s is not a valid value for `against`. `against` must be "
"the name of a `mach` command, or else the string "
'"general".' % against
)
return 1
if against ==
"general":
product =
"Firefox Build System"
component =
"General"
else:
import inspect
import mozpack.path
as mozpath
# Look up the file implementing that command, then cross-refernce
# moz.build files to get the product/component.
handler = command_context._mach_context.commands.command_handlers[against]
sourcefile = mozpath.relpath(
inspect.getsourcefile(handler.func), command_context.topsrcdir
)
reader = command_context.mozbuild_reader(config_mode=
"empty")
try:
res = reader.files_info([sourcefile])[sourcefile][
"BUG_COMPONENT"]
product, component = res.product, res.component
except TypeError:
# The file might not have a bug set.
product =
"Firefox Build System"
component =
"General"
uri = (
"https://bugzilla.mozilla.org/enter_bug.cgi?"
"product=%s&component=%s&blocked=1543241" % (product, component)
)
webbrowser.open_new_tab(uri)
MACH_PASTEBIN_DURATIONS = {
"onetime":
"onetime",
"hour":
"3600",
"day":
"86400",
"week":
"604800",
"month":
"2073600",
}
EXTENSION_TO_HIGHLIGHTER = {
".hgrc":
"ini",
"Dockerfile":
"docker",
"Makefile":
"make",
"applescript":
"applescript",
"arduino":
"arduino",
"bash":
"bash",
"bat":
"bat",
"c":
"c",
"clojure":
"clojure",
"cmake":
"cmake",
"coffee":
"coffee-script",
"console":
"console",
"cpp":
"cpp",
"cs":
"csharp",
"css":
"css",
"cu":
"cuda",
"cuda":
"cuda",
"dart":
"dart",
"delphi":
"delphi",
"diff":
"diff",
"django":
"django",
"docker":
"docker",
"elixir":
"elixir",
"erlang":
"erlang",
"go":
"go",
"h":
"c",
"handlebars":
"handlebars",
"haskell":
"haskell",
"hs":
"haskell",
"html":
"html",
"ini":
"ini",
"ipy":
"ipythonconsole",
"ipynb":
"ipythonconsole",
"irc":
"irc",
"j2":
"django",
"java":
"java",
"js":
"js",
"json":
"json",
"jsx":
"jsx",
"kt":
"kotlin",
"less":
"less",
"lisp":
"common-lisp",
"lsp":
"common-lisp",
"lua":
"lua",
"m":
"objective-c",
"make":
"make",
"matlab":
"matlab",
"md":
"_markdown",
"nginx":
"nginx",
"numpy":
"numpy",
"patch":
"diff",
"perl":
"perl",
"php":
"php",
"pm":
"perl",
"postgresql":
"postgresql",
"py":
"python",
"rb":
"rb",
"rs":
"rust",
"rst":
"rst",
"sass":
"sass",
"scss":
"scss",
"sh":
"bash",
"sol":
"sol",
"sql":
"sql",
"swift":
"swift",
"tex":
"tex",
"typoscript":
"typoscript",
"vim":
"vim",
"xml":
"xml",
"xslt":
"xslt",
"yaml":
"yaml",
"yml":
"yaml",
}
def guess_highlighter_from_path(path):
"""Return a known highlighter from a given path
Attempt to select a highlighter by checking the file extension
in the mapping
of extensions to highlighter.
If that fails, attempt to
pass the basename of
the file.
Return `_code`
as the default highlighter
if that fails.
"""
import os
_name, ext = os.path.splitext(path)
if ext.startswith(
"."):
ext = ext[1:]
if ext
in EXTENSION_TO_HIGHLIGHTER:
return EXTENSION_TO_HIGHLIGHTER[ext]
basename = os.path.basename(path)
return EXTENSION_TO_HIGHLIGHTER.get(basename,
"_code")
PASTEMO_MAX_CONTENT_LENGTH = 250 * 1024 * 1024
PASTEMO_URL =
"https://paste.mozilla.org/api/"
@Command(
"pastebin",
category=
"misc",
description=
"Command line interface to paste.mozilla.org.",
)
@CommandArgument(
"--list-highlighters",
action=
"store_true",
help=
"List known highlighters and exit",
)
@CommandArgument(
"--highlighter", default=
None, help=
"Syntax highlighting to use for paste"
)
@CommandArgument(
"--expires",
default=
"week",
choices=sorted(MACH_PASTEBIN_DURATIONS.keys()),
help=
"Expire paste after given time duration (default: %(default)s)",
)
@CommandArgument(
"--verbose",
action=
"store_true",
help=
"Print extra info such as selected syntax highlighter",
)
@CommandArgument(
"path",
nargs=
"?",
default=
None,
help=
"Path to file for upload to paste.mozilla.org",
)
def pastebin(command_context, list_highlighters, highlighter, expires, verbose, path):
"""Command line interface to `paste.mozilla.org`.
Takes either a filename whose content should be pasted,
or reads
content
from standard input.
If a highlighter
is specified it will
be used, otherwise the file name will be used to determine an
appropriate highlighter.
"""
import requests
def verbose_print(*args, **kwargs):
"""Print a string if `--verbose` flag is set"""
if verbose:
print(*args, **kwargs)
# Show known highlighters and exit.
if list_highlighters:
lexers = set(EXTENSION_TO_HIGHLIGHTER.values())
print(
"Available lexers:\n - %s" %
"\n - ".join(sorted(lexers)))
return 0
# Get a correct expiry value.
try:
verbose_print(
"Setting expiry from %s" % expires)
expires = MACH_PASTEBIN_DURATIONS[expires]
verbose_print(
"Using %s as expiry" % expires)
except KeyError:
print(
"%s is not a valid duration.\n"
"(hint: try one of %s)"
% (expires,
", ".join(MACH_PASTEBIN_DURATIONS.keys()))
)
return 1
data = {
"format":
"json",
"expires": expires,
}
# Get content to be pasted.
if path:
verbose_print(
"Reading content from %s" % path)
try:
with open(path,
"r")
as f:
content = f.read()
except IOError:
print(
"ERROR. No such file %s" % path)
return 1
lexer = guess_highlighter_from_path(path)
if lexer:
data[
"lexer"] = lexer
else:
verbose_print(
"Reading content from stdin")
content = sys.stdin.read()
# Assert the length of content to be posted does not exceed the maximum.
content_length = len(content)
verbose_print(
"Checking size of content is okay (%d)" % content_length)
if content_length > PASTEMO_MAX_CONTENT_LENGTH:
print(
"Paste content is too large (%d, maximum %d)"
% (content_length, PASTEMO_MAX_CONTENT_LENGTH)
)
return 1
data[
"content"] = content
# Highlight as specified language, overwriting value set from filename.
if highlighter:
verbose_print(
"Setting %s as highlighter" % highlighter)
data[
"lexer"] = highlighter
try:
verbose_print(
"Sending request to %s" % PASTEMO_URL)
resp = requests.post(PASTEMO_URL, data=data)
# Error code should always be 400.
# Response content will include a helpful error message,
# so print it here (for example, if an invalid highlighter is
# provided, it will return a list of valid highlighters).
if resp.status_code >= 400:
print(
"Error code %d: %s" % (resp.status_code, resp.content))
return 1
verbose_print(
"Pasted successfully")
response_json = resp.json()
verbose_print(
"Paste highlighted as %s" % response_json[
"lexer"])
print(response_json[
"url"])
return 0
except Exception
as e:
print(
"ERROR. Paste failed.")
print(
"%s" % e)
return 1
class PypiBasedTool:
"""
Helper
for loading a tool that
is hosted on pypi. The package
is expected
to expose a `mach_interface` module which has `new_release_on_pypi`,
`parser`,
and `run` functions.
"""
def __init__(self, module_name, pypi_name=
None):
self.name = module_name
self.pypi_name = pypi_name
or module_name
def _
import(self):
# Lazy loading of the tools mach interface.
# Note that only the mach_interface module should be used from this file.
import importlib
try:
return importlib.import_module(
"%s.mach_interface" % self.name)
except ImportError:
return None
def create_parser(self, subcommand=
None):
# Create the command line parser.
# If the tool is not installed, or not up to date, it will
# first be installed.
cmd = MozbuildObject.from_environment()
cmd.activate_virtualenv()
tool = self._
import()
if not tool:
# The tool is not here at all, install it
cmd.virtualenv_manager.install_pip_package(self.pypi_name)
print(
"%s was installed. please re-run your"
" command. If you keep getting this message please "
" manually run: 'pip install -U %s'." % (self.pypi_name, self.pypi_name)
)
else:
# Check if there is a new release available
release = tool.new_release_on_pypi()
if release:
print(release)
# there is one, so install it. Note that install_pip_package
# does not work here, so just run pip directly.
subprocess.check_call(
[
cmd.virtualenv_manager.python_path,
"-m",
"pip",
"install",
f
"{self.pypi_name}=={release}",
]
)
print(
"%s was updated to version %s. please"
" re-run your command." % (self.pypi_name, release)
)
else:
# Tool is up to date, return the parser.
if subcommand:
return tool.parser(subcommand)
else:
return tool.parser()
# exit if we updated or installed mozregression because
# we may have already imported mozregression and running it
# as this may cause issues.
sys.exit(0)
def run(self, **options):
tool = self._
import()
tool.run(options)
def mozregression_create_parser():
# Create the mozregression command line parser.
# if mozregression is not installed, or not up to date, it will
# first be installed.
loader = PypiBasedTool(
"mozregression")
return loader.create_parser()
@Command(
"mozregression",
category=
"misc",
description=
"Regression range finder for nightly and inbound builds.",
parser=mozregression_create_parser,
)
def run(command_context, **options):
command_context.activate_virtualenv()
mozregression = PypiBasedTool(
"mozregression")
mozregression.run(**options)
@Command(
"node",
category=
"devenv",
description=
"Run the NodeJS interpreter used for building.",
)
@CommandArgument(
"args", nargs=argparse.REMAINDER)
def node(command_context, args):
from mozbuild.nodeutil
import find_node_executable
# Avoid logging the command
command_context.log_manager.terminal_handler.setLevel(logging.CRITICAL)
node_path, _ = find_node_executable()
return command_context.run_process(
[node_path] + args,
pass_thru=
True,
# Allow user to run Node interactively.
ensure_exit_code=
False,
# Don't throw on non-zero exit code.
)
@Command(
"npm",
category=
"devenv",
description=
"Run the npm executable from the NodeJS used for building.",
)
@CommandArgument(
"args", nargs=argparse.REMAINDER)
def npm(command_context, args):
from mozbuild.nodeutil
import find_npm_executable
# Avoid logging the command
command_context.log_manager.terminal_handler.setLevel(logging.CRITICAL)
import os
# Add node and npm from mozbuild to front of system path
#
# This isn't pretty, but npm currently executes itself with
# `#!/usr/bin/env node`, which means it just uses the node in the
# current PATH. As a result, stuff gets built wrong and installed
# in the wrong places and probably other badness too without this:
npm_path, _ = find_npm_executable()
if not npm_path:
exit(-1,
"could not find npm executable")
path = os.path.abspath(os.path.dirname(npm_path))
os.environ[
"PATH"] =
"{}{}{}".format(path, os.pathsep, os.environ[
"PATH"])
# karma-firefox-launcher needs the path to firefox binary.
firefox_bin = command_context.get_binary_path(validate_exists=
False)
if os.path.exists(firefox_bin):
os.environ[
"FIREFOX_BIN"] = firefox_bin
return command_context.run_process(
[npm_path,
"--scripts-prepend-node-path=auto"] + args,
pass_thru=
True,
# Avoid eating npm output/error messages
ensure_exit_code=
False,
# Don't throw on non-zero exit code.
)
def logspam_create_parser(subcommand):
# Create the logspam command line parser.
# if logspam is not installed, or not up to date, it will
# first be installed.
loader = PypiBasedTool(
"logspam",
"mozilla-log-spam")
return loader.create_parser(subcommand)
from functools
import partial
@Command(
"logspam",
category=
"misc",
description=
"Warning categorizer for treeherder test runs.",
)
def logspam(command_context):
pass
@SubCommand(
"logspam",
"report", parser=partial(logspam_create_parser,
"report"))
def report(command_context, **options):
command_context.activate_virtualenv()
logspam = PypiBasedTool(
"logspam")
logspam.run(command=
"report", **options)
@SubCommand(
"logspam",
"bisect", parser=partial(logspam_create_parser,
"bisect"))
def bisect(command_context, **options):
command_context.activate_virtualenv()
logspam = PypiBasedTool(
"logspam")
logspam.run(command=
"bisect", **options)
@SubCommand(
"logspam",
"file", parser=partial(logspam_create_parser,
"file"))
def create(command_context, **options):
command_context.activate_virtualenv()
logspam = PypiBasedTool(
"logspam")
logspam.run(command=
"file", **options)
# mots_loader will be used when running commands and subcommands, as well as
# when creating the parsers.
mots_loader = PypiBasedTool(
"mots")
def mots_create_parser(subcommand=
None):
return mots_loader.create_parser(subcommand)
def mots_run_subcommand(command, command_context, **options):
command_context.activate_virtualenv()
mots_loader.run(command=command, **options)
class motsSubCommand(SubCommand):
"""A helper subclass that reduces repitition when defining subcommands."""
def __init__(self, subcommand):
super().__init__(
"mots",
subcommand,
parser=partial(mots_create_parser, subcommand),
)
@Command(
"mots",
category=
"misc",
description=
"Manage module information in-tree using the mots CLI.",
parser=mots_create_parser,
)
def mots(command_context, **options):
"""The main mots command call."""
command_context.activate_virtualenv()
mots_loader.run(**options)
# Define subcommands that will be proxied through mach.
for sc
in (
"clean",
"check-hashes",
"export",
"export-and-clean",
"module",
"query",
"settings",
"user",
"validate",
):
# Pass through args and kwargs, but add the subcommand string as the first argument.
motsSubCommand(sc)(
lambda *a, **kw: mots_run_subcommand(sc, *a, **kw))
