blob: 7cb13a0299777c8168d600ec31b09a7b83c72171 [file] [log] [blame]
/*
* Copyright (C) 2011 The Android Open Source Project
*
* 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.android.ant;
import com.google.common.base.Charsets;
import com.google.common.io.Files;
import org.apache.tools.ant.BuildException;
import java.io.File;
import java.io.IOException;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
/**
* This class takes care of dependency tracking for all targets and prerequisites listed in
* a single dependency file. A dependency graph always has a dependency file associated with it
* for the duration of its lifetime
*/
public class DependencyGraph {
private final static boolean DEBUG = false;
private static enum DependencyStatus {
NONE, NEW_FILE, UPDATED_FILE, MISSING_FILE, ERROR;
}
// Files that we know about from the dependency file
private Set<File> mTargets = Collections.emptySet();
private Set<File> mPrereqs = mTargets;
private File mFirstPrereq = null;
private boolean mMissingDepFile = false;
private long mDepFileLastModified;
private final List<InputPath> mNewInputs;
public DependencyGraph(String dependencyFilePath, List<InputPath> newInputPaths) {
mNewInputs = newInputPaths;
parseDependencyFile(dependencyFilePath);
}
/**
* Check all the dependencies to see if anything has changed.
*
* @param printStatus will print to {@link System#out} the dependencies status.
* @return true if new prerequisites have appeared, target files are missing or if
* prerequisite files have been modified since the last target generation.
*/
public boolean dependenciesHaveChanged(boolean printStatus) {
// If no dependency file has been set up, then we'll just return true
// if we have a dependency file, we'll check to see what's been changed
if (mMissingDepFile) {
System.out.println("No Dependency File Found");
return true;
}
// check for missing output first
if (missingTargetFile()) {
if (printStatus) {
System.out.println("Found Deleted Target File");
}
return true;
}
// get the time stamp of the oldest target.
long oldestTarget = getOutputLastModified();
// first look through the input folders and look for new files or modified files.
DependencyStatus status = checkInputs(oldestTarget);
// this can't find missing files. This is done later.
switch (status) {
case ERROR:
throw new BuildException();
case NEW_FILE:
if (printStatus) {
System.out.println("Found new input file");
}
return true;
case UPDATED_FILE:
if (printStatus) {
System.out.println("Found modified input file");
}
return true;
}
// now do a full check on the remaining files.
status = checkPrereqFiles(oldestTarget);
// this can't find new input files. This is done above.
switch (status) {
case ERROR:
throw new BuildException();
case MISSING_FILE:
if (printStatus) {
System.out.println("Found deleted input file");
}
return true;
case UPDATED_FILE:
if (printStatus) {
System.out.println("Found modified input file");
}
return true;
}
return false;
}
public Set<File> getTargets() {
return Collections.unmodifiableSet(mTargets);
}
public File getFirstPrereq() {
return mFirstPrereq;
}
/**
* Parses the given dependency file and stores the file paths
*
* @param dependencyFilePath the dependency file
*/
private void parseDependencyFile(String dependencyFilePath) {
// first check if the dependency file is here.
File depFile = new File(dependencyFilePath);
if (depFile.isFile() == false) {
mMissingDepFile = true;
return;
}
// get the modification time of the dep file as we may need it later
mDepFileLastModified = depFile.lastModified();
// Read in our dependency file
List<String> content = readFile(depFile);
if (content == null) {
System.err.println("ERROR: Couldn't read " + dependencyFilePath);
return;
}
// The format is something like:
// output1 output2 [...]: dep1 dep2 [...]
// expect it's likely split on several lines. So let's move it back on a single line
// first
StringBuilder sb = new StringBuilder();
for (String line : content) {
line = line.trim();
if (line.endsWith("\\")) {
line = line.substring(0, line.length() - 1);
}
sb.append(line);
}
// split the left and right part
String[] files = sb.toString().split(":");
// get the target files:
String[] targets = files[0].trim().split(" ");
String[] prereqs = {};
// Check to make sure our dependency file is okay
if (files.length < 1) {
System.err.println(
"Warning! Dependency file does not list any prerequisites after ':' ");
} else {
// and the prerequisite files:
prereqs = files[1].trim().split(" ");
}
mTargets = new HashSet<File>(targets.length);
for (String path : targets) {
if (path.length() > 0) {
mTargets.add(new File(path));
}
}
mPrereqs = new HashSet<File>(prereqs.length);
for (String path : prereqs) {
if (path.length() > 0) {
if (DEBUG) {
System.out.println("PREREQ: " + path);
}
File f = new File(path);
if (mFirstPrereq == null) {
mFirstPrereq = f;
}
mPrereqs.add(f);
}
}
}
/**
* Check all the input files and folders to see if there have been new
* files added to them or if any of the existing files have been modified.
*
* This looks at the input paths, not at the list of known prereq. Therefore this
* will not find missing files. It will however remove processed files from the
* prereq file list so that we can process those in a 2nd step.
*
* This should be followed by a call to {@link #checkPrereqFiles(long)} which
* will process the remaining files in the prereq list.
*
* If a change is found, this will return immediately with either
* {@link DependencyStatus#NEW_FILE} or {@link DependencyStatus#UPDATED_FILE}.
*
* @param oldestTarget the timestamp of the oldest output file to compare against.
*
* @return the status of the file in the watched folders.
*
*/
private DependencyStatus checkInputs(long oldestTarget) {
if (mNewInputs != null) {
for (InputPath input : mNewInputs) {
File file = input.getFile();
if (file.isDirectory()) {
DependencyStatus status = checkInputFolder(file, input, oldestTarget);
if (status != DependencyStatus.NONE) {
return status;
}
} else if (file.isFile()) {
DependencyStatus status = checkInputFile(file, input, oldestTarget);
if (status != DependencyStatus.NONE) {
return status;
}
}
}
}
// If we make it all the way through our directories we're good.
return DependencyStatus.NONE;
}
/**
* Check all the files in the tree under root and check to see if the files are
* listed under the dependencies, or if they have been modified. Recurses into subdirs.
*
* @param folder the folder to search through.
* @param inputFolder the root level inputFolder
* @param oldestTarget the time stamp of the oldest output file to compare against.
*
* @return the status of the file in the folder.
*/
private DependencyStatus checkInputFolder(File folder, InputPath inputFolder,
long oldestTarget) {
if (inputFolder.ignores(folder)) {
return DependencyStatus.NONE;
}
File[] files = folder.listFiles();
if (files == null) {
System.err.println("ERROR " + folder.toString() + " is not a dir or can't be read");
return DependencyStatus.ERROR;
}
// Loop through files in this folder
for (File file : files) {
// If this is a directory, recurse into it
if (file.isDirectory()) {
DependencyStatus status = checkInputFolder(file, inputFolder, oldestTarget);
if (status != DependencyStatus.NONE) {
return status;
}
} else if (file.isFile()) {
DependencyStatus status = checkInputFile(file, inputFolder, oldestTarget);
if (status != DependencyStatus.NONE) {
return status;
}
}
}
// If we got to here then we didn't find anything interesting
return DependencyStatus.NONE;
}
private DependencyStatus checkInputFile(File file, InputPath inputFolder,
long oldestTarget) {
if (inputFolder.ignores(file)) {
return DependencyStatus.NONE;
}
// if it's a file, remove it from the list of prereqs.
// This way if files in this folder don't trigger a build we'll have less
// files to go through manually
if (mPrereqs.remove(file) == false) {
// turns out this is a new file!
if (DEBUG) {
System.out.println("NEW FILE: " + file.getAbsolutePath());
}
return DependencyStatus.NEW_FILE;
} else {
// check the time stamp on this file if it's a file we care about based what the
// input folder decides.
if (inputFolder.checksForModification(file)) {
if (file.lastModified() > oldestTarget) {
if (DEBUG) {
System.out.println("UPDATED FILE: " + file.getAbsolutePath());
}
return DependencyStatus.UPDATED_FILE;
}
}
}
return DependencyStatus.NONE;
}
/**
* Check all the prereq files we know about to make sure they're still there, or that they
* haven't been modified since the last build.
*
* @param oldestTarget the time stamp of the oldest output file to compare against.
*
* @return the status of the files
*/
private DependencyStatus checkPrereqFiles(long oldestTarget) {
// TODO: Optimize for the case of a specific file as inputPath.
// We should have a map of filepath to inputpath to quickly search through them?
// Loop through our prereq files and make sure they still exist
for (File prereq : mPrereqs) {
if (prereq.exists() == false) {
if (DEBUG) {
System.out.println("MISSING FILE: " + prereq.getAbsolutePath());
}
return DependencyStatus.MISSING_FILE;
}
// check the time stamp on this file if it's a file we care about.
// To know if we care about the file we have to find the matching input.
if (mNewInputs != null) {
String filePath = prereq.getAbsolutePath();
for (InputPath input : mNewInputs) {
File inputFile = input.getFile();
// if the input path is a directory, check if the prereq file is in it,
// otherwise check if the prereq file match exactly the input path.
if (inputFile.isDirectory()) {
if (filePath.startsWith(inputFile.getAbsolutePath())) {
// ok file is inside a directory type input folder.
// check if we need to check this type of file, and if yes, check it.
if (input.checksForModification(prereq)) {
if (prereq.lastModified() > oldestTarget) {
if (DEBUG) {
System.out.println(
"UPDATED FILE: " + prereq.getAbsolutePath());
}
return DependencyStatus.UPDATED_FILE;
}
}
}
} else {
// this is a file input path, we must check if the match is exact.
if (prereq.equals(inputFile)) {
if (input.checksForModification(prereq)) {
if (prereq.lastModified() > oldestTarget) {
if (DEBUG) {
System.out.println(
"UPDATED FILE: " + prereq.getAbsolutePath());
}
return DependencyStatus.UPDATED_FILE;
}
}
}
}
}
} else {
// no input? we consider all files.
if (prereq.lastModified() > oldestTarget) {
if (DEBUG) {
System.out.println("UPDATED FILE: " + prereq.getAbsolutePath());
}
return DependencyStatus.UPDATED_FILE;
}
}
}
// If we get this far, then all our prereq are okay
return DependencyStatus.NONE;
}
/**
* Check all the target files we know about to make sure they're still there
* @return true if any of the target files are missing.
*/
private boolean missingTargetFile() {
// Loop through our target files and make sure they still exist
for (File target : mTargets) {
if (target.exists() == false) {
return true;
}
}
// If we get this far, then all our targets are okay
return false;
}
/**
* Returns the earliest modification time stamp from all the output targets. If there
* are no known target, the dependency file time stamp is returned.
*/
private long getOutputLastModified() {
// Find the oldest target
long oldestTarget = Long.MAX_VALUE;
// if there's no output, then compare to the time of the dependency file.
if (mTargets.size() == 0) {
oldestTarget = mDepFileLastModified;
} else {
for (File target : mTargets) {
if (target.lastModified() < oldestTarget) {
oldestTarget = target.lastModified();
}
}
}
return oldestTarget;
}
/**
* Reads and returns the content of a text file.
* @param file the file to read
* @return null if the file could not be read
*/
private static List<String> readFile(File file) {
try {
return Files.readLines(file, Charsets.UTF_8);
} catch (IOException e) {
// return null below
}
return null;
}
}