Created a decoder handler to deserialize a MemcachedResponse

Package.swift

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

Sources/SwiftMemcache/MemcachedResponse.swift

@@ -0,0 +1,39 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+struct MemcachedResponse {
+ enum ReturnCode: UInt16 {
+ case stored
+ case notStored
+ case exists
+ case notFound
+
+ init(_ value: UInt16) {
+ switch value {
+ case 0x4844: // "HD"
+ self = .stored
+ case 0x4E53: // "NS"
+ self = .notStored
+ case 0x4558: // "EX"
+ self = .exists
+ case 0x4E46: // "NF"
+ self = .notFound
+ default:
+ preconditionFailure("Unrecognized response code.")
+ }
+ }
+ }
+
+ let returnCode: ReturnCode
+}

Sources/SwiftMemcache/MemcachedResponseDecoder.swift

@@ -0,0 +1,98 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 MemcachedResponseDecoder: NIOSingleStepByteToMessageDecoder {
+ /// Responses look like:
+ ///
+ /// <RC> <datalen*> <flag1> <flag2> <...>\r\n
+ ///
+ /// Where <RC> is a 2 character return code. The number of flags returned are
+ /// based off of the flags supplied.
+ ///
+ /// <datalen> is only for responses with payloads, with the return code 'VA'.
+ ///
+ /// Flags are single character codes, ie 'q' or 'k' or 'I', which adjust the
+ /// behavior of the command. If a flag requests a response flag (ie 't' for TTL
+ /// remaining), it is returned in the same order as they were in the original
+ /// command, though this is not strict.
+ ///
+ /// Flags are single character codes, ie 'q' or 'k' or 'O', which adjust the
+ /// behavior of a command. Flags may contain token arguments, which come after the
+ /// flag and before the next space or newline, ie 'Oopaque' or 'Kuserkey'. Flags
+ /// can return new data or reflect information, in the same order they were
+ /// supplied in the request. Sending an 't' flag with a get for an item with 20
+ /// seconds of TTL remaining, would return 't20' in the response.
+ ///
+ /// All commands accept a tokens 'P' and 'L' which are completely ignored. The
+ /// arguments to 'P' and 'L' can be used as hints or path specifications to a
+ /// proxy or router inbetween a client and a memcached daemon. For example, a
+ /// client may prepend a "path" in the key itself: "mg /path/foo v" or in a proxy
+ /// token: "mg foo Lpath/ v" - the proxy may then optionally remove or forward the
+ /// token to a memcached daemon, which will ignore them.
+ ///
+ /// Syntax errors are handled the same as noted under 'Error strings' section
+ /// below.
+ ///
+ /// For usage examples beyond basic syntax, please see the wiki:
+ /// https://github.com/memcached/memcached/wiki/MetaCommands
+ typealias InboundOut = MemcachedResponse
+
+ func decode(buffer: inout ByteBuffer) throws -> InboundOut? {
+ // Ensure the buffer has at least 3 bytes (minimum for a response code and newline)
+ guard buffer.readableBytes >= 3 else {
+ return nil // Need more data
+ }
+
+ // Read the first two characters
+ guard let firstReturnCode = buffer.readInteger(as: UInt8.self),
+ let secondReturnCode = buffer.readInteger(as: UInt8.self) else {
+ preconditionFailure("Response code could not be read.")
+ }
+
+ let returnCode = MemcachedResponse.ReturnCode(
+ UInt16(firstReturnCode) << 8 | UInt16(secondReturnCode)
+ )
+
+ // If there is not a whitespace, then we are at the end of the line.
+ guard buffer.readableBytes > 0, let nextByte = buffer.getInteger(at: buffer.readerIndex, as: UInt8.self) else {
+ return nil // Need more dat
+ }
+
+ if nextByte != UInt8.whitespace {
+ // We're at the end of the line
+ buffer.moveReaderIndex(forwardBy: 1)
+ } else {
+ // We have additional data or flags to read
+ buffer.moveReaderIndex(forwardBy: 1)
+
+ // Assert that we really read \r\n
+ guard buffer.readableBytes >= 2,
+ buffer.getInteger(at: buffer.readerIndex, as: UInt8.self) == UInt8.carriageReturn,
+ buffer.getInteger(at: buffer.readerIndex + 1, as: UInt8.self) == UInt8.newline else {
+ preconditionFailure("Response ending '\r\n' not found.")
+ }
+
+ buffer.moveReaderIndex(forwardBy: 2)
+ }
+
+ return MemcachedResponse(returnCode: returnCode)
+ }
+
+ func decodeLast(buffer: inout ByteBuffer, seenEOF: Bool) throws -> InboundOut? {
+ return try self.decode(buffer: &buffer)
+ }
+}

Tests/SwiftMemcacheTests/IntegrationTest/MemcachedIntegrationTests.swift

