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.util.concurrent.TimeUnit.MINUTES
   8 import javax.imageio.ImageIO
   9 import javax.inject.Inject
  10
  11 /**
  12  * [ElementLoader] implementation that uses a simple Guava [com.google.common.cache.Cache].
  13  */
  14 class DefaultElementLoader(private val freenetInterface: FreenetInterface, ticker: Ticker) : ElementLoader {
  15
  16         @Inject constructor(freenetInterface: FreenetInterface) : this(freenetInterface, Ticker.systemTicker())
  17
  18         private val loadingLinks = CacheBuilder.newBuilder().build<String, Boolean>()
  19         private val failureCache = CacheBuilder.newBuilder().ticker(ticker).expireAfterWrite(30, MINUTES).build<String, Boolean>()
  20         private val imageCache = CacheBuilder.newBuilder().build<String, LinkedElement>()
  21         private val callback = object : FreenetInterface.BackgroundFetchCallback {
  22                 override fun cancelForMimeType(uri: FreenetURI, mimeType: String): Boolean {
  23                         println("Got MIME Type “$mimeType” for $uri.")
  24                         return !mimeType.startsWith("image/")
  25                 }
  26
  27                 override fun loaded(uri: FreenetURI, mimeType: String, data: ByteArray) {
  28                         println("Got ${data.size} Bytes with MIME Type $mimeType for $uri.")
  29                         if (!mimeType.startsWith("image/")) {
  30                                 return
  31                         }
  32                         ByteArrayInputStream(data).use {
  33                                 ImageIO.read(it)
  34                         }?.let {
  35                                 println("Successfully parsed images from $uri.")
  36                                 imageCache.get(uri.toString()) { LinkedElement(uri.toString()) }
  37                         }
  38                         removeLoadingLink(uri)
  39                 }
  40
  41                 override fun failed(uri: FreenetURI) {
  42                         println("Failed to load $uri.")
  43                         failureCache.put(uri.toString(), true)
  44                         removeLoadingLink(uri)
  45                 }
  46
  47                 private fun removeLoadingLink(uri: FreenetURI) {
  48                         println("Not loading anymore: $uri.")
  49                         synchronized(loadingLinks) {
  50                                 loadingLinks.invalidate(uri.toString())
  51                         }
  52                 }
  53         }
  54
  55         override fun loadElement(link: String): LinkedElement {
  56                 println("Checking for $link...")
  57                 synchronized(loadingLinks) {
  58                         imageCache.getIfPresent(link)?.run {
  59                                 println("In the Image Cache: $link")
  60                                 return this
  61                         }
  62                         failureCache.getIfPresent(link)?.run {
  63                                 println("In the Failure Cache: $link")
  64                                 return LinkedElement(link, failed = true)
  65                         }
  66                         if (loadingLinks.getIfPresent(link) == null) {
  67                                 println("Not loading: $link")
  68                                 loadingLinks.put(link, true)
  69                                 freenetInterface.startFetch(FreenetURI(link), callback)
  70                         }
  71                 }
  72                 println("Returning loading element: $link")
  73                 return LinkedElement(link, loading = true)
  74         }
  75
  76 }