Use AlfuCache

Author: frcroth

app/models/dataset/DatasetService.scala

@@ -488,9 +488,8 @@ class DatasetService @Inject()(organizationDAO: OrganizationDAO,
   private def notifyDatastoreOnUpdate(datasetId: ObjectId)(implicit ctx: DBAccessContext) =
     for {
       dataset <- datasetDAO.findOne(datasetId) ?~> "dataset.notFound"
-      dataSource <- fullDataSourceFor(dataset)
       dataStoreClient <- clientFor(dataset)
-      _ <- dataStoreClient.updateDatasetInDSCache(dataset._id.toString, dataSource)
+      _ <- dataStoreClient.updateDatasetInDSCache(dataset._id.toString)
     } yield ()
 
   private def logoUrlFor(dataset: Dataset, organization: Option[Organization]): Fox[String] =

app/models/dataset/WKRemoteDataStoreClient.scala

@@ -116,11 +116,11 @@ class WKRemoteDataStoreClient(dataStore: DataStore, rpc: RPC) extends LazyLoggin
       .postJsonWithJsonResponse[ExploreRemoteDatasetRequest, ExploreRemoteDatasetResponse](
         ExploreRemoteDatasetRequest(layerParameters, organizationId))
 
-  def updateDatasetInDSCache(datasetId: String, dataSource: InboxDataSourceLike): Fox[Unit] =
+  def updateDatasetInDSCache(datasetId: String): Fox[Unit] =
     for {
       _ <- rpc(s"${dataStore.url}/data/wkDatasets/$datasetId")
         .addQueryString("token" -> RpcTokenHolder.webknossosToken)
-        .putJson(dataSource)
+        .delete()
     } yield ()
 
 }

webknossos-datastore/app/com/scalableminds/webknossos/datastore/controllers/DataSourceController.scala

@@ -775,12 +775,11 @@ class DataSourceController @Inject()(
       }
     }
 
-  def updateCache(datasetId: String): Action[DataSource] =
-    Action.async(validateJson[DataSource]) { implicit request =>
-      accessTokenService.validateAccessFromTokenContext(UserAccessRequest.writeDataset(datasetId)) {
-        datasetCache.updateById(datasetId, request.body)
-        Future.successful(Ok)
-      }
+  def invalidateCache(datasetId: String): Action[AnyContent] = Action.async { implicit request =>
+    accessTokenService.validateAccessFromTokenContext(UserAccessRequest.writeDataset(datasetId)) {
+      datasetCache.invalidateCache(datasetId)
+      Future.successful(Ok)
     }
+  }
 
 }

webknossos-datastore/app/com/scalableminds/webknossos/datastore/services/DSRemoteWebknossosClient.scala

@@ -194,7 +194,7 @@ class DSRemoteWebknossosClient @Inject()(
     )
 
   def getDataset(datasetId: String): Fox[GenericDataSource[DataLayer]] =
-    rpc(s"$webknossosUri/api/datastores/$dataStoreName/datasets/$datasetId")
+    rpc(s"$webknossosUri/api/datastores/$dataStoreName/datasources/$datasetId")
       .addQueryString("key" -> dataStoreKey)
       .getWithJsonResponse[GenericDataSource[DataLayer]] ?~> "Failed to get data source from remote webknossos"
 }

webknossos-datastore/app/com/scalableminds/webknossos/datastore/services/DatasetCache.scala

@@ -1,38 +1,33 @@
 package com.scalableminds.webknossos.datastore.services
 
 import com.google.inject.name.Named
+import com.scalableminds.util.cache.AlfuCache
 import com.scalableminds.util.objectid.ObjectId
 import com.scalableminds.util.tools.{Fox, FoxImplicits}
 import com.scalableminds.webknossos.datastore.models.datasource.{DataLayer, DataSource}
-import com.scalableminds.webknossos.datastore.storage.TemporaryStore
 import org.apache.pekko.actor.ActorSystem
 
 import javax.inject.Inject
 import scala.concurrent.ExecutionContext
+import scala.concurrent.duration.DurationInt
 
 class DatasetCache @Inject()(remoteWebknossosClient: DSRemoteWebknossosClient,
                              @Named("webknossos-datastore") val actorSystem: ActorSystem)(implicit ec: ExecutionContext)
     extends FoxImplicits {
 
-  val cache = new TemporaryStore[ObjectId, DataSource](actorSystem)
+  lazy val cache = AlfuCache[ObjectId, DataSource](
+    timeToLive = 1 day // Cache for a longer time, since we invalidate the cache manually
+  )
 
   def getById(id: ObjectId): Fox[DataSource] =
-    cache.get(id) match {
-      case Some(dataSource) => Fox.successful(dataSource)
-      case None =>
-        for {
-          dataSource <- remoteWebknossosClient.getDataset(id.toString)
-          _ = cache.insert(id, dataSource)
-        } yield dataSource
-    }
+    cache.getOrLoad(id, id => remoteWebknossosClient.getDataset(id.toString))
 
   def getWithLayer(id: ObjectId, dataLayerName: String): Fox[(DataSource, DataLayer)] =
     for {
       dataSource <- getById(id)
       dataLayer <- dataSource.getDataLayer(dataLayerName).toFox ?~> "Data layer not found"
     } yield (dataSource, dataLayer)
 
-  def updateById(datasetId: String, dataSource: DataSource): Unit =
-    cache.insert(ObjectId(datasetId), dataSource)
+  def invalidateCache(datasetId: String): Unit = cache.remove(ObjectId(datasetId))
 
 }

webknossos-datastore/conf/com.scalableminds.webknossos.datastore.routes

@@ -124,7 +124,7 @@ DELETE        /datasets/:organizationId/:datasetDirectoryName/deleteOnDisk
 POST          /datasets/compose                                                                                                                       @com.scalableminds.webknossos.datastore.controllers.DataSourceController.compose()
 POST          /datasets/exploreRemote                                                                                                                 @com.scalableminds.webknossos.datastore.controllers.DataSourceController.exploreRemoteDataset()
 
-PUT           /wkDatasets/:datasetId                                                                                                                  @com.scalableminds.webknossos.datastore.controllers.DataSourceController.updateCache(datasetId: String)
+DELETE        /wkDatasets/:datasetId                                                                                                                  @com.scalableminds.webknossos.datastore.controllers.DataSourceController.invalidateCache(datasetId: String)
 
 # Actions
 POST          /triggers/checkInboxBlocking                                                                                                            @com.scalableminds.webknossos.datastore.controllers.DataSourceController.triggerInboxCheckBlocking()