| // Copyright 2022 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 org.junit.Assert.assertThrows; | |
| import com.google.common.collect.Iterables; | |
| import com.google.devtools.build.lib.actions.BuildFailedException; | |
| import com.google.devtools.build.lib.analysis.ViewCreationFailedException; | |
| import com.google.devtools.build.lib.buildtool.util.BuildIntegrationTestCase; | |
| import com.google.devtools.build.lib.vfs.Path; | |
| import com.google.testing.junit.testparameterinjector.TestParameter; | |
| import com.google.testing.junit.testparameterinjector.TestParameterInjector; | |
| import java.io.IOException; | |
| import org.junit.Before; | |
| import org.junit.Test; | |
| import org.junit.runner.RunWith; | |
| /** Integration tests for project Skymeld: interleaving Skyframe's analysis and execution phases. */ | |
| @RunWith(TestParameterInjector.class) | |
| public class SkymeldBuildIntegrationTest extends BuildIntegrationTestCase { | |
| @Before | |
| public void setUp() { | |
| addOptions("--experimental_merged_skyframe_analysis_execution"); | |
| } | |
| /** A simple rule that has srcs, deps and writes these attributes to its output. */ | |
| private void writeMyRuleBzl() throws IOException { | |
| write( | |
| "foo/my_rule.bzl", | |
| "def _path(file):", | |
| " return file.path", | |
| "def _impl(ctx):", | |
| " inputs = depset(", | |
| " ctx.files.srcs, transitive = [dep[DefaultInfo].files for dep in ctx.attr.deps])", | |
| " output = ctx.actions.declare_file(ctx.attr.name + '.out')", | |
| " command = 'echo $@ > %s' % (output.path)", | |
| " args = ctx.actions.args()", | |
| " args.add_all(inputs, map_each=_path)", | |
| " ctx.actions.run_shell(", | |
| " inputs = inputs,", | |
| " outputs = [output],", | |
| " command = command,", | |
| " arguments = [args]", | |
| " )", | |
| " return DefaultInfo(files = depset([output]))", | |
| "", | |
| "my_rule = rule(", | |
| " implementation = _impl,", | |
| " attrs = {", | |
| " 'srcs': attr.label_list(allow_files = True),", | |
| " 'deps': attr.label_list(providers = ['DefaultInfo']),", | |
| " }", | |
| ")"); | |
| } | |
| private void writeAnalysisFailureAspectBzl() throws IOException { | |
| write( | |
| "foo/aspect.bzl", | |
| "def _aspect_impl(target, ctx):", | |
| " malformed", | |
| "", | |
| "analysis_err_aspect = aspect(implementation = _aspect_impl)"); | |
| } | |
| private void writeExecutionFailureAspectBzl() throws IOException { | |
| write( | |
| "foo/aspect.bzl", | |
| "def _aspect_impl(target, ctx):", | |
| " output = ctx.actions.declare_file('aspect_output')", | |
| " ctx.actions.run_shell(", | |
| " outputs = [output],", | |
| " command = 'false',", | |
| " )", | |
| " return [OutputGroupInfo(", | |
| " files = depset([output])", | |
| " )]", | |
| "", | |
| "execution_err_aspect = aspect(implementation = _aspect_impl)"); | |
| } | |
| private void assertSingleOutputBuilt(String target) throws Exception { | |
| assertThat(Iterables.getOnlyElement(getArtifacts(target)).getPath().isFile()).isTrue(); | |
| } | |
| @Test | |
| public void multiTargetBuild_success() throws Exception { | |
| writeMyRuleBzl(); | |
| write( | |
| "foo/BUILD", | |
| "load('//foo:my_rule.bzl', 'my_rule')", | |
| "my_rule(name = 'bar', srcs = ['bar.in'])", | |
| "my_rule(name = 'foo', srcs = ['foo.in'])"); | |
| write("foo/foo.in"); | |
| write("foo/bar.in"); | |
| BuildResult result = buildTarget("//foo:foo", "//foo:bar"); | |
| assertThat(result.getSuccess()).isTrue(); | |
| assertSingleOutputBuilt("//foo:foo"); | |
| assertSingleOutputBuilt("//foo:bar"); | |
| assertThat(getLabelsOfAnalyzedTargets()).containsExactly("//foo:foo", "//foo:bar"); | |
| assertThat(getLabelsOfBuiltTargets()).containsExactly("//foo:foo", "//foo:bar"); | |
| } | |
| @Test | |
| public void aspectAnalysisFailure_consistentWithNonSkymeld( | |
| @TestParameter boolean keepGoing, @TestParameter boolean mergedAnalysisExecution) | |
| throws Exception { | |
| addOptions("--keep_going=" + keepGoing); | |
| addOptions("--experimental_merged_skyframe_analysis_execution=" + mergedAnalysisExecution); | |
| writeMyRuleBzl(); | |
| writeAnalysisFailureAspectBzl(); | |
| write( | |
| "foo/BUILD", | |
| "load('//foo:my_rule.bzl', 'my_rule')", | |
| "my_rule(name = 'foo', srcs = ['foo.in'])"); | |
| write("foo/foo.in"); | |
| addOptions("--aspects=//foo:aspect.bzl%analysis_err_aspect", "--output_groups=files"); | |
| if (keepGoing) { | |
| assertThrows(BuildFailedException.class, () -> buildTarget("//foo:foo")); | |
| } else { | |
| assertThrows(ViewCreationFailedException.class, () -> buildTarget("//foo:foo")); | |
| } | |
| events.assertContainsError("compilation of module 'foo/aspect.bzl' failed"); | |
| } | |
| @Test | |
| public void aspectExecutionFailure_consistentWithNonSkymeld( | |
| @TestParameter boolean keepGoing, @TestParameter boolean mergedAnalysisExecution) | |
| throws Exception { | |
| addOptions("--keep_going=" + keepGoing); | |
| addOptions("--experimental_merged_skyframe_analysis_execution=" + mergedAnalysisExecution); | |
| writeMyRuleBzl(); | |
| writeExecutionFailureAspectBzl(); | |
| write( | |
| "foo/BUILD", | |
| "load('//foo:my_rule.bzl', 'my_rule')", | |
| "my_rule(name = 'foo', srcs = ['foo.in'])"); | |
| write("foo/foo.in"); | |
| addOptions("--aspects=//foo:aspect.bzl%execution_err_aspect", "--output_groups=files"); | |
| assertThrows(BuildFailedException.class, () -> buildTarget("//foo:foo")); | |
| events.assertContainsError( | |
| "Action foo/aspect_output failed: (Exit 1): bash failed: error executing command"); | |
| // TODO(b/227138583) Update this. | |
| if (mergedAnalysisExecution) { | |
| assertThat(getLabelsOfAnalyzedTargets()).contains("//foo:foo"); | |
| } | |
| } | |
| @Test | |
| public void targetExecutionFailure_consistentWithNonSkymeld( | |
| @TestParameter boolean keepGoing, @TestParameter boolean mergedAnalysisExecution) | |
| throws Exception { | |
| addOptions("--keep_going=" + keepGoing); | |
| addOptions("--experimental_merged_skyframe_analysis_execution=" + mergedAnalysisExecution); | |
| writeMyRuleBzl(); | |
| write( | |
| "foo/BUILD", | |
| "load('//foo:my_rule.bzl', 'my_rule')", | |
| "my_rule(name = 'execution_failure', srcs = ['missing'])", | |
| "my_rule(name = 'foo', srcs = ['foo.in'])"); | |
| write("foo/foo.in"); | |
| assertThrows( | |
| BuildFailedException.class, () -> buildTarget("//foo:foo", "//foo:execution_failure")); | |
| if (keepGoing) { | |
| assertSingleOutputBuilt("//foo:foo"); | |
| } | |
| events.assertContainsError( | |
| "Action foo/execution_failure.out failed: missing input file '//foo:missing'"); | |
| // TODO(b/227138583) Update this. | |
| if (mergedAnalysisExecution) { | |
| assertThat(getLabelsOfAnalyzedTargets()).contains("//foo:execution_failure"); | |
| if (keepGoing) { | |
| assertThat(getLabelsOfAnalyzedTargets()) | |
| .containsExactly("//foo:foo", "//foo:execution_failure"); | |
| assertThat(getLabelsOfBuiltTargets()).containsExactly("//foo:foo"); | |
| } | |
| } | |
| } | |
| @Test | |
| public void targetAnalysisFailure_consistentWithNonSkymeld( | |
| @TestParameter boolean keepGoing, @TestParameter boolean mergedAnalysisExecution) | |
| throws Exception { | |
| addOptions("--keep_going=" + keepGoing); | |
| addOptions("--experimental_merged_skyframe_analysis_execution=" + mergedAnalysisExecution); | |
| writeMyRuleBzl(); | |
| write( | |
| "foo/BUILD", | |
| "load('//foo:my_rule.bzl', 'my_rule')", | |
| "my_rule(name = 'analysis_failure', srcs = ['foo.in'], deps = [':missing'])", | |
| "my_rule(name = 'foo', srcs = ['foo.in'])"); | |
| write("foo/foo.in"); | |
| if (keepGoing) { | |
| assertThrows( | |
| BuildFailedException.class, () -> buildTarget("//foo:foo", "//foo:analysis_failure")); | |
| assertSingleOutputBuilt("//foo:foo"); | |
| } else { | |
| assertThrows( | |
| ViewCreationFailedException.class, | |
| () -> buildTarget("//foo:foo", "//foo:analysis_failure")); | |
| } | |
| events.assertContainsError("rule '//foo:missing' does not exist"); | |
| // TODO(b/227138583) Update this. | |
| if (mergedAnalysisExecution) { | |
| if (keepGoing) { | |
| assertThat(getLabelsOfAnalyzedTargets()).contains("//foo:foo"); | |
| assertThat(getLabelsOfBuiltTargets()).containsExactly("//foo:foo"); | |
| } else { | |
| assertThat(getBuildResultListener().getBuiltTargets()).isEmpty(); | |
| } | |
| } | |
| } | |
| @Test | |
| public void analysisAndExecutionFailure_keepGoing_bothReported() throws Exception { | |
| addOptions("--keep_going"); | |
| writeMyRuleBzl(); | |
| write( | |
| "foo/BUILD", | |
| "load('//foo:my_rule.bzl', 'my_rule')", | |
| "my_rule(name = 'execution_failure', srcs = ['missing'])", | |
| "my_rule(name = 'analysis_failure', srcs = ['foo.in'], deps = [':missing'])"); | |
| write("foo/foo.in"); | |
| assertThrows( | |
| BuildFailedException.class, | |
| () -> buildTarget("//foo:analysis_failure", "//foo:execution_failure")); | |
| events.assertContainsError( | |
| "Action foo/execution_failure.out failed: missing input file '//foo:missing'"); | |
| events.assertContainsError("rule '//foo:missing' does not exist"); | |
| assertThat(getLabelsOfAnalyzedTargets()).contains("//foo:execution_failure"); | |
| assertThat(getLabelsOfBuiltTargets()).isEmpty(); | |
| } | |
| @Test | |
| public void symlinkPlantedLocalAction_success() throws Exception { | |
| addOptions("--spawn_strategy=standalone"); | |
| write( | |
| "foo/BUILD", | |
| "genrule(", | |
| " name = 'foo',", | |
| " srcs = ['foo.in'],", | |
| " outs = ['foo.out'],", | |
| " cmd = 'cp $< $@'", | |
| ")"); | |
| write("foo/foo.in"); | |
| BuildResult result = buildTarget("//foo:foo"); | |
| assertThat(result.getSuccess()).isTrue(); | |
| assertSingleOutputBuilt("//foo:foo"); | |
| } | |
| @Test | |
| public void symlinksPlanted() throws Exception { | |
| Path execroot = directories.getExecRoot(directories.getWorkspace().getBaseName()); | |
| writeMyRuleBzl(); | |
| Path fooDir = | |
| write( | |
| "foo/BUILD", | |
| "load('//foo:my_rule.bzl', 'my_rule')", | |
| "my_rule(name = 'foo', srcs = ['foo.in'])") | |
| .getParentDirectory(); | |
| write("foo/foo.in"); | |
| Path unusedDir = write("unused/dummy").getParentDirectory(); | |
| // Before the build: no symlink. | |
| assertThat(execroot.getRelative("foo").exists()).isFalse(); | |
| buildTarget("//foo:foo"); | |
| // After the build: symlinks to the source directory, even unused packages. | |
| assertThat(execroot.getRelative("foo").resolveSymbolicLinks()).isEqualTo(fooDir); | |
| assertThat(execroot.getRelative("unused").resolveSymbolicLinks()).isEqualTo(unusedDir); | |
| } | |
| @Test | |
| public void symlinksReplantedEachBuild() throws Exception { | |
| Path execroot = directories.getExecRoot(directories.getWorkspace().getBaseName()); | |
| writeMyRuleBzl(); | |
| Path fooDir = | |
| write( | |
| "foo/BUILD", | |
| "load('//foo:my_rule.bzl', 'my_rule')", | |
| "my_rule(name = 'foo', srcs = ['foo.in'])") | |
| .getParentDirectory(); | |
| write("foo/foo.in"); | |
| Path unusedDir = write("unused/dummy").getParentDirectory(); | |
| buildTarget("//foo:foo"); | |
| // After the 1st build: symlinks to the source directory, even unused packages. | |
| assertThat(execroot.getRelative("foo").resolveSymbolicLinks()).isEqualTo(fooDir); | |
| assertThat(execroot.getRelative("unused").resolveSymbolicLinks()).isEqualTo(unusedDir); | |
| unusedDir.deleteTree(); | |
| buildTarget("//foo:foo"); | |
| // After the 2nd build: symlink to unusedDir is gone, since the package itself was deleted. | |
| assertThat(execroot.getRelative("foo").resolveSymbolicLinks()).isEqualTo(fooDir); | |
| assertThat(execroot.getRelative("unused").exists()).isFalse(); | |
| } | |
| } |