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                         println("Got MIME Type “$mimeType” for $uri.")
  26                         return !mimeType.startsWith("image/")
  27                 }
  28
  29                 override fun loaded(uri: FreenetURI, mimeType: String, data: ByteArray) {
  30                         println("Got ${data.size} Bytes with MIME Type $mimeType for $uri.")
  31                         if (!mimeType.startsWith("image/")) {
  32                                 return
  33                         }
  34                         ByteArrayInputStream(data).use {
  35                                 ImageIO.read(it)
  36                         }?.let {
  37                                 println("Successfully parsed images from $uri.")
  38                                 imageCache.get(uri.toString().decode().normalize()) { LinkedElement(uri.toString()) }
  39                         }
  40                         removeLoadingLink(uri)
  41                 }
  42
  43                 override fun failed(uri: FreenetURI) {
  44                         println("Failed to load $uri.")
  45                         failureCache.put(uri.toString().decode().normalize(), true)
  46                         removeLoadingLink(uri)
  47                 }
  48
  49                 private fun removeLoadingLink(uri: FreenetURI) {
  50                         println("Not loading anymore: $uri.")
  51                         synchronized(loadingLinks) {
  52                                 loadingLinks.invalidate(uri.toString().decode().normalize())
  53                         }
  54                 }
  55         }
  56
  57         override fun loadElement(link: String): LinkedElement {
  58                 val normalizedLink = link.decode().normalize()
  59                 println("Checking for $normalizedLink...")
  60                 synchronized(loadingLinks) {
  61                         imageCache.getIfPresent(normalizedLink)?.run {
  62                                 println("In the Image Cache: $normalizedLink")
  63                                 return this
  64                         }
  65                         failureCache.getIfPresent(normalizedLink)?.run {
  66                                 println("In the Failure Cache: $normalizedLink")
  67                                 return LinkedElement(link, failed = true)
  68                         }
  69                         if (loadingLinks.getIfPresent(normalizedLink) == null) {
  70                                 println("Not loading: $normalizedLink")
  71                                 loadingLinks.put(normalizedLink, true)
  72                                 freenetInterface.startFetch(FreenetURI(link), callback)
  73                         }
  74                 }
  75                 println("Returning loading element: $normalizedLink")
  76                 return LinkedElement(link, loading = true)
  77         }
  78
  79         private fun String.decode() = URLDecoder.decode(this, "UTF-8")
  80         private fun String.normalize() = Normalizer.normalize(this, Normalizer.Form.NFC)
  81
  82 }