blob: adebfeac1dbf755505568533ff7c4270923cfe32 [file] [log] [blame]
// 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.base.Preconditions.checkArgument;
import static com.google.common.base.Preconditions.checkState;
import com.google.devtools.build.lib.vfs.FileSystem;
import com.google.devtools.build.lib.vfs.Path;
import com.google.devtools.build.lib.vfs.PathFragment;
import java.io.IOException;
import java.util.HashSet;
import java.util.Set;
/**
* A fake in-process sandboxfs implementation that uses symlinks on the Bazel file system API.
*/
final class FakeSandboxfsProcess implements SandboxfsProcess {
/** File system on which the fake sandboxfs instance operates. */
private final FileSystem fileSystem;
/** Directory on which the sandboxfs is serving. */
private final PathFragment mountPoint;
/**
* Tracker for the sandbox names that currently exist in the sandbox.
*
* <p>Used to catch mistakes in creating an already-existing sandbox or deleting a non-existent
* sandbox.
*/
private final Set<String> activeSandboxes = new HashSet<>();
/**
* Whether this "process" is valid or not. Used to better represent the workflow of a real
* sandboxfs subprocess.
*/
private boolean alive = true;
/**
* Initializes a new sandboxfs process instance.
*
* <p>To better represent reality, this ensures that the mount point is present and valid.
*
* @param fileSystem file system on which the fake sandboxfs instance operates
* @param mountPoint directory on which the sandboxfs instance is serving
* @throws IOException if the mount point is missing
*/
FakeSandboxfsProcess(FileSystem fileSystem, PathFragment mountPoint) throws IOException {
if (!fileSystem.getPath(mountPoint).exists()) {
throw new IOException("Mount point " + mountPoint + " does not exist");
} else if (!fileSystem.getPath(mountPoint).isDirectory()) {
throw new IOException("Mount point " + mountPoint + " is not a directory");
}
this.fileSystem = fileSystem;
this.mountPoint = mountPoint;
}
@Override
public Path getMountPoint() {
return fileSystem.getPath(mountPoint);
}
@Override
public synchronized boolean isAlive() {
return alive;
}
@Override
public synchronized void destroy() {
alive = false;
}
@Override
public synchronized void createSandbox(String name, SandboxCreator creator) throws IOException {
checkState(alive, "Cannot be called after destroy()");
checkArgument(!PathFragment.containsSeparator(name));
checkArgument(!activeSandboxes.contains(name), "Sandbox %s mapped more than once", name);
activeSandboxes.add(name);
creator.create(
(path, underlyingPath, writable) -> {
checkArgument(
path.isAbsolute(),
"Mapping specifications are expected to be absolute but %s is not",
path);
Path link =
fileSystem.getPath(mountPoint).getRelative(name).getRelative(path.toRelative());
link.getParentDirectory().createDirectoryAndParents();
Path target = fileSystem.getPath(underlyingPath);
if (!target.exists()) {
// Not a requirement for the creation of a symbolic link but this reflects the behavior
// of the real sandboxfs.
throw new IOException("Target " + underlyingPath + " does not exist");
}
if (target.isSymbolicLink()) {
// sandboxfs is able to expose symlinks as they are in the underlying file system.
// Mimic this behavior by respecting the symlink in that case, instead of just creating
// a new symlink that points to the actual target.
link.createSymbolicLink(target.readSymbolicLink());
} else {
link.createSymbolicLink(fileSystem.getPath(underlyingPath));
}
});
}
@Override
public synchronized void destroySandbox(String name) throws IOException {
checkState(alive, "Cannot be called after destroy()");
checkArgument(!PathFragment.containsSeparator(name));
checkArgument(activeSandboxes.contains(name), "Sandbox %s not previously created", name);
activeSandboxes.remove(name);
fileSystem.getPath(mountPoint).getRelative(name).deleteTree();
}
}