X-Git-Url: https://git.pterodactylus.net/?p=Sone.git;a=blobdiff_plain;f=src%2Fmain%2Fjava%2Fnet%2Fpterodactylus%2Fsone%2Fcore%2FFreenetInterface.java;h=3348e88cf90e38e74ffa5326902b1d95200352c9;hp=9241e351c3127198b0a31e08ae191e56506a9bb0;hb=c9e306ac8e3ada846e87a0cc256a20fc148f381c;hpb=ffd5ab370b2f665efd3c9cf129e59aef30b9bace diff --git a/src/main/java/net/pterodactylus/sone/core/FreenetInterface.java b/src/main/java/net/pterodactylus/sone/core/FreenetInterface.java index 9241e35..3348e88 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 @@ /* - * FreenetSone - FreenetInterface.java - Copyright © 2010 David Roden + * Sone - FreenetInterface.java - Copyright © 2010 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,19 +17,66 @@ package net.pterodactylus.sone.core; -import net.pterodactylus.util.service.AbstractService; +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.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 freenet.client.ClientMetadata; +import freenet.client.FetchException; +import freenet.client.FetchResult; +import freenet.client.HighLevelSimpleClient; +import freenet.client.HighLevelSimpleClientImpl; +import freenet.client.InsertBlock; +import freenet.client.InsertContext; +import freenet.client.InsertException; +import freenet.client.async.BaseClientPutter; +import freenet.client.async.ClientContext; +import freenet.client.async.ClientPutCallback; +import freenet.client.async.ClientPutter; +import freenet.client.async.USKCallback; +import freenet.keys.FreenetURI; +import freenet.keys.InsertableClientSSK; +import freenet.keys.USK; import freenet.node.Node; +import freenet.node.RequestStarter; +import freenet.support.api.Bucket; +import freenet.support.io.ArrayBucket; /** * Contains all necessary functionality for interacting with the Freenet node. * * @author David ‘Bombe’ Roden */ -public class FreenetInterface extends AbstractService { +public class FreenetInterface { + + /** The logger. */ + private static final Logger logger = Logging.getLogger(FreenetInterface.class); /** The node to interact with. */ private final Node node; + /** The high-level client to use for requests. */ + private final HighLevelSimpleClient client; + + /** The USK callbacks. */ + private final Map soneUskCallbacks = new HashMap(); + + /** The not-Sone-related USK callbacks. */ + private final Map uriUskCallbacks = Collections.synchronizedMap(new HashMap()); + /** * Creates a new Freenet interface. * @@ -38,6 +85,394 @@ public class FreenetInterface extends AbstractService { */ public FreenetInterface(Node node) { this.node = node; + this.client = node.clientCore.makeClient(RequestStarter.INTERACTIVE_PRIORITY_CLASS, false, true); + } + + // + // ACTIONS + // + + /** + * Fetches the given URI. + * + * @param uri + * The URI to fetch + * @return The result of the fetch, or {@code null} if an error occured + */ + public Pair fetchUri(FreenetURI uri) { + FetchResult fetchResult = null; + FreenetURI currentUri = new FreenetURI(uri); + while (true) { + try { + fetchResult = client.fetch(currentUri); + return new Pair(currentUri, fetchResult); + } catch (FetchException fe1) { + if (fe1.getMode() == FetchException.PERMANENT_REDIRECT) { + currentUri = fe1.newURI; + continue; + } + logger.log(Level.WARNING, String.format("Could not fetch “%s”!", uri), fe1); + return null; + } + } + } + + /** + * Creates a key pair. + * + * @return The request key at index 0, the insert key at index 1 + */ + public String[] generateKeyPair() { + FreenetURI[] keyPair = client.generateKeyPair(""); + return new String[] { keyPair[1].toString(), keyPair[0].toString() }; + } + + /** + * Inserts the image data of the given {@link TemporaryImage} and returns + * the given insert token that can be used to add listeners or cancel the + * insert. + * + * @param temporaryImage + * The temporary image data + * @param image + * The image + * @param insertToken + * The insert token + * @throws SoneException + * if the insert could not be started + */ + public void insertImage(TemporaryImage temporaryImage, Image image, InsertToken insertToken) throws SoneException { + String filenameHint = image.getId() + "." + temporaryImage.getMimeType().substring(temporaryImage.getMimeType().lastIndexOf("/") + 1); + InsertableClientSSK key = InsertableClientSSK.createRandom(node.random, ""); + FreenetURI targetUri = key.getInsertURI().setDocName(filenameHint); + InsertContext insertContext = client.getInsertContext(true); + Bucket bucket = new ArrayBucket(temporaryImage.getImageData()); + 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); + insertToken.setClientPutter(clientPutter); + } catch (InsertException ie1) { + throw new SoneInsertException("Could not start image insert.", ie1); + } + } + + /** + * Inserts a directory into Freenet. + * + * @param insertUri + * The insert URI + * @param manifestEntries + * The directory entries + * @param defaultFile + * The name of the default file + * @return The generated URI + * @throws SoneException + * if an insert error occurs + */ + public FreenetURI insertDirectory(FreenetURI insertUri, HashMap manifestEntries, String defaultFile) throws SoneException { + try { + return client.insertManifest(insertUri, manifestEntries, defaultFile); + } catch (InsertException ie1) { + throw new SoneException(ie1); + } + } + + /** + * Registers the USK for the given Sone and notifies the given + * {@link SoneDownloader} if an update was found. + * + * @param sone + * The Sone to watch + * @param soneDownloader + * The Sone download to notify on updates + */ + public void registerUsk(final Sone sone, final SoneDownloader soneDownloader) { + try { + logger.log(Level.FINE, String.format("Registering Sone “%s” for USK updates at %s…", 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, String.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.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; + } + }; + 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); + } catch (MalformedURLException mue1) { + logger.log(Level.WARNING, String.format("Could not subscribe USK “%s”!", sone.getRequestUri()), mue1); + } + } + + /** + * Unsubscribes the request URI of the given Sone. + * + * @param sone + * The Sone to unregister + */ + public void unregisterUsk(Sone sone) { + USKCallback uskCallback = soneUskCallbacks.remove(sone.getId()); + if (uskCallback == null) { + return; + } + try { + logger.log(Level.FINEST, String.format("Unsubscribing from USK for %s…", sone)); + node.clientCore.uskManager.unsubscribe(USK.create(sone.getRequestUri()), uskCallback); + } catch (MalformedURLException mue1) { + logger.log(Level.FINE, String.format("Could not unsubscribe USK “%s”!", sone.getRequestUri()), mue1); + } + } + + /** + * Registers an arbitrary URI and calls the given callback if a new edition + * is found. + * + * @param uri + * The URI to watch + * @param callback + * 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; + } + + }; + try { + node.clientCore.uskManager.subscribe(USK.create(uri), uskCallback, true, (HighLevelSimpleClientImpl) client); + uriUskCallbacks.put(uri, uskCallback); + } catch (MalformedURLException mue1) { + logger.log(Level.WARNING, String.format("Could not subscribe to USK: %s", uri), mue1); + } + } + + /** + * Unregisters the USK watcher for the given URI. + * + * @param uri + * The URI to unregister the USK watcher for + */ + public void unregisterUsk(FreenetURI uri) { + USKCallback uskCallback = uriUskCallbacks.remove(uri); + if (uskCallback == null) { + logger.log(Level.INFO, String.format("Could not unregister unknown USK: %s", uri)); + return; + } + try { + node.clientCore.uskManager.unsubscribe(USK.create(uri), uskCallback); + } catch (MalformedURLException mue1) { + logger.log(Level.INFO, String.format("Could not unregister invalid USK: %s", uri), mue1); + } + } + + /** + * Callback for USK watcher events. + * + * @author David ‘Bombe’ Roden + */ + public static interface Callback { + + /** + * Notifies a listener that a new edition was found for a URI. + * + * @param uri + * The URI that a new edition was found for + * @param edition + * The found edition + * @param newKnownGood + * Whether the found edition was actually fetched + * @param newSlot + * Whether the found edition is higher than all previously + * found editions + */ + public void editionFound(FreenetURI uri, long edition, boolean newKnownGood, boolean newSlot); + + } + + /** + * Insert token that can be used to add {@link ImageInsertListener}s and + * cancel a running insert. + * + * @author David ‘Bombe’ Roden + */ + public class InsertToken implements ClientPutCallback { + + /** 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; + + /** The final URI. */ + private volatile FreenetURI resultingUri; + + /** + * Creates a new insert token for the given image. + * + * @param image + * The image being inserted + */ + public InsertToken(Image image) { + this.image = image; + } + + // + // 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 + // + + /** + * 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 + */ + public void setClientPutter(ClientPutter clientPutter) { + this.clientPutter = clientPutter; + for (ImageInsertListener imageInsertListener : imageInsertListeners) { + imageInsertListener.imageInsertStarted(image); + } + } + + // + // ACTIONS + // + + /** + * 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); + } + } + + // + // INTERFACE ClientPutCallback + // + + /** + * {@inheritDoc} + */ + @Override + public void onMajorProgress(ObjectContainer objectContainer) { + /* ignore, we don’t care. */ + } + + /** + * {@inheritDoc} + */ + @Override + 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); + } + } + } + + /** + * {@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. */ + } + + /** + * {@inheritDoc} + */ + @Override + public void onGeneratedURI(FreenetURI generatedUri, BaseClientPutter clientPutter, ObjectContainer objectContainer) { + resultingUri = generatedUri; + } + + /** + * {@inheritDoc} + */ + @Override + public void onSuccess(BaseClientPutter clientPutter, ObjectContainer objectContainer) { + for (ImageInsertListener imageInsertListener : imageInsertListeners) { + imageInsertListener.imageInsertFinished(image, resultingUri); + } + } + } }