get rid of caching profile, use the value of spring.cache.type instead.

Author: derlin

README.md

@@ -152,41 +152,43 @@ The application needs to fetch the metadata associated to an object (and a token
 To speed it up, the application can be configured to cache those metadata using either an in-memory concurrent hashmap,
 or an external database such as redis.
 
-**To enable caching**, set the `caching` active profile. It will use in-memory caching by default (`simple`). 
-To use another caching strategy, use the property `spring.cache.type=redis|simple|none` (none = no cache).
-Note that `none` doesn't disable caching, just ensures nothing is actually put into the cache.
+**To enable/disable caching**, set the `spring.cache.type` property. The former can take three values:
+
+* `none`: value by default, no caching at all,
+* `simple`: in-memory caching, only possible when the application runs in standalone mode, with both input and output enabled,
+* `redis`: use a redis instance for caching; this is mandatory if you want to deploy input and output separately and still use a cache.
+
 Example:
 ```
-./bbdata-api-*.jar --spring.profiles.active=caching
+./bbdata-api-*.jar --spring.cache.type=simple
 ```
 
-
-Redis default properties are shown below (can be overriden from a property file). To use redis, activate the `caching` profile
-and set `spring.cache.type=redis`:
+Redis default properties are shown below (can be overriden from a property file). When using `spring.cache.type=redis`,
+you can override any of those properties to point to your redis server instance:
 
 ```properties
-# To actually use redis cache, enable caching through the caching profile and uncomment this line:
-#spring.cache.type=redis
+# Relevant properties in order to use redis (localhost and 6379 are the default)
+spring.cache.type=redis
 spring.redis.host=localhost
 spring.redis.port=6379
 ```
 
-By default, the cache logger is set to `TRACE`. This can be problematic in production, so feel free to turn it off using:
+By default, the cache logger is set to `INFO`. Feel free to change it using:
 ```properties
-# default to TRACE
-logging.level.org.springframework.cache=WARN
+# default to INFO
+logging.level.org.springframework.cache=TRACE
 ```
 
-If caching is enabled, a hidden endpoint is available in order to clear all cache entries: `GET /cache-evict`. 
+When caching is enabled, a hidden endpoint is available in order to clear all cache entries: `GET /cache-evict`. 
 In order to avoid having folks discover this endpoint and play with it, you can configure a secret key to use via the property:
-```
+```properties
 cache.evict.secret-key=XXX
 ```
 If this property is defined, you will have to use `GET /cache-evict?key=XXX` for the eviction to be performed.
 
 
 **IMPORTANT**: in case you deploy the input api and the output api separately (using profiles), 
-YOU NEED TO USE AN EXTERNAL CACHE (e.g. redis). This is because the output API is responsible for evicting old entries
+YOU NEED TO USE AN EXTERNAL CACHE (i.e. redis). This is because the output API is responsible for evicting old entries
 from the cache. If the input and the output do not run in the same JVM, the cache strategy `simple` is *dangerous*:
 the input api won't see if a token gets deleted, or if an object becomes disabled.
 

src/main/kotlin/ch/derlin/bbdata/BBDataApplication.kt

@@ -1,5 +1,6 @@
 package ch.derlin.bbdata
 
+import ch.derlin.bbdata.common.OnCacheEnabled
 import ch.derlin.bbdata.common.dates.JodaUtils
 import io.swagger.v3.oas.annotations.OpenAPIDefinition
 import io.swagger.v3.oas.annotations.enums.SecuritySchemeType
@@ -83,9 +84,9 @@ class CassandraConfig
 
 // @EnableCaching adds many layers of AOP/interceptor, even if spring.cache.type=none
 // Hence, we only enable it if explicitly asked.
-// see https://stackoverflow.com/a/56901878
+// see @OnCacheEnabled and https://stackoverflow.com/a/56901878
 @Configuration
-@Profile(Profiles.CACHING)
+@OnCacheEnabled
 @EnableCaching
 class CachingConfig {
 
@@ -99,11 +100,8 @@ class CachingConfig {
 
     @PostConstruct
     fun checkCacheType() {
-        if (cacheType.toLowerCase() == "none") {
-            // ensure some caching mechanism is set, or generate an error in the log
-            logger.error("${Profiles.CACHING} is set, but cache type is none. This create unnecessary overhead. " +
-                    "Either disable caching or set spring.cache.type=simple.")
-        } else if (cacheType.toLowerCase() == "simple" &&
+        logger.info("caching ENABLED")
+        if (cacheType.toLowerCase() == "simple" &&
                 (environment.activeProfiles.contains(Profiles.INPUT_ONLY) || environment.activeProfiles.contains(Profiles.OUTPUT_ONLY))) {
             // forbid in-memory caching if launching the app in split mode (input only or output only)
             logger.error("Using in-memory caching with split application (input|output in different JVMs) can lead to security issues." +
@@ -113,7 +111,6 @@ class CachingConfig {
     }
 }
 
-
 fun main(args: Array<String>) {
     runApplication<BBDataApplication>(*args)
 }

src/main/kotlin/ch/derlin/bbdata/CustomProperties.kt

@@ -14,10 +14,15 @@ object HiddenEnvironmentVariables {
 
     /** boolean to turn off kafka */
     const val NO_KAFKA = "BB_NO_KAFKA"
+
     /** integer to override the default user when the unsecured profile is used */
     const val UNSECURED_USER = "UNSECURED_BBUSER"
 }
 
+object Constants {
+    const val META_CACHE = "metas"
+}
+
 @Configuration
 @ConfigurationProperties(prefix = "scan")
 class ScanExcludeProperties {
@@ -43,7 +48,8 @@ class AsyncProperties {
 
 @Configuration
 @ConfigurationProperties(prefix = "cache.evict")
-class CacheProperties {
+class CacheEvictProperties {
+
     /** Optional secret key to call cache evict: see CacheEvictController */
     var secretKey: String = ""
 

src/main/kotlin/ch/derlin/bbdata/Excluders.kt

@@ -50,7 +50,7 @@ class ExcludeAutoConfigPostProcessor : EnvironmentPostProcessor {
 
         val excludes = env.getPrefixedProperties(PROP)
         // also exclude Redis AutoConfiguration unless the caching profile is enabled and redis is selected
-        if (!(env.activeProfiles.contains("caching") && env.getProperty("spring.cache.type") == "redis"))
+        if (env.getProperty("spring.cache.type") != "redis")
             excludes.add(RedisAutoConfiguration::class.qualifiedName!!)
         // override $PROP
         env.propertySources.addFirst(MapPropertySource(PROP, mapOf(PROP to excludes)))

src/main/kotlin/ch/derlin/bbdata/Profiles.kt

@@ -26,7 +26,4 @@ object Profiles {
     // where do you store statistics about objects
     const val SQL_STATS = "sqlstats"
     const val CASSANDRA_STATS = "!$SQL_STATS"
-
-    // optionally enable caching
-    const val CACHING = "caching"
 }

src/main/kotlin/ch/derlin/bbdata/common/CacheConstants.kt

@@ -0,0 +1,25 @@
+package ch.derlin.bbdata.common
+
+import org.springframework.boot.autoconfigure.condition.ConditionalOnExpression
+
+/**
+ * This annotation can be used to only enable a component or configuration is the
+ * spring.cache.type property is set (i.e. not none).
+ * example:
+ *
+ * ```
+ * @Configuration
+ * @CachingEnabled
+ * @EnableCaching
+ * class CacheConfig {
+ *      /** enable caching only if spring.cache.type specified */
+ * }
+ * ```
+ *
+ * date: 14.09.20
+ * @author Lucy Linder <lucy.derlin@gmail.com>
+ */
+@kotlin.annotation.Retention(AnnotationRetention.RUNTIME)
+@kotlin.annotation.Target(AnnotationTarget.TYPE, AnnotationTarget.CLASS, AnnotationTarget.FUNCTION)
+@ConditionalOnExpression("'\${spring.cache.type:none}' != 'none'")
+annotation class OnCacheEnabled

src/main/kotlin/ch/derlin/bbdata/common/CachingEnabled.kt

@@ -1,7 +1,6 @@
 package ch.derlin.bbdata.input
 
-import ch.derlin.bbdata.common.CacheConstants
-import org.springframework.beans.factory.annotation.Autowired
+import ch.derlin.bbdata.Constants
 import org.springframework.cache.annotation.Cacheable
 import org.springframework.stereotype.Component
 import java.io.Serializable
@@ -15,7 +14,7 @@ import javax.persistence.EntityManager
 
 
 @Component
-class InputRepository {
+class InputRepository(private val em: EntityManager) {
 
     class MeasureMeta(fields: Array<Any>) : Serializable {
         val unitName: String = fields[0] as String
@@ -33,11 +32,7 @@ class InputRepository {
         }
     }
 
-
-    @Autowired
-    private lateinit var em: EntityManager
-
-    @Cacheable(CacheConstants.CACHE_NAME, key = "#objectId.toString().concat(':').concat(#token)", unless = "#result == null")
+    @Cacheable(Constants.META_CACHE, key = "#objectId.toString().concat(':').concat(#token)", unless = "#result == null")
     fun getMeasureMeta(objectId: Long, token: String): Optional<MeasureMeta> {
         val query = em.createNativeQuery(MeasureMeta.NATIVE_QUERY)
 

src/main/kotlin/ch/derlin/bbdata/input/InputRepository.kt

@@ -1,13 +1,12 @@
 package ch.derlin.bbdata.output
 
-import ch.derlin.bbdata.CacheProperties
-import ch.derlin.bbdata.Profiles
-import ch.derlin.bbdata.common.CacheConstants
+import ch.derlin.bbdata.CacheEvictProperties
+import ch.derlin.bbdata.Constants
+import ch.derlin.bbdata.common.OnCacheEnabled
 import ch.derlin.bbdata.common.exceptions.ForbiddenException
 import ch.derlin.bbdata.output.api.CommonResponses
 import io.swagger.v3.oas.annotations.Hidden
 import org.springframework.cache.CacheManager
-import org.springframework.context.annotation.Profile
 import org.springframework.http.ResponseEntity
 import org.springframework.web.bind.annotation.GetMapping
 import org.springframework.web.bind.annotation.RequestParam
@@ -18,16 +17,16 @@ import org.springframework.web.bind.annotation.RestController
  * @author Lucy Linder <lucy.derlin@gmail.com>
  */
 @RestController
-@Profile(Profiles.CACHING)
+@OnCacheEnabled
 class CacheEvictController(
-        private val cacheProperties: CacheProperties,
+        private val cacheEvictProperties: CacheEvictProperties,
         private val cacheManager: CacheManager) {
 
     @Hidden
     @GetMapping("/cache-evict")
     fun cacheEvict(@RequestParam("key", required = false) key: String?): ResponseEntity<String> {
-        if (cacheProperties.matches(key)) {
-            cacheManager.getCache(CacheConstants.CACHE_NAME)?.clear()
+        if (cacheEvictProperties.matches(key)) {
+            cacheManager.getCache(Constants.META_CACHE)?.clear()
             return CommonResponses.ok("Cache evicted.")
         } else {
             throw ForbiddenException("This endpoint is not available.")

src/main/kotlin/ch/derlin/bbdata/output/CacheEvictController.kt

@@ -5,10 +5,8 @@ package ch.derlin.bbdata.output.api.objects
  * @author Lucy Linder <lucy.derlin@gmail.com>
  */
 
-import ch.derlin.bbdata.common.Beans
-import ch.derlin.bbdata.common.CacheConstants
-import ch.derlin.bbdata.common.HiddenParam
-import ch.derlin.bbdata.common.PageableAsQueryParam
+import ch.derlin.bbdata.Constants
+import ch.derlin.bbdata.common.*
 import ch.derlin.bbdata.common.exceptions.ItemNotFoundException
 import ch.derlin.bbdata.common.exceptions.WrongParamsException
 import ch.derlin.bbdata.output.api.CommonResponses
@@ -215,9 +213,9 @@ class ObjectsController(private val objectsAccessManager: ObjectsAccessManager,
 
     @Protected(SecurityConstants.SCOPE_WRITE)
     @Operation(description = "Enable an object you own. If the object is already enabled, it simply returns NOT MODIFIED.")
+    @CacheEvict(Constants.META_CACHE, allEntries = true)
     @SimpleModificationStatusResponse
     @PostMapping("{objectId}/enable")
-    @CacheEvict(CacheConstants.CACHE_NAME, allEntries = true) // TODO: find a better way
     fun enableObject(
             @UserId userId: Int,
             @PathVariable(value = "objectId") id: Long): ResponseEntity<String> =
@@ -226,9 +224,9 @@ class ObjectsController(private val objectsAccessManager: ObjectsAccessManager,
     @Protected(SecurityConstants.SCOPE_WRITE)
     @Operation(description = "Disable an object you own. If the object is already disabled, it simply returns NOT MODIFIED. " +
             "When an object gets disabled, all its tokens are deleted and it cannot receive new values (no new measures).")
+    @CacheEvict(Constants.META_CACHE, allEntries = true)
     @SimpleModificationStatusResponse
     @PostMapping("{objectId}/disable")
-    @CacheEvict(CacheConstants.CACHE_NAME, allEntries = true) // TODO: find a better way
     fun disableObject(
             @UserId userId: Int,
             @PathVariable(value = "objectId") id: Long): ResponseEntity<String> =