Replace unnecessary type parameters with <>
[Sone.git] / src / main / java / net / pterodactylus / sone / core / SoneDownloaderImpl.java
1 /*
2  * Sone - SoneDownloaderImpl.java - Copyright © 2010–2016 David Roden
3  *
4  * This program is free software: you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License as published by
6  * the Free Software Foundation, either version 3 of the License, or
7  * (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
16  */
17
18 package net.pterodactylus.sone.core;
19
20 import static freenet.support.io.Closer.close;
21 import static java.lang.String.format;
22 import static java.lang.System.currentTimeMillis;
23 import static java.util.concurrent.TimeUnit.DAYS;
24 import static java.util.logging.Logger.getLogger;
25
26 import java.io.InputStream;
27 import java.util.HashSet;
28 import java.util.Set;
29 import java.util.logging.Level;
30 import java.util.logging.Logger;
31
32 import javax.inject.Inject;
33
34 import net.pterodactylus.sone.data.Sone;
35 import net.pterodactylus.sone.data.Sone.SoneStatus;
36 import net.pterodactylus.util.service.AbstractService;
37
38 import freenet.client.FetchResult;
39 import freenet.client.async.ClientContext;
40 import freenet.client.async.USKCallback;
41 import freenet.keys.FreenetURI;
42 import freenet.keys.USK;
43 import freenet.node.RequestStarter;
44 import freenet.support.api.Bucket;
45
46 /**
47  * The Sone downloader is responsible for download Sones as they are updated.
48  */
49 public class SoneDownloaderImpl extends AbstractService implements SoneDownloader {
50
51         /** The logger. */
52         private static final Logger logger = getLogger(SoneDownloaderImpl.class.getName());
53
54         /** The maximum protocol version. */
55         private static final int MAX_PROTOCOL_VERSION = 0;
56
57         /** The core. */
58         private final UpdatedSoneProcessor updatedSoneProcessor;
59         private final SoneParser soneParser;
60
61         /** The Freenet interface. */
62         private final FreenetInterface freenetInterface;
63
64         /** The sones to update. */
65         private final Set<Sone> sones = new HashSet<>();
66
67         @Inject
68         SoneDownloaderImpl(UpdatedSoneProcessor updatedSoneProcessor, FreenetInterface freenetInterface, SoneParser soneParser) {
69                 super("Sone Downloader", false);
70                 this.updatedSoneProcessor = updatedSoneProcessor;
71                 this.freenetInterface = freenetInterface;
72                 this.soneParser = soneParser;
73         }
74
75         //
76         // ACTIONS
77         //
78
79         /**
80          * Adds the given Sone to the set of Sones that will be watched for updates.
81          *
82          * @param sone
83          *              The Sone to add
84          */
85         @Override
86         public void addSone(final Sone sone) {
87                 if (!sones.add(sone)) {
88                         freenetInterface.unregisterUsk(sone);
89                 }
90                 final USKCallback uskCallback = new USKCallback() {
91
92                         @Override
93                         @SuppressWarnings("synthetic-access")
94                         public void onFoundEdition(long edition, USK key,
95                                         ClientContext clientContext, boolean metadata,
96                                         short codec, byte[] data, boolean newKnownGood,
97                                         boolean newSlotToo) {
98                                 logger.log(Level.FINE, format(
99                                                 "Found USK update for Sone “%s” at %s, new known good: %s, new slot too: %s.",
100                                                 sone, key, newKnownGood, newSlotToo));
101                                 if (edition > sone.getLatestEdition()) {
102                                         sone.setLatestEdition(edition);
103                                         new Thread(fetchSoneAsSskAction(sone),
104                                                         "Sone Downloader").start();
105                                 }
106                         }
107
108                         @Override
109                         public short getPollingPriorityProgress() {
110                                 return RequestStarter.INTERACTIVE_PRIORITY_CLASS;
111                         }
112
113                         @Override
114                         public short getPollingPriorityNormal() {
115                                 return RequestStarter.INTERACTIVE_PRIORITY_CLASS;
116                         }
117                 };
118                 if (soneHasBeenActiveRecently(sone)) {
119                         freenetInterface.registerActiveUsk(sone.getRequestUri(),
120                                         uskCallback);
121                 } else {
122                         freenetInterface.registerPassiveUsk(sone.getRequestUri(),
123                                         uskCallback);
124                 }
125         }
126
127         private boolean soneHasBeenActiveRecently(Sone sone) {
128                 return (currentTimeMillis() - sone.getTime()) < DAYS.toMillis(7);
129         }
130
131         private void fetchSoneAsSsk(Sone sone) {
132                 fetchSone(sone, sone.getRequestUri().sskForUSK(), false);
133         }
134
135         /**
136          * Fetches the Sone from the given URI.
137          *
138          * @param sone
139          *              The Sone to fetch
140          * @param soneUri
141          *              The URI of the Sone to fetch
142          * @param fetchOnly
143          *              {@code true} to only fetch and parse the Sone, {@code false}
144          *              to {@link Core#updateSone(Sone) update} it in the core
145          * @return The downloaded Sone, or {@code null} if the Sone could not be
146          *         downloaded
147          */
148         @Override
149         public Sone fetchSone(Sone sone, FreenetURI soneUri, boolean fetchOnly) {
150                 logger.log(Level.FINE, String.format("Starting fetch for Sone “%s” from %s…", sone, soneUri));
151                 FreenetURI requestUri = soneUri.setMetaString(new String[] { "sone.xml" });
152                 sone.setStatus(SoneStatus.downloading);
153                 try {
154                         Fetched fetchResults = freenetInterface.fetchUri(requestUri);
155                         if (fetchResults == null) {
156                                 /* TODO - mark Sone as bad. */
157                                 return null;
158                         }
159                         logger.log(Level.FINEST, String.format("Got %d bytes back.", fetchResults.getFetchResult().size()));
160                         Sone parsedSone = parseSone(sone, fetchResults.getFetchResult(), fetchResults.getFreenetUri());
161                         if (parsedSone != null) {
162                                 if (!fetchOnly) {
163                                         parsedSone.setStatus((parsedSone.getTime() == 0) ? SoneStatus.unknown : SoneStatus.idle);
164                                         updatedSoneProcessor.updateSone(parsedSone);
165                                         addSone(parsedSone);
166                                 }
167                         }
168                         return parsedSone;
169                 } finally {
170                         sone.setStatus((sone.getTime() == 0) ? SoneStatus.unknown : SoneStatus.idle);
171                 }
172         }
173
174         /**
175          * Parses a Sone from a fetch result.
176          *
177          * @param originalSone
178          *              The sone to parse, or {@code null} if the Sone is yet unknown
179          * @param fetchResult
180          *              The fetch result
181          * @param requestUri
182          *              The requested URI
183          * @return The parsed Sone, or {@code null} if the Sone could not be parsed
184          */
185         private Sone parseSone(Sone originalSone, FetchResult fetchResult, FreenetURI requestUri) {
186                 logger.log(Level.FINEST, String.format("Parsing FetchResult (%d bytes, %s) for %s…", fetchResult.size(), fetchResult.getMimeType(), originalSone));
187                 Bucket soneBucket = fetchResult.asBucket();
188                 InputStream soneInputStream = null;
189                 try {
190                         soneInputStream = soneBucket.getInputStream();
191                         Sone parsedSone = soneParser.parseSone(originalSone,
192                                         soneInputStream);
193                         if (parsedSone != null) {
194                                 parsedSone.setLatestEdition(requestUri.getEdition());
195                         }
196                         return parsedSone;
197                 } catch (Exception e1) {
198                         logger.log(Level.WARNING, String.format("Could not parse Sone from %s!", requestUri), e1);
199                 } finally {
200                         close(soneInputStream);
201                         close(soneBucket);
202                 }
203                 return null;
204         }
205
206         @Override
207         public Runnable fetchSoneAsUskAction(final Sone sone) {
208                 return new Runnable() {
209                         @Override
210                         public void run() {
211                                 fetchSone(sone, sone.getRequestUri(), false);
212                         }
213                 };
214         }
215
216         @Override
217         public Runnable fetchSoneAsSskAction(final Sone sone) {
218                 return new Runnable() {
219                         @Override
220                         public void run() {
221                                 fetchSoneAsSsk(sone);
222                         }
223                 };
224         }
225
226         /** {@inheritDoc} */
227         @Override
228         protected void serviceStop() {
229                 for (Sone sone : sones) {
230                         freenetInterface.unregisterUsk(sone);
231                 }
232         }
233
234 }