679 lines
26 KiB
Python
679 lines
26 KiB
Python
#!/usr/bin/env python3
|
|
# Copyright (c) 2013 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.
|
|
|
|
|
|
"""Top-level presubmit script for Skia.
|
|
|
|
See http://dev.chromium.org/developers/how-tos/depottools/presubmit-scripts
|
|
for more details about the presubmit API built into gcl.
|
|
"""
|
|
|
|
import fnmatch
|
|
import os
|
|
import re
|
|
import subprocess
|
|
import sys
|
|
import traceback
|
|
|
|
|
|
RELEASE_NOTES_FILE_NAME = 'RELEASE_NOTES.txt'
|
|
|
|
GOLD_TRYBOT_URL = 'https://gold.skia.org/search?issue='
|
|
|
|
SERVICE_ACCOUNT_SUFFIX = [
|
|
'@%s.iam.gserviceaccount.com' % project for project in [
|
|
'skia-buildbots.google.com', 'skia-swarming-bots', 'skia-public',
|
|
'skia-corp.google.com', 'chops-service-accounts']]
|
|
|
|
USE_PYTHON3 = True
|
|
|
|
|
|
def _CheckChangeHasEol(input_api, output_api, source_file_filter=None):
|
|
"""Checks that files end with at least one \n (LF)."""
|
|
eof_files = []
|
|
for f in input_api.AffectedSourceFiles(source_file_filter):
|
|
contents = input_api.ReadFile(f, 'rb')
|
|
# Check that the file ends in at least one newline character.
|
|
if len(contents) > 1 and contents[-1:] != '\n':
|
|
eof_files.append(f.LocalPath())
|
|
|
|
if eof_files:
|
|
return [output_api.PresubmitPromptWarning(
|
|
'These files should end in a newline character:',
|
|
items=eof_files)]
|
|
return []
|
|
|
|
|
|
def _JsonChecks(input_api, output_api):
|
|
"""Run checks on any modified json files."""
|
|
failing_files = []
|
|
for affected_file in input_api.AffectedFiles(None):
|
|
affected_file_path = affected_file.LocalPath()
|
|
is_json = affected_file_path.endswith('.json')
|
|
is_metadata = (affected_file_path.startswith('site/') and
|
|
affected_file_path.endswith('/METADATA'))
|
|
if is_json or is_metadata:
|
|
try:
|
|
input_api.json.load(open(affected_file_path, 'r'))
|
|
except ValueError:
|
|
failing_files.append(affected_file_path)
|
|
|
|
results = []
|
|
if failing_files:
|
|
results.append(
|
|
output_api.PresubmitError(
|
|
'The following files contain invalid json:\n%s\n\n' %
|
|
'\n'.join(failing_files)))
|
|
return results
|
|
|
|
|
|
def _IfDefChecks(input_api, output_api):
|
|
"""Ensures if/ifdef are not before includes. See skbug/3362 for details."""
|
|
comment_block_start_pattern = re.compile('^\s*\/\*.*$')
|
|
comment_block_middle_pattern = re.compile('^\s+\*.*')
|
|
comment_block_end_pattern = re.compile('^\s+\*\/.*$')
|
|
single_line_comment_pattern = re.compile('^\s*//.*$')
|
|
def is_comment(line):
|
|
return (comment_block_start_pattern.match(line) or
|
|
comment_block_middle_pattern.match(line) or
|
|
comment_block_end_pattern.match(line) or
|
|
single_line_comment_pattern.match(line))
|
|
|
|
empty_line_pattern = re.compile('^\s*$')
|
|
def is_empty_line(line):
|
|
return empty_line_pattern.match(line)
|
|
|
|
failing_files = []
|
|
for affected_file in input_api.AffectedSourceFiles(None):
|
|
affected_file_path = affected_file.LocalPath()
|
|
if affected_file_path.endswith('.cpp') or affected_file_path.endswith('.h'):
|
|
f = open(affected_file_path)
|
|
for line in f:
|
|
if is_comment(line) or is_empty_line(line):
|
|
continue
|
|
# The below will be the first real line after comments and newlines.
|
|
if line.startswith('#if 0 '):
|
|
pass
|
|
elif line.startswith('#if ') or line.startswith('#ifdef '):
|
|
failing_files.append(affected_file_path)
|
|
break
|
|
|
|
results = []
|
|
if failing_files:
|
|
results.append(
|
|
output_api.PresubmitError(
|
|
'The following files have #if or #ifdef before includes:\n%s\n\n'
|
|
'See https://bug.skia.org/3362 for why this should be fixed.' %
|
|
'\n'.join(failing_files)))
|
|
return results
|
|
|
|
|
|
def _CopyrightChecks(input_api, output_api, source_file_filter=None):
|
|
results = []
|
|
year_pattern = r'\d{4}'
|
|
year_range_pattern = r'%s(-%s)?' % (year_pattern, year_pattern)
|
|
years_pattern = r'%s(,%s)*,?' % (year_range_pattern, year_range_pattern)
|
|
copyright_pattern = (
|
|
r'Copyright (\([cC]\) )?%s \w+' % years_pattern)
|
|
|
|
for affected_file in input_api.AffectedSourceFiles(source_file_filter):
|
|
if ('third_party/' in affected_file.LocalPath() or
|
|
'tests/sksl/' in affected_file.LocalPath() or
|
|
'bazel/rbe/' in affected_file.LocalPath() or
|
|
'bazel/external/' in affected_file.LocalPath() or
|
|
'bazel/exporter/interfaces/mocks/' in affected_file.LocalPath()):
|
|
continue
|
|
contents = input_api.ReadFile(affected_file, 'rb')
|
|
if not re.search(copyright_pattern, contents):
|
|
results.append(output_api.PresubmitError(
|
|
'%s is missing a correct copyright header.' % affected_file))
|
|
return results
|
|
|
|
|
|
def _InfraTests(input_api, output_api):
|
|
"""Run the infra tests."""
|
|
results = []
|
|
if not any(f.LocalPath().startswith('infra')
|
|
for f in input_api.AffectedFiles()):
|
|
return results
|
|
|
|
cmd = ['python3', os.path.join('infra', 'bots', 'infra_tests.py')]
|
|
try:
|
|
subprocess.check_output(cmd)
|
|
except subprocess.CalledProcessError as e:
|
|
results.append(output_api.PresubmitError(
|
|
'`%s` failed:\n%s' % (' '.join(cmd), e.output)))
|
|
return results
|
|
|
|
|
|
def _CheckGNFormatted(input_api, output_api):
|
|
"""Make sure any .gn files we're changing have been formatted."""
|
|
files = []
|
|
for f in input_api.AffectedFiles(include_deletes=False):
|
|
if (f.LocalPath().endswith('.gn') or
|
|
f.LocalPath().endswith('.gni')):
|
|
files.append(f)
|
|
if not files:
|
|
return []
|
|
|
|
cmd = ['python3', os.path.join('bin', 'fetch-gn')]
|
|
try:
|
|
subprocess.check_output(cmd)
|
|
except subprocess.CalledProcessError as e:
|
|
return [output_api.PresubmitError(
|
|
'`%s` failed:\n%s' % (' '.join(cmd), e.output))]
|
|
|
|
results = []
|
|
for f in files:
|
|
gn = 'gn.exe' if 'win32' in sys.platform else 'gn'
|
|
gn = os.path.join(input_api.PresubmitLocalPath(), 'bin', gn)
|
|
cmd = [gn, 'format', '--dry-run', f.LocalPath()]
|
|
try:
|
|
subprocess.check_output(cmd)
|
|
except subprocess.CalledProcessError:
|
|
fix = 'bin/gn format ' + f.LocalPath()
|
|
results.append(output_api.PresubmitError(
|
|
'`%s` failed, try\n\t%s' % (' '.join(cmd), fix)))
|
|
return results
|
|
|
|
|
|
def _CheckGitConflictMarkers(input_api, output_api):
|
|
pattern = input_api.re.compile('^(?:<<<<<<<|>>>>>>>) |^=======$')
|
|
results = []
|
|
for f in input_api.AffectedFiles():
|
|
for line_num, line in f.ChangedContents():
|
|
if f.LocalPath().endswith('.md'):
|
|
# First-level headers in markdown look a lot like version control
|
|
# conflict markers. http://daringfireball.net/projects/markdown/basics
|
|
continue
|
|
if pattern.match(line):
|
|
results.append(
|
|
output_api.PresubmitError(
|
|
'Git conflict markers found in %s:%d %s' % (
|
|
f.LocalPath(), line_num, line)))
|
|
return results
|
|
|
|
|
|
def _CheckIncludesFormatted(input_api, output_api):
|
|
"""Make sure #includes in files we're changing have been formatted."""
|
|
files = [str(f) for f in input_api.AffectedFiles() if f.Action() != 'D']
|
|
cmd = ['python3',
|
|
'tools/rewrite_includes.py',
|
|
'--dry-run'] + files
|
|
if 0 != subprocess.call(cmd):
|
|
return [output_api.PresubmitError('`%s` failed' % ' '.join(cmd))]
|
|
return []
|
|
|
|
|
|
class _WarningsAsErrors():
|
|
def __init__(self, output_api):
|
|
self.output_api = output_api
|
|
self.old_warning = None
|
|
def __enter__(self):
|
|
self.old_warning = self.output_api.PresubmitPromptWarning
|
|
self.output_api.PresubmitPromptWarning = self.output_api.PresubmitError
|
|
return self.output_api
|
|
def __exit__(self, ex_type, ex_value, ex_traceback):
|
|
self.output_api.PresubmitPromptWarning = self.old_warning
|
|
|
|
|
|
def _RegenerateAllExamplesCPP(input_api, output_api):
|
|
"""Regenerates all_examples.cpp if an example was added or deleted."""
|
|
if not any(f.LocalPath().startswith('docs/examples/')
|
|
for f in input_api.AffectedFiles()):
|
|
return []
|
|
command_str = 'tools/fiddle/make_all_examples_cpp.py'
|
|
cmd = ['python3', command_str]
|
|
if 0 != subprocess.call(cmd):
|
|
return [output_api.PresubmitError('`%s` failed' % ' '.join(cmd))]
|
|
|
|
results = []
|
|
git_diff_output = input_api.subprocess.check_output(
|
|
['git', 'diff', '--no-ext-diff'])
|
|
if git_diff_output:
|
|
results += [output_api.PresubmitError(
|
|
'Diffs found after running "%s":\n\n%s\n'
|
|
'Please commit or discard the above changes.' % (
|
|
command_str,
|
|
git_diff_output,
|
|
)
|
|
)]
|
|
return results
|
|
|
|
|
|
def _CheckExamplesForPrivateAPIs(input_api, output_api):
|
|
"""We only want our checked-in examples (aka fiddles) to show public API."""
|
|
banned_includes = [
|
|
input_api.re.compile(r'#\s*include\s+("src/.*)'),
|
|
input_api.re.compile(r'#\s*include\s+("include/private/.*)'),
|
|
]
|
|
file_filter = lambda x: (x.LocalPath().startswith('docs/examples/'))
|
|
errors = []
|
|
for affected_file in input_api.AffectedSourceFiles(file_filter):
|
|
affected_filepath = affected_file.LocalPath()
|
|
for (line_num, line) in affected_file.ChangedContents():
|
|
for re in banned_includes:
|
|
match = re.search(line)
|
|
if match:
|
|
errors.append('%s:%s: Fiddles should not use private/internal API like %s.' % (
|
|
affected_filepath, line_num, match.group(1)))
|
|
|
|
if errors:
|
|
return [output_api.PresubmitError('\n'.join(errors))]
|
|
return []
|
|
|
|
|
|
def _CheckGeneratedBazelBUILDFiles(input_api, output_api):
|
|
if 'win32' in sys.platform:
|
|
# TODO(crbug.com/skia/12541): Remove when Bazel builds work on Windows.
|
|
# Note: `make` is not installed on Windows by default.
|
|
return []
|
|
if 'darwin' in sys.platform:
|
|
# This takes too long on Mac with default settings. Probably due to sandboxing.
|
|
return []
|
|
for affected_file in input_api.AffectedFiles(include_deletes=True):
|
|
affected_file_path = affected_file.LocalPath()
|
|
if (affected_file_path.endswith('.go') or
|
|
affected_file_path.endswith('BUILD.bazel')):
|
|
return _RunCommandAndCheckGitDiff(output_api,
|
|
['make', '-C', 'bazel', 'generate_go'])
|
|
return [] # No modified Go source files.
|
|
|
|
|
|
def _CheckBazelBUILDFiles(input_api, output_api):
|
|
"""Makes sure our BUILD.bazel files are compatible with G3."""
|
|
results = []
|
|
for affected_file in input_api.AffectedFiles(include_deletes=False):
|
|
affected_file_path = affected_file.LocalPath()
|
|
is_bazel = affected_file_path.endswith('BUILD.bazel')
|
|
# This list lines up with the one in autoroller_lib.py (see G3).
|
|
excluded_paths = ["infra/", "bazel/rbe/", "bazel/external/", "bazel/common_config_settings/",
|
|
"modules/canvaskit/go/", "experimental/", "bazel/platform", "third_party/",
|
|
"tests/", "resources/", "bazel/deps_parser/", "bazel/exporter_tool/",
|
|
"tools/gpu/gl/interface/", "bazel/utils/", "include/config/"]
|
|
is_excluded = any(affected_file_path.startswith(n) for n in excluded_paths)
|
|
if is_bazel and not is_excluded:
|
|
with open(affected_file_path, 'r') as file:
|
|
contents = file.read()
|
|
if 'exports_files_legacy(' not in contents:
|
|
results.append(output_api.PresubmitError(
|
|
('%s needs to call exports_files_legacy() to support legacy G3 ' +
|
|
'rules.\nPut this near the top of the file, beneath ' +
|
|
'licenses(["notice"]).') % affected_file_path
|
|
))
|
|
if 'licenses(["notice"])' not in contents:
|
|
results.append(output_api.PresubmitError(
|
|
('%s needs to have\nlicenses(["notice"])\nimmediately after ' +
|
|
'the load() calls to comply with G3 policies.') % affected_file_path
|
|
))
|
|
if 'cc_library(' in contents and '"skia_cc_library"' not in contents:
|
|
results.append(output_api.PresubmitError(
|
|
('%s needs to load skia_cc_library from macros.bzl instead of using the ' +
|
|
'native one. This allows us to build differently for G3.\n' +
|
|
'Add "skia_cc_library" to load("//bazel:macros.bzl", ...)')
|
|
% affected_file_path
|
|
))
|
|
return results
|
|
|
|
|
|
def _CheckPublicBzl(input_api, output_api):
|
|
"""Reminds devs to add/remove files from public.bzl."""
|
|
results = []
|
|
public_bzl = ''
|
|
with open('public.bzl', 'r', encoding='utf-8') as f:
|
|
public_bzl = f.read().strip()
|
|
for affected_file in input_api.AffectedFiles(include_deletes=True):
|
|
# action is A for newly added, D for newly deleted, M for modified
|
|
action = affected_file.Action()
|
|
affected_file_path = affected_file.LocalPath()
|
|
if ((affected_file_path.startswith("include") or affected_file_path.startswith("src")) and
|
|
(affected_file_path.endswith(".cpp") or affected_file_path.endswith(".h"))):
|
|
affected_file_path = '"' + affected_file_path + '"'
|
|
if action == "D" and affected_file_path in public_bzl:
|
|
results.append(output_api.PresubmitError(
|
|
"Need to delete %s from public.bzl (or rename it)" % affected_file_path))
|
|
elif action == "A" and affected_file_path not in public_bzl:
|
|
results.append(output_api.PresubmitPromptWarning(
|
|
"You may need to add %s to public.bzl" % affected_file_path))
|
|
return results
|
|
|
|
|
|
def _RunCommandAndCheckGitDiff(output_api, command):
|
|
"""Run an arbitrary command. Fail if it produces any diffs."""
|
|
command_str = ' '.join(command)
|
|
results = []
|
|
|
|
try:
|
|
output = subprocess.check_output(
|
|
command,
|
|
stderr=subprocess.STDOUT, encoding='utf-8')
|
|
except subprocess.CalledProcessError as e:
|
|
results += [output_api.PresubmitError(
|
|
'Command "%s" returned non-zero exit code %d. Output: \n\n%s' % (
|
|
command_str,
|
|
e.returncode,
|
|
e.output,
|
|
)
|
|
)]
|
|
|
|
git_diff_output = subprocess.check_output(
|
|
['git', 'diff', '--no-ext-diff'], encoding='utf-8')
|
|
if git_diff_output:
|
|
results += [output_api.PresubmitError(
|
|
'Diffs found after running "%s":\n\n%s\n'
|
|
'Please commit or discard the above changes.' % (
|
|
command_str,
|
|
git_diff_output,
|
|
)
|
|
)]
|
|
|
|
return results
|
|
|
|
|
|
def _CheckGNIGenerated(input_api, output_api):
|
|
"""Ensures that the generated *.gni files are current.
|
|
|
|
The Bazel project files are authoritative and some *.gni files are
|
|
generated from them using the exporter_tool. This check ensures they
|
|
are still current.
|
|
"""
|
|
if 'win32' in sys.platform:
|
|
# TODO(crbug.com/skia/12541): Remove when Bazel builds work on Windows.
|
|
# Note: `make` is not installed on Windows by default.
|
|
return [
|
|
output_api.PresubmitPromptWarning(
|
|
'Skipping Bazel=>GNI export check on Windows (unsupported platform).'
|
|
)
|
|
]
|
|
if 'darwin' in sys.platform:
|
|
# This takes too long on Mac with default settings. Probably due to sandboxing.
|
|
return []
|
|
should_run = False
|
|
for affected_file in input_api.AffectedFiles(include_deletes=True):
|
|
affected_file_path = affected_file.LocalPath()
|
|
if affected_file_path.endswith('BUILD.bazel') or affected_file_path.endswith('.gni'):
|
|
should_run = True
|
|
# Generate GNI files and verify no changes.
|
|
if should_run:
|
|
return _RunCommandAndCheckGitDiff(output_api,
|
|
['make', '-C', 'bazel', 'generate_gni'])
|
|
|
|
# No Bazel build files changed.
|
|
return []
|
|
|
|
|
|
def _CheckBuildifier(input_api, output_api):
|
|
"""Runs Buildifier and fails on linting errors, or if it produces any diffs.
|
|
|
|
This check only runs if the affected files include any WORKSPACE, BUILD,
|
|
BUILD.bazel or *.bzl files.
|
|
"""
|
|
files = []
|
|
for affected_file in input_api.AffectedFiles(include_deletes=False):
|
|
affected_file_path = affected_file.LocalPath()
|
|
if affected_file_path.endswith('BUILD.bazel') or affected_file_path.endswith('.bzl'):
|
|
if not affected_file_path.endswith('public.bzl') and not affected_file_path.endswith('go_repositories.bzl'):
|
|
files.append(affected_file_path)
|
|
if not files:
|
|
return []
|
|
try:
|
|
subprocess.check_output(
|
|
['buildifier', '--version'],
|
|
stderr=subprocess.STDOUT)
|
|
except:
|
|
return [output_api.PresubmitNotifyResult(
|
|
'Skipping buildifier check because it is not on PATH. \n' +
|
|
'You can download it from https://github.com/bazelbuild/buildtools/releases')]
|
|
|
|
return _RunCommandAndCheckGitDiff(
|
|
# One can change --lint=warn to --lint=fix to have things automatically fixed where possible.
|
|
# However, --lint=fix will not cause a presubmit error if there are things that require
|
|
# manual intervention, so we leave --lint=warn on by default.
|
|
output_api, ['buildifier', '--mode=fix', '--lint=warn'] + files)
|
|
|
|
|
|
def _CheckBannedAPIs(input_api, output_api):
|
|
"""Check source code for functions and packages that should not be used."""
|
|
|
|
# A list of tuples of a regex to match an API and a suggested replacement for
|
|
# that API. There is an optional third parameter for files which *can* use this
|
|
# API without warning.
|
|
banned_replacements = [
|
|
(r'std::stof\(', 'std::strtof(), which does not throw'),
|
|
(r'std::stod\(', 'std::strtod(), which does not throw'),
|
|
(r'std::stold\(', 'std::strtold(), which does not throw'),
|
|
]
|
|
|
|
compiled_replacements = []
|
|
for rep in banned_replacements:
|
|
exceptions = []
|
|
if len(rep) == 3:
|
|
(re, replacement, exceptions) = rep
|
|
else:
|
|
(re, replacement) = rep
|
|
|
|
compiled_re = input_api.re.compile(re)
|
|
compiled_exceptions = [input_api.re.compile(exc) for exc in exceptions]
|
|
compiled_replacements.append(
|
|
(compiled_re, replacement, compiled_exceptions))
|
|
|
|
errors = []
|
|
file_filter = lambda x: (x.LocalPath().endswith('.h') or
|
|
x.LocalPath().endswith('.cpp') or
|
|
x.LocalPath().endswith('.cc') or
|
|
x.LocalPath().endswith('.m') or
|
|
x.LocalPath().endswith('.mm'))
|
|
for affected_file in input_api.AffectedSourceFiles(file_filter):
|
|
affected_filepath = affected_file.LocalPath()
|
|
for (line_num, line) in affected_file.ChangedContents():
|
|
for (re, replacement, exceptions) in compiled_replacements:
|
|
match = re.search(line)
|
|
if match:
|
|
for exc in exceptions:
|
|
if exc.search(affected_filepath):
|
|
break
|
|
else:
|
|
errors.append('%s:%s: Instead of %s, please use %s.' % (
|
|
affected_filepath, line_num, match.group(), replacement))
|
|
|
|
if errors:
|
|
return [output_api.PresubmitError('\n'.join(errors))]
|
|
|
|
return []
|
|
|
|
|
|
def _CheckDEPS(input_api, output_api):
|
|
"""If DEPS was modified, run the deps_parser to update bazel/deps.bzl"""
|
|
needs_running = False
|
|
for affected_file in input_api.AffectedFiles(include_deletes=False):
|
|
affected_file_path = affected_file.LocalPath()
|
|
if affected_file_path.endswith('DEPS') or affected_file_path.endswith('deps.bzl'):
|
|
needs_running = True
|
|
break
|
|
if not needs_running:
|
|
return []
|
|
try:
|
|
subprocess.check_output(
|
|
['bazelisk', '--version'],
|
|
stderr=subprocess.STDOUT)
|
|
except:
|
|
return [output_api.PresubmitNotifyResult(
|
|
'Skipping DEPS check because bazelisk is not on PATH. \n' +
|
|
'You can download it from https://github.com/bazelbuild/bazelisk/releases/tag/v1.14.0')]
|
|
|
|
return _RunCommandAndCheckGitDiff(
|
|
output_api, ['bazelisk', 'run', '//bazel/deps_parser'])
|
|
|
|
|
|
def _CommonChecks(input_api, output_api):
|
|
"""Presubmit checks common to upload and commit."""
|
|
results = []
|
|
sources = lambda x: (x.LocalPath().endswith('.h') or
|
|
x.LocalPath().endswith('.py') or
|
|
x.LocalPath().endswith('.sh') or
|
|
x.LocalPath().endswith('.m') or
|
|
x.LocalPath().endswith('.mm') or
|
|
x.LocalPath().endswith('.go') or
|
|
x.LocalPath().endswith('.c') or
|
|
x.LocalPath().endswith('.cc') or
|
|
x.LocalPath().endswith('.cpp'))
|
|
results.extend(_CheckChangeHasEol(
|
|
input_api, output_api, source_file_filter=sources))
|
|
with _WarningsAsErrors(output_api):
|
|
results.extend(input_api.canned_checks.CheckChangeHasNoCR(
|
|
input_api, output_api, source_file_filter=sources))
|
|
results.extend(input_api.canned_checks.CheckChangeHasNoStrayWhitespace(
|
|
input_api, output_api, source_file_filter=sources))
|
|
results.extend(_JsonChecks(input_api, output_api))
|
|
results.extend(_IfDefChecks(input_api, output_api))
|
|
results.extend(_CopyrightChecks(input_api, output_api,
|
|
source_file_filter=sources))
|
|
results.extend(_CheckIncludesFormatted(input_api, output_api))
|
|
results.extend(_CheckGNFormatted(input_api, output_api))
|
|
results.extend(_CheckGitConflictMarkers(input_api, output_api))
|
|
results.extend(_RegenerateAllExamplesCPP(input_api, output_api))
|
|
results.extend(_CheckExamplesForPrivateAPIs(input_api, output_api))
|
|
results.extend(_CheckBazelBUILDFiles(input_api, output_api))
|
|
results.extend(_CheckBannedAPIs(input_api, output_api))
|
|
return results
|
|
|
|
|
|
def CheckChangeOnUpload(input_api, output_api):
|
|
"""Presubmit checks for the change on upload."""
|
|
results = []
|
|
results.extend(_CommonChecks(input_api, output_api))
|
|
# Run on upload, not commit, since the presubmit bot apparently doesn't have
|
|
# coverage or Go installed.
|
|
results.extend(_InfraTests(input_api, output_api))
|
|
results.extend(_CheckReleaseNotesForPublicAPI(input_api, output_api))
|
|
# Only check public.bzl on upload because new files are likely to be a source
|
|
# of false positives and we don't want to unnecessarily block commits.
|
|
results.extend(_CheckPublicBzl(input_api, output_api))
|
|
# Buildifier might not be on the CI machines.
|
|
results.extend(_CheckBuildifier(input_api, output_api))
|
|
# We don't want this to block the CQ (for now).
|
|
results.extend(_CheckDEPS(input_api, output_api))
|
|
# Bazelisk is not yet included in the Presubmit job.
|
|
results.extend(_CheckGeneratedBazelBUILDFiles(input_api, output_api))
|
|
results.extend(_CheckGNIGenerated(input_api, output_api))
|
|
return results
|
|
|
|
|
|
class CodeReview(object):
|
|
"""Abstracts which codereview tool is used for the specified issue."""
|
|
|
|
def __init__(self, input_api):
|
|
self._issue = input_api.change.issue
|
|
self._gerrit = input_api.gerrit
|
|
|
|
def GetOwnerEmail(self):
|
|
return self._gerrit.GetChangeOwner(self._issue)
|
|
|
|
def GetSubject(self):
|
|
return self._gerrit.GetChangeInfo(self._issue)['subject']
|
|
|
|
def GetDescription(self):
|
|
return self._gerrit.GetChangeDescription(self._issue)
|
|
|
|
def GetReviewers(self):
|
|
code_review_label = (
|
|
self._gerrit.GetChangeInfo(self._issue)['labels']['Code-Review'])
|
|
return [r['email'] for r in code_review_label.get('all', [])]
|
|
|
|
def GetApprovers(self):
|
|
approvers = []
|
|
code_review_label = (
|
|
self._gerrit.GetChangeInfo(self._issue)['labels']['Code-Review'])
|
|
for m in code_review_label.get('all', []):
|
|
if m.get("value") == 1:
|
|
approvers.append(m["email"])
|
|
return approvers
|
|
|
|
|
|
def _CheckReleaseNotesForPublicAPI(input_api, output_api):
|
|
"""Checks to see if release notes file is updated with public API changes."""
|
|
results = []
|
|
public_api_changed = False
|
|
release_file_changed = False
|
|
for affected_file in input_api.AffectedFiles():
|
|
affected_file_path = affected_file.LocalPath()
|
|
file_path, file_ext = os.path.splitext(affected_file_path)
|
|
# We only care about files that end in .h and are under the top-level
|
|
# include dir, but not include/private.
|
|
if (file_ext == '.h' and
|
|
file_path.split(os.path.sep)[0] == 'include' and
|
|
'private' not in file_path):
|
|
public_api_changed = True
|
|
elif affected_file_path == RELEASE_NOTES_FILE_NAME:
|
|
release_file_changed = True
|
|
|
|
if public_api_changed and not release_file_changed:
|
|
results.append(output_api.PresubmitPromptWarning(
|
|
'If this change affects a client API, please add a summary line '
|
|
'to the %s file.' % RELEASE_NOTES_FILE_NAME))
|
|
return results
|
|
|
|
|
|
def PostUploadHook(gerrit, change, output_api):
|
|
"""git cl upload will call this hook after the issue is created/modified.
|
|
|
|
This hook does the following:
|
|
* Adds a link to preview docs changes if there are any docs changes in the CL.
|
|
* Adds 'No-Try: true' if the CL contains only docs changes.
|
|
"""
|
|
if not change.issue:
|
|
return []
|
|
|
|
# Skip PostUploadHooks for all auto-commit service account bots. New
|
|
# patchsets (caused due to PostUploadHooks) invalidates the CQ+2 vote from
|
|
# the "--use-commit-queue" flag to "git cl upload".
|
|
for suffix in SERVICE_ACCOUNT_SUFFIX:
|
|
if change.author_email.endswith(suffix):
|
|
return []
|
|
|
|
results = []
|
|
at_least_one_docs_change = False
|
|
all_docs_changes = True
|
|
for affected_file in change.AffectedFiles():
|
|
affected_file_path = affected_file.LocalPath()
|
|
file_path, _ = os.path.splitext(affected_file_path)
|
|
if 'site' == file_path.split(os.path.sep)[0]:
|
|
at_least_one_docs_change = True
|
|
else:
|
|
all_docs_changes = False
|
|
if at_least_one_docs_change and not all_docs_changes:
|
|
break
|
|
|
|
footers = change.GitFootersFromDescription()
|
|
description_changed = False
|
|
|
|
# If the change includes only doc changes then add No-Try: true in the
|
|
# CL's description if it does not exist yet.
|
|
if all_docs_changes and 'true' not in footers.get('No-Try', []):
|
|
description_changed = True
|
|
change.AddDescriptionFooter('No-Try', 'true')
|
|
results.append(
|
|
output_api.PresubmitNotifyResult(
|
|
'This change has only doc changes. Automatically added '
|
|
'\'No-Try: true\' to the CL\'s description'))
|
|
|
|
# If the description has changed update it.
|
|
if description_changed:
|
|
gerrit.UpdateDescription(
|
|
change.FullDescriptionText(), change.issue)
|
|
|
|
return results
|
|
|
|
|
|
def CheckChangeOnCommit(input_api, output_api):
|
|
"""Presubmit checks for the change on commit."""
|
|
results = []
|
|
results.extend(_CommonChecks(input_api, output_api))
|
|
# Checks for the presence of 'DO NOT''SUBMIT' in CL description and in
|
|
# content of files.
|
|
results.extend(
|
|
input_api.canned_checks.CheckDoNotSubmit(input_api, output_api))
|
|
return results
|