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
|
// 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.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 java.util.Map;
/**
* RecursiveDirectoryTraversalFunction traverses the subdirectories of a directory, looking for and
* loading packages, and builds up a value from the packages and package loading errors in a manner
* customized by classes that derive from it.
*/
abstract class RecursiveDirectoryTraversalFunction<
TConsumer extends RecursiveDirectoryTraversalFunction.PackageDirectoryConsumer, TReturn> {
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
* PackageDirectoryConsumer#notePackage} 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 TConsumer getInitialConsumer();
/**
* 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 consumer} and the {@link SkyValue}s computed for subdirectories of the
* directory specified by {@code recursivePkgKey}, contained in {@code subdirectorySkyValues}.
*/
protected abstract TReturn aggregateWithSubdirectorySkyValues(
TConsumer consumer, Map<SkyKey, SkyValue> subdirectorySkyValues);
/**
* A type of consumer used by {@link #visitDirectory} as it checks for a package in the directory
* specified by {@code recursivePkgKey}; if such a package exists, {@link #notePackage} is called.
*
* <p>The consumer is then provided to {@link #aggregateWithSubdirectorySkyValues} to compute the
* value returned by {@link #visitDirectory}.
*/
interface PackageDirectoryConsumer {
/** Called iff the directory contains a package. */
void notePackage(PathFragment pkgPath) throws InterruptedException;
/**
* Called iff the directory contains a BUILD file but *not* a package, which can happen under
* the following circumstances:
*
* <ol>
* <li>The BUILD file contains a Skylark load statement that is in error
* <li>TODO(mschaller), not yet implemented: The BUILD file is a symlink that points into a
* cycle
* </ol>
*/
void notePackageError(String noSuchPackageExceptionErrorMessage);
}
/**
* Looks in the directory specified by {@code recursivePkgKey} for a package, does some work as
* specified by {@link PackageDirectoryConsumer} if such a package exists, then recursively does
* work in each non-excluded subdirectory as specified by {@link #getSkyKeyForSubdirectory}, and
* finally aggregates the {@link PackageDirectoryConsumer} 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}.
*/
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();
TConsumer consumer = getInitialConsumer();
Map<SkyKey, SkyValue> subdirectorySkyValues;
if (packageExistenceAndSubdirDeps.packageExists()) {
PathFragment rootRelativePath = rootedPath.getRootRelativePath();
SkyKey packageErrorMessageKey =
PackageErrorMessageValue.key(
PackageIdentifier.create(recursivePkgKey.getRepository(), rootRelativePath));
Map<SkyKey, SkyValue> dependentSkyValues =
env.getValues(Iterables.concat(childDeps, ImmutableList.of(packageErrorMessageKey)));
if (env.valuesMissing()) {
return null;
}
PackageErrorMessageValue pkgErrorMessageValue =
(PackageErrorMessageValue) dependentSkyValues.get(packageErrorMessageKey);
switch (pkgErrorMessageValue.getResult()) {
case NO_ERROR:
consumer.notePackage(rootRelativePath);
break;
case ERROR:
env.getListener()
.handle(Event.error("package contains errors: " + rootRelativePath.getPathString()));
consumer.notePackage(rootRelativePath);
break;
case NO_SUCH_PACKAGE_EXCEPTION:
// The package had errors, but don't fail-fast as there might be subpackages below the
// current directory.
String msg = pkgErrorMessageValue.getNoSuchPackageExceptionMessage();
env.getListener().handle(Event.error(msg));
consumer.notePackageError(msg);
break;
default:
throw new IllegalStateException(pkgErrorMessageValue.getResult().toString());
}
subdirectorySkyValues =
ImmutableMap.copyOf(
Maps.filterKeys(
dependentSkyValues, Predicates.not(Predicates.equalTo(packageErrorMessageKey))));
} else {
subdirectorySkyValues = env.getValues(childDeps);
}
if (env.valuesMissing()) {
return null;
}
return aggregateWithSubdirectorySkyValues(consumer, subdirectorySkyValues);
}
}
|
