Created a encoder handler to serializing a MemcachedRequest (#8)

* Created a encoder handler that is capable of serializing a MemcachedRequest

* no need to return anything here

* fixed test case for consistency

* clean up comments

* rename extension

* cleaned up imports and avoided writing Strings

* pr comment fixes, i.e precond on key

* consistency removings accessor

* rename meta and set to m s

* soundess ci failure fixes

Author: dkz2

Package.swift

@@ -38,6 +38,7 @@ let package = Package(
             name: "SwiftMemcache",
             dependencies: [
                 .product(name: "NIOCore", package: "swift-nio"),
+                .product(name: "NIOPosix", package: "swift-nio"),
                 .product(name: "Logging", package: "swift-log"),
             ]
         ),

Sources/SwiftMemcache/Extensions/ByteBuffer+IntegerAsASCII.swift

@@ -0,0 +1,27 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+
+extension ByteBuffer {
+    /// Write `integer` into this `ByteBuffer` as ASCII digits, without leading zeros, moving the writer index forward appropriately.
+    ///
+    /// - parameters:
+    ///     - integer: The integer to serialize.
+    @inlinable
+    mutating func writeIntegerAsASCII(_ integer: some FixedWidthInteger) {
+        let string = String(integer)
+        self.writeString(string)
+    }
+}

Tests/SwiftMemcacheTests/empty.swift renamed to Sources/SwiftMemcache/Extensions/UInt8+Characters.swift

@@ -11,3 +11,11 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 //===----------------------------------------------------------------------===//
+
+extension UInt8 {
+    static var whitespace: UInt8 = .init(ascii: " ")
+    static var newline: UInt8 = .init(ascii: "\n")
+    static var carriageReturn: UInt8 = .init(ascii: "\r")
+    static var m: UInt8 = .init(ascii: "m")
+    static var s: UInt8 = .init(ascii: "s")
+}

Sources/SwiftMemcache/empty.swift renamed to Sources/SwiftMemcache/MemcachedRequest.swift

@@ -11,3 +11,14 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 //===----------------------------------------------------------------------===//
+
+import NIOCore
+
+enum MemcachedRequest {
+    struct SetCommand {
+        let key: String
+        var value: ByteBuffer
+    }
+
+    case set(SetCommand)
+}

Sources/SwiftMemcache/MemcachedRequestEncoder.swift

@@ -0,0 +1,47 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+
+struct MemcachedRequestEncoder: MessageToByteEncoder {
+    typealias OutboundIn = MemcachedRequest
+
+    func encode(data: MemcachedRequest, out: inout ByteBuffer) throws {
+        switch data {
+        case .set(var command):
+            precondition(!command.key.isEmpty, "Key must not be empty")
+
+            // write command and key
+            out.writeInteger(UInt8.m)
+            out.writeInteger(UInt8.s)
+            out.writeInteger(UInt8.whitespace)
+            out.writeBytes(command.key.utf8)
+            out.writeInteger(UInt8.whitespace)
+
+            // write value length
+            let length = command.value.readableBytes
+            out.writeIntegerAsASCII(length)
+
+            // write separator
+            out.writeInteger(UInt8.carriageReturn)
+            out.writeInteger(UInt8.newline)
+
+            // write value and end line
+            out.writeBuffer(&command.value)
+            out.writeInteger(UInt8.carriageReturn)
+            out.writeInteger(UInt8.newline)
+        }
+    }
+}

Tests/SwiftMemcacheTests/IntegrationTest/MemcachedIntegrationTests.swift

@@ -0,0 +1,63 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+@testable import SwiftMemcache
+import XCTest
+
+final class MemcachedIntegrationTest: XCTestCase {
+    var channel: ClientBootstrap!
+    var group: EventLoopGroup!
+
+    override func setUp() {
+        super.setUp()
+        self.group = MultiThreadedEventLoopGroup(numberOfThreads: 1)
+        self.channel = ClientBootstrap(group: self.group)
+            .channelOption(ChannelOptions.socket(SocketOptionLevel(SOL_SOCKET), SO_REUSEADDR), value: 1)
+            .channelInitializer { channel in
+                channel.pipeline.addHandler(MessageToByteHandler(MemcachedRequestEncoder()))
+            }
+    }
+
+    override func tearDown() {
+        XCTAssertNoThrow(try self.group.syncShutdownGracefully())
+        super.tearDown()
+    }
+
+    func testConnectionToMemcachedServer() throws {
+        do {
+            let connection = try channel.connect(host: "memcached", port: 11211).wait()
+            XCTAssertNotNil(connection)
+
+            // Prepare a MemcachedRequest
+            var buffer = ByteBufferAllocator().buffer(capacity: 3)
+            buffer.writeString("hi")
+            let command = MemcachedRequest.SetCommand(key: "foo", value: buffer)
+            let request = MemcachedRequest.set(command)
+
+            // Write the request to the connection and wait for the result
+            connection.writeAndFlush(request).whenComplete { result in
+                switch result {
+                case .success:
+                    print("Request successfully sent to the server.")
+                case .failure(let error):
+                    XCTFail("Failed to send request: \(error)")
+                }
+            }
+        } catch {
+            XCTFail("Failed to connect to Memcached server: \(error)")
+        }
+    }
+}

Tests/SwiftMemcacheTests/UnitTest/MemcachedRequestEncoderTests.swift

@@ -0,0 +1,45 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 MemcachedRequestEncoderTests: XCTestCase {
+    var encoder: MemcachedRequestEncoder!
+
+    override func setUp() {
+        super.setUp()
+        self.encoder = MemcachedRequestEncoder()
+    }
+
+    func testEncodeSetRequest() {
+        // Prepare a MemcachedRequest
+        var buffer = ByteBufferAllocator().buffer(capacity: 2)
+        buffer.writeString("hi")
+        let command = MemcachedRequest.SetCommand(key: "foo", value: buffer)
+        let request = MemcachedRequest.set(command)
+
+        // pass our request through the encoder
+        var outBuffer = ByteBufferAllocator().buffer(capacity: 0)
+        do {
+            try self.encoder.encode(data: request, out: &outBuffer)
+        } catch {
+            XCTFail("Encoding failed with error: \(error)")
+        }
+
+        let expectedEncodedData = "ms foo 2\r\nhi\r\n"
+        XCTAssertEqual(outBuffer.getString(at: 0, length: outBuffer.readableBytes), expectedEncodedData)
+    }
+}

docker/docker-compose.yaml

@@ -3,7 +3,12 @@ version: "3.9"
 services:
   # Swift on Server CI
   # e.g. docker-compose -f docker/docker-compose.yaml -f docker/docker-compose.2204.57.yaml run test
-
+  
+  memcached:
+    image: memcached:latest
+    ports:
+        - "11211:11211"
+  
   runtime-setup:
     image: swift-memcache-gsoc:default
     build:
@@ -24,7 +29,9 @@ services:
 
   test:
     <<: *common
-    depends_on: [runtime-setup]
+    depends_on:
+        - runtime-setup
+        - memcached
     command: /bin/bash -xcl "swift $${SWIFT_TEST_VERB-test} $${WARN_AS_ERROR_ARG-} $${SANITIZER_ARG-} $${IMPORT_CHECK_ARG-}"
 
   # util