/*
|
* Copyright (C) 2009 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 vogar;
|
|
import java.io.File;
|
import java.util.Collection;
|
import java.util.Collections;
|
import java.util.HashSet;
|
import java.util.LinkedHashMap;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Set;
|
import vogar.tasks.BuildActionTask;
|
import vogar.tasks.PrepareTarget;
|
import vogar.tasks.PrepareUserDirTask;
|
import vogar.tasks.RetrieveFilesTask;
|
import vogar.tasks.RmTask;
|
import vogar.tasks.Task;
|
import vogar.util.TimeUtilities;
|
|
/**
|
* Compiles, installs, runs and reports on actions.
|
*/
|
public final class Driver {
|
private final Run run;
|
|
public Driver(Run run) {
|
this.run = run;
|
}
|
|
private int successes = 0;
|
private int failures = 0;
|
private int skipped = 0;
|
private int warnings = 0;
|
|
private Task prepareTargetTask;
|
private Set<Task> installVogarTasks;
|
|
private final Map<String, Action> actions = Collections.synchronizedMap(
|
new LinkedHashMap<String, Action>());
|
private final Map<String, Outcome> outcomes = Collections.synchronizedMap(
|
new LinkedHashMap<String, Outcome>());
|
public boolean recordResults = true;
|
|
/**
|
* Builds and executes the actions in the given files.
|
*/
|
public boolean buildAndRun(Collection<File> files, Collection<String> classes) {
|
if (!actions.isEmpty()) {
|
throw new IllegalStateException("Drivers are not reusable");
|
}
|
|
run.mkdir.mkdirs(run.localTemp);
|
|
filesToActions(files);
|
classesToActions(classes);
|
|
if (actions.isEmpty()) {
|
run.console.info("Nothing to do.");
|
return false;
|
}
|
|
run.console.info("Actions: " + actions.size());
|
final long t0 = System.currentTimeMillis();
|
|
prepareTargetTask = new PrepareTarget(run, run.target);
|
run.taskQueue.enqueue(prepareTargetTask);
|
|
installVogarTasks = run.mode.installTasks();
|
run.taskQueue.enqueueAll(installVogarTasks);
|
registerPrerequisites(Collections.singleton(prepareTargetTask), installVogarTasks);
|
|
for (Action action : actions.values()) {
|
action.setUserDir(new File(run.runnerDir, action.getName()));
|
Outcome outcome = outcomes.get(action.getName());
|
if (outcome != null) {
|
addEarlyResult(outcome);
|
} else if (run.expectationStore.get(action.getName()).getResult()
|
== Result.UNSUPPORTED) {
|
addEarlyResult(new Outcome(action.getName(), Result.UNSUPPORTED,
|
"Unsupported according to expectations file"));
|
} else {
|
enqueueActionTasks(action);
|
}
|
}
|
|
if (run.cleanAfter) {
|
Set<Task> shutdownTasks = new HashSet<Task>();
|
shutdownTasks.add(new RmTask(run.rm, run.localTemp));
|
shutdownTasks.add(run.target.rmTask(run.runnerDir));
|
for (Task task : shutdownTasks) {
|
task.after(run.taskQueue.getTasks());
|
}
|
run.taskQueue.enqueueAll(shutdownTasks);
|
}
|
|
run.taskQueue.printTasks();
|
run.taskQueue.runTasks();
|
if (run.taskQueue.hasFailedTasks()) {
|
run.taskQueue.printProblemTasks();
|
return false;
|
}
|
|
if (run.reportPrinter.isReady()) {
|
run.console.info("Printing XML Reports... ");
|
int numFiles = run.reportPrinter.generateReports(outcomes.values());
|
run.console.info(numFiles + " XML files written.");
|
}
|
|
long t1 = System.currentTimeMillis();
|
|
Map<String, AnnotatedOutcome> annotatedOutcomes = run.outcomeStore.read(this.outcomes);
|
if (recordResults) {
|
run.outcomeStore.write(outcomes);
|
}
|
|
run.console.summarizeOutcomes(annotatedOutcomes.values());
|
|
List<String> jarStringList = run.jarSuggestions.getStringList();
|
if (!jarStringList.isEmpty()) {
|
run.console.warn(
|
"consider adding the following to the classpath:",
|
jarStringList);
|
}
|
|
if (failures > 0 || skipped > 0 || warnings > 0) {
|
run.console.info(String.format(
|
"Outcomes: %s. Passed: %d, Failed: %d, Skipped: %d, Warnings: %d. Took %s.",
|
(successes + failures + warnings + skipped), successes, failures, skipped, warnings,
|
TimeUtilities.msToString(t1 - t0)));
|
} else {
|
run.console.info(String.format("Outcomes: %s. All successful. Took %s.",
|
successes, TimeUtilities.msToString(t1 - t0)));
|
}
|
return failures == 0;
|
}
|
|
private void enqueueActionTasks(Action action) {
|
Expectation expectation = run.expectationStore.get(action.getName());
|
boolean useLargeTimeout = expectation.getTags().contains("large");
|
File jar = run.hostJar(action);
|
Task build = new BuildActionTask(run, action, this, jar);
|
run.taskQueue.enqueue(build);
|
|
Task prepareUserDir = new PrepareUserDirTask(run.target, action);
|
prepareUserDir.after(installVogarTasks);
|
run.taskQueue.enqueue(prepareUserDir);
|
|
Set<Task> install = run.mode.installActionTasks(action, jar);
|
registerPrerequisites(Collections.singleton(build), install);
|
registerPrerequisites(installVogarTasks, install);
|
registerPrerequisites(Collections.singleton(prepareTargetTask), install);
|
run.taskQueue.enqueueAll(install);
|
|
Task execute = run.mode.executeActionTask(action, useLargeTimeout)
|
.afterSuccess(installVogarTasks)
|
.afterSuccess(build)
|
.afterSuccess(prepareUserDir)
|
.afterSuccess(install);
|
run.taskQueue.enqueue(execute);
|
|
Task retrieveFiles = new RetrieveFilesTask(run, action.getUserDir()).after(execute);
|
run.taskQueue.enqueue(retrieveFiles);
|
|
if (run.cleanAfter) {
|
run.taskQueue.enqueue(new RmTask(run.rm, run.localFile(action))
|
.after(execute).after(retrieveFiles));
|
Set<Task> cleanupTasks = run.mode.cleanupTasks(action);
|
for (Task task : cleanupTasks) {
|
task.after(execute).after(retrieveFiles);
|
}
|
run.taskQueue.enqueueAll(cleanupTasks);
|
}
|
}
|
|
private void registerPrerequisites(Set<Task> allBefore, Set<Task> allAfter) {
|
for (Task task : allAfter) {
|
task.afterSuccess(allBefore);
|
}
|
}
|
|
private void classesToActions(Collection<String> classNames) {
|
for (String className : classNames) {
|
Action action = new Action(className, className, null, null, null);
|
actions.put(action.getName(), action);
|
}
|
}
|
|
private void filesToActions(Collection<File> files) {
|
for (File file : files) {
|
new ActionFinder(run.console, actions, outcomes).findActions(file);
|
}
|
}
|
|
public synchronized void addEarlyResult(Outcome earlyFailure) {
|
if (earlyFailure.getResult() == Result.UNSUPPORTED) {
|
run.console.verbose("skipped " + earlyFailure.getName());
|
skipped++;
|
|
} else {
|
for (String line : earlyFailure.getOutputLines()) {
|
run.console.streamOutput(earlyFailure.getName(), line + "\n");
|
}
|
recordOutcome(earlyFailure);
|
}
|
}
|
|
public synchronized void recordOutcome(Outcome outcome) {
|
outcomes.put(outcome.getName(), outcome);
|
Expectation expectation = run.expectationStore.get(outcome);
|
ResultValue resultValue = outcome.getResultValue(expectation);
|
|
if (resultValue == ResultValue.OK) {
|
successes++;
|
} else if (resultValue == ResultValue.FAIL) {
|
failures++;
|
} else if (resultValue == ResultValue.WARNING) {
|
warnings++;
|
} else { // ResultValue.IGNORE
|
skipped++;
|
}
|
|
Result result = outcome.getResult();
|
run.console.outcome(outcome.getName());
|
run.console.printResult(outcome.getName(), result, resultValue, expectation);
|
|
JarSuggestions singleOutcomeJarSuggestions = new JarSuggestions();
|
singleOutcomeJarSuggestions.addSuggestionsFromOutcome(outcome, run.classFileIndex,
|
run.classpath);
|
List<String> jarStringList = singleOutcomeJarSuggestions.getStringList();
|
if (!jarStringList.isEmpty()) {
|
run.console.warn(
|
"may have failed because some of these jars are missing from the classpath:",
|
jarStringList);
|
}
|
run.jarSuggestions.addSuggestions(singleOutcomeJarSuggestions);
|
}
|
}
|
