Use local Sones in more places where it’s appropriate.
[Sone.git] / src / main / java / net / pterodactylus / sone / database / memory / MemoryDatabase.java
1 /*
2  * Sone - MemoryDatabase.java - Copyright © 2013 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.database.memory;
19
20 import static com.google.common.base.Optional.fromNullable;
21 import static com.google.common.base.Preconditions.checkNotNull;
22 import static com.google.common.base.Predicates.not;
23 import static com.google.common.collect.FluentIterable.from;
24 import static java.lang.String.format;
25 import static java.util.logging.Level.WARNING;
26 import static net.pterodactylus.sone.data.Reply.TIME_COMPARATOR;
27 import static net.pterodactylus.sone.data.Sone.LOCAL_SONE_FILTER;
28 import static net.pterodactylus.sone.data.Sone.toAllAlbums;
29 import static net.pterodactylus.sone.data.Sone.toAllImages;
30
31 import java.util.Collection;
32 import java.util.Collections;
33 import java.util.Comparator;
34 import java.util.HashMap;
35 import java.util.HashSet;
36 import java.util.List;
37 import java.util.Map;
38 import java.util.Set;
39 import java.util.concurrent.locks.ReadWriteLock;
40 import java.util.concurrent.locks.ReentrantReadWriteLock;
41 import java.util.logging.Level;
42 import java.util.logging.Logger;
43
44 import net.pterodactylus.sone.core.ConfigurationSoneParser;
45 import net.pterodactylus.sone.core.ConfigurationSoneParser.InvalidAlbumFound;
46 import net.pterodactylus.sone.core.ConfigurationSoneParser.InvalidImageFound;
47 import net.pterodactylus.sone.core.ConfigurationSoneParser.InvalidParentAlbumFound;
48 import net.pterodactylus.sone.core.ConfigurationSoneParser.InvalidPostFound;
49 import net.pterodactylus.sone.core.ConfigurationSoneParser.InvalidPostReplyFound;
50 import net.pterodactylus.sone.data.Album;
51 import net.pterodactylus.sone.data.Client;
52 import net.pterodactylus.sone.data.Image;
53 import net.pterodactylus.sone.data.LocalSone;
54 import net.pterodactylus.sone.data.Post;
55 import net.pterodactylus.sone.data.PostReply;
56 import net.pterodactylus.sone.data.Profile;
57 import net.pterodactylus.sone.data.Profile.Field;
58 import net.pterodactylus.sone.data.Sone;
59 import net.pterodactylus.sone.data.Sone.ShowCustomAvatars;
60 import net.pterodactylus.sone.data.impl.AlbumBuilderImpl;
61 import net.pterodactylus.sone.data.impl.ImageBuilderImpl;
62 import net.pterodactylus.sone.database.AlbumBuilder;
63 import net.pterodactylus.sone.database.Database;
64 import net.pterodactylus.sone.database.DatabaseException;
65 import net.pterodactylus.sone.database.ImageBuilder;
66 import net.pterodactylus.sone.database.PostBuilder;
67 import net.pterodactylus.sone.database.PostDatabase;
68 import net.pterodactylus.sone.database.PostReplyBuilder;
69 import net.pterodactylus.sone.database.SoneBuilder;
70 import net.pterodactylus.sone.database.SoneProvider;
71 import net.pterodactylus.sone.freenet.wot.OwnIdentity;
72 import net.pterodactylus.sone.main.SonePlugin;
73 import net.pterodactylus.sone.utils.Optionals;
74 import net.pterodactylus.util.config.Configuration;
75 import net.pterodactylus.util.config.ConfigurationException;
76
77 import com.google.common.base.Function;
78 import com.google.common.base.Optional;
79 import com.google.common.base.Predicate;
80 import com.google.common.collect.FluentIterable;
81 import com.google.common.collect.HashMultimap;
82 import com.google.common.collect.Multimap;
83 import com.google.common.collect.SortedSetMultimap;
84 import com.google.common.collect.TreeMultimap;
85 import com.google.common.primitives.Longs;
86 import com.google.common.util.concurrent.AbstractService;
87 import com.google.inject.Inject;
88 import com.google.inject.Singleton;
89
90 /**
91  * Memory-based {@link PostDatabase} implementation.
92  *
93  * @author <a href="mailto:bombe@pterodactylus.net">David ‘Bombe’ Roden</a>
94  */
95 @Singleton
96 public class MemoryDatabase extends AbstractService implements Database {
97
98         private static final Logger logger = Logger.getLogger("Sone.Database.Memory");
99         private static final String LATEST_EDITION_PROPERTY = "Sone.LatestEdition";
100         /** The lock. */
101         private final ReadWriteLock lock = new ReentrantReadWriteLock();
102
103         /** The Sone provider. */
104         private final SoneProvider soneProvider;
105
106         /** The configuration. */
107         private final Configuration configuration;
108         private final ConfigurationLoader configurationLoader;
109
110         private final Set<String> localSones = new HashSet<String>();
111         private final Map<String, Sone> allSones = new HashMap<String, Sone>();
112         private final Map<String, String> lastInsertFingerprints = new HashMap<String, String>();
113
114         /** All post replies by their ID. */
115         private final Map<String, PostReply> allPostReplies = new HashMap<String, PostReply>();
116
117         /** Replies sorted by Sone. */
118         private final SortedSetMultimap<String, PostReply> sonePostReplies = TreeMultimap.create(new Comparator<String>() {
119
120                 @Override
121                 public int compare(String leftString, String rightString) {
122                         return leftString.compareTo(rightString);
123                 }
124         }, TIME_COMPARATOR);
125
126         /** Whether post replies are known. */
127         private final Set<String> knownPostReplies = new HashSet<String>();
128
129         private final Map<String, Album> allAlbums = new HashMap<String, Album>();
130         private final Multimap<String, Album> soneAlbums = HashMultimap.create();
131
132         private final Map<String, Image> allImages = new HashMap<String, Image>();
133         private final Multimap<String, Image> soneImages = HashMultimap.create();
134
135         private final MemorySoneDatabase soneDatabase;
136         private final MemoryPostDatabase postDatabase;
137         private final MemoryBookmarkDatabase memoryBookmarkDatabase;
138         private final MemoryFriendDatabase memoryFriendDatabase;
139
140         /**
141          * Creates a new memory database.
142          *
143          * @param soneProvider
144          *              The Sone provider
145          * @param configuration
146          *              The configuration for loading and saving elements
147          */
148         @Inject
149         public MemoryDatabase(SoneProvider soneProvider, Configuration configuration) {
150                 this.soneProvider = soneProvider;
151                 this.configuration = configuration;
152                 this.configurationLoader = new ConfigurationLoader(configuration);
153                 soneDatabase = new MemorySoneDatabase(configurationLoader);
154                 postDatabase = new MemoryPostDatabase(this, configurationLoader);
155                 memoryBookmarkDatabase =
156                                 new MemoryBookmarkDatabase(this, configurationLoader);
157                 memoryFriendDatabase = new MemoryFriendDatabase(configurationLoader);
158         }
159
160         //
161         // DATABASE METHODS
162         //
163
164         @Override
165         public Optional<LocalSone> getLocalSone(String localSoneId) {
166                 lock.readLock().lock();
167                 try {
168                         if (!localSones.contains(localSoneId)) {
169                                 return Optional.absent();
170                         }
171                         return Optional.of((LocalSone) allSones.get(localSoneId));
172                 } finally {
173                         lock.readLock().unlock();
174                 }
175         }
176
177         @Override
178         public LocalSone registerLocalSone(OwnIdentity ownIdentity) {
179                 final LocalSone localSone = loadLocalSone(ownIdentity);
180                 localSones.add(ownIdentity.getId());
181                 return localSone;
182         }
183
184         private LocalSone loadLocalSone(OwnIdentity ownIdentity) {
185                 LocalSone localSone = (LocalSone) newSoneBuilder().local().from(ownIdentity).build();
186                 localSone.setLatestEdition(
187                                 Optional.fromNullable(
188                                                 Longs.tryParse(ownIdentity.getProperty(LATEST_EDITION_PROPERTY)))
189                                 .or(0L));
190                 localSone.setClient(new Client("Sone", SonePlugin.VERSION.toString()));
191                 localSone.setKnown(true);
192
193                 loadSone(localSone);
194                 return localSone;
195         }
196
197         public void loadSone(LocalSone sone) {
198                 long soneTime = configurationLoader.getLocalSoneTime(sone.getId());
199                 if (soneTime == -1) {
200                         return;
201                 }
202
203                 /* load profile. */
204                 ConfigurationSoneParser configurationSoneParser = new ConfigurationSoneParser(configuration, sone);
205                 Profile profile = configurationSoneParser.parseProfile();
206
207                 /* load posts. */
208                 Collection<Post> posts;
209                 try {
210                         posts = configurationSoneParser.parsePosts(this);
211                 } catch (InvalidPostFound ipf) {
212                         logger.log(Level.WARNING, "Invalid post found, aborting load!");
213                         return;
214                 }
215
216                 /* load replies. */
217                 Collection<PostReply> postReplies;
218                 try {
219                         postReplies = configurationSoneParser.parsePostReplies(this);
220                 } catch (InvalidPostReplyFound iprf) {
221                         logger.log(Level.WARNING, "Invalid reply found, aborting load!");
222                         return;
223                 }
224
225                 /* load post likes. */
226                 Set<String> likedPostIds = configurationSoneParser.parseLikedPostIds();
227
228                 /* load reply likes. */
229                 Set<String> likedReplyIds = configurationSoneParser.parseLikedPostReplyIds();
230
231                 /* load albums. */
232                 List<Album> topLevelAlbums;
233                 try {
234                         topLevelAlbums = configurationSoneParser.parseTopLevelAlbums(this);
235                 } catch (InvalidAlbumFound iaf) {
236                         logger.log(Level.WARNING, "Invalid album found, aborting load!");
237                         return;
238                 } catch (InvalidParentAlbumFound ipaf) {
239                         logger.log(Level.WARNING,
240                                         format("Invalid parent album ID: %s", ipaf.getAlbumParentId()));
241                         return;
242                 }
243
244                 /* load images. */
245                 try {
246                         configurationSoneParser.parseImages(this);
247                 } catch (InvalidImageFound iif) {
248                         logger.log(WARNING, "Invalid image found, aborting load!");
249                         return;
250                 } catch (InvalidParentAlbumFound ipaf) {
251                         logger.log(Level.WARNING,
252                                         format("Invalid album image (%s) encountered, aborting load!",
253                                                         ipaf.getAlbumParentId()));
254                         return;
255                 }
256
257                 /* load avatar. */
258                 String sonePrefix = "Sone/" + sone.getId();
259                 String avatarId = configuration.getStringValue(sonePrefix + "/Profile/Avatar").getValue(null);
260                 if (avatarId != null) {
261                         final Map<String, Image> images = configurationSoneParser.getImages();
262                         profile.setAvatar(images.get(avatarId));
263                 }
264
265                 /* load options. */
266                 sone.getOptions().setAutoFollow(configuration.getBooleanValue(sonePrefix + "/Options/AutoFollow").getValue(null));
267                 sone.getOptions().setSoneInsertNotificationEnabled(configuration.getBooleanValue(sonePrefix + "/Options/EnableSoneInsertNotifications").getValue(null));
268                 sone.getOptions().setShowNewSoneNotifications(configuration.getBooleanValue(sonePrefix + "/Options/ShowNotification/NewSones").getValue(null));
269                 sone.getOptions().setShowNewPostNotifications(configuration.getBooleanValue(sonePrefix + "/Options/ShowNotification/NewPosts").getValue(null));
270                 sone.getOptions().setShowNewReplyNotifications(configuration.getBooleanValue(sonePrefix + "/Options/ShowNotification/NewReplies").getValue(null));
271                 sone.getOptions().setShowCustomAvatars(ShowCustomAvatars.valueOf(
272                                 configuration.getStringValue(sonePrefix + "/Options/ShowCustomAvatars")
273                                                 .getValue(ShowCustomAvatars.NEVER.name())));
274
275                 /* if we’re still here, Sone was loaded successfully. */
276                 lock.writeLock().lock();
277                 try {
278                         sone.setTime(soneTime);
279                         sone.setProfile(profile);
280                         sone.setLikePostIds(likedPostIds);
281                         sone.setLikeReplyIds(likedReplyIds);
282
283                         String lastInsertFingerprint = configurationLoader.getLastInsertFingerprint(sone.getId());
284                         lastInsertFingerprints.put(sone.getId(), lastInsertFingerprint);
285
286                         allSones.put(sone.getId(), sone);
287                         storePosts(sone.getId(), posts);
288                         storePostReplies(sone.getId(), postReplies);
289                         storeAlbums(sone.getId(), topLevelAlbums);
290                         storeImages(sone.getId(), from(topLevelAlbums).transformAndConcat(Album.FLATTENER).transformAndConcat(Album.IMAGES).toList());
291                 } finally {
292                         lock.writeLock().unlock();
293                 }
294                 for (Post post : posts) {
295                         post.setKnown(true);
296                 }
297                 for (PostReply reply : postReplies) {
298                         reply.setKnown(true);
299                 }
300
301                 logger.info(String.format("Sone loaded successfully: %s", sone));
302         }
303
304         @Override
305         public String getLastInsertFingerprint(Sone sone) {
306                 lock.readLock().lock();
307                 try {
308                         if (!lastInsertFingerprints.containsKey(sone.getId())) {
309                                 return "";
310                         }
311                         return lastInsertFingerprints.get(sone.getId());
312                 } finally {
313                         lock.readLock().unlock();
314                 }
315         }
316
317         @Override
318         public void setLastInsertFingerprint(Sone sone, String lastInsertFingerprint) {
319                 lock.writeLock().lock();
320                 try {
321                         lastInsertFingerprints.put(sone.getId(), lastInsertFingerprint);
322                 } finally {
323                         lock.writeLock().unlock();
324                 }
325         }
326
327         /**
328          * Saves the database.
329          *
330          * @throws DatabaseException
331          *              if an error occurs while saving
332          */
333         @Override
334         public void save() throws DatabaseException {
335                 lock.writeLock().lock();
336                 try {
337                         saveKnownPostReplies();
338                         for (Sone localSone : from(localSones).transform(soneLoader()).transform(Optionals.<Sone>get())) {
339                                 saveSone(localSone);
340                         }
341                 } finally {
342                         lock.writeLock().unlock();
343                 }
344         }
345
346         private synchronized void saveSone(Sone sone) {
347                 logger.log(Level.INFO, String.format("Saving Sone: %s", sone));
348                 try {
349                         /* save Sone into configuration. */
350                         String sonePrefix = "Sone/" + sone.getId();
351                         configuration.getLongValue(sonePrefix + "/Time").setValue(sone.getTime());
352                         configuration.getStringValue(sonePrefix + "/LastInsertFingerprint").setValue(lastInsertFingerprints.get(sone.getId()));
353
354                         /* save profile. */
355                         Profile profile = sone.getProfile();
356                         configuration.getStringValue(sonePrefix + "/Profile/FirstName").setValue(profile.getFirstName());
357                         configuration.getStringValue(sonePrefix + "/Profile/MiddleName").setValue(profile.getMiddleName());
358                         configuration.getStringValue(sonePrefix + "/Profile/LastName").setValue(profile.getLastName());
359                         configuration.getIntValue(sonePrefix + "/Profile/BirthDay").setValue(profile.getBirthDay());
360                         configuration.getIntValue(sonePrefix + "/Profile/BirthMonth").setValue(profile.getBirthMonth());
361                         configuration.getIntValue(sonePrefix + "/Profile/BirthYear").setValue(profile.getBirthYear());
362                         configuration.getStringValue(sonePrefix + "/Profile/Avatar").setValue(profile.getAvatar());
363
364                         /* save profile fields. */
365                         int fieldCounter = 0;
366                         for (Field profileField : profile.getFields()) {
367                                 String fieldPrefix = sonePrefix + "/Profile/Fields/" + fieldCounter++;
368                                 configuration.getStringValue(fieldPrefix + "/Name").setValue(profileField.getName());
369                                 configuration.getStringValue(fieldPrefix + "/Value").setValue(profileField.getValue());
370                         }
371                         configuration.getStringValue(sonePrefix + "/Profile/Fields/" + fieldCounter + "/Name").setValue(null);
372
373                         /* save posts. */
374                         int postCounter = 0;
375                         for (Post post : sone.getPosts()) {
376                                 String postPrefix = sonePrefix + "/Posts/" + postCounter++;
377                                 configuration.getStringValue(postPrefix + "/ID").setValue(post.getId());
378                                 configuration.getStringValue(postPrefix + "/Recipient").setValue(post.getRecipientId().orNull());
379                                 configuration.getLongValue(postPrefix + "/Time").setValue(post.getTime());
380                                 configuration.getStringValue(postPrefix + "/Text").setValue(post.getText());
381                         }
382                         configuration.getStringValue(sonePrefix + "/Posts/" + postCounter + "/ID").setValue(null);
383
384                         /* save replies. */
385                         int replyCounter = 0;
386                         for (PostReply reply : sone.getReplies()) {
387                                 String replyPrefix = sonePrefix + "/Replies/" + replyCounter++;
388                                 configuration.getStringValue(replyPrefix + "/ID").setValue(reply.getId());
389                                 configuration.getStringValue(replyPrefix + "/Post/ID").setValue(reply.getPostId());
390                                 configuration.getLongValue(replyPrefix + "/Time").setValue(reply.getTime());
391                                 configuration.getStringValue(replyPrefix + "/Text").setValue(reply.getText());
392                         }
393                         configuration.getStringValue(sonePrefix + "/Replies/" + replyCounter + "/ID").setValue(null);
394
395                         /* save post likes. */
396                         int postLikeCounter = 0;
397                         for (String postId : sone.getLikedPostIds()) {
398                                 configuration.getStringValue(sonePrefix + "/Likes/Post/" + postLikeCounter++ + "/ID").setValue(postId);
399                         }
400                         configuration.getStringValue(sonePrefix + "/Likes/Post/" + postLikeCounter + "/ID").setValue(null);
401
402                         /* save reply likes. */
403                         int replyLikeCounter = 0;
404                         for (String replyId : sone.getLikedReplyIds()) {
405                                 configuration.getStringValue(sonePrefix + "/Likes/Reply/" + replyLikeCounter++ + "/ID").setValue(replyId);
406                         }
407                         configuration.getStringValue(sonePrefix + "/Likes/Reply/" + replyLikeCounter + "/ID").setValue(null);
408
409                         /* save albums. first, collect in a flat structure, top-level first. */
410                         List<Album> albums = FluentIterable.from(sone.getRootAlbum().getAlbums()).transformAndConcat(Album.FLATTENER).toList();
411
412                         int albumCounter = 0;
413                         for (Album album : albums) {
414                                 String albumPrefix = sonePrefix + "/Albums/" + albumCounter++;
415                                 configuration.getStringValue(albumPrefix + "/ID").setValue(album.getId());
416                                 configuration.getStringValue(albumPrefix + "/Title").setValue(album.getTitle());
417                                 configuration.getStringValue(albumPrefix + "/Description").setValue(album.getDescription());
418                                 configuration.getStringValue(albumPrefix + "/Parent").setValue(album.getParent().equals(sone.getRootAlbum()) ? null : album.getParent().getId());
419                                 configuration.getStringValue(albumPrefix + "/AlbumImage").setValue(album.getAlbumImage() == null ? null : album.getAlbumImage().getId());
420                         }
421                         configuration.getStringValue(sonePrefix + "/Albums/" + albumCounter + "/ID").setValue(null);
422
423                         /* save images. */
424                         int imageCounter = 0;
425                         for (Album album : albums) {
426                                 for (Image image : album.getImages()) {
427                                         if (!image.isInserted()) {
428                                                 continue;
429                                         }
430                                         String imagePrefix = sonePrefix + "/Images/" + imageCounter++;
431                                         configuration.getStringValue(imagePrefix + "/ID").setValue(image.getId());
432                                         configuration.getStringValue(imagePrefix + "/Album").setValue(album.getId());
433                                         configuration.getStringValue(imagePrefix + "/Key").setValue(image.getKey());
434                                         configuration.getStringValue(imagePrefix + "/Title").setValue(image.getTitle());
435                                         configuration.getStringValue(imagePrefix + "/Description").setValue(image.getDescription());
436                                         configuration.getLongValue(imagePrefix + "/CreationTime").setValue(image.getCreationTime());
437                                         configuration.getIntValue(imagePrefix + "/Width").setValue(image.getWidth());
438                                         configuration.getIntValue(imagePrefix + "/Height").setValue(image.getHeight());
439                                 }
440                         }
441                         configuration.getStringValue(sonePrefix + "/Images/" + imageCounter + "/ID").setValue(null);
442
443                         /* save options. */
444                         configuration.getBooleanValue(sonePrefix + "/Options/AutoFollow").setValue(sone.getOptions().isAutoFollow());
445                         configuration.getBooleanValue(sonePrefix + "/Options/EnableSoneInsertNotifications").setValue(sone.getOptions().isSoneInsertNotificationEnabled());
446                         configuration.getBooleanValue(sonePrefix + "/Options/ShowNotification/NewSones").setValue(sone.getOptions().isShowNewSoneNotifications());
447                         configuration.getBooleanValue(sonePrefix + "/Options/ShowNotification/NewPosts").setValue(sone.getOptions().isShowNewPostNotifications());
448                         configuration.getBooleanValue(sonePrefix + "/Options/ShowNotification/NewReplies").setValue(sone.getOptions().isShowNewReplyNotifications());
449                         configuration.getStringValue(sonePrefix + "/Options/ShowCustomAvatars").setValue(sone.getOptions().getShowCustomAvatars().name());
450
451                         configuration.save();
452
453                         logger.log(Level.INFO, String.format("Sone %s saved.", sone));
454                 } catch (ConfigurationException ce1) {
455                         logger.log(Level.WARNING, String.format("Could not save Sone: %s", sone), ce1);
456                 }
457         }
458
459         //
460         // SERVICE METHODS
461         //
462
463         /** {@inheritDocs} */
464         @Override
465         protected void doStart() {
466                 soneDatabase.start();
467                 postDatabase.start();
468                 memoryBookmarkDatabase.start();
469                 loadKnownPostReplies();
470                 notifyStarted();
471         }
472
473         /** {@inheritDocs} */
474         @Override
475         protected void doStop() {
476                 try {
477                         soneDatabase.stop();
478                         postDatabase.stop();
479                         memoryBookmarkDatabase.stop();
480                         save();
481                         notifyStopped();
482                 } catch (DatabaseException de1) {
483                         notifyFailed(de1);
484                 }
485         }
486
487         @Override
488         public SoneBuilder newSoneBuilder() {
489                 return new MemorySoneBuilder(this);
490         }
491
492         @Override
493         public void storeSone(Sone sone) {
494                 lock.writeLock().lock();
495                 try {
496                         removeSone(sone);
497
498                         allSones.put(sone.getId(), sone);
499                         storePosts(sone.getId(), sone.getPosts());
500                         storePostReplies(sone.getId(), sone.getReplies());
501                         storeAlbums(sone.getId(), toAllAlbums.apply(sone));
502                         storeImages(sone.getId(), toAllImages.apply(sone));
503                 } finally {
504                         lock.writeLock().unlock();
505                 }
506         }
507
508         @Override
509         public boolean isSoneKnown(Sone sone) {
510                 return soneDatabase.isKnownSone(sone.getId());
511         }
512
513         @Override
514         public void setSoneKnown(Sone sone) {
515                 soneDatabase.setSoneKnown(sone.getId());
516         }
517
518         private void storePosts(String soneId, Collection<Post> posts) {
519                 postDatabase.storePosts(soneId, posts);
520         }
521
522         private void storePostReplies(String soneId, Collection<PostReply> postReplies) {
523                 sonePostReplies.putAll(soneId, postReplies);
524                 for (PostReply postReply : postReplies) {
525                         allPostReplies.put(postReply.getId(), postReply);
526                 }
527         }
528
529         private void storeAlbums(String soneId, Collection<Album> albums) {
530                 soneAlbums.putAll(soneId, albums);
531                 for (Album album : albums) {
532                         allAlbums.put(album.getId(), album);
533                 }
534         }
535
536         private void storeImages(String soneId, Collection<Image> images) {
537                 soneImages.putAll(soneId, images);
538                 for (Image image : images) {
539                         allImages.put(image.getId(), image);
540                 }
541         }
542
543         @Override
544         public void removeSone(Sone sone) {
545                 lock.writeLock().lock();
546                 try {
547                         allSones.remove(sone.getId());
548                         postDatabase.removePostsFor(sone.getId());
549                         Collection<PostReply> removedPostReplies =
550                                         sonePostReplies.removeAll(sone.getId());
551                         for (PostReply removedPostReply : removedPostReplies) {
552                                 allPostReplies.remove(removedPostReply.getId());
553                         }
554                         Collection<Album> removedAlbums =
555                                         soneAlbums.removeAll(sone.getId());
556                         for (Album removedAlbum : removedAlbums) {
557                                 allAlbums.remove(removedAlbum.getId());
558                         }
559                         Collection<Image> removedImages =
560                                         soneImages.removeAll(sone.getId());
561                         for (Image removedImage : removedImages) {
562                                 allImages.remove(removedImage.getId());
563                         }
564                 } finally {
565                         lock.writeLock().unlock();
566                 }
567         }
568
569         @Override
570         public Function<String, Optional<Sone>> soneLoader() {
571                 return new Function<String, Optional<Sone>>() {
572                         @Override
573                         public Optional<Sone> apply(String soneId) {
574                                 return getSone(soneId);
575                         }
576                 };
577         }
578
579         @Override
580         public Optional<Sone> getSone(String soneId) {
581                 lock.readLock().lock();
582                 try {
583                         return fromNullable(allSones.get(soneId));
584                 } finally {
585                         lock.readLock().unlock();
586                 }
587         }
588
589         @Override
590         public Collection<Sone> getSones() {
591                 lock.readLock().lock();
592                 try {
593                         return new HashSet<Sone>(allSones.values());
594                 } finally {
595                         lock.readLock().unlock();
596                 }
597         }
598
599         @Override
600         public Collection<LocalSone> getLocalSones() {
601                 lock.readLock().lock();
602                 try {
603                         return from(allSones.values()).filter(LOCAL_SONE_FILTER).transform(new Function<Sone, LocalSone>() {
604                                 @Override
605                                 public LocalSone apply(Sone sone) {
606                                         // FIXME – Sones will not always implement LocalSone
607                                         return (LocalSone) sone;
608                                 }
609                         }).toSet();
610                 } finally {
611                         lock.readLock().unlock();
612                 }
613         }
614
615         @Override
616         public Collection<Sone> getRemoteSones() {
617                 lock.readLock().lock();
618                 try {
619                         return from(allSones.values())
620                                         .filter(not(LOCAL_SONE_FILTER)) .toSet();
621                 } finally {
622                         lock.readLock().unlock();
623                 }
624         }
625
626         @Override
627         public Collection<String> getFriends(LocalSone localSone) {
628                 if (!localSone.isLocal()) {
629                         return Collections.emptySet();
630                 }
631                 return memoryFriendDatabase.getFriends(localSone.getId());
632         }
633
634         @Override
635         public boolean isFriend(LocalSone localSone, String friendSoneId) {
636                 if (!localSone.isLocal()) {
637                         return false;
638                 }
639                 return memoryFriendDatabase.isFriend(localSone.getId(), friendSoneId);
640         }
641
642         @Override
643         public void addFriend(LocalSone localSone, String friendSoneId) {
644                 memoryFriendDatabase.addFriend(localSone.getId(), friendSoneId);
645         }
646
647         @Override
648         public void removeFriend(LocalSone localSone, String friendSoneId) {
649                 memoryFriendDatabase.removeFriend(localSone.getId(), friendSoneId);
650         }
651
652         //
653         // POSTPROVIDER METHODS
654         //
655
656         /** {@inheritDocs} */
657         @Override
658         public Optional<Post> getPost(String postId) {
659                 return postDatabase.getPost(postId);
660         }
661
662         /** {@inheritDocs} */
663         @Override
664         public Collection<Post> getPosts(String soneId) {
665                 return new HashSet<Post>(getPostsFrom(soneId));
666         }
667
668         /** {@inheritDocs} */
669         @Override
670         public Collection<Post> getDirectedPosts(final String recipientId) {
671                 return postDatabase.getDirectedPosts(recipientId);
672         }
673
674         //
675         // POSTBUILDERFACTORY METHODS
676         //
677
678         /** {@inheritDocs} */
679         @Override
680         public PostBuilder newPostBuilder() {
681                 return new MemoryPostBuilder(this, soneProvider);
682         }
683
684         //
685         // POSTSTORE METHODS
686         //
687
688         /** {@inheritDocs} */
689         @Override
690         public void storePost(Post post) {
691                 checkNotNull(post, "post must not be null");
692                 postDatabase.storePost(post);
693         }
694
695         /** {@inheritDocs} */
696         @Override
697         public void removePost(Post post) {
698                 checkNotNull(post, "post must not be null");
699                 postDatabase.removePost(post.getId());
700         }
701
702         //
703         // POSTREPLYPROVIDER METHODS
704         //
705
706         /** {@inheritDocs} */
707         @Override
708         public Optional<PostReply> getPostReply(String id) {
709                 lock.readLock().lock();
710                 try {
711                         return fromNullable(allPostReplies.get(id));
712                 } finally {
713                         lock.readLock().unlock();
714                 }
715         }
716
717         /** {@inheritDocs} */
718         @Override
719         public List<PostReply> getReplies(final String postId) {
720                 lock.readLock().lock();
721                 try {
722                         return from(allPostReplies.values())
723                                         .filter(new Predicate<PostReply>() {
724                                                 @Override
725                                                 public boolean apply(PostReply postReply) {
726                                                         return postReply.getPostId().equals(postId);
727                                                 }
728                                         }).toSortedList(TIME_COMPARATOR);
729                 } finally {
730                         lock.readLock().unlock();
731                 }
732         }
733
734         //
735         // POSTREPLYBUILDERFACTORY METHODS
736         //
737
738         /** {@inheritDocs} */
739         @Override
740         public PostReplyBuilder newPostReplyBuilder() {
741                 return new MemoryPostReplyBuilder(this, soneProvider);
742         }
743
744         //
745         // POSTREPLYSTORE METHODS
746         //
747
748         /** {@inheritDocs} */
749         @Override
750         public void storePostReply(PostReply postReply) {
751                 lock.writeLock().lock();
752                 try {
753                         allPostReplies.put(postReply.getId(), postReply);
754                 } finally {
755                         lock.writeLock().unlock();
756                 }
757         }
758
759         /** {@inheritDocs} */
760         @Override
761         public void removePostReply(PostReply postReply) {
762                 lock.writeLock().lock();
763                 try {
764                         allPostReplies.remove(postReply.getId());
765                 } finally {
766                         lock.writeLock().unlock();
767                 }
768         }
769
770         //
771         // ALBUMPROVDER METHODS
772         //
773
774         @Override
775         public Optional<Album> getAlbum(String albumId) {
776                 lock.readLock().lock();
777                 try {
778                         return fromNullable(allAlbums.get(albumId));
779                 } finally {
780                         lock.readLock().unlock();
781                 }
782         }
783
784         //
785         // ALBUMBUILDERFACTORY METHODS
786         //
787
788         @Override
789         public AlbumBuilder newAlbumBuilder() {
790                 return new AlbumBuilderImpl();
791         }
792
793         //
794         // ALBUMSTORE METHODS
795         //
796
797         @Override
798         public void storeAlbum(Album album) {
799                 lock.writeLock().lock();
800                 try {
801                         allAlbums.put(album.getId(), album);
802                         soneAlbums.put(album.getSone().getId(), album);
803                 } finally {
804                         lock.writeLock().unlock();
805                 }
806         }
807
808         @Override
809         public void removeAlbum(Album album) {
810                 lock.writeLock().lock();
811                 try {
812                         allAlbums.remove(album.getId());
813                         soneAlbums.remove(album.getSone().getId(), album);
814                 } finally {
815                         lock.writeLock().unlock();
816                 }
817         }
818
819         //
820         // IMAGEPROVIDER METHODS
821         //
822
823         @Override
824         public Optional<Image> getImage(String imageId) {
825                 lock.readLock().lock();
826                 try {
827                         return fromNullable(allImages.get(imageId));
828                 } finally {
829                         lock.readLock().unlock();
830                 }
831         }
832
833         //
834         // IMAGEBUILDERFACTORY METHODS
835         //
836
837         @Override
838         public ImageBuilder newImageBuilder() {
839                 return new ImageBuilderImpl();
840         }
841
842         //
843         // IMAGESTORE METHODS
844         //
845
846         @Override
847         public void storeImage(Image image) {
848                 lock.writeLock().lock();
849                 try {
850                         allImages.put(image.getId(), image);
851                         soneImages.put(image.getSone().getId(), image);
852                 } finally {
853                         lock.writeLock().unlock();
854                 }
855         }
856
857         @Override
858         public void removeImage(Image image) {
859                 lock.writeLock().lock();
860                 try {
861                         allImages.remove(image.getId());
862                         soneImages.remove(image.getSone().getId(), image);
863                 } finally {
864                         lock.writeLock().unlock();
865                 }
866         }
867
868         @Override
869         public void bookmarkPost(Post post) {
870                 memoryBookmarkDatabase.bookmarkPost(post);
871         }
872
873         @Override
874         public void unbookmarkPost(Post post) {
875                 memoryBookmarkDatabase.unbookmarkPost(post);
876         }
877
878         @Override
879         public boolean isPostBookmarked(Post post) {
880                 return memoryBookmarkDatabase.isPostBookmarked(post);
881         }
882
883         @Override
884         public Set<Post> getBookmarkedPosts() {
885                 return memoryBookmarkDatabase.getBookmarkedPosts();
886         }
887
888         //
889         // PACKAGE-PRIVATE METHODS
890         //
891
892         /**
893          * Returns whether the given post is known.
894          *
895          * @param post
896          *              The post
897          * @return {@code true} if the post is known, {@code false} otherwise
898          */
899         boolean isPostKnown(Post post) {
900                 return postDatabase.isPostKnown(post.getId());
901         }
902
903         /**
904          * Sets whether the given post is known.
905          *
906          * @param post
907          *              The post
908          * @param known
909          *              {@code true} if the post is known, {@code false} otherwise
910          */
911         void setPostKnown(Post post, boolean known) {
912                 postDatabase.setPostKnown(post.getId(), known);
913         }
914
915         /**
916          * Returns whether the given post reply is known.
917          *
918          * @param postReply
919          *              The post reply
920          * @return {@code true} if the given post reply is known, {@code false}
921          *         otherwise
922          */
923         boolean isPostReplyKnown(PostReply postReply) {
924                 lock.readLock().lock();
925                 try {
926                         return knownPostReplies.contains(postReply.getId());
927                 } finally {
928                         lock.readLock().unlock();
929                 }
930         }
931
932         /**
933          * Sets whether the given post reply is known.
934          *
935          * @param postReply
936          *              The post reply
937          * @param known
938          *              {@code true} if the post reply is known, {@code false} otherwise
939          */
940         void setPostReplyKnown(PostReply postReply, boolean known) {
941                 lock.writeLock().lock();
942                 try {
943                         if (known) {
944                                 knownPostReplies.add(postReply.getId());
945                         } else {
946                                 knownPostReplies.remove(postReply.getId());
947                         }
948                 } finally {
949                         lock.writeLock().unlock();
950                 }
951         }
952
953         //
954         // PRIVATE METHODS
955         //
956
957         /**
958          * Gets all posts for the given Sone, creating a new collection if there is
959          * none yet.
960          *
961          * @param soneId
962          *              The ID of the Sone to get the posts for
963          * @return All posts
964          */
965         private Collection<Post> getPostsFrom(String soneId) {
966                 return postDatabase.getPostsFrom(soneId);
967         }
968
969         /** Loads the known post replies. */
970         private void loadKnownPostReplies() {
971                 Set<String> knownPostReplies = configurationLoader.loadKnownPostReplies();
972                 lock.writeLock().lock();
973                 try {
974                         this.knownPostReplies.clear();
975                         this.knownPostReplies.addAll(knownPostReplies);
976                 } finally {
977                         lock.writeLock().unlock();
978                 }
979         }
980
981         /**
982          * Saves the known post replies to the configuration.
983          *
984          * @throws DatabaseException
985          *              if a configuration error occurs
986          */
987         private void saveKnownPostReplies() throws DatabaseException {
988                 lock.readLock().lock();
989                 try {
990                         int replyCounter = 0;
991                         for (String knownReplyId : knownPostReplies) {
992                                 configuration.getStringValue("KnownReplies/" + replyCounter++ + "/ID").setValue(
993                                                 knownReplyId);
994                         }
995                         configuration.getStringValue("KnownReplies/" + replyCounter + "/ID").setValue(null);
996                 } catch (ConfigurationException ce1) {
997                         throw new DatabaseException("Could not save database.", ce1);
998                 } finally {
999                         lock.readLock().unlock();
1000                 }
1001         }
1002
1003 }