src/main/kotlin/net/pterodactylus/sone/core/DefaultElementLoader.kt

   1 package net.pterodactylus.sone.core
   2
   3 import com.google.common.base.Ticker
   4 import com.google.common.cache.CacheBuilder
   5 import freenet.keys.FreenetURI
   6 import java.io.ByteArrayInputStream
   7 import java.net.URLDecoder
   8 import java.text.Normalizer
   9 import java.util.concurrent.TimeUnit.MINUTES
  10 import javax.imageio.ImageIO
  11 import javax.inject.Inject
  12
  13 /**
  14  * [ElementLoader] implementation that uses a simple Guava [com.google.common.cache.Cache].
  15  */
  16 class DefaultElementLoader(private val freenetInterface: FreenetInterface, ticker: Ticker) : ElementLoader {
  17
  18         @Inject constructor(freenetInterface: FreenetInterface) : this(freenetInterface, Ticker.systemTicker())
  19
  20         private val loadingLinks = CacheBuilder.newBuilder().build<String, Boolean>()
  21         private val failureCache = CacheBuilder.newBuilder().ticker(ticker).expireAfterWrite(30, MINUTES).build<String, Boolean>()
  22         private val imageCache = CacheBuilder.newBuilder().build<String, LinkedElement>()
  23         private val callback = object : FreenetInterface.BackgroundFetchCallback {
  24                 override fun cancelForMimeType(uri: FreenetURI, mimeType: String): Boolean {
  25                         return !mimeType.startsWith("image/")
  26                 }
  27
  28                 override fun loaded(uri: FreenetURI, mimeType: String, data: ByteArray) {
  29                         if (!mimeType.startsWith("image/")) {
  30                                 return
  31                         }
  32                         ByteArrayInputStream(data).use {
  33                                 ImageIO.read(it)
  34                         }?.let {
  35                                 imageCache.get(uri.toString().decode().normalize()) { LinkedElement(uri.toString()) }
  36                         }
  37                         removeLoadingLink(uri)
  38                 }
  39
  40                 override fun failed(uri: FreenetURI) {
  41                         failureCache.put(uri.toString().decode().normalize(), true)
  42                         removeLoadingLink(uri)
  43                 }
  44
  45                 private fun removeLoadingLink(uri: FreenetURI) {
  46                         synchronized(loadingLinks) {
  47                                 loadingLinks.invalidate(uri.toString().decode().normalize())
  48                         }
  49                 }
  50         }
  51
  52         override fun loadElement(link: String): LinkedElement {
  53                 val normalizedLink = link.decode().normalize()
  54                 synchronized(loadingLinks) {
  55                         imageCache.getIfPresent(normalizedLink)?.run {
  56                                 return this
  57                         }
  58                         failureCache.getIfPresent(normalizedLink)?.run {
  59                                 return LinkedElement(link, failed = true)
  60                         }
  61                         if (loadingLinks.getIfPresent(normalizedLink) == null) {
  62                                 loadingLinks.put(normalizedLink, true)
  63                                 freenetInterface.startFetch(FreenetURI(link), callback)
  64                         }
  65                 }
  66                 return LinkedElement(link, loading = true)
  67         }
  68
  69         private fun String.decode() = URLDecoder.decode(this, "UTF-8")
  70         private fun String.normalize() = Normalizer.normalize(this, Normalizer.Form.NFC)
  71
  72 }