// Copyright 2014 Google Inc. 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.skyframe;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Sets;
import com.google.devtools.build.lib.pkgcache.PathPackageLocator;
import com.google.devtools.build.lib.util.Pair;
import com.google.devtools.build.lib.vfs.Path;
import com.google.devtools.build.lib.vfs.PathFragment;
import com.google.devtools.build.lib.vfs.RootedPath;
import com.google.devtools.build.skyframe.SkyFunction;
import com.google.devtools.build.skyframe.SkyFunctionException;
import com.google.devtools.build.skyframe.SkyFunctionException.Transience;
import com.google.devtools.build.skyframe.SkyKey;
import com.google.devtools.build.skyframe.SkyValue;
import java.util.LinkedHashSet;
import java.util.concurrent.atomic.AtomicReference;
import javax.annotation.Nullable;
/**
* A {@link SkyFunction} for {@link FileValue}s.
*
*
Most of the complexity in the implementation is associated to handling symlinks. Namely,
* this class makes sure that {@code FileValue}s corresponding to symlinks are correctly invalidated
* if the destination of the symlink is invalidated. Directory symlinks are also covered.
*/
public class FileFunction implements SkyFunction {
private final AtomicReference pkgLocator;
private final ExternalFilesHelper externalFilesHelper;
public FileFunction(AtomicReference pkgLocator,
ExternalFilesHelper externalFilesHelper) {
this.pkgLocator = pkgLocator;
this.externalFilesHelper = externalFilesHelper;
}
@Override
public SkyValue compute(SkyKey skyKey, Environment env) throws FileFunctionException {
RootedPath rootedPath = (RootedPath) skyKey.argument();
RootedPath realRootedPath = rootedPath;
FileStateValue realFileStateValue = null;
PathFragment relativePath = rootedPath.getRelativePath();
// Resolve ancestor symlinks, but only if the current file is not the filesystem root (has no
// parent) or a package path root (treated opaquely and handled by skyframe's DiffAwareness
// interface) or otherwise assumed to be immutable (handling ancestors would add dependencies
// too aggressively). Note that this is the first thing we do - if an ancestor is part of a
// symlink cycle, we want to detect that quickly as it gives a more informative error message
// than we'd get doing bogus filesystem operations.
if (!relativePath.equals(PathFragment.EMPTY_FRAGMENT)
&& !externalFilesHelper.shouldAssumeImmutable(rootedPath)) {
Pair resolvedState =
resolveFromAncestors(rootedPath, env);
if (resolvedState == null) {
return null;
}
realRootedPath = resolvedState.getFirst();
realFileStateValue = resolvedState.getSecond();
}
FileStateValue fileStateValue = (FileStateValue) env.getValue(FileStateValue.key(rootedPath));
if (fileStateValue == null) {
return null;
}
if (realFileStateValue == null) {
realFileStateValue = fileStateValue;
}
LinkedHashSet seenPaths = Sets.newLinkedHashSet();
while (realFileStateValue.getType().equals(FileStateValue.Type.SYMLINK)) {
if (!seenPaths.add(realRootedPath)) {
FileSymlinkCycleException fileSymlinkCycleException =
makeFileSymlinkCycleException(realRootedPath, seenPaths);
if (env.getValue(FileSymlinkCycleUniquenessValue.key(fileSymlinkCycleException.getCycle()))
== null) {
// Note that this dependency is merely to ensure that each unique cycle gets reported
// exactly once.
return null;
}
throw new FileFunctionException(fileSymlinkCycleException);
}
Pair resolvedState = getSymlinkTargetRootedPath(realRootedPath,
realFileStateValue.getSymlinkTarget(), env);
if (resolvedState == null) {
return null;
}
realRootedPath = resolvedState.getFirst();
realFileStateValue = resolvedState.getSecond();
}
return FileValue.value(rootedPath, fileStateValue, realRootedPath, realFileStateValue);
}
/**
* Returns the path and file state of {@code rootedPath}, accounting for ancestor symlinks, or
* {@code null} if there was a missing dep.
*/
@Nullable
private Pair resolveFromAncestors(RootedPath rootedPath,
Environment env) throws FileFunctionException {
PathFragment relativePath = rootedPath.getRelativePath();
RootedPath realRootedPath = rootedPath;
FileValue parentFileValue = null;
if (!relativePath.equals(PathFragment.EMPTY_FRAGMENT)) {
RootedPath parentRootedPath = RootedPath.toRootedPath(rootedPath.getRoot(),
relativePath.getParentDirectory());
parentFileValue = (FileValue) env.getValue(FileValue.key(parentRootedPath));
if (parentFileValue == null) {
return null;
}
PathFragment baseName = new PathFragment(relativePath.getBaseName());
RootedPath parentRealRootedPath = parentFileValue.realRootedPath();
realRootedPath = RootedPath.toRootedPath(parentRealRootedPath.getRoot(),
parentRealRootedPath.getRelativePath().getRelative(baseName));
}
FileStateValue realFileStateValue =
(FileStateValue) env.getValue(FileStateValue.key(realRootedPath));
if (realFileStateValue == null) {
return null;
}
if (realFileStateValue.getType() != FileStateValue.Type.NONEXISTENT
&& parentFileValue != null && !parentFileValue.isDirectory()) {
String type = realFileStateValue.getType().toString().toLowerCase();
String message = type + " " + rootedPath.asPath() + " exists but its parent "
+ "directory " + parentFileValue.realRootedPath().asPath() + " doesn't exist.";
throw new FileFunctionException(new InconsistentFilesystemException(message),
Transience.TRANSIENT);
}
return Pair.of(realRootedPath, realFileStateValue);
}
/**
* Returns the symlink target and file state of {@code rootedPath}'s symlink to
* {@code symlinkTarget}, accounting for ancestor symlinks, or {@code null} if there was a
* missing dep.
*/
@Nullable
private Pair getSymlinkTargetRootedPath(RootedPath rootedPath,
PathFragment symlinkTarget, Environment env) throws FileFunctionException {
if (symlinkTarget.isAbsolute()) {
Path path = rootedPath.asPath().getFileSystem().getRootDirectory().getRelative(
symlinkTarget);
return resolveFromAncestors(
RootedPath.toRootedPathMaybeUnderRoot(path, pkgLocator.get().getPathEntries()), env);
}
Path path = rootedPath.asPath();
Path symlinkTargetPath;
if (path.getParentDirectory() != null) {
RootedPath parentRootedPath = RootedPath.toRootedPathMaybeUnderRoot(
path.getParentDirectory(), pkgLocator.get().getPathEntries());
FileValue parentFileValue = (FileValue) env.getValue(FileValue.key(parentRootedPath));
if (parentFileValue == null) {
return null;
}
symlinkTargetPath = parentFileValue.realRootedPath().asPath().getRelative(symlinkTarget);
} else {
// This means '/' is a symlink to 'symlinkTarget'.
symlinkTargetPath = path.getRelative(symlinkTarget);
}
RootedPath symlinkTargetRootedPath = RootedPath.toRootedPathMaybeUnderRoot(symlinkTargetPath,
pkgLocator.get().getPathEntries());
return resolveFromAncestors(symlinkTargetRootedPath, env);
}
private FileSymlinkCycleException makeFileSymlinkCycleException(RootedPath startOfCycle,
Iterable symlinkPaths) {
boolean inPathToCycle = true;
ImmutableList.Builder pathToCycleBuilder = ImmutableList.builder();
ImmutableList.Builder cycleBuilder = ImmutableList.builder();
for (RootedPath path : symlinkPaths) {
if (path.equals(startOfCycle)) {
inPathToCycle = false;
}
if (inPathToCycle) {
pathToCycleBuilder.add(path);
} else {
cycleBuilder.add(path);
}
}
return new FileSymlinkCycleException(pathToCycleBuilder.build(), cycleBuilder.build());
}
@Nullable
@Override
public String extractTag(SkyKey skyKey) {
return null;
}
/**
* Used to declare all the exception types that can be wrapped in the exception thrown by
* {@link FileFunction#compute}.
*/
private static final class FileFunctionException extends SkyFunctionException {
public FileFunctionException(InconsistentFilesystemException e, Transience transience) {
super(e, transience);
}
public FileFunctionException(FileSymlinkCycleException e) {
super(e, Transience.PERSISTENT);
}
}
}