Store current reference cache in redis

Package.swift

@@ -27,7 +27,6 @@ let package = Package(
         .library(name: "S3Store", targets: ["S3Store"]),
     ],
     dependencies: [
-        .package(url: "https://github.com/0xLeif/Cache.git", from: "2.1.0"),
         .package(url: "https://github.com/JohnSundell/Ink.git", from: "0.5.1"),
         .package(url: "https://github.com/swift-server/swift-prometheus.git", from: "1.0.0"),
         .package(url: "https://github.com/SwiftPackageIndex/Plot.git", branch: "main"),
@@ -63,7 +62,6 @@ let package = Package(
                     .product(name: "SPIManifest", package: "SPIManifest"),
                     .product(name: "SemanticVersion", package: "SemanticVersion"),
                     .product(name: "SwiftSoup", package: "SwiftSoup"),
-                    .product(name: "Cache", package: "cache"),
                     .product(name: "CanonicalPackageURL", package: "CanonicalPackageURL"),
                     .product(name: "CustomDump", package: "swift-custom-dump"),
                     .product(name: "Dependencies", package: "swift-dependencies"),

Sources/App/Core/Dependencies/CurrentReferenceCacheClient.swift

@@ -0,0 +1,86 @@
+// Copyright Dave Verwer, Sven A. Schmidt, and other contributors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import Dependencies
+import DependenciesMacros
+
+
+@DependencyClient
+struct CurrentReferenceCacheClient {
+    var set: @Sendable (_ owner: String, _ repository: String, _ reference: String?) async -> Void
+    var get: @Sendable (_ owner: String, _ repository: String) async -> String?
+}
+
+
+extension CurrentReferenceCacheClient: DependencyKey {
+    static let timeToLive: Duration = .seconds(5*60)
+
+    static var liveValue: CurrentReferenceCacheClient {
+        .init(
+            set: { owner, repository, reference async in
+                @Dependency(\.redis) var redis
+                await redis.set(key: getKey(owner: owner, repository: repository),
+                                value: reference,
+                                expiresIn: timeToLive)
+            },
+            get: { owner, repository in
+                @Dependency(\.redis) var redis
+                return await redis.get(key: getKey(owner: owner, repository: repository))
+            }
+        )
+    }
+
+    static func getKey(owner: String, repository: String) -> String {
+        "\(owner)/\(repository)".lowercased()
+    }
+}
+
+
+extension CurrentReferenceCacheClient: TestDependencyKey {
+    static var testValue: Self { Self() }
+}
+
+
+extension DependencyValues {
+    var currentReferenceCache: CurrentReferenceCacheClient {
+        get { self[CurrentReferenceCacheClient.self] }
+        set { self[CurrentReferenceCacheClient.self] = newValue }
+    }
+}
+
+
+#if DEBUG
+extension CurrentReferenceCacheClient {
+    static var disabled: Self {
+        .init(set: { _, _, _ in }, get: { _, _ in nil })
+    }
+
+    static var inMemory: Self {
+        .init(
+            set: { owner, repository, reference in
+                _cache.withValue {
+                    $0[getKey(owner: owner, repository: repository)] = reference
+                }
+            },
+            get: { owner, repository in
+                _cache.withValue {
+                    $0[getKey(owner: owner, repository: repository)]
+                }
+            }
+        )
+    }
+
+    nonisolated(unsafe) static var _cache = LockIsolated<[String: String]>([:])
+}
+#endif

Sources/App/Core/Dependencies/EnvironmentClient.swift

@@ -39,7 +39,6 @@ struct EnvironmentClient {
     var collectionSigningCertificateChain: @Sendable () -> [URL] = { XCTFail("collectionSigningCertificateChain"); return [] }
     var collectionSigningPrivateKey: @Sendable () -> Data?
     var current: @Sendable () -> Environment = { XCTFail("current"); return .development }
-    var currentReferenceCache: @Sendable () -> CurrentReferenceCache?
     var dbId: @Sendable () -> String?
     var mastodonCredentials: @Sendable () -> Mastodon.Credentials?
     var random: @Sendable (_ range: ClosedRange<Double>) -> Double = { XCTFail("random"); return Double.random(in: $0) }
@@ -102,7 +101,6 @@ extension EnvironmentClient: DependencyKey {
                 Environment.get("COLLECTION_SIGNING_PRIVATE_KEY").map { Data($0.utf8) }
             },
             current: { (try? Environment.detect()) ?? .development },
-            currentReferenceCache: { .live },
             dbId: { Environment.get("DATABASE_ID") },
             mastodonCredentials: {
                 Environment.get("MASTODON_ACCESS_TOKEN")

Sources/App/Core/Dependencies/RedisClient.swift

@@ -0,0 +1,127 @@
+// Copyright Dave Verwer, Sven A. Schmidt, and other contributors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import NIOCore
+@preconcurrency import RediStack
+import Dependencies
+import DependenciesMacros
+
+
+@DependencyClient
+struct RedisClient {
+    var set: @Sendable (_ key: String, _ value: String?, Duration?) async -> Void
+    var get: @Sendable (_ key: String) async -> String?
+}
+
+
+extension RedisClient {
+    func set(key: String, value: String?, expiresIn: Duration? = nil) async {
+        await set(key: key, value: value, expiresIn)
+    }
+}
+
+
+extension RedisClient: DependencyKey {
+    static var liveValue: RedisClient {
+        .init(
+            set: { key, value, expiresIn in
+                await Redis.shared?.set(key: key, value: value, expiresIn: expiresIn)
+            },
+            get: { key in await Redis.shared?.get(key: key) }
+        )
+    }
+}
+
+
+extension RedisClient: TestDependencyKey {
+    static var testValue: Self { Self() }
+}
+
+
+extension DependencyValues {
+    var redis: RedisClient {
+        get { self[RedisClient.self] }
+        set { self[RedisClient.self] = newValue }
+    }
+}
+
+
+#if DEBUG
+extension RedisClient {
+    static var disabled: Self {
+        .init(set: { _, _, _ in }, get: { _ in nil })
+    }
+}
+#endif
+
+
+private actor Redis {
+    var client: RediStack.RedisClient
+    static private var task: Task<Redis?, Never>?
+
+    static var shared: Redis? {
+        get async {
+            if let task {
+                return await task.value
+            }
+            let task = Task<Redis?, Never> {
+                var attemptsLeft = maxConnectionAttempts
+                while attemptsLeft > 0 {
+                    do {
+                        return try await Redis()
+                    } catch {
+                        attemptsLeft -= 1
+                        Current.logger().warning("Redis connection failed, \(attemptsLeft) attempts left. Error: \(error)")
+                        try? await Task.sleep(for: .milliseconds(500))
+                    }
+                }
+                return nil
+            }
+            self.task = task
+            return await task.value
+        }
+    }
+
+    private init() async throws {
+        let connection = RedisConnection.make(
+            configuration: try .init(hostname: Redis.hostname),
+            boundEventLoop: NIOSingletons.posixEventLoopGroup.any()
+        )
+        self.client = try await connection.get()
+    }
+
+    // This hostname has to match the redir service name in app.yml.
+    static let hostname = "redis"
+    static let maxConnectionAttempts = 3
+
+    func set(key: String, value: String?, expiresIn: Duration?) async -> Void {
+        if let value {
+            let buffer = ByteBuffer(string: value)
+            let value = RESPValue.bulkString(buffer)
+            if let expiresIn {
+                let ttl = Int(expiresIn.components.seconds)
+                try? await client.setex(.init(key), to: value, expirationInSeconds: ttl).get()
+            } else {
+                try? await client.set(.init(key), to: value).get()
+            }
+        } else {
+            _ = try? await client.delete([.init(key)]).get()
+        }
+    }
+
+    func get(key: String) async -> String? {
+        return try? await client.get(.init(key)).map(\.string).get()
+    }
+}
+

Sources/App/configure.swift

@@ -14,7 +14,6 @@
 
 import Fluent
 import FluentPostgresDriver
-import Redis
 import Vapor
 
 
@@ -78,13 +77,6 @@ public func configure(_ app: Application) async throws -> String {
                                 sqlLogLevel: .debug),
                       as: .psql)
 
-    // Setup Redis connection
-    do {
-        app.redis.configuration = try RedisConfiguration(hostname: "redis")
-    } catch {
-        app.logger.warning("Failed to configure Redis, caching disabled. Error: \(error)")
-    }
-
     do {  // Migration 001 - schema 1.0
         app.migrations.add(CreatePackage())
         app.migrations.add(CreateRepository())

Sources/App/routes+documentation.swift

@@ -178,14 +178,15 @@ extension Request {
 
         let docVersion = try await { () -> DocVersion in
             if reference == String.current {
-                if let ref = environment.currentReferenceCache()?[owner: owner, repository: repository] {
+                @Dependency(\.currentReferenceCache) var currentReferenceCache
+                if let ref = await currentReferenceCache.get(owner: owner, repository: repository) {
                     return .current(referencing: ref)
                 }
 
                 guard let params = try await DocumentationTarget.query(on: db, owner: owner, repository: repository)?.internal
                 else { throw Abort(.notFound) }
 
-                environment.currentReferenceCache()?[owner: owner, repository: repository] = "\(params.docVersion)"
+                await currentReferenceCache.set(owner: owner, repository: repository, reference: "\(params.docVersion)")
                 return .current(referencing: "\(params.docVersion)")
             } else {
                 return .reference(reference)