1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
|
// 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 com.google.common.base.Predicates;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Iterables;
import com.google.common.collect.Maps;
import com.google.devtools.build.lib.analysis.BlazeDirectories;
import com.google.devtools.build.lib.cmdline.PackageIdentifier;
import com.google.devtools.build.lib.cmdline.RepositoryName;
import com.google.devtools.build.lib.events.Event;
import com.google.devtools.build.lib.packages.NoSuchPackageException;
import com.google.devtools.build.lib.packages.Package;
import com.google.devtools.build.lib.skyframe.RecursivePkgValue.RecursivePkgKey;
import com.google.devtools.build.lib.vfs.PathFragment;
import com.google.devtools.build.lib.vfs.RootedPath;
import com.google.devtools.build.skyframe.SkyFunction.Environment;
import com.google.devtools.build.skyframe.SkyKey;
import com.google.devtools.build.skyframe.SkyValue;
import com.google.devtools.build.skyframe.ValueOrException;
import java.util.Map;
/**
* RecursiveDirectoryTraversalFunction traverses the subdirectories of a directory, looking for
* and loading packages, and builds up a value from these packages in a manner customized by
* classes that derive from it.
*/
abstract class RecursiveDirectoryTraversalFunction
<TVisitor extends RecursiveDirectoryTraversalFunction.Visitor, TReturn> {
private static final String SENTINEL_FILE_NAME_FOR_NOT_TRAVERSING_SYMLINKS =
"DONT_FOLLOW_SYMLINKS_WHEN_TRAVERSING_THIS_DIRECTORY_VIA_A_RECURSIVE_TARGET_PATTERN";
private final ProcessPackageDirectory processPackageDirectory;
protected RecursiveDirectoryTraversalFunction(BlazeDirectories directories) {
this.processPackageDirectory =
new ProcessPackageDirectory(
directories,
new ProcessPackageDirectory.SkyKeyTransformer() {
@Override
public SkyKey makeSkyKey(
RepositoryName repository,
RootedPath subdirectory,
ImmutableSet<PathFragment> excludedSubdirectoriesBeneathSubdirectory) {
return getSkyKeyForSubdirectory(
repository, subdirectory, excludedSubdirectoriesBeneathSubdirectory);
}
});
}
/**
* Called by {@link #visitDirectory}, which will next call {@link Visitor#visitPackageValue} if
* the {@code recursivePkgKey} specifies a directory with a package, and which will lastly be
* provided to {@link #aggregateWithSubdirectorySkyValues} to compute the {@code TReturn} value
* returned by {@link #visitDirectory}.
*/
protected abstract TVisitor getInitialVisitor();
/**
* Called by {@link #visitDirectory} to get the {@link SkyKey}s associated with recursive
* computation in subdirectories of {@code subdirectory}, excluding directories in
* {@code excludedSubdirectoriesBeneathSubdirectory}, all of which must be proper subdirectories
* of {@code subdirectory}.
*/
protected abstract SkyKey getSkyKeyForSubdirectory(
RepositoryName repository, RootedPath subdirectory,
ImmutableSet<PathFragment> excludedSubdirectoriesBeneathSubdirectory);
/**
* Called by {@link #visitDirectory} to compute the {@code TReturn} value it returns, as a
* function of {@code visitor} and the {@link SkyValue}s computed for subdirectories
* of the directory specified by {@code recursivePkgKey}, contained in
* {@code subdirectorySkyValues}.
*/
protected abstract TReturn aggregateWithSubdirectorySkyValues(
TVisitor visitor, Map<SkyKey, SkyValue> subdirectorySkyValues);
/**
* A type of value used by {@link #visitDirectory} as it checks for a package in the directory
* specified by {@code recursivePkgKey}; if such a package exists, {@link #visitPackageValue}
* is called.
*
* <p>The value is then provided to {@link #aggregateWithSubdirectorySkyValues} to compute the
* value returned by {@link #visitDirectory}.
*/
interface Visitor {
/**
* Called iff the directory contains a package. Provides an {@link Environment} {@code env} so
* that the visitor may do additional lookups. {@link Environment#valuesMissing} will be checked
* afterwards.
*/
void visitPackageValue(Package pkg, Environment env) throws InterruptedException;
}
/**
* Looks in the directory specified by {@code recursivePkgKey} for a package, does some work as
* specified by {@link Visitor} if such a package exists, then recursively does work in each
* non-excluded subdirectory as specified by {@link #getSkyKeyForSubdirectory}, and finally
* aggregates the {@link Visitor} value along with values from each subdirectory as specified by
* {@link #aggregateWithSubdirectorySkyValues}, and returns that aggregation.
*
* <p>Returns null if {@code env.valuesMissing()} is true, checked after each call to one of
* {@link RecursiveDirectoryTraversalFunction}'s abstract methods that were given {@code env}.
* (And after each of {@code visitDirectory}'s own uses of {@code env}, of course.)
*/
TReturn visitDirectory(RecursivePkgKey recursivePkgKey, Environment env)
throws InterruptedException {
RootedPath rootedPath = recursivePkgKey.getRootedPath();
ProcessPackageDirectoryResult packageExistenceAndSubdirDeps =
processPackageDirectory.getPackageExistenceAndSubdirDeps(
rootedPath, recursivePkgKey.getRepository(), env, recursivePkgKey.getExcludedPaths());
if (env.valuesMissing()) {
return null;
}
Iterable<SkyKey> childDeps = packageExistenceAndSubdirDeps.getChildDeps();
TVisitor visitor = getInitialVisitor();
Map<SkyKey, SkyValue> subdirectorySkyValues;
if (packageExistenceAndSubdirDeps.packageExists()) {
PathFragment rootRelativePath = rootedPath.getRelativePath();
SkyKey packageKey =
PackageValue.key(
PackageIdentifier.create(recursivePkgKey.getRepository(), rootRelativePath));
Map<SkyKey, ValueOrException<NoSuchPackageException>> dependentSkyValues =
env.getValuesOrThrow(
Iterables.concat(childDeps, ImmutableList.of(packageKey)),
NoSuchPackageException.class);
if (env.valuesMissing()) {
return null;
}
Package pkg = null;
try {
PackageValue pkgValue = (PackageValue) dependentSkyValues.get(packageKey).get();
if (pkgValue == null) {
return null;
}
pkg = pkgValue.getPackage();
if (pkg.containsErrors()) {
env.getListener()
.handle(Event.error("package contains errors: " + rootRelativePath.getPathString()));
}
} catch (NoSuchPackageException e) {
// The package had errors, but don't fail-fast as there might be subpackages below the
// current directory.
env.getListener()
.handle(Event.error("package contains errors: " + rootRelativePath.getPathString()));
}
if (pkg != null) {
visitor.visitPackageValue(pkg, env);
if (env.valuesMissing()) {
return null;
}
}
ImmutableMap.Builder<SkyKey, SkyValue> subdirectoryBuilder = ImmutableMap.builder();
for (Map.Entry<SkyKey, ValueOrException<NoSuchPackageException>> entry :
Maps.filterKeys(dependentSkyValues, Predicates.not(Predicates.equalTo(packageKey)))
.entrySet()) {
try {
subdirectoryBuilder.put(entry.getKey(), entry.getValue().get());
} catch (NoSuchPackageException e) {
// ignored.
}
}
subdirectorySkyValues = subdirectoryBuilder.build();
} else {
subdirectorySkyValues = env.getValues(childDeps);
}
if (env.valuesMissing()) {
return null;
}
return aggregateWithSubdirectorySkyValues(visitor, subdirectorySkyValues);
}
}
|
