Implement a get request (#14)

* init get request structure

* re work MemcachedFlags model

* dataLengthOrFlag split + readMemcachedFlags

* decoder pr refactors

* write and read memcached flag fixes

* combine flag states into one

* data length is written as text not encoded as UInt64

* remaining PR changes

* optimized dataLength read by fixing readIntegerFromASCII

* removed flagToByte prop

* final clean up closes #6

* flag state clean up + set up for partial buffers impl to come soon

* closes #6

* ensure we have \r\n before parsing

* \r\n + partial/split buffer test

* closes #6

* .suffix(2) is costly removed it

* walk buffer to find first \r\n

Author: dkz2

Sources/SwiftMemcache/Extensions/ByteBuffer+SwiftMemcache.swift

@@ -25,3 +25,67 @@ extension ByteBuffer {
         self.writeString(string)
     }
 }
+
+extension ByteBuffer {
+    /// Reads an integer from ASCII characters directly from this `ByteBuffer`.
+    /// The reading stops as soon as a non-digit character is encountered.
+    ///
+    /// - Returns: A `UInt64` integer read from the buffer.
+    /// If the buffer does not contain any digits at the current reading position, returns `nil`.
+    mutating func readIntegerFromASCII() -> UInt64? {
+        var value: UInt64 = 0
+        while self.readableBytes > 0, let currentByte = self.readInteger(as: UInt8.self),
+              currentByte >= UInt8.zero && currentByte <= UInt8.nine {
+            value = (value * 10) + UInt64(currentByte - UInt8.zero)
+        }
+        return value > 0 ? value : nil
+    }
+}
+
+extension ByteBuffer {
+    /// Serialize and writes MemcachedFlags to the ByteBuffer.
+    ///
+    /// This method runs a loop over the flags contained in a MemcachedFlags instance.
+    /// For each flag that is set to true, its corresponding byte value,
+    /// followed by a whitespace character, is added to the ByteBuffer.
+    ///
+    /// - parameters:
+    ///     - flags: An instance of MemcachedFlags that holds the flags intended to be serialized and written to the ByteBuffer.
+    mutating func writeMemcachedFlags(flags: MemcachedFlags) {
+        if let shouldReturnValue = flags.shouldReturnValue, shouldReturnValue {
+            self.writeInteger(UInt8.whitespace)
+            self.writeInteger(UInt8.v)
+        }
+    }
+}
+
+extension ByteBuffer {
+    /// Parses flags from this `ByteBuffer`, advancing the reader index accordingly.
+    ///
+    /// - returns: A `MemcachedFlags` instance populated with the flags read from the buffer.
+    mutating func readMemcachedFlags() -> MemcachedFlags {
+        let flags = MemcachedFlags()
+        while let nextByte = self.getInteger(at: self.readerIndex, as: UInt8.self) {
+            switch nextByte {
+            case UInt8.whitespace:
+                self.moveReaderIndex(forwardBy: 1)
+                continue
+            case UInt8.carriageReturn:
+                guard let followingByte = self.getInteger(at: self.readerIndex + 1, as: UInt8.self) else {
+                    // We were expecting a newline after the carriage return, but didn't get it.
+                    fatalError("Unexpected end of flags. Expected newline after carriage return.")
+                }
+                if followingByte == UInt8.newline {
+                    self.moveReaderIndex(forwardBy: 2)
+                } else {
+                    // If it wasn't a newline, it is something unexpected.
+                    fatalError("Unexpected character in flags. Expected newline after carriage return.")
+                }
+            default:
+                // Encountered a character we weren't expecting. This should be a fatal error.
+                fatalError("Unexpected character in flags.")
+            }
+        }
+        return flags
+    }
+}

Sources/SwiftMemcache/Extensions/UInt8+Characters.swift

@@ -18,4 +18,8 @@ extension UInt8 {
     static var carriageReturn: UInt8 = .init(ascii: "\r")
     static var m: UInt8 = .init(ascii: "m")
     static var s: UInt8 = .init(ascii: "s")
+    static var g: UInt8 = .init(ascii: "g")
+    static var v: UInt8 = .init(ascii: "v")
+    static var zero: UInt8 = .init(ascii: "0")
+    static var nine: UInt8 = .init(ascii: "9")
 }

Sources/SwiftMemcache/MemcachedFlag.swift

@@ -0,0 +1,30 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 representing the flags of a Memcached command.
+///
+/// Flags for the 'mg' (meta get) command are represented in this struct.
+/// Currently, only the 'v' flag for the meta get command is supported,
+/// which dictates whether the item value should be returned in the data block.
+struct MemcachedFlags {
+    /// Flag 'v' for the 'mg' (meta get) command.
+    ///
+    /// If true, the item value is returned in the data block.
+    /// If false, the data block for the 'mg' response is optional, and the response code changes from "HD" to "VA <size>".
+    var shouldReturnValue: Bool?
+
+    init() {}
+}
+
+extension MemcachedFlags: Hashable {}

Sources/SwiftMemcache/MemcachedFlags.swift

