Change Cache to Embedded H2

pom.xml

@@ -58,6 +58,12 @@
             <version>${kotlin.version}</version>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>com.h2database</groupId>
+            <artifactId>h2</artifactId>
+            <version>2.1.212</version>
+            <scope>runtime</scope>
+        </dependency>
     </dependencies>
 
     <build>

src/main/kotlin/app/CacheService.kt

@@ -0,0 +1,101 @@
+@file:Suppress("SqlResolve")
+
+package app
+
+import com.fasterxml.jackson.core.JsonParser
+import com.fasterxml.jackson.databind.DeserializationContext
+import com.fasterxml.jackson.databind.deser.std.StdDeserializer
+import com.fasterxml.jackson.databind.module.SimpleModule
+import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
+import com.fasterxml.jackson.module.kotlin.readValue
+import org.slf4j.LoggerFactory
+import java.sql.DriverManager
+import java.time.Instant
+import java.time.temporal.ChronoUnit
+import java.util.Date
+
+object CacheService {
+    private const val urlToDb = "jdbc:h2:mem:userinfo"
+    private val log = LoggerFactory.getLogger(CacheService.javaClass)
+    private val objectMapper = jacksonObjectMapper()
+        .registerModule(SimpleModule().addDeserializer(Date::class.java, DateDeserializer()))
+
+    private fun createTableIfAbsent() {
+        val connection = DriverManager.getConnection(urlToDb)
+        val statement = connection.createStatement()
+
+        statement.execute(
+            "CREATE TABLE IF NOT EXISTS userinfo (" +
+            "id VARCHAR2 PRIMARY KEY," +
+            "timestamp TIMESTAMP WITH TIME ZONE, " +
+            "data JSON" +
+            ")"
+        )
+    }
+
+    fun lookUpInCache(username: String): String? {
+        val connection = DriverManager.getConnection(urlToDb)
+
+        createTableIfAbsent()
+
+        val preparedStatement = connection.prepareStatement(
+            "SELECT " +
+            "timestamp, " +
+            "data " +
+            "FROM userinfo " +
+            "WHERE id = ?"
+        )
+        preparedStatement.setString(1, username)
+
+        val result = preparedStatement.executeQuery()
+        result.use {
+            // guaranteed to be at most one.
+            if (it.next()) {
+                val timestamp = it.getTimestamp(1).toInstant()
+                val diffInHours = ChronoUnit.HOURS.between(timestamp, Instant.now())
+                if (diffInHours <= 6) {
+                    val json: String? = it.getString(2)
+                    if (json != null) {
+                        log.debug("cache hit: {}", json)
+                    }
+
+                    return json
+                }
+            }
+        }
+
+        log.debug("cache miss for username: {}", username)
+
+        return null
+    }
+
+    fun getUserFromCache(username: String): UserProfile? {
+        val json = lookUpInCache(username) ?: return null
+
+        return objectMapper.readValue<UserProfile>(json)
+    }
+
+    fun saveInCache(userProfile: UserProfile) {
+        val connection = DriverManager.getConnection(urlToDb)
+
+        createTableIfAbsent()
+
+        val json = objectMapper.writeValueAsString(userProfile)
+
+        val preparedStatement = connection.prepareStatement(
+            "MERGE INTO userinfo (id, timestamp, data) KEY (id) " +
+            "VALUES (?, CURRENT_TIMESTAMP(), ? FORMAT JSON)"
+        )
+
+        preparedStatement.setString(1, userProfile.user.login)
+        preparedStatement.setString(2, json)
+
+        preparedStatement.execute()
+    }
+
+    private class DateDeserializer: StdDeserializer<Date>(Date::class.java) {
+        override fun deserialize(jsonParser: JsonParser, context: DeserializationContext): Date {
+            return Date(jsonParser.readValueAs(Long::class.java))
+        }
+    }
+}

src/main/kotlin/app/UserProfile.kt

@@ -0,0 +1,15 @@
+package app
+
+import org.eclipse.egit.github.core.User
+
+data class UserProfile(
+    val user: User,
+    val quarterCommitCount: Map<String, Int>,
+    val langRepoCount: Map<String, Int>,
+    val langStarCount: Map<String, Int>,
+    val langCommitCount: Map<String, Int>,
+    val repoCommitCount: Map<String, Int>,
+    val repoStarCount: Map<String, Int>,
+    val repoCommitCountDescriptions: Map<String, String?>,
+    val repoStarCountDescriptions: Map<String, String?>
+)

src/main/kotlin/app/UserService.kt

@@ -3,10 +3,7 @@ package app
 import app.util.CommitCountUtil
 import org.eclipse.egit.github.core.Repository
 import org.eclipse.egit.github.core.RepositoryCommit
-import org.eclipse.egit.github.core.User
 import org.slf4j.LoggerFactory
-import java.io.Serializable
-import java.time.Instant
 import java.util.concurrent.ConcurrentHashMap
 import java.util.stream.IntStream
 import kotlin.streams.toList