@@ -27,7 +27,7 @@ final class MemcachedIntegrationTest: XCTestCase {
  self.channel = ClientBootstrap(group: self.group)
  .channelOption(ChannelOptions.socket(SocketOptionLevel(SOL_SOCKET), SO_REUSEADDR), value: 1)
  .channelInitializer { channel in
- channel.pipeline.addHandler(MessageToByteHandler(MemcachedRequestEncoder()))
+ return channel.pipeline.addHandlers([MessageToByteHandler(MemcachedRequestEncoder()), ByteToMessageHandler(MemcachedResponseDecoder())])
  }
  }
 
@@ -36,6 +36,21 @@ final class MemcachedIntegrationTest: XCTestCase {
  super.tearDown()
  }
 
+ class ResponseHandler: ChannelInboundHandler {
+ typealias InboundIn = MemcachedResponse
+
+ let p: EventLoopPromise<MemcachedResponse>
+
+ init(p: EventLoopPromise<MemcachedResponse>) {
+ self.p = p
+ }
+
+ func channelRead(context: ChannelHandlerContext, data: NIOAny) {
+ let response = self.unwrapInboundIn(data)
+ self.p.succeed(response)
+ }
+ }
+
  func testConnectionToMemcachedServer() throws {
  do {
  let connection = try channel.connect(host: "memcached", port: 11211).wait()
@@ -47,15 +62,24 @@ final class MemcachedIntegrationTest: XCTestCase {
  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)")
- }
- }
+ // Write the request to the connection
+ _ = connection.write(request)
+
+ // Prepare the promise for the response
+ let promise = connection.eventLoop.makePromise(of: MemcachedResponse.self)
+ let responseHandler = ResponseHandler(p: promise)
+ _ = connection.pipeline.addHandler(responseHandler)
+
+ // Flush and then read the response from the server
+ connection.flush()
+ connection.read()
+
+ // Wait for the promise to be fulfilled
+ let response = try promise.futureResult.wait()
+
+ // Check the response from the server.
+ print("Response return code: \(response.returnCode)")
+
  } catch {
  XCTFail("Failed to connect to Memcached server: \(error)")
  }

Tests/SwiftMemcacheTests/UnitTest/MemcachedResponseDecoderTests.swift

@@ -0,0 +1,70 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 NIOEmbedded
+@testable import SwiftMemcache
+import XCTest
+
+final class MemcachedResponseDecoderTests: XCTestCase {
+ var decoder: MemcachedResponseDecoder!
+ var channel: EmbeddedChannel!
+
+ override func setUp() {
+ super.setUp()
+ self.decoder = MemcachedResponseDecoder()
+ self.channel = EmbeddedChannel(handler: ByteToMessageHandler(self.decoder))
+ }
+
+ override func tearDown() {
+ XCTAssertNoThrow(try self.channel.finish())
+ }
+
+ func testDecodeSetResponse(returnCode: [UInt8], expectedReturnCode: MemcachedResponse.ReturnCode) throws {
+ // Prepare a response buffer with a response code
+ var buffer = ByteBufferAllocator().buffer(capacity: 8)
+ buffer.writeBytes(returnCode)
+ buffer.writeBytes([UInt8.carriageReturn, UInt8.newline])
+
+ // Pass our response through the decoder
+ XCTAssertNoThrow(try self.channel.writeInbound(buffer))
+
+ // Read the decoded response
+ if let decoded = try self.channel.readInbound(as: MemcachedResponse.self) {
+ XCTAssertEqual(decoded.returnCode, expectedReturnCode)
+ } else {
+ XCTFail("Failed to decode the inbound response.")
+ }
+ }
+
+ func testDecodeSetStoredResponse() throws {
+ let storedReturnCode = [UInt8(ascii: "H"), UInt8(ascii: "D")]
+ try testDecodeSetResponse(returnCode: storedReturnCode, expectedReturnCode: .stored)
+ }
+
+ func testDecodeSetNotStoredResponse() throws {
+ let notStoredReturnCode = [UInt8(ascii: "N"), UInt8(ascii: "S")]
+ try testDecodeSetResponse(returnCode: notStoredReturnCode, expectedReturnCode: .notStored)
+ }
+
+ func testDecodeSetExistResponse() throws {
+ let existReturnCode = [UInt8(ascii: "E"), UInt8(ascii: "X")]
+ try testDecodeSetResponse(returnCode: existReturnCode, expectedReturnCode: .exists)
+ }
+
+ func testDecodeSetNotFoundResponse() throws {
+ let notFoundResponseCode = [UInt8(ascii: "N"), UInt8(ascii: "F")]
+ try testDecodeSetResponse(returnCode: notFoundResponseCode, expectedReturnCode: .notFound)
+ }
+}