Faster reading of request body and headers

Sources/HttpParser.swift

@@ -64,11 +64,9 @@ public class HttpParser {
  return c + [(name, value)]
  }
  }
- 
+
  private func readBody(_ socket: Socket, size: Int) throws -> [UInt8] {
- var body = [UInt8]()
- for _ in 0..<size { body.append(try socket.read()) }
- return body
+ return try socket.read(length: size)
  }
 
  private func readHeaders(_ socket: Socket) throws -> [String: String] {

Sources/Socket.swift

@@ -112,21 +112,65 @@ open class Socket: Hashable, Equatable {
  }
  }
 
+ /// Read a single byte off the socket. This method is optimized for reading
+ /// a single byte. For reading multiple bytes, use read(length:), which will
+ /// pre-allocate heap space and read directly into it.
+ ///
+ /// - Returns: A single byte
+ /// - Throws: SocketError.recvFailed if unable to read from the socket
  open func read() throws -> UInt8 {
- var buffer = [UInt8](repeating: 0, count: 1)
- #if os(Linux)
- let next = recv(self.socketFileDescriptor as Int32, &buffer, Int(buffer.count), Int32(MSG_NOSIGNAL))
- #else
- let next = recv(self.socketFileDescriptor as Int32, &buffer, Int(buffer.count), 0)
- #endif
- if next <= 0 {
+ var byte: UInt8 = 0
+ let count = Darwin.read(self.socketFileDescriptor as Int32, &byte, 1)
+ guard count > 0 else {
  throw SocketError.recvFailed(Errno.description())
  }
- return buffer[0]
+ return byte
+ }
+
+ /// Read up to `length` bytes from this socket
+ ///
+ /// - Parameter length: The maximum bytes to read
+ /// - Returns: A buffer containing the bytes read
+ /// - Throws: SocketError.recvFailed if unable to read bytes from the socket
+ open func read(length: Int) throws -> [UInt8] {
+ var buffer = UnsafeMutableBufferPointer<UInt8>.allocate(capacity: length)
+
+ let bytesRead = try read(into: &buffer, length: length)
+
+ let rv = [UInt8](buffer[0..<bytesRead])
+ buffer.deallocate()
+ return rv
+ }
+
+ static let kBufferLength = 1024
+
+ /// Read up to `length` bytes from this socket into an existing buffer
+ ///
+ /// - Parameter into: The buffer to read into (must be at least length bytes in size)
+ /// - Parameter length: The maximum bytes to read
+ /// - Returns: The number of bytes read
+ /// - Throws: SocketError.recvFailed if unable to read bytes from the socket
+ func read(into buffer: inout UnsafeMutableBufferPointer<UInt8>, length: Int) throws -> Int {
+ var offset = 0
+ guard let baseAddress = buffer.baseAddress else { return 0 }
+
+ while offset < length {
+ // Compute next read length in bytes. The bytes read is never more than kBufferLength at once.
+ let readLength = offset + Socket.kBufferLength < length ? Socket.kBufferLength : length - offset
+
+ let bytesRead = Darwin.read(self.socketFileDescriptor as Int32, baseAddress + offset, readLength)
+ guard bytesRead > 0 else {
+ throw SocketError.recvFailed(Errno.description())
+ }
+
+ offset += bytesRead
+ }
+
+ return offset
  }
 
- private static let CR = UInt8(13)
- private static let NL = UInt8(10)
+ private static let CR: UInt8 = 13
+ private static let NL: UInt8 = 10
 
  public func readLine() throws -> String {
  var characters: String = ""

XCode/SwifterTestsCommon/SwifterTestsHttpParser.swift

@@ -6,29 +6,46 @@
 //
 
 import XCTest
-import Swifter
+@testable import Swifter
 
 class SwifterTestsHttpParser: XCTestCase {
 
+ /// A specialized Socket which creates a linked socket pair with a pipe, and
+ /// immediately writes in fixed data. This enables tests to static fixture
+ /// data into the regular Socket flow.
  class TestSocket: Socket {
- var content = [UInt8]()
- var offset = 0
-
  init(_ content: String) {
- super.init(socketFileDescriptor: -1)
- self.content.append(contentsOf: [UInt8](content.utf8))
- }
-
- override func read() throws -> UInt8 {
- if offset < content.count {
- let value = self.content[offset]
- offset = offset + 1
- return value
+ /// Create an array to hold the read and write sockets that pipe creates
+ var fds = [Int32](repeating: 0, count: 2)
+ fds.withUnsafeMutableBufferPointer { ptr in
+ let rv = pipe(ptr.baseAddress!)
+ guard rv >= 0 else { fatalError("Pipe error!") }
+ }
+
+ // Extract the read and write handles into friendly variables
+ let fdRead = fds[0]
+ let fdWrite = fds[1]
+
+ // Set non-blocking I/O on both sockets. This is required!
+ _ = fcntl(fdWrite, F_SETFL, O_NONBLOCK)
+ _ = fcntl(fdRead, F_SETFL, O_NONBLOCK)
+
+ // Push the content bytes into the write socket.
+ _ = content.withCString { stringPointer in
+ // Count will be either >=0 to indicate bytes written, or -1
+ // if the bytes will be written later (non-blocking).
+ let count = write(fdWrite, stringPointer, content.lengthOfBytes(using: .utf8) + 1)
+ guard count != -1 || errno == EAGAIN else { fatalError("Write error!") }
  }
- throw SocketError.recvFailed("")
+
+ // Close the write socket immediately. The OS will add an EOF byte
+ // and the read socket will remain open.
+ Darwin.close(fdWrite) // the super instance will close fdRead in deinit!
+
+ super.init(socketFileDescriptor: fdRead)
  }
  }
- 
+
  func testParser() {
  let parser = HttpParser()
 
@@ -89,6 +106,43 @@ class SwifterTestsHttpParser: XCTestCase {
  let _ = try parser.readHttpRequest(TestSocket("GET / HTTP/1.0\nContent-Length: 10\r\n\n"))
  XCTAssert(false, "Parser should throw an error if request' body is too short.")
  } catch { }
+
+ do { // test payload less than 1 read segmant
+ let contentLength = Socket.kBufferLength - 128
+ let bodyString = [String](repeating: "A", count: contentLength).joined(separator: "")
+
+ let payload = "GET / HTTP/1.0\nContent-Length: \(contentLength)\n\n".appending(bodyString)
+ let request = try parser.readHttpRequest(TestSocket(payload))
+
+ XCTAssert(bodyString.lengthOfBytes(using: .utf8) == contentLength, "Has correct request size")
+
+ let unicodeBytes = bodyString.utf8.map { return $0 }
+ XCTAssert(request.body == unicodeBytes, "Request body must be correct")
+ } catch { }
+
+ do { // test payload equal to 1 read segmant
+ let contentLength = Socket.kBufferLength
+ let bodyString = [String](repeating: "B", count: contentLength).joined(separator: "")
+ let payload = "GET / HTTP/1.0\nContent-Length: \(contentLength)\n\n".appending(bodyString)
+ let request = try parser.readHttpRequest(TestSocket(payload))
+
+ XCTAssert(bodyString.lengthOfBytes(using: .utf8) == contentLength, "Has correct request size")
+
+ let unicodeBytes = bodyString.utf8.map { return $0 }
+ XCTAssert(request.body == unicodeBytes, "Request body must be correct")
+ } catch { }
+
+ do { // test very large multi-segment payload
+ let contentLength = Socket.kBufferLength * 4
+ let bodyString = [String](repeating: "C", count: contentLength).joined(separator: "")
+ let payload = "GET / HTTP/1.0\nContent-Length: \(contentLength)\n\n".appending(bodyString)
+ let request = try parser.readHttpRequest(TestSocket(payload))
+
+ XCTAssert(bodyString.lengthOfBytes(using: .utf8) == contentLength, "Has correct request size")
+
+ let unicodeBytes = bodyString.utf8.map { return $0 }
+ XCTAssert(request.body == unicodeBytes, "Request body must be correct")
+ } catch { }
 
  var r = try? parser.readHttpRequest(TestSocket("GET /open?link=https://www.youtube.com/watch?v=D2cUBG4PnOA HTTP/1.0\nContent-Length: 10\n\n1234567890"))