@@ -28,42 +25,17 @@ object UserService {
     fun canLoadUser(user: String): Boolean {
         val remainingRequests by lazy { GhService.remainingRequests }
         val hasFreeRemainingRequests by lazy { remainingRequests > (freeRequestCutoff ?: remainingRequests) }
+        val userCache by lazy { CacheService.lookUpInCache(user) }
         return Config.unrestricted()
-                || Cache.contains(user)
+                || (userCache != null)
                 || hasFreeRemainingRequests
                 || (remainingRequests > 0 && hasStarredRepo(user))
     }
 
     fun getUserProfile(username: String): UserProfile {
-        if (Cache.invalid(username)) {
-            val user = GhService.users.getUser(username)
-            val repos = GhService.repos.getRepositories(username).filter { !it.isFork && it.size != 0 }
-            val repoCommits = repos.parallelStream().map { it to commitsForRepo(it).filter { it.author?.login.equals(username, ignoreCase = true) } }.toList().toMap()
-            val langRepoGrouping = repos.groupingBy { (it.language ?: "Unknown") }
-
-            val quarterCommitCount = CommitCountUtil.getCommitsForQuarters(user, repoCommits)
-            val langRepoCount = langRepoGrouping.eachCount().toList().sortedBy { (_, v) -> -v }.toMap()
-            val langStarCount = langRepoGrouping.fold(0) { acc, repo -> acc + repo.watchers }.toList().sortedBy { (_, v) -> -v }.toMap()
-            val langCommitCount = langRepoGrouping.fold(0) { acc, repo -> acc + repoCommits[repo]!!.size }.toList().sortedBy { (_, v) -> -v }.toMap()
-            val repoCommitCount = repoCommits.map { it.key.name to it.value.size }.toList().sortedBy { (_, v) -> -v }.take(10).toMap()
-            val repoStarCount = repos.filter { it.watchers > 0 }.map { it.name to it.watchers }.sortedBy { (_, v) -> -v }.take(10).toMap()
-
-            val repoCommitCountDescriptions = repoCommitCount.map { it.key to repos.find { r -> r.name == it.key }?.description }.toMap()
-            val repoStarCountDescriptions = repoStarCount.map { it.key to repos.find { r -> r.name == it.key }?.description }.toMap()
-
-            Cache.putUserProfile(UserProfile(
-                    user,
-                    quarterCommitCount,
-                    langRepoCount,
-                    langStarCount,
-                    langCommitCount,
-                    repoCommitCount,
-                    repoStarCount,
-                    repoCommitCountDescriptions,
-                    repoStarCountDescriptions
-            ))
+        synchronized(username) {
+            return (CacheService.getUserFromCache(username) ?: generateUserProfile(username))
         }
-        return Cache.getUserProfile(username)!!
     }
 
     private fun hasStarredRepo(username: String): Boolean {
@@ -97,18 +69,36 @@ object UserService {
         listOf()
     }
 
-}
+    private fun generateUserProfile(username: String): UserProfile {
+        val user = GhService.users.getUser(username)
+        val repos = GhService.repos.getRepositories(username).filter { !it.isFork && it.size != 0 }
+        val repoCommits = repos.parallelStream().map { it to commitsForRepo(it).filter { it.author?.login.equals(username, ignoreCase = true) } }.toList().toMap()
+        val langRepoGrouping = repos.groupingBy { (it.language ?: "Unknown") }
+
+        val quarterCommitCount = CommitCountUtil.getCommitsForQuarters(user, repoCommits)
+        val langRepoCount = langRepoGrouping.eachCount().toList().sortedBy { (_, v) -> -v }.toMap()
+        val langStarCount = langRepoGrouping.fold(0) { acc, repo -> acc + repo.watchers }.toList().sortedBy { (_, v) -> -v }.toMap()
+        val langCommitCount = langRepoGrouping.fold(0) { acc, repo -> acc + repoCommits[repo]!!.size }.toList().sortedBy { (_, v) -> -v }.toMap()
+        val repoCommitCount = repoCommits.map { it.key.name to it.value.size }.toList().sortedBy { (_, v) -> -v }.take(10).toMap()
+        val repoStarCount = repos.filter { it.watchers > 0 }.map { it.name to it.watchers }.sortedBy { (_, v) -> -v }.take(10).toMap()
+
+        val repoCommitCountDescriptions = repoCommitCount.map { it.key to repos.find { r -> r.name == it.key }?.description }.toMap()
+        val repoStarCountDescriptions = repoStarCount.map { it.key to repos.find { r -> r.name == it.key }?.description }.toMap()
 
-data class UserProfile(
-        val user: User,
-        val quarterCommitCount: Map<String, Int>,
-        val langRepoCount: Map<String, Int>,
-        val langStarCount: Map<String, Int>,
-        val langCommitCount: Map<String, Int>,
-        val repoCommitCount: Map<String, Int>,
-        val repoStarCount: Map<String, Int>,
-        val repoCommitCountDescriptions: Map<String, String?>,
-        val repoStarCountDescriptions: Map<String, String?>
-) : Serializable {
-    val timeStamp = Instant.now().toEpochMilli()
+        val userProfile = UserProfile(
+            user,
+            quarterCommitCount,
+            langRepoCount,
+            langStarCount,
+            langCommitCount,
+            repoCommitCount,
+            repoStarCount,
+            repoCommitCountDescriptions,
+            repoStarCountDescriptions
+        )
+
+        CacheService.saveInCache(userProfile)
+
+        return userProfile;
+    }
 }