package net.pterodactylus.sone.core;
-import static com.google.common.base.Optional.absent;
-import static com.google.common.base.Optional.of;
import static com.google.common.base.Preconditions.checkArgument;
import static java.lang.System.currentTimeMillis;
import static net.pterodactylus.sone.data.Album.NOT_EMPTY;
+import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.StringWriter;
import java.nio.charset.Charset;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
+import java.util.concurrent.atomic.AtomicInteger;
import java.util.logging.Level;
import java.util.logging.Logger;
+import net.pterodactylus.sone.core.Options.Option;
+import net.pterodactylus.sone.core.Options.OptionWatcher;
import net.pterodactylus.sone.core.event.SoneInsertAbortedEvent;
import net.pterodactylus.sone.core.event.SoneInsertedEvent;
import net.pterodactylus.sone.core.event.SoneInsertingEvent;
import net.pterodactylus.util.template.TemplateParser;
import net.pterodactylus.util.template.XmlFilter;
-import com.google.common.base.Optional;
+import com.google.common.annotations.VisibleForTesting;
import com.google.common.collect.FluentIterable;
import com.google.common.collect.Ordering;
import com.google.common.eventbus.EventBus;
private static final Logger logger = Logging.getLogger(SoneInserter.class);
/** The insertion delay (in seconds). */
- private static volatile int insertionDelay = 60;
+ private static final AtomicInteger insertionDelay = new AtomicInteger(60);
/** The template factory used to create the templates. */
private static final TemplateContextFactory templateContextFactory = new TemplateContextFactory();
/** The Freenet interface. */
private final FreenetInterface freenetInterface;
+ private final SoneModificationDetector soneModificationDetector;
+ private final long delay;
+
/** The Sone to insert. */
private volatile Sone sone;
- /** Whether a modification has been detected. */
- private volatile boolean modified = false;
-
- /** The fingerprint of the last insert. */
- private volatile String lastInsertFingerprint;
-
/**
* Creates a new Sone inserter.
*
* The Sone to insert
*/
public SoneInserter(Core core, EventBus eventBus, FreenetInterface freenetInterface, Sone sone) {
+ this(core, eventBus, freenetInterface, sone, new SoneModificationDetector(core, sone, insertionDelay), 1000);
+ }
+
+ @VisibleForTesting
+ SoneInserter(Core core, EventBus eventBus, FreenetInterface freenetInterface, Sone sone, SoneModificationDetector soneModificationDetector, long delay) {
super("Sone Inserter for “" + sone.getName() + "”", false);
this.core = core;
this.eventBus = eventBus;
this.freenetInterface = freenetInterface;
this.sone = sone;
+ this.soneModificationDetector = soneModificationDetector;
+ this.delay = delay;
}
//
* @return This Sone inserter
*/
public SoneInserter setSone(Sone sone) {
- checkArgument((this.sone == null) || sone.equals(this.sone), "Sone to insert can not be set to a different Sone");
+ checkArgument(sone.equals(this.sone), "Sone to insert can not be set to a different Sone");
this.sone = sone;
return this;
}
+ @VisibleForTesting
+ static AtomicInteger getInsertionDelay() {
+ return insertionDelay;
+ }
+
/**
* Changes the insertion delay, i.e. the time the Sone inserter waits after it
* has noticed a Sone modification before it starts the insert.
* The insertion delay (in seconds)
*/
public static void setInsertionDelay(int insertionDelay) {
- SoneInserter.insertionDelay = insertionDelay;
+ SoneInserter.insertionDelay.set(insertionDelay);
}
/**
* @return The fingerprint of the last insert
*/
public String getLastInsertFingerprint() {
- return lastInsertFingerprint;
+ return soneModificationDetector.getOriginalFingerprint();
}
/**
* The fingerprint of the last insert
*/
public void setLastInsertFingerprint(String lastInsertFingerprint) {
- this.lastInsertFingerprint = lastInsertFingerprint;
+ soneModificationDetector.setFingerprint(lastInsertFingerprint);
}
/**
* otherwise
*/
public boolean isModified() {
- return modified;
+ return soneModificationDetector.isModified();
}
//
*/
@Override
protected void serviceRun() {
- Optional<Long> lastModificationTime = absent();
- String lastInsertedFingerprint = lastInsertFingerprint;
- String lastFingerprint = "";
while (!shouldStop()) {
try {
/* check every second. */
- sleep(1000);
-
- /* don’t insert locked Sones. */
- Sone sone = this.sone;
- if (core.isLocked(sone)) {
- /* trigger redetection when the Sone is unlocked. */
- synchronized (sone) {
- modified = !sone.getFingerprint().equals(lastInsertedFingerprint);
- }
- lastFingerprint = "";
- lastModificationTime = absent();
- continue;
- }
-
- InsertInformation insertInformation = null;
- synchronized (sone) {
- String fingerprint = sone.getFingerprint();
- if (!fingerprint.equals(lastFingerprint)) {
- if (fingerprint.equals(lastInsertedFingerprint)) {
- modified = false;
- lastModificationTime = absent();
- logger.log(Level.FINE, String.format("Sone %s has been reverted to last insert state.", sone));
- } else {
- lastModificationTime = of(currentTimeMillis());
- modified = true;
- logger.log(Level.FINE, String.format("Sone %s has been modified, waiting %d seconds before inserting.", sone.getName(), insertionDelay));
- }
- lastFingerprint = fingerprint;
- }
- if (modified && lastModificationTime.isPresent() && ((currentTimeMillis() - lastModificationTime.get()) > (insertionDelay * 1000))) {
- lastInsertedFingerprint = fingerprint;
- insertInformation = new InsertInformation(sone);
- }
- }
+ sleep(delay);
- if (insertInformation != null) {
+ if (soneModificationDetector.isEligibleForInsert()) {
+ InsertInformation insertInformation = new InsertInformation(sone);
logger.log(Level.INFO, String.format("Inserting Sone “%s”…", sone.getName()));
boolean success = false;
try {
sone.setStatus(SoneStatus.inserting);
long insertTime = currentTimeMillis();
- insertInformation.setTime(insertTime);
eventBus.post(new SoneInsertingEvent(sone));
FreenetURI finalUri = freenetInterface.insertDirectory(insertInformation.getInsertUri(), insertInformation.generateManifestEntries(), "index.html");
eventBus.post(new SoneInsertedEvent(sone, currentTimeMillis() - insertTime));
*/
if (success) {
synchronized (sone) {
- if (lastInsertedFingerprint.equals(sone.getFingerprint())) {
+ if (insertInformation.getFingerprint().equals(sone.getFingerprint())) {
logger.log(Level.FINE, String.format("Sone “%s” was not modified further, resetting counter…", sone));
- lastModificationTime = absent();
- lastInsertFingerprint = lastInsertedFingerprint;
+ soneModificationDetector.setFingerprint(insertInformation.getFingerprint());
core.touchConfiguration();
- modified = false;
}
}
}
}
}
+ static class SetInsertionDelay implements OptionWatcher<Integer> {
+
+ @Override
+ public void optionChanged(Option<Integer> option, Integer oldValue, Integer newValue) {
+ setInsertionDelay(newValue);
+ }
+
+ }
+
/**
* Container for information that are required to insert a Sone. This
* container merely exists to copy all relevant data without holding a lock
*
* @author <a href="mailto:bombe@pterodactylus.net">David ‘Bombe’ Roden</a>
*/
- private class InsertInformation {
+ @VisibleForTesting
+ class InsertInformation {
+
+ private final String fingerprint;
/** All properties of the Sone, copied for thread safety. */
private final Map<String, Object> soneProperties = new HashMap<String, Object>();
* The sone to insert
*/
public InsertInformation(Sone sone) {
+ this.fingerprint = sone.getFingerprint();
soneProperties.put("id", sone.getId());
soneProperties.put("name", sone.getName());
- soneProperties.put("time", sone.getTime());
+ soneProperties.put("time", currentTimeMillis());
soneProperties.put("requestUri", sone.getRequestUri());
soneProperties.put("insertUri", sone.getInsertUri());
soneProperties.put("profile", sone.getProfile());
// ACCESSORS
//
+ @VisibleForTesting
+ String getFingerprint() {
+ return fingerprint;
+ }
+
/**
* Returns the insert URI of the Sone.
*
return (FreenetURI) soneProperties.get("insertUri");
}
- /**
- * Sets the time of the Sone at the time of the insert.
- *
- * @param time
- * The time of the Sone
- */
- public void setTime(long time) {
- soneProperties.put("time", time);
- }
-
//
// ACTIONS
//
@SuppressWarnings("synthetic-access")
private ManifestElement createManifestElement(String name, String contentType, String templateName) {
InputStreamReader templateInputStreamReader = null;
+ InputStream templateInputStream = null;
Template template;
try {
- templateInputStreamReader = new InputStreamReader(getClass().getResourceAsStream(templateName), utf8Charset);
+ templateInputStream = getClass().getResourceAsStream(templateName);
+ templateInputStreamReader = new InputStreamReader(templateInputStream, utf8Charset);
template = TemplateParser.parse(templateInputStreamReader);
} catch (TemplateException te1) {
logger.log(Level.SEVERE, String.format("Could not parse template “%s”!", templateName), te1);
return null;
} finally {
Closer.close(templateInputStreamReader);
+ Closer.close(templateInputStream);
}
TemplateContext templateContext = templateContextFactory.createTemplateContext();