blob: 77104d996b1ee30a09d3be118e932465c6bf8a8c [file] [log] [blame]
// Copyright 2014 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.skyframe;
import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.base.Preconditions.checkNotNull;
import static com.google.common.base.Preconditions.checkState;
import static java.util.concurrent.TimeUnit.MINUTES;
import com.google.common.base.MoreObjects;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Sets;
import com.google.common.flogger.GoogleLogger;
import com.google.common.io.BaseEncoding;
import com.google.devtools.build.lib.actions.ActionInput;
import com.google.devtools.build.lib.actions.ActionInputMap;
import com.google.devtools.build.lib.actions.Artifact;
import com.google.devtools.build.lib.actions.Artifact.ArchivedTreeArtifact;
import com.google.devtools.build.lib.actions.Artifact.SpecialArtifact;
import com.google.devtools.build.lib.actions.Artifact.TreeFileArtifact;
import com.google.devtools.build.lib.actions.ArtifactPathResolver;
import com.google.devtools.build.lib.actions.FileArtifactValue;
import com.google.devtools.build.lib.actions.FileStateType;
import com.google.devtools.build.lib.actions.FileStateValue;
import com.google.devtools.build.lib.actions.FilesetManifest;
import com.google.devtools.build.lib.actions.FilesetManifest.RelativeSymlinkBehaviorWithoutError;
import com.google.devtools.build.lib.actions.FilesetOutputSymlink;
import com.google.devtools.build.lib.actions.cache.MetadataHandler;
import com.google.devtools.build.lib.util.io.TimestampGranularityMonitor;
import com.google.devtools.build.lib.vfs.DigestUtils;
import com.google.devtools.build.lib.vfs.Dirent;
import com.google.devtools.build.lib.vfs.FileStatus;
import com.google.devtools.build.lib.vfs.FileStatusWithDigest;
import com.google.devtools.build.lib.vfs.FileStatusWithDigestAdapter;
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.lib.vfs.Symlinks;
import com.google.devtools.build.lib.vfs.XattrProvider;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.atomic.AtomicBoolean;
import javax.annotation.Nullable;
/**
* Handler provided by {@link ActionExecutionFunction} which allows the execution engine to obtain
* {@linkplain FileArtifactValue metadata} about inputs and outputs and to store metadata about an
* action's outputs for purposes of creating the final {@link ActionExecutionValue}.
*
* <p>The handler can be in one of two modes. After construction, it acts as a cache for input and
* output metadata while {@link com.google.devtools.build.lib.actions.ActionCacheChecker} determines
* whether the action needs to be executed. If the action needs to be executed (i.e. no action cache
* hit), {@link #prepareForActionExecution} is called. This call switches the handler to a mode
* where it accepts {@linkplain com.google.devtools.build.lib.actions.cache.MetadataInjector
* injected output data}, or otherwise obtains metadata from the filesystem. Freshly created output
* files are set read-only and executable <em>before</em> statting them to ensure that the stat's
* ctime is up to date.
*
* <p>After action execution, {@link #getMetadata} should be called on each of the action's outputs
* (except those that were {@linkplain #artifactOmitted omitted}) to ensure that declared outputs
* were in fact created and are valid.
*/
final class ActionMetadataHandler implements MetadataHandler {
private static final GoogleLogger logger = GoogleLogger.forEnclosingClass();
/**
* Creates a new metadata handler.
*
* <p>If the handler is for use during input discovery, calling {@link #getMetadata} with an
* artifact which is neither in {@code inputArtifactData} nor {@code outputs} is tolerated and
* will return {@code null}. To subsequently transform the handler for regular action execution
* (where such a call is not permitted), use {@link #transformAfterInputDiscovery}.
*/
static ActionMetadataHandler create(
ActionInputMap inputArtifactData,
boolean forInputDiscovery,
boolean archivedTreeArtifactsEnabled,
ImmutableSet<Artifact> outputs,
XattrProvider xattrProvider,
TimestampGranularityMonitor tsgm,
ArtifactPathResolver artifactPathResolver,
PathFragment execRoot,
PathFragment derivedPathPrefix,
Map<Artifact, ImmutableList<FilesetOutputSymlink>> expandedFilesets) {
return new ActionMetadataHandler(
inputArtifactData,
forInputDiscovery,
archivedTreeArtifactsEnabled,
outputs,
xattrProvider,
tsgm,
artifactPathResolver,
execRoot,
derivedPathPrefix,
createFilesetMapping(expandedFilesets, execRoot),
new OutputStore());
}
private final ActionInputMap inputArtifactData;
private final boolean forInputDiscovery;
private final boolean archivedTreeArtifactsEnabled;
private final ImmutableMap<PathFragment, FileArtifactValue> filesetMapping;
private final Set<Artifact> omittedOutputs = Sets.newConcurrentHashSet();
private final ImmutableSet<Artifact> outputs;
private final XattrProvider xattrProvider;
private final TimestampGranularityMonitor tsgm;
private final ArtifactPathResolver artifactPathResolver;
private final PathFragment execRoot;
private final PathFragment derivedPathPrefix;
private final AtomicBoolean executionMode = new AtomicBoolean(false);
private final OutputStore store;
private ActionMetadataHandler(
ActionInputMap inputArtifactData,
boolean forInputDiscovery,
boolean archivedTreeArtifactsEnabled,
ImmutableSet<Artifact> outputs,
XattrProvider xattrProvider,
TimestampGranularityMonitor tsgm,
ArtifactPathResolver artifactPathResolver,
PathFragment execRoot,
PathFragment derivedPathPrefix,
ImmutableMap<PathFragment, FileArtifactValue> filesetMapping,
OutputStore store) {
this.inputArtifactData = checkNotNull(inputArtifactData);
this.forInputDiscovery = forInputDiscovery;
this.archivedTreeArtifactsEnabled = archivedTreeArtifactsEnabled;
this.outputs = checkNotNull(outputs);
this.xattrProvider = xattrProvider;
this.tsgm = checkNotNull(tsgm);
this.artifactPathResolver = checkNotNull(artifactPathResolver);
this.execRoot = checkNotNull(execRoot);
this.derivedPathPrefix = checkNotNull(derivedPathPrefix);
this.filesetMapping = checkNotNull(filesetMapping);
this.store = checkNotNull(store);
}
/**
* Returns a new handler mostly identical to this one, except uses the given {@code store} and
* does not permit {@link #getMetadata} to be called with an artifact which is neither in inputs
* nor outputs.
*
* <p>The returned handler will be in the mode for action cache checking. To prepare it for action
* execution, call {@link #prepareForActionExecution}.
*
* <p>This method is designed to be called after input discovery when a fresh handler is needed
* but all of the parameters in {@link #create} would be the same as the original handler.
*/
ActionMetadataHandler transformAfterInputDiscovery(OutputStore store) {
return new ActionMetadataHandler(
inputArtifactData,
/*forInputDiscovery=*/ false,
archivedTreeArtifactsEnabled,
outputs,
xattrProvider,
tsgm,
artifactPathResolver,
execRoot,
derivedPathPrefix,
filesetMapping,
store);
}
/**
* If {@code value} represents an existing file, returns it as is, otherwise throws {@link
* FileNotFoundException}.
*/
private static FileArtifactValue checkExists(FileArtifactValue value, Artifact artifact)
throws FileNotFoundException {
if (FileArtifactValue.MISSING_FILE_MARKER.equals(value)
|| FileArtifactValue.OMITTED_FILE_MARKER.equals(value)) {
throw new FileNotFoundException(artifact + " does not exist");
}
return checkNotNull(value, artifact);
}
/**
* If {@code value} represents an existing tree artifact, returns it as is, otherwise throws
* {@link FileNotFoundException}.
*/
private static TreeArtifactValue checkExists(TreeArtifactValue value, Artifact artifact)
throws FileNotFoundException {
if (TreeArtifactValue.MISSING_TREE_ARTIFACT.equals(value)
|| TreeArtifactValue.OMITTED_TREE_MARKER.equals(value)) {
throw new FileNotFoundException(artifact + " does not exist");
}
return checkNotNull(value, artifact);
}
private static ImmutableMap<PathFragment, FileArtifactValue> createFilesetMapping(
Map<Artifact, ImmutableList<FilesetOutputSymlink>> filesets, PathFragment execRoot) {
Map<PathFragment, FileArtifactValue> filesetMap = new HashMap<>();
for (Map.Entry<Artifact, ImmutableList<FilesetOutputSymlink>> entry : filesets.entrySet()) {
FilesetManifest fileset =
FilesetManifest.constructFilesetManifestWithoutError(
entry.getValue(), execRoot, RelativeSymlinkBehaviorWithoutError.RESOLVE);
for (Map.Entry<String, FileArtifactValue> favEntry :
fileset.getArtifactValues().entrySet()) {
if (favEntry.getValue().getDigest() != null) {
filesetMap.put(PathFragment.create(favEntry.getKey()), favEntry.getValue());
}
}
}
return ImmutableMap.copyOf(filesetMap);
}
private boolean isKnownOutput(Artifact artifact) {
return outputs.contains(artifact)
|| (artifact.hasParent() && outputs.contains(artifact.getParent()));
}
@Override
@Nullable
public FileArtifactValue getMetadata(ActionInput actionInput) throws IOException {
if (!(actionInput instanceof Artifact)) {
PathFragment inputPath = actionInput.getExecPath();
PathFragment filesetKeyPath =
inputPath.startsWith(execRoot) ? inputPath.relativeTo(execRoot) : inputPath;
return filesetMapping.get(filesetKeyPath);
}
Artifact artifact = (Artifact) actionInput;
FileArtifactValue value;
if (!isKnownOutput(artifact)) {
value = inputArtifactData.getMetadata(artifact);
if (value != null) {
return checkExists(value, artifact);
}
checkState(forInputDiscovery, "%s is not present in declared outputs: %s", artifact, outputs);
return null;
}
if (artifact.isMiddlemanArtifact()) {
// A middleman artifact's data was either already injected from the action cache checker using
// #setDigestForVirtualArtifact, or it has the default middleman value.
value = store.getArtifactData(artifact);
if (value != null) {
return checkExists(value, artifact);
}
store.putArtifactData(artifact, FileArtifactValue.DEFAULT_MIDDLEMAN);
return FileArtifactValue.DEFAULT_MIDDLEMAN;
}
if (artifact.isTreeArtifact()) {
TreeArtifactValue tree = getTreeArtifactValue((SpecialArtifact) artifact);
return tree.getMetadata();
}
if (artifact.isChildOfDeclaredDirectory()) {
TreeArtifactValue tree = getTreeArtifactValue(artifact.getParent());
value = tree.getChildValues().getOrDefault(artifact, FileArtifactValue.MISSING_FILE_MARKER);
return checkExists(value, artifact);
}
value = store.getArtifactData(artifact);
if (value != null) {
return checkExists(value, artifact);
}
// No existing metadata; this can happen if the output metadata is not injected after a spawn
// is executed. SkyframeActionExecutor.checkOutputs calls this method for every output file of
// the action, which hits this code path. Another possibility is that an action runs multiple
// spawns, and a subsequent spawn requests the metadata of an output of a previous spawn.
// If necessary, we first call chmod the output file. The FileArtifactValue may use a
// FileContentsProxy, which is based on ctime (affected by chmod).
if (executionMode.get()) {
setPathReadOnlyAndExecutableIfFile(artifactPathResolver.toPath(artifact));
}
value = constructFileArtifactValueFromFilesystem(artifact);
store.putArtifactData(artifact, value);
return checkExists(value, artifact);
}
@Override
public ActionInput getInput(String execPath) {
return inputArtifactData.getInput(execPath);
}
@Override
public void setDigestForVirtualArtifact(Artifact artifact, byte[] digest) {
checkArgument(artifact.isMiddlemanArtifact(), artifact);
checkNotNull(digest, artifact);
store.putArtifactData(artifact, FileArtifactValue.createProxy(digest));
}
@Override
public TreeArtifactValue getTreeArtifactValue(SpecialArtifact artifact) throws IOException {
checkState(artifact.isTreeArtifact(), "%s is not a tree artifact", artifact);
TreeArtifactValue value = store.getTreeArtifactData(artifact);
if (value != null) {
return checkExists(value, artifact);
}
value = constructTreeArtifactValueFromFilesystem(artifact);
store.putTreeArtifactData(artifact, value);
return checkExists(value, artifact);
}
private TreeArtifactValue constructTreeArtifactValueFromFilesystem(SpecialArtifact parent)
throws IOException {
Path treeDir = artifactPathResolver.toPath(parent);
boolean chmod = executionMode.get();
// Make sure the tree artifact root is a regular directory. Note that this is how the action is
// initialized, so this should hold unless the action itself has deleted the root.
if (!treeDir.isDirectory(Symlinks.FOLLOW)) {
if (chmod) {
setPathReadOnlyAndExecutableIfFile(treeDir);
}
return TreeArtifactValue.MISSING_TREE_ARTIFACT;
}
if (chmod) {
setPathReadOnlyAndExecutable(treeDir);
}
TreeArtifactValue.Builder tree = TreeArtifactValue.newBuilder(parent);
TreeArtifactValue.visitTree(
treeDir,
(parentRelativePath, type) -> {
if (chmod && type != Dirent.Type.SYMLINK) {
setPathReadOnlyAndExecutable(treeDir.getRelative(parentRelativePath));
}
if (type == Dirent.Type.DIRECTORY) {
return; // The final TreeArtifactValue does not contain child directories.
}
TreeFileArtifact child = TreeFileArtifact.createTreeOutput(parent, parentRelativePath);
FileArtifactValue metadata;
try {
metadata = constructFileArtifactValueFromFilesystem(child);
} catch (FileNotFoundException e) {
String errorMessage =
String.format(
"Failed to resolve relative path %s inside TreeArtifact %s. "
+ "The associated file is either missing or is an invalid symlink.",
parentRelativePath, treeDir);
throw new IOException(errorMessage, e);
}
tree.putChild(child, metadata);
});
if (archivedTreeArtifactsEnabled) {
ArchivedTreeArtifact archivedTreeArtifact = ArchivedTreeArtifact.createForTree(parent);
FileStatus statNoFollow =
artifactPathResolver.toPath(archivedTreeArtifact).statIfFound(Symlinks.NOFOLLOW);
if (statNoFollow != null) {
tree.setArchivedRepresentation(
archivedTreeArtifact,
constructFileArtifactValue(
archivedTreeArtifact,
FileStatusWithDigestAdapter.maybeAdapt(statNoFollow),
/*injectedDigest=*/ null));
} else {
logger.atInfo().atMostEvery(5, MINUTES).log(
"Archived tree artifact: %s not created", archivedTreeArtifact);
}
}
return tree.build();
}
@Override
public ImmutableSet<TreeFileArtifact> getTreeArtifactChildren(SpecialArtifact treeArtifact) {
checkArgument(treeArtifact.isTreeArtifact(), "%s is not a tree artifact", treeArtifact);
TreeArtifactValue tree = store.getTreeArtifactData(treeArtifact);
return tree != null ? tree.getChildren() : ImmutableSet.of();
}
@Override
public FileArtifactValue constructMetadataForDigest(
Artifact output, FileStatus statNoFollow, byte[] digest) throws IOException {
checkArgument(!output.isSymlink(), "%s is a symlink", output);
checkNotNull(digest, "Missing digest for %s", output);
checkNotNull(statNoFollow, "Missing stat for %s", output);
checkState(
executionMode.get(), "Tried to construct metadata for %s outside of execution", output);
// We already have a stat, so no need to call chmod.
return constructFileArtifactValue(
output, FileStatusWithDigestAdapter.maybeAdapt(statNoFollow), digest);
}
@Override
public void injectFile(Artifact output, FileArtifactValue metadata) {
checkArgument(isKnownOutput(output), "%s is not a declared output of this action", output);
checkArgument(
!output.isTreeArtifact() && !output.isChildOfDeclaredDirectory(),
"Tree artifacts and their children must be injected via injectTree: %s",
output);
store.putArtifactData(output, metadata);
}
@Override
public void injectTree(SpecialArtifact output, TreeArtifactValue tree) {
checkArgument(isKnownOutput(output), "%s is not a declared output of this action", output);
checkArgument(output.isTreeArtifact(), "Output must be a tree artifact: %s", output);
checkArgument(
archivedTreeArtifactsEnabled == tree.getArchivedRepresentation().isPresent(),
"Archived representation presence mismatched for: %s with archivedTreeArtifactsEnabled: %s",
tree,
archivedTreeArtifactsEnabled);
store.putTreeArtifactData(output, tree);
}
@Override
public void markOmitted(Artifact output) {
checkState(executionMode.get(), "Tried to mark %s omitted outside of execution", output);
boolean newlyOmitted = omittedOutputs.add(output);
if (output.isTreeArtifact()) {
// Tolerate marking a tree artifact as omitted multiple times so that callers don't have to
// deduplicate when a tree artifact has several omitted children.
if (newlyOmitted) {
store.putTreeArtifactData((SpecialArtifact) output, TreeArtifactValue.OMITTED_TREE_MARKER);
}
} else {
checkState(newlyOmitted, "%s marked as omitted twice", output);
store.putArtifactData(output, FileArtifactValue.OMITTED_FILE_MARKER);
}
}
@Override
public boolean artifactOmitted(Artifact artifact) {
return omittedOutputs.contains(artifact);
}
@Override
public void resetOutputs(Iterable<? extends Artifact> outputs) {
checkState(
executionMode.get(), "resetOutputs() should only be called from within a running action.");
for (Artifact output : outputs) {
omittedOutputs.remove(output);
store.remove(output);
}
}
/**
* Informs this handler that the action is about to be executed.
*
* <p>Any stale metadata cached in the underlying {@link OutputStore} from action cache checking
* is cleared.
*/
void prepareForActionExecution() {
checkState(!executionMode.getAndSet(true), "Already in execution mode");
store.clear();
}
/**
* Returns the underlying {@link OutputStore} containing metadata cached during the lifetime of
* this handler.
*
* <p>The store may be passed to {@link ActionExecutionValue#createFromOutputStore}.
*/
OutputStore getOutputStore() {
return store;
}
@Override
public String toString() {
return MoreObjects.toStringHelper(this)
.add("outputs", outputs)
.add("store", store)
.add("inputArtifactDataSize", inputArtifactData.sizeForDebugging())
.toString();
}
/** Constructs a new {@link FileArtifactValue} by reading from the file system. */
private FileArtifactValue constructFileArtifactValueFromFilesystem(Artifact artifact)
throws IOException {
return constructFileArtifactValue(artifact, /*statNoFollow=*/ null, /*injectedDigest=*/ null);
}
/** Constructs a new {@link FileArtifactValue}, optionally taking a known stat and digest. */
private FileArtifactValue constructFileArtifactValue(
Artifact artifact,
@Nullable FileStatusWithDigest statNoFollow,
@Nullable byte[] injectedDigest)
throws IOException {
checkState(!artifact.isTreeArtifact(), "%s is a tree artifact", artifact);
FileArtifactValue value =
fileArtifactValueFromArtifact(
artifact,
artifactPathResolver,
statNoFollow,
injectedDigest != null,
xattrProvider,
// Prevent constant metadata artifacts from notifying the timestamp granularity monitor
// and potentially delaying the build for no reason.
artifact.isConstantMetadata() ? null : tsgm);
// Ensure that we don't have both an injected digest and a digest from the filesystem.
byte[] fileDigest = value.getDigest();
if (fileDigest != null && injectedDigest != null) {
throw new IllegalStateException(
String.format(
"Digest %s was injected for artifact %s, but got %s from the filesystem (%s)",
BaseEncoding.base16().encode(injectedDigest),
artifact,
BaseEncoding.base16().encode(fileDigest),
value));
}
FileStateType type = value.getType();
if (!type.exists()) {
// Nonexistent files should only occur before executing an action.
throw new FileNotFoundException(artifact.prettyPrint() + " does not exist");
}
if (type.isSymlink()) {
// We always create a FileArtifactValue for an unresolved symlink with a digest (calling
// readlink() is easy, unlike checksumming a potentially huge file).
checkNotNull(fileDigest, "%s missing digest", value);
return value;
}
if (type.isFile() && fileDigest != null) {
// The digest is in the file value and that is all that is needed for this file's metadata.
return value;
}
if (type.isDirectory()) {
// This branch is taken when the output of an action is a directory:
// - A Fileset (in this case, Blaze is correct)
// - A directory someone created in a local action (in this case, changes under the
// directory may not be detected since we use the mtime of the directory for
// up-to-dateness checks)
// - A symlink to a source directory due to Filesets
return FileArtifactValue.createForDirectoryWithMtime(
artifactPathResolver.toPath(artifact).getLastModifiedTime());
}
if (injectedDigest == null && type.isFile()) {
// We don't have an injected digest and there is no digest in the file value (which attempts a
// fast digest). Manually compute the digest instead.
injectedDigest =
DigestUtils.manuallyComputeDigest(artifactPathResolver.toPath(artifact), value.getSize());
}
return FileArtifactValue.createFromInjectedDigest(value, injectedDigest);
}
/**
* Constructs a {@link FileArtifactValue} for a regular (non-tree, non-middleman) artifact for the
* purpose of determining whether an existing {@link FileArtifactValue} is still valid.
*
* <p>The returned metadata may be compared with metadata present in an {@link
* ActionExecutionValue} using {@link FileArtifactValue#couldBeModifiedSince} to check for
* inter-build modifications.
*/
static FileArtifactValue fileArtifactValueFromArtifact(
Artifact artifact,
@Nullable FileStatusWithDigest statNoFollow,
XattrProvider xattrProvider,
@Nullable TimestampGranularityMonitor tsgm)
throws IOException {
return fileArtifactValueFromArtifact(
artifact,
ArtifactPathResolver.IDENTITY,
statNoFollow,
/*digestWillBeInjected=*/ false,
xattrProvider,
tsgm);
}
private static FileArtifactValue fileArtifactValueFromArtifact(
Artifact artifact,
ArtifactPathResolver artifactPathResolver,
@Nullable FileStatusWithDigest statNoFollow,
boolean digestWillBeInjected,
XattrProvider xattrProvider,
@Nullable TimestampGranularityMonitor tsgm)
throws IOException {
checkState(!artifact.isTreeArtifact() && !artifact.isMiddlemanArtifact(), artifact);
Path pathNoFollow = artifactPathResolver.toPath(artifact);
// If we expect a symlink, we can readlink it directly and handle errors appropriately - there
// is no need for the stat below.
if (artifact.isSymlink()) {
return FileArtifactValue.createForUnresolvedSymlink(pathNoFollow);
}
RootedPath rootedPathNoFollow =
RootedPath.toRootedPath(
artifactPathResolver.transformRoot(artifact.getRoot().getRoot()),
artifact.getRootRelativePath());
if (statNoFollow == null) {
// Stat the file. All output artifacts of an action are deleted before execution, so if a file
// exists, it was most likely created by the current action. There is a race condition here if
// an external process creates (or modifies) the file between the deletion and this stat,
// which we cannot solve.
statNoFollow =
FileStatusWithDigestAdapter.maybeAdapt(pathNoFollow.statIfFound(Symlinks.NOFOLLOW));
}
if (statNoFollow == null || !statNoFollow.isSymbolicLink()) {
return fileArtifactValueFromStat(
rootedPathNoFollow, statNoFollow, digestWillBeInjected, xattrProvider, tsgm);
}
// We use FileStatus#isSymbolicLink over Path#isSymbolicLink to avoid the unnecessary stat
// done by the latter. We need to protect against symlink cycles since
// ArtifactFileMetadata#value assumes it's dealing with a file that's not in a symlink cycle.
Path realPath = pathNoFollow.resolveSymbolicLinks();
if (realPath.equals(pathNoFollow)) {
throw new IOException("symlink cycle");
}
RootedPath realRootedPath =
RootedPath.toRootedPathMaybeUnderRoot(
realPath,
ImmutableList.of(artifactPathResolver.transformRoot(artifact.getRoot().getRoot())));
// TODO(bazel-team): consider avoiding a 'stat' here when the symlink target hasn't changed
// and is a source file (since changes to those are checked separately).
FileStatus realStat = realRootedPath.asPath().statIfFound(Symlinks.NOFOLLOW);
FileStatusWithDigest realStatWithDigest = FileStatusWithDigestAdapter.maybeAdapt(realStat);
return fileArtifactValueFromStat(
realRootedPath, realStatWithDigest, digestWillBeInjected, xattrProvider, tsgm);
}
private static FileArtifactValue fileArtifactValueFromStat(
RootedPath rootedPath,
FileStatusWithDigest stat,
boolean digestWillBeInjected,
XattrProvider xattrProvider,
@Nullable TimestampGranularityMonitor tsgm)
throws IOException {
if (stat == null) {
return FileArtifactValue.MISSING_FILE_MARKER;
}
FileStateValue fileStateValue =
FileStateValue.createWithStatNoFollow(
rootedPath, stat, digestWillBeInjected, xattrProvider, tsgm);
return stat.isDirectory()
? FileArtifactValue.createForDirectoryWithMtime(stat.getLastModifiedTime())
: FileArtifactValue.createForNormalFile(
fileStateValue.getDigest(), fileStateValue.getContentsProxy(), stat.getSize());
}
private static void setPathReadOnlyAndExecutableIfFile(Path path) throws IOException {
if (path.isFile(Symlinks.NOFOLLOW)) {
setPathReadOnlyAndExecutable(path);
}
}
private static void setPathReadOnlyAndExecutable(Path path) throws IOException {
path.chmod(0555);
}
}