public static int parseAndWriteBuckCompatibleDepfile(
ExecutionContext context,
ProjectFilesystem filesystem,
HeaderPathNormalizer headerPathNormalizer,
HeaderVerification headerVerification,
Path sourceDepFile,
Path destDepFile,
Path inputPath,
Path outputPath)
throws IOException {
// Process the dependency file, fixing up the paths, and write it out to it's final location.
// The paths of the headers written out to the depfile are the paths to the symlinks from the
// root of the repo if the compilation included them from the header search paths pointing to
// the symlink trees, or paths to headers relative to the source file if the compilation
// included them using source relative include paths. To handle both cases we check for the
// prerequisites both in the values and the keys of the replacement map.
Logger.get(Depfiles.class).debug("Processing dependency file %s as Makefile", sourceDepFile);
ImmutableMap<String, Object> params =
ImmutableMap.<String, Object>of("input", inputPath, "output", outputPath);
try (InputStream input = filesystem.newFileInputStream(sourceDepFile);
BufferedReader reader = new BufferedReader(new InputStreamReader(input));
OutputStream output = filesystem.newFileOutputStream(destDepFile);
BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(output));
SimplePerfEvent.Scope perfEvent =
SimplePerfEvent.scope(
context.getBuckEventBus(), PerfEventId.of("depfile-parse"), params)) {
ImmutableList<String> prereqs = Depfiles.parseDepfile(reader).getPrereqs();
// Skip the first prereq, as it's the input source file.
Preconditions.checkState(inputPath.toString().equals(prereqs.get(0)));
ImmutableList<String> headers = prereqs.subList(1, prereqs.size());
for (String rawHeader : headers) {
Path header = Paths.get(rawHeader).normalize();
Optional<Path> absolutePath =
headerPathNormalizer.getAbsolutePathForUnnormalizedPath(header);
if (absolutePath.isPresent()) {
Preconditions.checkState(absolutePath.get().isAbsolute());
writer.write(absolutePath.get().toString());
writer.newLine();
} else if (headerVerification.getMode() != HeaderVerification.Mode.IGNORE
&& !headerVerification.isWhitelisted(header.toString())) {
context
.getBuckEventBus()
.post(
ConsoleEvent.create(
headerVerification.getMode() == HeaderVerification.Mode.ERROR
? Level.SEVERE
: Level.WARNING,
"%s: included an untracked header \"%s\"",
inputPath,
header));
if (headerVerification.getMode() == HeaderVerification.Mode.ERROR) {
return 1;
}
}
}
}
return 0;
}
@SuppressWarnings({"rawtypes", "unchecked"})
private TargetNode<?> createTargetNode(
BuckEventBus eventBus,
Cell cell,
Path buildFile,
BuildTarget target,
Map<String, Object> rawNode,
TargetNodeListener nodeListener) {
BuildRuleType buildRuleType = parseBuildRuleTypeFromRawRule(cell, rawNode);
// Because of the way that the parser works, we know this can never return null.
Description<?> description = cell.getDescription(buildRuleType);
if (target.isFlavored()) {
if (description instanceof Flavored) {
if (!((Flavored) description).hasFlavors(ImmutableSet.copyOf(target.getFlavors()))) {
throw new HumanReadableException(
"Unrecognized flavor in target %s while parsing %s%s.",
target,
UnflavoredBuildTarget.BUILD_TARGET_PREFIX,
MorePaths.pathWithUnixSeparators(
target.getBasePath().resolve(cell.getBuildFileName())));
}
} else {
LOG.warn(
"Target %s (type %s) must implement the Flavored interface "
+ "before we can check if it supports flavors: %s",
target.getUnflavoredBuildTarget(), buildRuleType, target.getFlavors());
throw new HumanReadableException(
"Target %s (type %s) does not currently support flavors (tried %s)",
target.getUnflavoredBuildTarget(), buildRuleType, target.getFlavors());
}
}
Cell targetCell = cell.getCell(target);
BuildRuleFactoryParams factoryParams =
new BuildRuleFactoryParams(
targetCell.getFilesystem(),
target.withoutCell(),
new FilesystemBackedBuildFileTree(cell.getFilesystem(), cell.getBuildFileName()),
targetCell.isEnforcingBuckPackageBoundaries());
Object constructorArg = description.createUnpopulatedConstructorArg();
try {
ImmutableSet.Builder<BuildTarget> declaredDeps = ImmutableSet.builder();
ImmutableSet.Builder<BuildTargetPattern> visibilityPatterns = ImmutableSet.builder();
try (SimplePerfEvent.Scope scope =
SimplePerfEvent.scope(
eventBus, PerfEventId.of("MarshalledConstructorArg"), "target", target)) {
marshaller.populate(
targetCell.getCellRoots(),
targetCell.getFilesystem(),
factoryParams,
constructorArg,
declaredDeps,
visibilityPatterns,
rawNode);
}
try (SimplePerfEvent.Scope scope =
SimplePerfEvent.scope(eventBus, PerfEventId.of("CreatedTargetNode"), "target", target)) {
Hasher hasher = Hashing.sha1().newHasher();
hasher.putString(BuckVersion.getVersion(), UTF_8);
JsonObjectHashing.hashJsonObject(hasher, rawNode);
synchronized (this) {
targetsCornucopia.put(target.getUnflavoredBuildTarget(), target);
}
TargetNode<?> node =
new TargetNode(
hasher.hash(),
description,
constructorArg,
typeCoercerFactory,
factoryParams,
declaredDeps.build(),
visibilityPatterns.build(),
targetCell.getCellRoots());
nodeListener.onCreate(buildFile, node);
return node;
}
} catch (NoSuchBuildTargetException | TargetNode.InvalidSourcePathInputException e) {
throw new HumanReadableException(e);
} catch (ConstructorArgMarshalException e) {
throw new HumanReadableException("%s: %s", target, e.getMessage());
} catch (IOException e) {
throw new HumanReadableException(e.getMessage(), e);
}
}
