Add a new SandboxfsSandboxedSpawn to spawn actions using sandboxfs.

RELNOTES: None.
PiperOrigin-RevId: 190062172

3 files changed, 217 insertions, 33 deletions

diff --git a/src/test/java/com/google/devtools/build/lib/sandbox/SandboxedSpawnTest.java b/src/test/java/com/google/devtools/build/lib/sandbox/SandboxedSpawnTest.java
new file mode 100644
index 0000000000..e6d8c558a7
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/sandbox/SandboxedSpawnTest.java
@@ -0,0 +1,84 @@
+// Copyright 2018 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.sandbox;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.fail;
+
+import com.google.common.collect.ImmutableSet;
+import com.google.devtools.build.lib.vfs.FileSystemUtils;
+import com.google.devtools.build.lib.vfs.Path;
+import com.google.devtools.build.lib.vfs.PathFragment;
+import com.google.devtools.build.lib.vfs.Symlinks;
+import java.io.IOException;
+import java.util.Set;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Tests for {@link SandboxedSpawn}. */
+@RunWith(JUnit4.class)
+public class SandboxedSpawnTest extends SandboxTestCase {
+
+  @Test
+  public void testMoveOutputs() throws Exception {
+    Path execRoot = testRoot.getRelative("execroot");
+    execRoot.createDirectory();
+
+    Path outputFile = execRoot.getRelative("very/output.txt");
+    Path outputLink = execRoot.getRelative("very/output.link");
+    Path outputDangling = execRoot.getRelative("very/output.dangling");
+    Path outputDir = execRoot.getRelative("very/output.dir");
+    Path outputInUncreatedTargetDir = execRoot.getRelative("uncreated/output.txt");
+
+    Set<PathFragment> outputs = ImmutableSet.of(
+        outputFile.relativeTo(execRoot),
+        outputLink.relativeTo(execRoot),
+        outputDangling.relativeTo(execRoot),
+        outputDir.relativeTo(execRoot),
+        outputInUncreatedTargetDir.relativeTo(execRoot));
+    for (PathFragment path : outputs) {
+      execRoot.getRelative(path).getParentDirectory().createDirectoryAndParents();
+    }
+
+    FileSystemUtils.createEmptyFile(outputFile);
+    outputLink.createSymbolicLink(PathFragment.create("output.txt"));
+    outputDangling.createSymbolicLink(PathFragment.create("doesnotexist"));
+    outputDir.createDirectory();
+    FileSystemUtils.createEmptyFile(outputDir.getRelative("test.txt"));
+    FileSystemUtils.createEmptyFile(outputInUncreatedTargetDir);
+
+    Path outputsDir = testRoot.getRelative("outputs");
+    outputsDir.createDirectory();
+    outputsDir.getRelative("very").createDirectory();
+    SandboxedSpawn.moveOutputs(outputs, execRoot, outputsDir);
+
+    assertThat(outputsDir.getRelative("very/output.txt").isFile(Symlinks.NOFOLLOW)).isTrue();
+    assertThat(outputsDir.getRelative("very/output.link").isSymbolicLink()).isTrue();
+    assertThat(outputsDir.getRelative("very/output.link").resolveSymbolicLinks())
+        .isEqualTo(outputsDir.getRelative("very/output.txt"));
+    assertThat(outputsDir.getRelative("very/output.dangling").isSymbolicLink()).isTrue();
+    try {
+      outputsDir.getRelative("very/output.dangling").resolveSymbolicLinks();
+      fail("expected IOException");
+    } catch (IOException e) {
+      // Ignored.
+    }
+    assertThat(outputsDir.getRelative("very/output.dir").isDirectory(Symlinks.NOFOLLOW)).isTrue();
+    assertThat(outputsDir.getRelative("very/output.dir/test.txt").isFile(Symlinks.NOFOLLOW))
+        .isTrue();
+    assertThat(outputsDir.getRelative("uncreated/output.txt").isFile(Symlinks.NOFOLLOW)).isTrue();
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/sandbox/SandboxfsSandboxedSpawnTest.java b/src/test/java/com/google/devtools/build/lib/sandbox/SandboxfsSandboxedSpawnTest.java
new file mode 100644
index 0000000000..e83520eb23
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/sandbox/SandboxfsSandboxedSpawnTest.java
@@ -0,0 +1,127 @@
+// Copyright 2018 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.sandbox;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import com.google.devtools.build.lib.vfs.FileSystemUtils;
+import com.google.devtools.build.lib.vfs.Path;
+import com.google.devtools.build.lib.vfs.PathFragment;
+import com.google.devtools.build.lib.vfs.Symlinks;
+import java.io.IOException;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Tests for {@link SandboxfsSandboxedSpawn}. */
+@RunWith(JUnit4.class)
+public class SandboxfsSandboxedSpawnTest extends SandboxTestCase {
+  private Path workspaceDir;
+  private Path outerDir;
+  private SandboxfsProcess sandboxfs;
+
+  @Before
+  public final void setupTestDirs() throws IOException {
+    workspaceDir = testRoot.getRelative("workspace");
+    workspaceDir.createDirectory();
+    outerDir = testRoot.getRelative("scratch");
+    outerDir.createDirectory();
+
+    Path mountPoint = testRoot.getRelative("sandbox");
+    mountPoint.createDirectory();
+    sandboxfs = new FakeSandboxfsProcess(
+        mountPoint.getFileSystem(), mountPoint.asFragment());
+    }
+
+  @Test
+  public void testCreateFileSystem() throws Exception {
+    Path helloTxt = workspaceDir.getRelative("hello.txt");
+    FileSystemUtils.createEmptyFile(helloTxt);
+
+    SandboxedSpawn spawn =
+        new SandboxfsSandboxedSpawn(
+            sandboxfs,
+            outerDir,
+            ImmutableList.of("/bin/true"),
+            ImmutableMap.of(),
+            ImmutableMap.of(PathFragment.create("such/input.txt"), helloTxt),
+            ImmutableSet.of(PathFragment.create("very/output.txt")),
+            ImmutableSet.of(PathFragment.create("wow/writable")));
+
+    spawn.createFileSystem();
+    Path execRoot = spawn.getSandboxExecRoot();
+
+    assertThat(execRoot.getRelative("such/input.txt").isSymbolicLink()).isTrue();
+    assertThat(execRoot.getRelative("such/input.txt").resolveSymbolicLinks()).isEqualTo(helloTxt);
+    assertThat(execRoot.getRelative("very").isDirectory()).isTrue();
+    assertThat(execRoot.getRelative("wow/writable").isDirectory()).isTrue();
+  }
+
+  @Test
+  public void testDelete() throws Exception {
+    Path helloTxt = workspaceDir.getRelative("hello.txt");
+    FileSystemUtils.createEmptyFile(helloTxt);
+
+    SandboxedSpawn spawn = new SandboxfsSandboxedSpawn(
+        sandboxfs,
+        outerDir,
+        ImmutableList.of("/bin/true"),
+        ImmutableMap.of(),
+        ImmutableMap.of(PathFragment.create("such/input.txt"), helloTxt),
+        ImmutableSet.of(PathFragment.create("very/output.txt")),
+        ImmutableSet.of(PathFragment.create("wow/writable")));
+    spawn.createFileSystem();
+    Path execRoot = spawn.getSandboxExecRoot();
+
+    // Pretend to do some work inside the execRoot.
+    execRoot.getRelative("tempdir").createDirectory();
+    FileSystemUtils.createEmptyFile(execRoot.getRelative("very/output.txt"));
+    FileSystemUtils.createEmptyFile(execRoot.getRelative("wow/writable/temp.txt"));
+
+    spawn.delete();
+
+    assertThat(execRoot.exists()).isFalse();
+  }
+
+  @Test
+  public void testCopyOutputs() throws Exception {
+    // These tests are very simple because we just rely on SandboxedSpawnTest.testMoveOutputs to
+    // properly verify all corner cases.
+    PathFragment outputFile = PathFragment.create("very/output.txt");
+
+    SandboxedSpawn spawn =
+        new SandboxfsSandboxedSpawn(
+            sandboxfs,
+            outerDir,
+            ImmutableList.of("/bin/true"),
+            ImmutableMap.of(),
+            ImmutableMap.of(),
+            ImmutableSet.of(outputFile),
+            ImmutableSet.of());
+    spawn.createFileSystem();
+    Path execRoot = spawn.getSandboxExecRoot();
+
+    FileSystemUtils.createEmptyFile(execRoot.getRelative(outputFile));
+
+    Path outputsDir = testRoot.getRelative("outputs");
+    outputsDir.getRelative(outputFile.getParentDirectory()).createDirectoryAndParents();
+    spawn.copyOutputs(outputsDir);
+
+    assertThat(outputsDir.getRelative(outputFile).isFile(Symlinks.NOFOLLOW)).isTrue();
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/sandbox/SymlinkedSandboxedSpawnTest.java b/src/test/java/com/google/devtools/build/lib/sandbox/SymlinkedSandboxedSpawnTest.java
index 6f797afbd4..5e24deea4a 100644
--- a/src/test/java/com/google/devtools/build/lib/sandbox/SymlinkedSandboxedSpawnTest.java
+++ b/src/test/java/com/google/devtools/build/lib/sandbox/SymlinkedSandboxedSpawnTest.java
@@ -14,7 +14,6 @@
 package com.google.devtools.build.lib.sandbox;
 
 import static com.google.common.truth.Truth.assertThat;
-import static org.junit.Assert.fail;
 
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
@@ -103,52 +102,26 @@ public class SymlinkedSandboxedSpawnTest extends SandboxTestCase {
 
   @Test
   public void copyOutputs() throws Exception {
+    // These tests are very simple because we just rely on SandboxedSpawnTest.testMoveOutputs to
+    // properly verify all corner cases.
     Path outputFile = execRoot.getRelative("very/output.txt");
-    Path outputLink = execRoot.getRelative("very/output.link");
-    Path outputDangling = execRoot.getRelative("very/output.dangling");
-    Path outputDir = execRoot.getRelative("very/output.dir");
-    Path outputInUncreatedTargetDir = execRoot.getRelative("uncreated/output.txt");
 
     SymlinkedSandboxedSpawn symlinkedExecRoot =
         new SymlinkedSandboxedSpawn(
             sandboxDir,
             execRoot,
             ImmutableList.of("/bin/true"),
-            ImmutableMap.<String, String>of(),
-            ImmutableMap.<PathFragment, Path>of(),
-            ImmutableSet.of(
-                outputFile.relativeTo(execRoot),
-                outputLink.relativeTo(execRoot),
-                outputDangling.relativeTo(execRoot),
-                outputDir.relativeTo(execRoot),
-                outputInUncreatedTargetDir.relativeTo(execRoot)),
-            ImmutableSet.<Path>of());
+            ImmutableMap.of(),
+            ImmutableMap.of(),
+            ImmutableSet.of(outputFile.relativeTo(execRoot)),
+            ImmutableSet.of());
     symlinkedExecRoot.createFileSystem();
 
     FileSystemUtils.createEmptyFile(outputFile);
-    outputLink.createSymbolicLink(PathFragment.create("output.txt"));
-    outputDangling.createSymbolicLink(PathFragment.create("doesnotexist"));
-    outputDir.createDirectory();
-    FileSystemUtils.createEmptyFile(outputDir.getRelative("test.txt"));
-    FileSystemUtils.createEmptyFile(outputInUncreatedTargetDir);
 
     outputsDir.getRelative("very").createDirectory();
     symlinkedExecRoot.copyOutputs(outputsDir);
 
     assertThat(outputsDir.getRelative("very/output.txt").isFile(Symlinks.NOFOLLOW)).isTrue();
-    assertThat(outputsDir.getRelative("very/output.link").isSymbolicLink()).isTrue();
-    assertThat(outputsDir.getRelative("very/output.link").resolveSymbolicLinks())
-        .isEqualTo(outputsDir.getRelative("very/output.txt"));
-    assertThat(outputsDir.getRelative("very/output.dangling").isSymbolicLink()).isTrue();
-    try {
-      outputsDir.getRelative("very/output.dangling").resolveSymbolicLinks();
-      fail("expected IOException");
-    } catch (IOException e) {
-      // Ignored.
-    }
-    assertThat(outputsDir.getRelative("very/output.dir").isDirectory(Symlinks.NOFOLLOW)).isTrue();
-    assertThat(outputsDir.getRelative("very/output.dir/test.txt").isFile(Symlinks.NOFOLLOW))
-        .isTrue();
-    assertThat(outputsDir.getRelative("uncreated/output.txt").isFile(Symlinks.NOFOLLOW)).isTrue();
   }
 }