src/main/kotlin/net/pterodactylus/sone/database/memory/MemoryDatabase.kt

   1 /*
   2  * Sone - MemoryDatabase.kt - Copyright © 2013–2020 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 com.google.common.base.Preconditions.checkNotNull
  21 import com.google.common.collect.HashMultimap
  22 import com.google.common.collect.Multimap
  23 import com.google.common.collect.TreeMultimap
  24 import com.google.common.util.concurrent.AbstractService
  25 import com.google.common.util.concurrent.RateLimiter
  26 import com.google.inject.Inject
  27 import com.google.inject.Singleton
  28 import net.pterodactylus.sone.data.Album
  29 import net.pterodactylus.sone.data.Image
  30 import net.pterodactylus.sone.data.Post
  31 import net.pterodactylus.sone.data.PostReply
  32 import net.pterodactylus.sone.data.Sone
  33 import net.pterodactylus.sone.data.allAlbums
  34 import net.pterodactylus.sone.data.allImages
  35 import net.pterodactylus.sone.data.impl.AlbumBuilderImpl
  36 import net.pterodactylus.sone.data.impl.ImageBuilderImpl
  37 import net.pterodactylus.sone.data.newestReplyFirst
  38 import net.pterodactylus.sone.database.AlbumBuilder
  39 import net.pterodactylus.sone.database.Database
  40 import net.pterodactylus.sone.database.DatabaseException
  41 import net.pterodactylus.sone.database.ImageBuilder
  42 import net.pterodactylus.sone.database.PostBuilder
  43 import net.pterodactylus.sone.database.PostDatabase
  44 import net.pterodactylus.sone.database.PostReplyBuilder
  45 import net.pterodactylus.sone.utils.ifTrue
  46 import net.pterodactylus.sone.utils.unit
  47 import net.pterodactylus.util.config.Configuration
  48 import net.pterodactylus.util.config.ConfigurationException
  49 import java.util.concurrent.locks.ReentrantReadWriteLock
  50 import kotlin.concurrent.withLock
  51
  52 /**
  53  * Memory-based [PostDatabase] implementation.
  54  */
  55 @Singleton
  56 class MemoryDatabase @Inject constructor(private val configuration: Configuration) : AbstractService(), Database {
  57
  58         private val lock = ReentrantReadWriteLock()
  59         private val readLock by lazy { lock.readLock()!! }
  60         private val writeLock by lazy { lock.writeLock()!! }
  61         private val configurationLoader = ConfigurationLoader(configuration)
  62         private val allSones = mutableMapOf<String, Sone>()
  63         private val allPosts = mutableMapOf<String, Post>()
  64         private val sonePosts: Multimap<String, Post> = HashMultimap.create<String, Post>()
  65         private val knownPosts = mutableSetOf<String>()
  66         private val allPostReplies = mutableMapOf<String, PostReply>()
  67         private val sonePostReplies: Multimap<String, PostReply> = TreeMultimap.create<String, PostReply>(Comparator { leftString, rightString -> leftString.compareTo(rightString) }, newestReplyFirst)
  68         private val knownPostReplies = mutableSetOf<String>()
  69         private val allAlbums = mutableMapOf<String, Album>()
  70         private val soneAlbums: Multimap<String, Album> = HashMultimap.create<String, Album>()
  71         private val allImages = mutableMapOf<String, Image>()
  72         private val soneImages: Multimap<String, Image> = HashMultimap.create<String, Image>()
  73         private val memoryBookmarkDatabase = MemoryBookmarkDatabase(this, configurationLoader)
  74         private val memoryFriendDatabase = MemoryFriendDatabase(configurationLoader)
  75         private val saveRateLimiter: RateLimiter = RateLimiter.create(1.0)
  76         private val saveKnownPostsRateLimiter: RateLimiter = RateLimiter.create(1.0)
  77         private val saveKnownPostRepliesRateLimiter: RateLimiter = RateLimiter.create(1.0)
  78
  79         override val soneLoader get() = this::getSone
  80
  81         override val sones get() = readLock.withLock { allSones.values.toSet() }
  82
  83         override val localSones get() = readLock.withLock { allSones.values.filter(Sone::isLocal) }
  84
  85         override val remoteSones get() = readLock.withLock { allSones.values.filterNot(Sone::isLocal) }
  86
  87         override val bookmarkedPosts get() = memoryBookmarkDatabase.bookmarkedPosts
  88
  89         override fun save() {
  90                 if (saveRateLimiter.tryAcquire()) {
  91                         saveKnownPosts()
  92                         saveKnownPostReplies()
  93                 }
  94         }
  95
  96         override fun doStart() {
  97                 memoryBookmarkDatabase.start()
  98                 loadKnownPosts()
  99                 loadKnownPostReplies()
 100                 notifyStarted()
 101         }
 102
 103         override fun doStop() {
 104                 try {
 105                         memoryBookmarkDatabase.stop()
 106                         save()
 107                         notifyStopped()
 108                 } catch (de1: DatabaseException) {
 109                         notifyFailed(de1)
 110                 }
 111         }
 112
 113         override fun newSoneBuilder() = MemorySoneBuilder(this)
 114
 115         override fun storeSone(sone: Sone) {
 116                 writeLock.withLock {
 117                         removeSone(sone)
 118
 119                         allSones[sone.id] = sone
 120                         sonePosts.putAll(sone.id, sone.posts)
 121                         for (post in sone.posts) {
 122                                 allPosts[post.id] = post
 123                         }
 124                         sonePostReplies.putAll(sone.id, sone.replies)
 125                         for (postReply in sone.replies) {
 126                                 allPostReplies[postReply.id] = postReply
 127                         }
 128                         sone.allAlbums.let { albums ->
 129                                 soneAlbums.putAll(sone.id, albums)
 130                                 albums.forEach { album -> allAlbums[album.id] = album }
 131                         }
 132                         sone.rootAlbum.allImages.let { images ->
 133                                 soneImages.putAll(sone.id, images)
 134                                 images.forEach { image -> allImages[image.id] = image }
 135                         }
 136                 }
 137         }
 138
 139         override fun removeSone(sone: Sone) {
 140                 writeLock.withLock {
 141                         allSones.remove(sone.id)
 142                         val removedPosts = sonePosts.removeAll(sone.id)
 143                         for (removedPost in removedPosts) {
 144                                 allPosts.remove(removedPost.id)
 145                         }
 146                         val removedPostReplies = sonePostReplies.removeAll(sone.id)
 147                         for (removedPostReply in removedPostReplies) {
 148                                 allPostReplies.remove(removedPostReply.id)
 149                         }
 150                         val removedAlbums = soneAlbums.removeAll(sone.id)
 151                         for (removedAlbum in removedAlbums) {
 152                                 allAlbums.remove(removedAlbum.id)
 153                         }
 154                         val removedImages = soneImages.removeAll(sone.id)
 155                         for (removedImage in removedImages) {
 156                                 allImages.remove(removedImage.id)
 157                         }
 158                 }
 159         }
 160
 161         override fun getSone(soneId: String) = readLock.withLock { allSones[soneId] }
 162
 163         override fun getFriends(localSone: Sone): Collection<String> =
 164                         if (!localSone.isLocal) {
 165                                 emptySet()
 166                         } else {
 167                                 memoryFriendDatabase.getFriends(localSone.id)
 168                         }
 169
 170         override fun isFriend(localSone: Sone, friendSoneId: String) =
 171                         if (!localSone.isLocal) {
 172                                 false
 173                         } else {
 174                                 memoryFriendDatabase.isFriend(localSone.id, friendSoneId)
 175                         }
 176
 177         override fun addFriend(localSone: Sone, friendSoneId: String) {
 178                 if (!localSone.isLocal) {
 179                         return
 180                 }
 181                 memoryFriendDatabase.addFriend(localSone.id, friendSoneId)
 182         }
 183
 184         override fun removeFriend(localSone: Sone, friendSoneId: String) {
 185                 if (!localSone.isLocal) {
 186                         return
 187                 }
 188                 memoryFriendDatabase.removeFriend(localSone.id, friendSoneId)
 189         }
 190
 191         override fun getFollowingTime(friendSoneId: String) =
 192                         memoryFriendDatabase.getFollowingTime(friendSoneId)
 193
 194         override fun getPost(postId: String) =
 195                         readLock.withLock { allPosts[postId] }
 196
 197         override fun getPosts(soneId: String): Collection<Post> =
 198                         sonePosts[soneId].toSet()
 199
 200         override fun getDirectedPosts(recipientId: String) =
 201                         readLock.withLock {
 202                                 allPosts.values.filter {
 203                                         it.recipientId.orNull() == recipientId
 204                                 }
 205                         }
 206
 207         override fun newPostBuilder(): PostBuilder = MemoryPostBuilder(this, this)
 208
 209         override fun storePost(post: Post) {
 210                 checkNotNull(post, "post must not be null")
 211                 writeLock.withLock {
 212                         allPosts[post.id] = post
 213                         sonePosts[post.sone.id].add(post)
 214                 }
 215         }
 216
 217         override fun removePost(post: Post) {
 218                 checkNotNull(post, "post must not be null")
 219                 writeLock.withLock {
 220                         allPosts.remove(post.id)
 221                         sonePosts[post.sone.id].remove(post)
 222                         post.sone.removePost(post)
 223                 }
 224         }
 225
 226         override fun getPostReply(id: String) = readLock.withLock { allPostReplies[id] }
 227
 228         override fun getReplies(postId: String) =
 229                         readLock.withLock {
 230                                 allPostReplies.values
 231                                                 .filter { it.postId == postId }
 232                                                 .sortedWith(newestReplyFirst.reversed())
 233                         }
 234
 235         override fun newPostReplyBuilder(): PostReplyBuilder =
 236                         MemoryPostReplyBuilder(this, this)
 237
 238         override fun storePostReply(postReply: PostReply) =
 239                         writeLock.withLock {
 240                                 allPostReplies[postReply.id] = postReply
 241                         }
 242
 243         override fun removePostReply(postReply: PostReply) =
 244                         writeLock.withLock {
 245                                 allPostReplies.remove(postReply.id)
 246                         }.unit
 247
 248         override fun getAlbum(albumId: String) = readLock.withLock { allAlbums[albumId] }
 249
 250         override fun newAlbumBuilder(): AlbumBuilder = AlbumBuilderImpl()
 251
 252         override fun storeAlbum(album: Album) =
 253                         writeLock.withLock {
 254                                 allAlbums[album.id] = album
 255                                 soneAlbums.put(album.sone.id, album)
 256                         }.unit
 257
 258         override fun removeAlbum(album: Album) =
 259                         writeLock.withLock {
 260                                 allAlbums.remove(album.id)
 261                                 soneAlbums.remove(album.sone.id, album)
 262                         }.unit
 263
 264         override fun getImage(imageId: String) = readLock.withLock { allImages[imageId] }
 265
 266         override fun newImageBuilder(): ImageBuilder = ImageBuilderImpl()
 267
 268         override fun storeImage(image: Image): Unit =
 269                         writeLock.withLock {
 270                                 allImages[image.id] = image
 271                                 soneImages.put(image.sone.id, image)
 272                         }
 273
 274         override fun removeImage(image: Image): Unit =
 275                         writeLock.withLock {
 276                                 allImages.remove(image.id)
 277                                 soneImages.remove(image.sone.id, image)
 278                         }
 279
 280         override fun bookmarkPost(post: Post) =
 281                         memoryBookmarkDatabase.bookmarkPost(post)
 282
 283         override fun unbookmarkPost(post: Post) =
 284                         memoryBookmarkDatabase.unbookmarkPost(post)
 285
 286         override fun isPostBookmarked(post: Post) =
 287                         memoryBookmarkDatabase.isPostBookmarked(post)
 288
 289         protected fun isPostKnown(post: Post) = readLock.withLock { post.id in knownPosts }
 290
 291         fun setPostKnown(post: Post, known: Boolean): Unit =
 292                         writeLock.withLock {
 293                                 if (known)
 294                                         knownPosts.add(post.id)
 295                                 else
 296                                         knownPosts.remove(post.id)
 297                                 saveKnownPosts()
 298                         }
 299
 300         protected fun isPostReplyKnown(postReply: PostReply) = readLock.withLock { postReply.id in knownPostReplies }
 301
 302         override fun setPostReplyKnown(postReply: PostReply): Unit =
 303                         writeLock.withLock {
 304                                 knownPostReplies.add(postReply.id)
 305                                 saveKnownPostReplies()
 306                         }
 307
 308         private fun loadKnownPosts() =
 309                         configurationLoader.loadKnownPosts()
 310                                         .let {
 311                                                 writeLock.withLock {
 312                                                         knownPosts.clear()
 313                                                         knownPosts.addAll(it)
 314                                                 }
 315                                         }
 316
 317         private fun saveKnownPosts() =
 318                         saveKnownPostsRateLimiter.tryAcquire().ifTrue {
 319                                 try {
 320                                         readLock.withLock {
 321                                                 knownPosts.forEachIndexed { index, knownPostId ->
 322                                                         configuration.getStringValue("KnownPosts/$index/ID").value = knownPostId
 323                                                 }
 324                                                 configuration.getStringValue("KnownPosts/${knownPosts.size}/ID").value = null
 325                                         }
 326                                 } catch (ce1: ConfigurationException) {
 327                                         throw DatabaseException("Could not save database.", ce1)
 328                                 }
 329                         }
 330
 331         private fun loadKnownPostReplies(): Unit =
 332                         configurationLoader.loadKnownPostReplies().let { knownPostReplies ->
 333                                 writeLock.withLock {
 334                                         this.knownPostReplies.clear()
 335                                         this.knownPostReplies.addAll(knownPostReplies)
 336                                 }
 337                         }
 338
 339         private fun saveKnownPostReplies() =
 340                         saveKnownPostRepliesRateLimiter.tryAcquire().ifTrue {
 341                                 try {
 342                                         readLock.withLock {
 343                                                 knownPostReplies.forEachIndexed { index, knownPostReply ->
 344                                                         configuration.getStringValue("KnownReplies/$index/ID").value = knownPostReply
 345                                                 }
 346                                                 configuration.getStringValue("KnownReplies/${knownPostReplies.size}/ID").value = null
 347                                         }
 348                                 } catch (ce1: ConfigurationException) {
 349                                         throw DatabaseException("Could not save database.", ce1)
 350                                 }
 351                         }
 352
 353 }