X-Git-Url: https://git.pterodactylus.net/?p=Sone.git;a=blobdiff_plain;f=src%2Fmain%2Fjava%2Fnet%2Fpterodactylus%2Fsone%2Fcore%2FFreenetInterface.java;h=48c1c6bf717e98880dbe0c840ef3438f8503e961;hp=39f342c389a9564d1b0a07feb64f7b7e4537fe32;hb=c37b5e0044a3d48d6bc2c3bb71a0b38a9302d455;hpb=4f92a116596bf5d42c5b8beadb5df2bc8149e809 diff --git a/src/main/java/net/pterodactylus/sone/core/FreenetInterface.java b/src/main/java/net/pterodactylus/sone/core/FreenetInterface.java index 39f342c..48c1c6b 100644 --- a/src/main/java/net/pterodactylus/sone/core/FreenetInterface.java +++ b/src/main/java/net/pterodactylus/sone/core/FreenetInterface.java @@ -1,5 +1,5 @@ /* - * Sone - FreenetInterface.java - Copyright © 2010 David Roden + * Sone - FreenetInterface.java - Copyright © 2010–2013 David Roden * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -17,24 +17,37 @@ package net.pterodactylus.sone.core; +import static freenet.client.FetchException.PERMANENT_REDIRECT; +import static freenet.node.RequestStarter.INTERACTIVE_PRIORITY_CLASS; +import static freenet.node.RequestStarter.PREFETCH_PRIORITY_CLASS; +import static java.lang.String.format; +import static java.util.Collections.synchronizedMap; +import static java.util.concurrent.TimeUnit.DAYS; +import static java.util.logging.Level.FINE; +import static java.util.logging.Level.FINEST; +import static java.util.logging.Level.INFO; +import static java.util.logging.Level.WARNING; +import static net.pterodactylus.sone.data.Sone.TO_FREENET_URI; +import static net.pterodactylus.util.logging.Logging.getLogger; + import java.net.MalformedURLException; -import java.util.ArrayList; -import java.util.Collections; import java.util.HashMap; -import java.util.List; import java.util.Map; -import java.util.logging.Level; import java.util.logging.Logger; -import net.pterodactylus.sone.core.SoneException.Type; +import net.pterodactylus.sone.core.event.ImageInsertAbortedEvent; +import net.pterodactylus.sone.core.event.ImageInsertFailedEvent; +import net.pterodactylus.sone.core.event.ImageInsertFinishedEvent; +import net.pterodactylus.sone.core.event.ImageInsertStartedEvent; import net.pterodactylus.sone.data.Image; import net.pterodactylus.sone.data.Sone; import net.pterodactylus.sone.data.TemporaryImage; -import net.pterodactylus.util.collection.Pair; import net.pterodactylus.util.logging.Logging; import com.db4o.ObjectContainer; - +import com.google.common.annotations.VisibleForTesting; +import com.google.common.eventbus.EventBus; +import com.google.inject.Inject; import freenet.client.ClientMetadata; import freenet.client.FetchException; import freenet.client.FetchResult; @@ -48,10 +61,12 @@ import freenet.client.async.ClientContext; import freenet.client.async.ClientPutCallback; import freenet.client.async.ClientPutter; import freenet.client.async.USKCallback; +import freenet.client.async.USKManager; import freenet.keys.FreenetURI; import freenet.keys.InsertableClientSSK; import freenet.keys.USK; import freenet.node.Node; +import freenet.node.RequestClient; import freenet.node.RequestStarter; import freenet.support.api.Bucket; import freenet.support.io.ArrayBucket; @@ -64,29 +79,49 @@ import freenet.support.io.ArrayBucket; public class FreenetInterface { /** The logger. */ - private static final Logger logger = Logging.getLogger(FreenetInterface.class); + private static final Logger logger = getLogger(FreenetInterface.class); + + /** The event bus. */ + private final EventBus eventBus; /** The node to interact with. */ private final Node node; /** The high-level client to use for requests. */ private final HighLevelSimpleClient client; + private final RequestClient requestClient; /** The USK callbacks. */ private final Map soneUskCallbacks = new HashMap(); /** The not-Sone-related USK callbacks. */ - private final Map uriUskCallbacks = Collections.synchronizedMap(new HashMap()); + private final Map uriUskCallbacks = synchronizedMap(new HashMap()); + private USKManager uskManager; /** * Creates a new Freenet interface. * + * @param eventBus + * The event bus * @param node * The node to interact with */ - public FreenetInterface(Node node) { + @Inject + public FreenetInterface(EventBus eventBus, Node node) { + this.eventBus = eventBus; + this.node = node; + this.client = node.clientCore.makeClient(INTERACTIVE_PRIORITY_CLASS, false, true); + this.requestClient = (HighLevelSimpleClientImpl) client; + this.uskManager = node.clientCore.uskManager; + } + + @VisibleForTesting + public FreenetInterface(EventBus eventBus, Node node, HighLevelSimpleClient highLevelSimpleClient, RequestClient requestClient, USKManager uskManager) { + this.eventBus = eventBus; this.node = node; - this.client = node.clientCore.makeClient(RequestStarter.INTERACTIVE_PRIORITY_CLASS, false, true); + this.client = highLevelSimpleClient; + this.requestClient = requestClient; + this.uskManager = uskManager; } // @@ -100,19 +135,19 @@ public class FreenetInterface { * The URI to fetch * @return The result of the fetch, or {@code null} if an error occured */ - public Pair fetchUri(FreenetURI uri) { + public Fetched fetchUri(FreenetURI uri) { FetchResult fetchResult = null; FreenetURI currentUri = new FreenetURI(uri); while (true) { try { fetchResult = client.fetch(currentUri); - return new Pair(currentUri, fetchResult); + return new Fetched(currentUri, fetchResult); } catch (FetchException fe1) { - if (fe1.getMode() == FetchException.PERMANENT_REDIRECT) { + if (fe1.getMode() == PERMANENT_REDIRECT) { currentUri = fe1.newURI; continue; } - logger.log(Level.WARNING, "Could not fetch “" + uri + "”!", fe1); + logger.log(WARNING, format("Could not fetch “%s”!", uri), fe1); return null; } } @@ -151,10 +186,10 @@ public class FreenetInterface { ClientMetadata metadata = new ClientMetadata(temporaryImage.getMimeType()); InsertBlock insertBlock = new InsertBlock(bucket, metadata, targetUri); try { - ClientPutter clientPutter = client.insert(insertBlock, false, null, false, insertContext, insertToken, RequestStarter.INTERACTIVE_PRIORITY_CLASS); + ClientPutter clientPutter = client.insert(insertBlock, false, null, false, insertContext, insertToken, INTERACTIVE_PRIORITY_CLASS); insertToken.setClientPutter(clientPutter); } catch (InsertException ie1) { - throw new SoneException(Type.INSERT_FAILED, "Could not start image insert.", ie1); + throw new SoneInsertException("Could not start image insert.", ie1); } } @@ -175,7 +210,7 @@ public class FreenetInterface { try { return client.insertManifest(insertUri, manifestEntries, defaultFile); } catch (InsertException ie1) { - throw new SoneException(null, ie1); + throw new SoneException(ie1); } } @@ -190,42 +225,20 @@ public class FreenetInterface { */ public void registerUsk(final Sone sone, final SoneDownloader soneDownloader) { try { - logger.log(Level.FINE, "Registering Sone “%s” for USK updates at %s…", new Object[] { sone, sone.getRequestUri().setMetaString(new String[] { "sone.xml" }) }); - USKCallback uskCallback = new USKCallback() { - - @Override - @SuppressWarnings("synthetic-access") - public void onFoundEdition(long edition, USK key, ObjectContainer objectContainer, ClientContext clientContext, boolean metadata, short codec, byte[] data, boolean newKnownGood, boolean newSlotToo) { - logger.log(Level.FINE, "Found USK update for Sone “%s” at %s, new known good: %s, new slot too: %s.", new Object[] { sone, key, newKnownGood, newSlotToo }); - if (edition > sone.getLatestEdition()) { - sone.setLatestEdition(edition); - new Thread(new Runnable() { - - @Override - public void run() { - soneDownloader.fetchSone(sone); - } - }, "Sone Downloader").start(); - } - } - - @Override - public short getPollingPriorityProgress() { - return RequestStarter.INTERACTIVE_PRIORITY_CLASS; - } - - @Override - public short getPollingPriorityNormal() { - return RequestStarter.INTERACTIVE_PRIORITY_CLASS; - } - }; + logger.log(FINE, format("Registering Sone “%s” for USK updates at %s…", sone, TO_FREENET_URI.apply(sone).setMetaString(new String[]{"sone.xml"}))); + USKCallback uskCallback = new NewEditionFound(sone, soneDownloader); soneUskCallbacks.put(sone.getId(), uskCallback); - node.clientCore.uskManager.subscribe(USK.create(sone.getRequestUri()), uskCallback, (System.currentTimeMillis() - sone.getTime()) < 7 * 24 * 60 * 60 * 1000, (HighLevelSimpleClientImpl) client); + boolean runBackgroundFetch = soneWasUpdatedInTheLastWeek(sone); + uskManager.subscribe(USK.create(TO_FREENET_URI.apply(sone)), uskCallback, runBackgroundFetch, requestClient); } catch (MalformedURLException mue1) { - logger.log(Level.WARNING, "Could not subscribe USK “" + sone.getRequestUri() + "”!", mue1); + logger.log(WARNING, format("Could not subscribe USK “%s”!", TO_FREENET_URI.apply(sone)), mue1); } } + private boolean soneWasUpdatedInTheLastWeek(Sone sone) { + return (System.currentTimeMillis() - sone.getTime()) < DAYS.toMillis(7); + } + /** * Unsubscribes the request URI of the given Sone. * @@ -238,10 +251,10 @@ public class FreenetInterface { return; } try { - logger.log(Level.FINEST, "Unsubscribing from USK for %s…", new Object[] { sone }); - node.clientCore.uskManager.unsubscribe(USK.create(sone.getRequestUri()), uskCallback); + logger.log(FINEST, format("Unsubscribing from USK for %s…", sone)); + uskManager.unsubscribe(USK.create(TO_FREENET_URI.apply(sone)), uskCallback); } catch (MalformedURLException mue1) { - logger.log(Level.FINE, "Could not unsubscribe USK “" + sone.getRequestUri() + "”!", mue1); + logger.log(FINE, format("Could not unsubscribe USK “%s”!", TO_FREENET_URI.apply(sone)), mue1); } } @@ -255,29 +268,12 @@ public class FreenetInterface { * The callback to call */ public void registerUsk(FreenetURI uri, final Callback callback) { - USKCallback uskCallback = new USKCallback() { - - @Override - public void onFoundEdition(long edition, USK key, ObjectContainer objectContainer, ClientContext clientContext, boolean metadata, short codec, byte[] data, boolean newKnownGood, boolean newSlotToo) { - callback.editionFound(key.getURI(), edition, newKnownGood, newSlotToo); - } - - @Override - public short getPollingPriorityNormal() { - return RequestStarter.PREFETCH_PRIORITY_CLASS; - } - - @Override - public short getPollingPriorityProgress() { - return RequestStarter.INTERACTIVE_PRIORITY_CLASS; - } - - }; + USKCallback uskCallback = new CallbackWrapper(callback); try { - node.clientCore.uskManager.subscribe(USK.create(uri), uskCallback, true, (HighLevelSimpleClientImpl) client); + uskManager.subscribe(USK.create(uri), uskCallback, true, requestClient); uriUskCallbacks.put(uri, uskCallback); } catch (MalformedURLException mue1) { - logger.log(Level.WARNING, "Could not subscribe to USK: " + uri, uri); + logger.log(WARNING, format("Could not subscribe to USK: %s", uri), mue1); } } @@ -290,14 +286,64 @@ public class FreenetInterface { public void unregisterUsk(FreenetURI uri) { USKCallback uskCallback = uriUskCallbacks.remove(uri); if (uskCallback == null) { - logger.log(Level.INFO, "Could not unregister unknown USK: " + uri); + logger.log(INFO, format("Could not unregister unknown USK: %s", uri)); return; } try { - node.clientCore.uskManager.unsubscribe(USK.create(uri), uskCallback); + uskManager.unsubscribe(USK.create(uri), uskCallback); } catch (MalformedURLException mue1) { - logger.log(Level.INFO, "Could not unregister invalid USK: " + uri); + logger.log(INFO, format("Could not unregister invalid USK: %s", uri), mue1); + } + } + + /** + * Container for a fetched URI and the {@link FetchResult}. + * + * @author David Roden + */ + public static class Fetched { + + /** The fetched URI. */ + private final FreenetURI freenetUri; + + /** The fetch result. */ + private final FetchResult fetchResult; + + /** + * Creates a new fetched URI. + * + * @param freenetUri + * The URI that was fetched + * @param fetchResult + * The fetch result + */ + public Fetched(FreenetURI freenetUri, FetchResult fetchResult) { + this.freenetUri = freenetUri; + this.fetchResult = fetchResult; } + + // + // ACCESSORS + // + + /** + * Returns the fetched URI. + * + * @return The fetched URI + */ + public FreenetURI getFreenetUri() { + return freenetUri; + } + + /** + * Returns the fetch result. + * + * @return The fetch result + */ + public FetchResult getFetchResult() { + return fetchResult; + } + } /** @@ -324,10 +370,75 @@ public class FreenetInterface { } + private static class NewEditionFound implements USKCallback { + + private final Sone sone; + private final SoneDownloader soneDownloader; + + public NewEditionFound(Sone sone, SoneDownloader soneDownloader) { + this.sone = sone; + this.soneDownloader = soneDownloader; + } + + @Override + @SuppressWarnings("synthetic-access") + public void onFoundEdition(long edition, USK key, ObjectContainer objectContainer, ClientContext clientContext, boolean metadata, short codec, byte[] data, boolean newKnownGood, boolean newSlotToo) { + logger.log(FINE, format("Found USK update for Sone “%s” at %s, new known good: %s, new slot too: %s.", sone, key, newKnownGood, newSlotToo)); + if (edition > sone.getLatestEdition()) { + sone.modify().setLatestEdition(edition).update(); + new Thread(new Runnable() { + + @Override + public void run() { + soneDownloader.fetchSone(sone); + } + }, format("Sone Downloader for %s", sone.getId())).start(); + } + } + + @Override + public short getPollingPriorityProgress() { + return INTERACTIVE_PRIORITY_CLASS; + } + + @Override + public short getPollingPriorityNormal() { + return INTERACTIVE_PRIORITY_CLASS; + } + } + + private static class CallbackWrapper implements USKCallback { + + private final Callback callback; + + public CallbackWrapper(Callback callback) { + this.callback = callback; + } + + @Override + public void onFoundEdition(long edition, USK key, ObjectContainer objectContainer, ClientContext clientContext, boolean metadata, short codec, byte[] data, boolean newKnownGood, boolean newSlotToo) { + callback.editionFound(key.getURI(), edition, newKnownGood, newSlotToo); + } + + @Override + public short getPollingPriorityNormal() { + return PREFETCH_PRIORITY_CLASS; + } + + @Override + public short getPollingPriorityProgress() { + return INTERACTIVE_PRIORITY_CLASS; + } + + } + /** - * Insert token that can be used to add {@link ImageInsertListener}s and - * cancel a running insert. + * Insert token that can cancel a running insert and sends events. * + * @see ImageInsertAbortedEvent + * @see ImageInsertStartedEvent + * @see ImageInsertFailedEvent + * @see ImageInsertFinishedEvent * @author David ‘Bombe’ Roden */ public class InsertToken implements ClientPutCallback { @@ -335,9 +446,6 @@ public class FreenetInterface { /** The image being inserted. */ private final Image image; - /** The list of registered image insert listeners. */ - private final List imageInsertListeners = Collections.synchronizedList(new ArrayList()); - /** The client putter. */ private ClientPutter clientPutter; @@ -355,30 +463,6 @@ public class FreenetInterface { } // - // LISTENER MANAGEMENT - // - - /** - * Adds the given listener to the list of registered listener. - * - * @param imageInsertListener - * The listener to add - */ - public void addImageInsertListener(ImageInsertListener imageInsertListener) { - imageInsertListeners.add(imageInsertListener); - } - - /** - * Removes the given listener from the list of registered listener. - * - * @param imageInsertListener - * The listener to remove - */ - public void removeImageInsertListener(ImageInsertListener imageInsertListener) { - imageInsertListeners.remove(imageInsertListener); - } - - // // ACCESSORS // @@ -386,15 +470,13 @@ public class FreenetInterface { * Sets the client putter that is inserting the image. This will also * signal all registered listeners that the image has started. * - * @see ImageInsertListener#imageInsertStarted(Image) * @param clientPutter * The client putter */ + @SuppressWarnings("synthetic-access") public void setClientPutter(ClientPutter clientPutter) { this.clientPutter = clientPutter; - for (ImageInsertListener imageInsertListener : imageInsertListeners) { - imageInsertListener.imageInsertStarted(image); - } + eventBus.post(new ImageInsertStartedEvent(image)); } // @@ -403,67 +485,51 @@ public class FreenetInterface { /** * Cancels the running insert. - * - * @see ImageInsertListener#imageInsertAborted(Image) */ @SuppressWarnings("synthetic-access") public void cancel() { clientPutter.cancel(null, node.clientCore.clientContext); - for (ImageInsertListener imageInsertListener : imageInsertListeners) { - imageInsertListener.imageInsertAborted(image); - } + eventBus.post(new ImageInsertAbortedEvent(image)); } // // INTERFACE ClientPutCallback // - /** - * {@inheritDoc} - */ @Override public void onMajorProgress(ObjectContainer objectContainer) { /* ignore, we don’t care. */ } - /** - * {@inheritDoc} - */ @Override + @SuppressWarnings("synthetic-access") public void onFailure(InsertException insertException, BaseClientPutter clientPutter, ObjectContainer objectContainer) { - for (ImageInsertListener imageInsertListener : imageInsertListeners) { - if ((insertException != null) && ("Cancelled by user".equals(insertException.getMessage()))) { - imageInsertListener.imageInsertAborted(image); - } else { - imageInsertListener.imageInsertFailed(image, insertException); - } + if ((insertException != null) && ("Cancelled by user".equals(insertException.getMessage()))) { + eventBus.post(new ImageInsertAbortedEvent(image)); + } else { + eventBus.post(new ImageInsertFailedEvent(image, insertException)); } } - /** - * {@inheritDoc} - */ @Override public void onFetchable(BaseClientPutter clientPutter, ObjectContainer objectContainer) { /* ignore, we don’t care. */ } - /** - * {@inheritDoc} - */ + @Override + public void onGeneratedMetadata(Bucket metadata, BaseClientPutter clientPutter, ObjectContainer objectContainer) { + /* ignore, we don’t care. */ + } + @Override public void onGeneratedURI(FreenetURI generatedUri, BaseClientPutter clientPutter, ObjectContainer objectContainer) { resultingUri = generatedUri; } - /** - * {@inheritDoc} - */ @Override + @SuppressWarnings("synthetic-access") public void onSuccess(BaseClientPutter clientPutter, ObjectContainer objectContainer) { - for (ImageInsertListener imageInsertListener : imageInsertListeners) { - imageInsertListener.imageInsertFinished(image, resultingUri); - } + eventBus.post(new ImageInsertFinishedEvent(image, resultingUri)); } }