@@ -20,5 +20,11 @@ enum MemcachedRequest {
         var value: ByteBuffer
     }
 
+    struct GetCommand {
+        let key: String
+        var flags: MemcachedFlags
+    }
+
     case set(SetCommand)
+    case get(GetCommand)
 }

Sources/SwiftMemcache/MemcachedRequest.swift

@@ -42,6 +42,22 @@ struct MemcachedRequestEncoder: MessageToByteEncoder {
             out.writeBuffer(&command.value)
             out.writeInteger(UInt8.carriageReturn)
             out.writeInteger(UInt8.newline)
+
+        case .get(let command):
+            precondition(!command.key.isEmpty, "Key must not be empty")
+
+            // write command and key
+            out.writeInteger(UInt8.m)
+            out.writeInteger(UInt8.g)
+            out.writeInteger(UInt8.whitespace)
+            out.writeBytes(command.key.utf8)
+
+            // write flags if there are any
+            out.writeMemcachedFlags(flags: command.flags)
+
+            // write separator
+            out.writeInteger(UInt8.carriageReturn)
+            out.writeInteger(UInt8.newline)
         }
     }
 }

Sources/SwiftMemcache/MemcachedRequestEncoder.swift

@@ -12,6 +12,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+import NIOCore
+
 struct MemcachedResponse {
     enum ReturnCode {
         case HD
@@ -40,4 +42,6 @@ struct MemcachedResponse {
 
     var returnCode: ReturnCode
     var dataLength: UInt64?
+    var flags: MemcachedFlags?
+    var value: ByteBuffer?
 }

Sources/SwiftMemcache/MemcachedResponse.swift

@@ -56,12 +56,10 @@ struct MemcachedResponseDecoder: NIOSingleStepByteToMessageDecoder {
         /// This error is thrown when EOF is encountered but there are still
         /// readable bytes in the buffer, which can indicate a bad message.
         case unexpectedEOF
-
         /// This error is thrown when EOF is encountered but there is still an expected next step
         /// in the decoder's state machine. This error suggests that the message ended prematurely,
         /// possibly indicating a bad message.
         case unexpectedNextStep(NextStep)
-
         /// This error is thrown when an unexpected character is encountered in the buffer
         /// during the decoding process.
         case unexpectedCharacter(UInt8)
@@ -72,11 +70,12 @@ struct MemcachedResponseDecoder: NIOSingleStepByteToMessageDecoder {
     enum NextStep: Hashable {
         /// The initial step.
         case returnCode
-        /// Decode the data length, flags or check if we are the end
-        case dataLengthOrFlag(MemcachedResponse.ReturnCode)
-        /// Decode the next flag
-        case decodeNextFlag(MemcachedResponse.ReturnCode, UInt64?)
-        // TODO: Add a next step for decoding the response data if the return code is VA
+        /// Decode the data length
+        case dataLength(MemcachedResponse.ReturnCode)
+        /// Decode the flags
+        case decodeFlag(MemcachedResponse.ReturnCode, UInt64?)
+        /// Decode the Value
+        case decodeValue(MemcachedResponse.ReturnCode, UInt64, MemcachedFlags)
     }
 
     /// The action that the decoder will take in response to the current state of the ByteBuffer and the `NextStep`.
@@ -108,47 +107,84 @@ struct MemcachedResponseDecoder: NIOSingleStepByteToMessageDecoder {
     }
 
     mutating func next(buffer: inout ByteBuffer) throws -> NextDecodeAction {
+        // Check if the buffer contains "\r\n"
+        let bytesView = buffer.readableBytesView
+        guard let crIndex = bytesView.firstIndex(of: UInt8.carriageReturn), bytesView.index(after: crIndex) < bytesView.endIndex,
+              bytesView[bytesView.index(after: crIndex)] == UInt8.newline else {
+            return .waitForMoreBytes
+        }
         switch self.nextStep {
         case .returnCode:
             guard let bytes = buffer.readInteger(as: UInt16.self) else {
                 return .waitForMoreBytes
             }
 
             let returnCode = MemcachedResponse.ReturnCode(bytes)
-            self.nextStep = .dataLengthOrFlag(returnCode)
+            self.nextStep = .dataLength(returnCode)
             return .continueDecodeLoop
 
-        case .dataLengthOrFlag(let returnCode):
+        case .dataLength(let returnCode):
             if returnCode == .VA {
-                // TODO: Implement decoding of data length
-                fatalError("Decoding for VA return code is not yet implemented")
+                // Check if we have at least one whitespace in the buffer.
+                guard buffer.readableBytesView.contains(UInt8.whitespace) else {
+                    return .waitForMoreBytes
+                }
+
+                if let currentByte = buffer.getInteger(at: buffer.readerIndex, as: UInt8.self), currentByte == UInt8.whitespace {
+                    buffer.moveReaderIndex(forwardBy: 1)
+                }
+
+                guard let dataLength = buffer.readIntegerFromASCII() else {
+                    throw MemcachedDecoderError.unexpectedCharacter(buffer.readableBytesView[buffer.readerIndex])
+                }
+
+                self.nextStep = .decodeFlag(returnCode, dataLength)
+                return .continueDecodeLoop
+            } else {
+                self.nextStep = .decodeFlag(returnCode, nil)
+                return .continueDecodeLoop
             }
 
-            guard let nextByte = buffer.readInteger(as: UInt8.self) else {
-                return .waitForMoreBytes
+        case .decodeFlag(let returnCode, let dataLength):
+            if let nextByte = buffer.getInteger(at: buffer.readerIndex, as: UInt8.self), nextByte == UInt8.newline {
+                self.nextStep = .decodeValue(returnCode, dataLength!, MemcachedFlags())
+                buffer.moveReaderIndex(forwardBy: 1)
+                return .continueDecodeLoop
+            }
+
+            if let currentByte = buffer.getInteger(at: buffer.readerIndex, as: UInt8.self), currentByte == UInt8.whitespace {
+                buffer.moveReaderIndex(forwardBy: 1)
             }
 
-            if nextByte == UInt8.whitespace {
-                self.nextStep = .decodeNextFlag(returnCode, nil)
+            let flags = buffer.readMemcachedFlags()
+
+            if returnCode == .VA {
+                self.nextStep = .decodeValue(returnCode, dataLength!, flags)
                 return .continueDecodeLoop
-            } else if nextByte == UInt8.carriageReturn {
-                guard let nextNextByte = buffer.readInteger(as: UInt8.self), nextNextByte == UInt8.newline else {
-                    return .waitForMoreBytes
-                }
-                let response = MemcachedResponse(returnCode: returnCode, dataLength: nil)
+            } else {
+                let response = MemcachedResponse(returnCode: returnCode, dataLength: dataLength, flags: flags, value: nil)
                 self.nextStep = .returnCode
                 return .returnDecodedResponse(response)
-            } else {
-                throw MemcachedDecoderError.unexpectedCharacter(nextByte)
             }
 
-        case .decodeNextFlag(let returnCode, let dataLength):
-            while let nextByte = buffer.readInteger(as: UInt8.self), nextByte != UInt8.whitespace {
-                // for now consume the byte and do nothing with it.
-                // TODO: Implement decoding of flags
+        case .decodeValue(let returnCode, let dataLength, let flags):
+            guard buffer.readableBytes >= dataLength + 2 else {
+                return .waitForMoreBytes
+            }
+
+            guard let data = buffer.readSlice(length: Int(dataLength)) else {
+                throw MemcachedDecoderError.unexpectedEOF
+            }
+
+            guard buffer.readableBytes >= 2,
+                  let nextByte = buffer.readInteger(as: UInt8.self),
+                  nextByte == UInt8.carriageReturn,
+                  let nextNextByte = buffer.readInteger(as: UInt8.self),
+                  nextNextByte == UInt8.newline else {
+                preconditionFailure("Expected to find CRLF at end of response")
             }
 
-            let response = MemcachedResponse(returnCode: returnCode, dataLength: dataLength)
+            let response = MemcachedResponse(returnCode: returnCode, dataLength: dataLength, flags: flags, value: data)
             self.nextStep = .returnCode
             return .returnDecodedResponse(response)
         }

Sources/SwiftMemcache/MemcachedResponseDecoder.swift

@@ -15,9 +15,14 @@
 @testable import SwiftMemcache
 import XCTest
 
-final class MemcachedFlagTests: XCTestCase {
-    func testVFlagBytes() {
-        let flag = MemcachedFlag.v
-        XCTAssertEqual(flag.bytes, 0x76)
+final class MemcachedFlagsTests: XCTestCase {
+    func testVFlag() {
+        var flags = MemcachedFlags()
+        flags.shouldReturnValue = true
+        if let shouldReturnValue = flags.shouldReturnValue {
+            XCTAssertTrue(shouldReturnValue)
+        } else {
+            XCTFail("Flag shouldReturnValue is nil")
+        }
     }
 }

Tests/SwiftMemcacheTests/UnitTest/MemcachedFlagTests.swift renamed to Tests/SwiftMemcacheTests/UnitTest/MemcachedFlagsTests.swift

@@ -42,4 +42,24 @@ final class MemcachedRequestEncoderTests: XCTestCase {
         let expectedEncodedData = "ms foo 2\r\nhi\r\n"
         XCTAssertEqual(outBuffer.getString(at: 0, length: outBuffer.readableBytes), expectedEncodedData)
     }
+
+    func testEncodeGetRequest() {
+        // Prepare a MemcachedRequest
+        var flags = MemcachedFlags()
+        flags.shouldReturnValue = true
+        let command = MemcachedRequest.GetCommand(key: "foo", flags: flags)
+
+        let request = MemcachedRequest.get(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 = "mg foo v\r\n"
+        XCTAssertEqual(outBuffer.getString(at: 0, length: outBuffer.readableBytes), expectedEncodedData)
+    }
 }