Implements MemcachedValue Protocol and Conformances (#22)

dkz2 · web-flow · commit 67477dd74cd6 · 2023-07-19T23:44:25.000+01:00
* init MemcachedValue * added example usage * closes #21 * soundness likes some over generic type? * PR clean up * soundness * closes #22
diff --git a/Package.swift b/Package.swift
@@ -47,5 +47,11 @@ let package = Package(
             name: "SwiftMemcacheTests",
             dependencies: ["SwiftMemcache"]
         ),
+        .executableTarget(
+            name: "swift-memcache-gsoc-example",
+            dependencies: [
+                .target(name: "SwiftMemcache"),
+            ]
+        ),
     ]
 )
diff --git a/Sources/SwiftMemcache/MemcachedConnection.swift b/Sources/SwiftMemcache/MemcachedConnection.swift
@@ -57,6 +57,8 @@ public actor MemcachedConnection {
     enum MemcachedConnectionError: Error {
         /// Indicates that the connection has shut down.
         case connectionShutdown
+        /// Indicates that a nil response was received from the server.
+        case unexpectedNilResponse
     }
 
     private var state: State
@@ -137,8 +139,8 @@ public actor MemcachedConnection {
     /// Fetch the value for a key from the Memcache server.
     ///
     /// - Parameter key: The key to fetch the value for.
-    /// - Returns: A `ByteBuffer` containing the fetched value, or `nil` if no value was found.
-    public func get(_ key: String) async throws -> ByteBuffer? {
+    /// - Returns: A `Value` containing the fetched value, or `nil` if no value was found.
+    public func get<Value: MemcachedValue>(_ key: String, as valueType: Value.Type = Value.self) async throws -> Value? {
         switch self.state {
         case .initial(_, _, _, let requestContinuation),
              .running(_, _, _, let requestContinuation):
@@ -148,7 +150,7 @@ public actor MemcachedConnection {
             let command = MemcachedRequest.GetCommand(key: key, flags: flags)
             let request = MemcachedRequest.get(command)
 
-            return try await withCheckedThrowingContinuation { continuation in
+            let response = try await withCheckedThrowingContinuation { continuation in
                 switch requestContinuation.yield((request, continuation)) {
                 case .enqueued:
                     break
@@ -159,6 +161,11 @@ public actor MemcachedConnection {
                 }
             }.value
 
+            if var unwrappedResponse = response {
+                return Value.readFromBuffer(&unwrappedResponse)
+            } else {
+                throw MemcachedConnectionError.unexpectedNilResponse
+            }
         case .finished:
             throw MemcachedConnectionError.connectionShutdown
         }
@@ -168,19 +175,18 @@ public actor MemcachedConnection {
     ///
     /// - Parameters:
     ///   - key: The key to set the value for.
-    ///   - value: The value to set for the key.
-    /// - Returns: A `ByteBuffer` containing the server's response to the set request.
-    public func set(_ key: String, value: String) async throws -> ByteBuffer? {
+    ///   - value: The `Value` to set for the key.
+    public func set(_ key: String, value: some MemcachedValue) async throws {
         switch self.state {
         case .initial(_, let bufferAllocator, _, let requestContinuation),
              .running(let bufferAllocator, _, _, let requestContinuation):
 
             var buffer = bufferAllocator.buffer(capacity: 0)
-            buffer.writeString(value)
+            value.writeToBuffer(&buffer)
             let command = MemcachedRequest.SetCommand(key: key, value: buffer)
             let request = MemcachedRequest.set(command)
 
-            return try await withCheckedThrowingContinuation { continuation in
+            _ = try await withCheckedThrowingContinuation { continuation in
                 switch requestContinuation.yield((request, continuation)) {
                 case .enqueued:
                     break
diff --git a/Sources/SwiftMemcache/MemcachedValue.swift b/Sources/SwiftMemcache/MemcachedValue.swift
@@ -0,0 +1,75 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the swift-memcache-gsoc open source project
+//
+// Copyright (c) 2023 Apple Inc. and the swift-memcache-gsoc project authors
+// Licensed under Apache License v2.0
+//
+// See LICENSE.txt for license information
+// See CONTRIBUTORS.txt for the list of swift-memcache-gsoc project authors
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+//===----------------------------------------------------------------------===//
+
+import NIOCore
+
+/// Protocol defining the requirements for a type that can be converted to a ByteBuffer for transmission to Memcached.
+public protocol MemcachedValue {
+    /// Writes the value to a ByteBuffer.
+    ///
+    /// - Parameter buffer: The ByteBuffer to which the value should be written.
+    func writeToBuffer(_ buffer: inout ByteBuffer)
+
+    /// Reads the type from a ByteBuffer.
+    ///
+    /// - Parameter buffer: The ByteBuffer from which the value should be read.
+    static func readFromBuffer(_ buffer: inout ByteBuffer) -> Self?
+}
+
+/// Extension for FixedWidthInteger types to conform to MemcachedValue.
+extension MemcachedValue where Self: FixedWidthInteger {
+    /// Writes the integer to a ByteBuffer.
+    ///
+    /// - Parameter buffer: The ByteBuffer to which the integer should be written.
+    public func writeToBuffer(_ buffer: inout ByteBuffer) {
+        buffer.writeInteger(self)
+    }
+
+    /// Reads a FixedWidthInteger from a ByteBuffer.
+    ///
+    /// - Parameter buffer: The ByteBuffer from which the value should be read.
+    public static func readFromBuffer(_ buffer: inout ByteBuffer) -> Self? {
+        return buffer.readInteger()
+    }
+}
+
+/// Extension for StringProtocol types to conform to MemcachedValue.
+extension MemcachedValue where Self: StringProtocol {
+    /// Writes the string to a ByteBuffer.
+    ///
+    /// - Parameter buffer: The ByteBuffer to which the string should be written.
+    public func writeToBuffer(_ buffer: inout ByteBuffer) {
+        buffer.writeString(String(self))
+    }
+
+    /// Reads a String from a ByteBuffer.
+    ///
+    /// - Parameter buffer: The ByteBuffer from which the value should be read.
+    public static func readFromBuffer(_ buffer: inout ByteBuffer) -> Self? {
+        return buffer.readString(length: buffer.readableBytes) as? Self
+    }
+}
+
+/// MemcachedValue conformance to several standard Swift types.
+extension Int: MemcachedValue {}
+extension Int8: MemcachedValue {}
+extension Int16: MemcachedValue {}
+extension Int32: MemcachedValue {}
+extension Int64: MemcachedValue {}
+extension UInt: MemcachedValue {}
+extension UInt8: MemcachedValue {}
+extension UInt16: MemcachedValue {}
+extension UInt32: MemcachedValue {}
+extension UInt64: MemcachedValue {}
+extension String: MemcachedValue {}
diff --git a/Sources/swift-memcache-gsoc-example/Program.swift b/Sources/swift-memcache-gsoc-example/Program.swift
@@ -0,0 +1,50 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the swift-memcache-gsoc open source project
+//
+// Copyright (c) 2023 Apple Inc. and the swift-memcache-gsoc project authors
+// Licensed under Apache License v2.0
+//
+// See LICENSE.txt for license information
+// See CONTRIBUTORS.txt for the list of swift-memcache-gsoc project authors
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+//===----------------------------------------------------------------------===//
+
+import NIOCore
+import NIOPosix
+import SwiftMemcache
+
+@main
+struct Program {
+    // Create an event loop group with a single thread
+    static let eventLoopGroup = MultiThreadedEventLoopGroup(numberOfThreads: 1)
+
+    static func main() async throws {
+        // Instantiate a new MemcachedConnection actor with host, port, and event loop group
+        let memcachedConnection = MemcachedConnection(host: "127.0.0.1", port: 11211, eventLoopGroup: eventLoopGroup)
+
+        try await withThrowingTaskGroup(of: Void.self) { group in
+            // Add the connection actor's run function to the task group
+            // This opens the connection and handles requests until the task is cancelled or the connection is closed
+            group.addTask { try await memcachedConnection.run() }
+
+            // Set a value for a key.
+            let setValue = "bar"
+            try await memcachedConnection.set("foo", value: setValue)
+
+            // Get the value for a key.
+            // Specify the expected type for the value returned from Memcache.
+            let getValue: String? = try await memcachedConnection.get("foo")
+
+            // Assert that the get operation was successful by comparing the value set and the value returned from Memcache.
+            // If they are not equal, this will throw an error.
+            assert(getValue == setValue, "Value retrieved from Memcache does not match the set value")
+
+            // Cancel all tasks in the task group.
+            // This also results in the connection to Memcache being closed.
+            group.cancelAll()
+        }
+    }
+}
diff --git a/Tests/SwiftMemcacheTests/IntegrationTest/MemcachedIntegrationTests.swift b/Tests/SwiftMemcacheTests/IntegrationTest/MemcachedIntegrationTests.swift
@@ -95,15 +95,43 @@ final class MemcachedIntegrationTest: XCTestCase {
         try await withThrowingTaskGroup(of: Void.self) { group in
             group.addTask { try await connectionActor.run() }
 
+            // Set key and value
             let setValue = "foo"
-            var setBuffer = ByteBufferAllocator().buffer(capacity: setValue.count)
-            setBuffer.writeString(setValue)
-            let _ = try await connectionActor.set("bar", value: setValue)
+            try await connectionActor.set("bar", value: setValue)
 
             // Get value for key
-            let getValue = try await connectionActor.get("bar")
-            let getValueString = getValue?.getString(at: getValue!.readerIndex, length: getValue!.readableBytes)
-            XCTAssertEqual(getValueString, setValue, "Received value should be the same as sent")
+            let getValue: String? = try await connectionActor.get("bar")
+            XCTAssertEqual(getValue, setValue, "Received value should be the same as sent")
+
+            group.cancelAll()
+        }
+    }
+
+    func testMemcachedConnectionActorWithUInt() async throws {
+        let group = MultiThreadedEventLoopGroup(numberOfThreads: 1)
+        defer {
+            XCTAssertNoThrow(try! group.syncShutdownGracefully())
+        }
+        let connectionActor = MemcachedConnection(host: "memcached", port: 11211, eventLoopGroup: group)
+
+        try await withThrowingTaskGroup(of: Void.self) { group in
+            group.addTask { try await connectionActor.run() }
+
+            // Set UInt32 value for key
+            let setUInt32Value: UInt32 = 1_234_567_890
+            try await connectionActor.set("UInt32Key", value: setUInt32Value)
+
+            // Get value for UInt32 key
+            let getUInt32Value: UInt32? = try await connectionActor.get("UInt32Key")
+            XCTAssertEqual(getUInt32Value, setUInt32Value, "Received UInt32 value should be the same as sent")
+
+            // Set UInt64 value for key
+            let setUInt64Value: UInt64 = 12_345_678_901_234_567_890
+            let _ = try await connectionActor.set("UInt64Key", value: setUInt64Value)
+
+            // Get value for UInt64 key
+            let getUInt64Value: UInt64? = try await connectionActor.get("UInt64Key")
+            XCTAssertEqual(getUInt64Value, setUInt64Value, "Received UInt64 value should be the same as sent")
 
             group.cancelAll()
         }
diff --git a/Tests/SwiftMemcacheTests/UnitTest/MemcachedValueTests.swift b/Tests/SwiftMemcacheTests/UnitTest/MemcachedValueTests.swift
@@ -0,0 +1,99 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the swift-memcache-gsoc open source project
+//
+// Copyright (c) 2023 Apple Inc. and the swift-memcache-gsoc project authors
+// Licensed under Apache License v2.0
+//
+// See LICENSE.txt for license information
+// See CONTRIBUTORS.txt for the list of swift-memcache-gsoc project authors
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+//===----------------------------------------------------------------------===//
+
+import NIOCore
+@testable import SwiftMemcache
+import XCTest
+
+final class MemcachedValueTests: XCTestCase {
+    func testMemcachedValueConformance() {
+        var buffer = ByteBufferAllocator().buffer(capacity: 0)
+
+        // Test for Int
+        let int = 100
+        int.writeToBuffer(&buffer)
+        let intResult = Int.readFromBuffer(&buffer)
+        XCTAssertEqual(intResult, 100)
+        buffer.clear()
+
+        // Test for Int8
+        let int8: Int8 = 8
+        int8.writeToBuffer(&buffer)
+        let int8Result = Int8.readFromBuffer(&buffer)
+        XCTAssertEqual(int8Result, 8)
+        buffer.clear()
+
+        // Test for Int16
+        let int16: Int16 = 16
+        int16.writeToBuffer(&buffer)
+        let int16Result = Int16.readFromBuffer(&buffer)
+        XCTAssertEqual(int16Result, 16)
+        buffer.clear()
+
+        // Test for Int32
+        let int32: Int32 = 32
+        int32.writeToBuffer(&buffer)
+        let int32Result = Int32.readFromBuffer(&buffer)
+        XCTAssertEqual(int32Result, 32)
+        buffer.clear()
+
+        // Test for Int64
+        let int64: Int64 = 64
+        int64.writeToBuffer(&buffer)
+        let int64Result = Int64.readFromBuffer(&buffer)
+        XCTAssertEqual(int64Result, 64)
+        buffer.clear()
+
+        // Test for UInt
+        let uint: UInt = 200
+        uint.writeToBuffer(&buffer)
+        let uintResult = UInt.readFromBuffer(&buffer)
+        XCTAssertEqual(uintResult, 200)
+        buffer.clear()
+
+        // Test for UInt8
+        let uint8: UInt8 = 9
+        uint8.writeToBuffer(&buffer)
+        let uint8Result = UInt8.readFromBuffer(&buffer)
+        XCTAssertEqual(uint8Result, 9)
+        buffer.clear()
+
+        // Test for UInt16
+        let uint16: UInt16 = 17
+        uint16.writeToBuffer(&buffer)
+        let uint16Result = UInt16.readFromBuffer(&buffer)
+        XCTAssertEqual(uint16Result, 17)
+        buffer.clear()
+
+        // Test for UInt32
+        let uint32: UInt32 = 33
+        uint32.writeToBuffer(&buffer)
+        let uint32Result = UInt32.readFromBuffer(&buffer)
+        XCTAssertEqual(uint32Result, 33)
+        buffer.clear()
+
+        // Test for UInt64
+        let uint64: UInt64 = 65
+        uint64.writeToBuffer(&buffer)
+        let uint64Result = UInt64.readFromBuffer(&buffer)
+        XCTAssertEqual(uint64Result, 65)
+        buffer.clear()
+
+        // Test for String
+        let string = "string"
+        string.writeToBuffer(&buffer)
+        let stringResult = String.readFromBuffer(&buffer)
+        XCTAssertEqual(stringResult, "string")
+    }
+}

Original file line number	Diff line number	Diff line change
`@@ -47,5 +47,11 @@ let package = Package(`
`47`	`47`	`name: "SwiftMemcacheTests",`
`48`	`48`	`dependencies: ["SwiftMemcache"]`
`49`	`49`	`),`
	`50`	`+ .executableTarget(`
	`51`	`+ name: "swift-memcache-gsoc-example",`
	`52`	`+ dependencies: [`
	`53`	`+ .target(name: "SwiftMemcache"),`
	`54`	`+ ]`
	`55`	`+ ),`
`50`	`56`	`]`
`51`	`57`	`)`