blob: db2793fad1b934532cbb465b4f0b880096fa2dd9 [file] [log] [blame]
// Copyright 2021 The Bazel Authors. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package com.google.devtools.build.lib.buildtool;
import static com.google.common.truth.Truth.assertThat;
import static com.google.common.truth.extensions.proto.ProtoTruth.assertThat;
import static org.junit.Assert.assertThrows;
import com.google.devtools.build.lib.actions.BuildFailedException;
import com.google.devtools.build.lib.buildtool.util.BuildIntegrationTestCase;
import com.google.devtools.build.lib.server.FailureDetails;
import com.google.devtools.build.lib.skyframe.DetailedException;
import com.google.devtools.build.lib.util.io.RecordingOutErr;
import com.google.devtools.build.lib.vfs.Path;
import com.google.devtools.build.lib.vfs.PathFragment;
import com.google.testing.junit.testparameterinjector.TestParameter;
import com.google.testing.junit.testparameterinjector.TestParameterInjector;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
/** Tests for Starlark "unused inputs list" functionality on failures caused by unused inputs. */
@RunWith(TestParameterInjector.class)
public final class UnusedInputsFailureIntegrationTest extends BuildIntegrationTestCase {
@TestParameter private boolean keepGoing;
@Before
public void setOptions() {
addOptions("--keep_going=" + keepGoing);
}
@Test
public void incrementalFailureOnUnusedInput() throws Exception {
RecordingBugReporter bugReporter = recordBugReportsAndReinitialize();
write(
"foo/pruning.bzl",
"def _impl(ctx):",
" inputs = ctx.attr.inputs.files",
" output = ctx.actions.declare_file(ctx.label.name + '.out')",
" unused_file = ctx.actions.declare_file(ctx.label.name + '.unused')",
" ctx.actions.run(",
" # Make sure original inputs are one level down, so 'leaf unrolling' doesn't get them",
" inputs = depset(transitive = [ctx.attr.filler.files, inputs]),",
" outputs = [output, unused_file],",
" arguments = [output.path, unused_file.path] + [f.path for f in inputs.to_list()],",
" executable = ctx.executable.executable,",
" unused_inputs_list = unused_file,",
" )",
" return DefaultInfo(files = depset([output]))",
"",
"build_rule = rule(",
" attrs = {",
" 'inputs': attr.label(allow_files = True),",
" 'filler': attr.label(allow_files = True),",
" 'executable': attr.label(executable = True, allow_files = True, cfg = 'exec'),",
" },",
" implementation = _impl,",
")");
write("foo/unused.sh", "touch $1", "shift", "unused=$1", "shift", "echo $@ > $unused")
.setExecutable(true);
write("foo/gen_run.sh", "true").setExecutable(true);
write("foo/filler");
write(
"foo/BUILD",
"load('//foo:pruning.bzl', 'build_rule')",
"build_rule(name = 'foo', filler = ':filler', inputs = ':in', executable = ':unused.sh')",
"genrule(name = 'gen', outs = ['in'], tools = [':gen_run.sh'], cmd = '$(location"
+ " :gen_run.sh) && touch $@')");
buildTarget("//foo:foo");
bugReporter.assertNoExceptions();
write("foo/gen_run.sh", "false");
if (keepGoing) {
buildTarget("//foo:foo");
bugReporter.assertNoExceptions();
} else {
RecordingOutErr outErr = new RecordingOutErr();
this.outErr = outErr;
BuildFailedException e = assertThrows(BuildFailedException.class, () -> buildTarget("//foo"));
assertThat(e.getDetailedExitCode().getFailureDetail())
.comparingExpectedFieldsOnly()
.isEqualTo(
FailureDetails.FailureDetail.newBuilder()
.setExecution(
FailureDetails.Execution.newBuilder()
.setCode(FailureDetails.Execution.Code.UNEXPECTED_EXCEPTION)
.build())
.build());
assertThat(outErr.errAsLatin1()).contains("Executing genrule //foo:gen failed");
Throwable cause = bugReporter.getFirstCause();
assertThat(cause).hasMessageThat().contains("Error evaluating artifact nested set");
assertThat(cause).hasMessageThat().contains("foo/gen_run.sh");
}
}
/**
* Regression test for b/185998331.
*
* <p>The action graph is:
*
* <pre>
* top [consume.out] -> [top.out]
* |
* consume [consume.sh, prune.out] -> [consume.out]
* |
* prune [prune.sh, [bad.out, good.out]] -> [prune.out, unused_list]
* / \
* bad [bad.sh] -> [bad.out] good [] -> [good.out]
* </pre>
*
* where 'prune' reports 'bad' as an unused input. On the first build, 'consume' fails. On the
* second build, 'bad' fails. If the error is not handled correctly by 'prune', 'top' won't know
* that 'consume' is unavailable.
*/
@Test
public void incrementalFailureOnUnusedInput_downstreamInputNotReady() throws Exception {
write(
"foo/defs.bzl",
"def _example_rule_impl(ctx):",
" bad = ctx.actions.declare_file('bad.out')",
" ctx.actions.run(",
" outputs = [bad],",
" executable = ctx.executable.bad_sh,",
" arguments = [bad.path],",
" )",
"",
" good = ctx.actions.declare_file('good.out')",
" ctx.actions.run_shell(outputs = [good], command = 'touch %s' % good.path)",
"",
" unused_list = ctx.actions.declare_file('unused_list')",
" prune = ctx.actions.declare_file('prune.out')",
" ctx.actions.run(",
" outputs = [prune, unused_list],",
" inputs = [bad, good],",
" unused_inputs_list = unused_list,",
" executable = ctx.executable.prune_sh,",
" arguments = [prune.path, unused_list.path, bad.path],",
" )",
"",
" consume = ctx.actions.declare_file('consume.out')",
" ctx.actions.run(",
" outputs = [consume],",
" inputs = [prune],",
" executable = ctx.executable.consume_sh,",
" arguments = [consume.path],",
" )",
"",
" top = ctx.actions.declare_file('top.out')",
" ctx.actions.run_shell(",
" outputs = [top],",
" inputs = [consume],",
" command = 'touch %s' % top.path,",
" )",
" return DefaultInfo(files = depset([top]))",
"",
"example_rule = rule(",
" implementation = _example_rule_impl,",
" attrs = {",
" 'bad_sh': attr.label(",
" executable = True, allow_single_file = True, cfg = 'exec', default = 'bad.sh'",
" ),",
" 'prune_sh': attr.label(",
" executable = True, allow_single_file = True, cfg = 'exec', default = 'prune.sh'",
" ),",
" 'consume_sh': attr.label(",
" executable = True, allow_single_file = True, cfg = 'exec', default = 'consume.sh'",
" ),",
" },",
")");
write("foo/BUILD", "load(':defs.bzl', 'example_rule')", "example_rule(name = 'example')");
write("foo/bad.sh", "#!/bin/bash", "touch $1").setExecutable(true);
write("foo/prune.sh", "#!/bin/bash", "touch $1 && echo $3 > $2").setExecutable(true);
write("foo/consume.sh", "#!/bin/bash", "exit 1").setExecutable(true);
assertThrows(BuildFailedException.class, () -> buildTarget("//foo:example"));
assertContainsError("Action foo/consume.out failed");
write("foo/bad.sh", "#!/bin/bash", "exit 1").setExecutable(true);
write("foo/consume.sh", "#!/bin/bash", "touch $@").setExecutable(true);
if (keepGoing) {
buildTarget("//foo:example");
} else {
assertThrows(BuildFailedException.class, () -> buildTarget("//foo:example"));
assertContainsError("Action foo/bad.out failed");
}
}
@Test
public void incrementalUnusedSymlinkCycle() throws Exception {
RecordingBugReporter bugReporter = recordBugReportsAndReinitialize();
write(
"foo/pruning.bzl",
"def _impl(ctx):",
" inputs = ctx.attr.inputs.files",
" output = ctx.actions.declare_file(ctx.label.name + '.out')",
" unused_inputs_list = ctx.actions.declare_file(ctx.label.name + '.unused')",
" arguments = [output.path, unused_inputs_list.path]",
" for input in inputs.to_list():",
" arguments += [input.path]",
" ctx.actions.run(",
" inputs = inputs,",
" outputs = [output, unused_inputs_list],",
" arguments = arguments,",
" executable = ctx.executable.executable,",
" unused_inputs_list = unused_inputs_list,",
" )",
" return DefaultInfo(files = depset([output]))",
"",
"build_rule = rule(",
" attrs = {",
" 'inputs': attr.label(allow_files = True),",
" 'executable': attr.label(executable = True, allow_files = True, cfg = 'exec'),",
" },",
" implementation = _impl,",
")");
Path unusedSh =
write("foo/all_unused.sh", "touch $1", "shift", "unused=$1", "shift", "echo $@ > $unused");
unusedSh.setExecutable(true);
Path inPath = write("foo/in");
write(
"foo/BUILD",
"load('//foo:pruning.bzl', 'build_rule')",
"build_rule(name = 'prune', inputs = ':in', executable = ':all_unused.sh')");
buildTarget("//foo:prune");
bugReporter.assertNoExceptions();
inPath.delete();
inPath.createSymbolicLink(PathFragment.create("in"));
if (keepGoing) {
buildTarget("//foo:prune");
bugReporter.assertNoExceptions();
} else {
RecordingOutErr outErr = new RecordingOutErr();
this.outErr = outErr;
BuildFailedException e =
assertThrows(BuildFailedException.class, () -> buildTarget("//foo:prune"));
assertDetailedExitCodeIsSourceIOFailure(e);
Throwable cause = bugReporter.getFirstCause();
assertDetailedExitCodeIsSourceIOFailure(cause);
assertThat(cause).hasMessageThat().isEqualTo("error reading file '//foo:in': Symlink cycle");
assertThat(outErr.errAsLatin1()).contains("error reading file '//foo:in': Symlink cycle");
}
}
private static final FailureDetails.FailureDetail SOURCE_IO_FAILURE =
FailureDetails.FailureDetail.newBuilder()
.setExecution(
FailureDetails.Execution.newBuilder()
.setCode(FailureDetails.Execution.Code.SOURCE_INPUT_IO_EXCEPTION))
.build();
private static void assertDetailedExitCodeIsSourceIOFailure(Throwable exception) {
assertThat(exception).isInstanceOf(DetailedException.class);
assertThat(((DetailedException) exception).getDetailedExitCode().getFailureDetail())
.comparingExpectedFieldsOnly()
.isEqualTo(SOURCE_IO_FAILURE);
}
@Test
public void incrementalUnusedDanglingSymlink() throws Exception {
write(
"foo/pruning.bzl",
"def _impl(ctx):",
" inputs = ctx.attr.inputs.files",
" output = ctx.actions.declare_file(ctx.label.name + '.out')",
" unused_inputs_list = ctx.actions.declare_file(ctx.label.name + '.unused')",
" arguments = [output.path, unused_inputs_list.path]",
" for input in inputs.to_list():",
" arguments += [input.path]",
" ctx.actions.run(",
" inputs = inputs,",
" outputs = [output, unused_inputs_list],",
" arguments = arguments,",
" executable = ctx.executable.executable,",
" unused_inputs_list = unused_inputs_list,",
" )",
" return DefaultInfo(files = depset([output]))",
"",
"build_rule = rule(",
" attrs = {",
" 'inputs': attr.label(allow_files = True),",
" 'executable': attr.label(executable = True, allow_files = True, cfg = 'exec'),",
" },",
" implementation = _impl,",
")");
Path unusedSh =
write("foo/all_unused.sh", "touch $1", "shift", "unused=$1", "shift", "echo $@ > $unused");
unusedSh.setExecutable(true);
Path inPath = write("foo/in");
write(
"foo/BUILD",
"load('//foo:pruning.bzl', 'build_rule')",
"build_rule(name = 'prune', inputs = ':in', executable = ':all_unused.sh')");
buildTarget("//foo:prune");
inPath.delete();
inPath.createSymbolicLink(PathFragment.create("nope"));
buildTarget("//foo:prune");
}
}