/*
* Copyright 2008 Google Inc.
*
* 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.gwt.benchmarks.viewer.server;
import com.google.gwt.benchmarks.client.Benchmark;
import com.google.gwt.benchmarks.viewer.client.Report;
import com.google.gwt.benchmarks.viewer.client.ReportSummary;
import org.w3c.dom.Document;
import java.io.File;
import java.io.FilenameFilter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
/**
* Serves up benchmark reports created during JUnit execution.
*
* The benchmark reports are read from the path specified by the system property
* named <code>Benchmark.REPORT_PATH</code>. In the case the property is not
* set, they are read from the user's current working directory.
*/
public class ReportDatabase {
/**
* Indicates that a supplied path was invalid.
*
*/
public static class BadPathException extends RuntimeException {
String path;
public BadPathException(String path) {
super("The path " + path + " does not exist.");
this.path = path;
}
public String getPath() {
return path;
}
}
private static class ReportEntry {
private long lastModified;
private Report report;
private ReportSummary summary;
public ReportEntry(Report report, ReportSummary summary, long lastModified) {
this.report = report;
this.summary = summary;
this.lastModified = lastModified;
}
}
private static class ReportFile {
File file;
long lastModified;
ReportFile(File f) {
this.file = f;
this.lastModified = f.lastModified();
}
}
private static ReportDatabase database = new ReportDatabase();
/**
* The amount of time to go between report updates.
*/
private static final int UPDATE_DURATION_MILLIS = 30000;
public static ReportDatabase getInstance() {
return database;
}
private static String getReportId(File f) {
return f.getName();
}
/**
* The last time we updated our reports.
*/
private long lastUpdateMillis = -1L;
/**
* The path to read benchmark reports from.
*/
private final String reportPath;
/**
* A list of all reports by id.
*/
private Map<String, ReportEntry> reports = new HashMap<String, ReportEntry>();
/**
* Lock for reports.
*/
private Object reportsLock = new Object();
/**
* Lock for updating from file system. (Guarantees a single update while not
* holding reportsLock open).
*/
private Object updateLock = new Object();
/**
* Are we currently undergoing updating?
*/
private boolean updating = false;
private ReportDatabase() throws BadPathException {
String path = System.getProperty(Benchmark.REPORT_PATH);
if (path == null || path.trim().equals("")) {
path = System.getProperty("user.dir");
}
reportPath = path;
if (!new File(reportPath).exists()) {
throw new BadPathException(reportPath);
}
}
public Report getReport(String reportId) {
synchronized (reportsLock) {
ReportEntry entry = reports.get(reportId);
return entry == null ? null : entry.report;
}
}
public List<ReportSummary> getReportSummaries() {
/**
* There are probably ways to make this faster, but I've taken basic
* precautions to try to make this scale ok with multiple clients.
*/
boolean update = false;
// See if we need to do an update
// Go ahead and let others continue reading, even if an update is required.
synchronized (updateLock) {
if (!updating) {
long currentTime = System.currentTimeMillis();
if (currentTime > lastUpdateMillis + UPDATE_DURATION_MILLIS) {
update = updating = true;
}
}
}
if (update) {
updateReports();
}
synchronized (reportsLock) {
List<ReportSummary> summaries = new ArrayList<ReportSummary>(reports.size());
for (ReportEntry entry : reports.values()) {
summaries.add(entry.summary);
}
return summaries;
}
}
private void updateReports() {
File path = new File(reportPath);
File[] files = path.listFiles(new FilenameFilter() {
public boolean accept(File f, String name) {
return name.startsWith("report-") && name.endsWith(".xml");
}
});
Map<String, ReportEntry> filesToUpdate = new HashMap<String, ReportEntry>();
Map<String, ReportFile> filesById = new HashMap<String, ReportFile>();
for (int i = 0; i < files.length; ++i) {
File f = files[i];
filesById.put(getReportId(f), new ReportFile(f));
}
// Lock temporarily so we can determine what needs updating
// (This could be a read-lock - not a general read-write lock,
// if we moved dead report removal outside of this critical section).
synchronized (reportsLock) {
// Add reports which need to be updated or are new
for (int i = 0; i < files.length; ++i) {
File file = files[i];
String reportId = getReportId(file);
ReportEntry entry = reports.get(reportId);
if (entry == null || entry.lastModified < file.lastModified()) {
filesToUpdate.put(reportId, null);
}
}
// Remove reports which no longer exist
for (Iterator<String> it = reports.keySet().iterator(); it.hasNext();) {
if (filesById.get(it.next()) == null) {
it.remove();
}
}
}
try {
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
factory.setIgnoringElementContentWhitespace(true);
factory.setIgnoringComments(true);
DocumentBuilder builder = factory.newDocumentBuilder();
for (String id : filesToUpdate.keySet()) {
ReportFile reportFile = filesById.get(id);
String filePath = reportFile.file.getAbsolutePath();
Document doc = builder.parse(filePath);
Report report = ReportXml.fromXml(doc.getDocumentElement());
report.setId(id);
ReportSummary summary = report.getSummary();
long lastModified = new File(filePath).lastModified();
filesToUpdate.put(id, new ReportEntry(report, summary, lastModified));
}
// Update the reports
synchronized (reportsLock) {
for (String id : filesToUpdate.keySet()) {
reports.put(id, filesToUpdate.get(id));
}
}
} catch (Exception e) {
// Even if we got an error, we'll just try again on the next update
// This might happen if a report has only been partially written, for
// example.
e.printStackTrace();
}
synchronized (updateLock) {
updating = false;
lastUpdateMillis = System.currentTimeMillis();
}
}
}