|
| 1 | +// This source file is part of the Swift.org open source project |
| 2 | +// |
| 3 | +// Copyright (c) 2014 - 2016 Apple Inc. and the Swift project authors |
| 4 | +// Licensed under Apache License v2.0 with Runtime Library Exception |
| 5 | +// |
| 6 | +// See http://swift.org/LICENSE.txt for license information |
| 7 | +// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors |
| 8 | +// |
| 9 | + |
| 10 | + |
| 11 | +//This is a very rudimentary HTTP server written plainly for testing URLSession. |
| 12 | +//It is not concurrent. It listens on a port, reads once and writes back only once. |
| 13 | +//We can make it better everytime we need more functionality to test different the aspects of URLSession. |
| 14 | + |
| 15 | +import Foundation |
| 16 | +import Dispatch |
| 17 | +import Glibc |
| 18 | + |
| 19 | +struct _HTTPUtils { |
| 20 | + static let CRLF = "\r\n" |
| 21 | + static let VERSION = "HTTP/1.1" |
| 22 | + static let SPACE = " " |
| 23 | + static let CRLF2 = CRLF + CRLF |
| 24 | +} |
| 25 | + |
| 26 | +class _TCPSocket { |
| 27 | + |
| 28 | + private var listenSocket: Int32! |
| 29 | + private var socketAddress = UnsafeMutablePointer<sockaddr_in>.allocate(capacity: 1) |
| 30 | + private var connectionSocket: Int32! |
| 31 | + |
| 32 | + private func isNotNegative(r: CInt) -> Bool { |
| 33 | + return r != -1 |
| 34 | + } |
| 35 | + |
| 36 | + private func isZero(r: CInt) -> Bool { |
| 37 | + return r == 0 |
| 38 | + } |
| 39 | + |
| 40 | + private func attempt(_ name: String, file: String = #file, line: UInt = #line, valid: (CInt) -> Bool, _ b: @autoclosure () -> CInt) throws -> CInt { |
| 41 | + let r = b() |
| 42 | + guard valid(r) else { throw ServerError(operation: name, errno: r, file: file, line: line) } |
| 43 | + return r |
| 44 | + } |
| 45 | + |
| 46 | + init(port: UInt16) throws { |
| 47 | + listenSocket = try attempt("socket", valid: isNotNegative, socket(AF_INET, Int32(SOCK_STREAM.rawValue), Int32(IPPROTO_TCP))) |
| 48 | + var on: Int = 1 |
| 49 | + _ = try attempt("setsockopt", valid: isZero, setsockopt(listenSocket, SOL_SOCKET, SO_REUSEADDR, &on, socklen_t(MemoryLayout<Int>.size))) |
| 50 | + let sa = sockaddr_in(sin_family: sa_family_t(AF_INET), sin_port: htons(port), sin_addr: in_addr(s_addr: INADDR_ANY), sin_zero: (0,0,0,0,0,0,0,0)) |
| 51 | + socketAddress.initialize(to: sa) |
| 52 | + try socketAddress.withMemoryRebound(to: sockaddr.self, capacity: MemoryLayout<sockaddr>.size, { |
| 53 | + let addr = UnsafePointer<sockaddr>($0) |
| 54 | + _ = try attempt("bind", valid: isZero, bind(listenSocket, addr, socklen_t(MemoryLayout<sockaddr>.size))) |
| 55 | + }) |
| 56 | + } |
| 57 | + |
| 58 | + func acceptConnection(notify: DispatchSemaphore) throws { |
| 59 | + _ = try attempt("listen", valid: isZero, listen(listenSocket, SOMAXCONN)) |
| 60 | + try socketAddress.withMemoryRebound(to: sockaddr.self, capacity: MemoryLayout<sockaddr>.size, { |
| 61 | + let addr = UnsafeMutablePointer<sockaddr>($0) |
| 62 | + var sockLen = socklen_t(MemoryLayout<sockaddr>.size) |
| 63 | + notify.signal() |
| 64 | + connectionSocket = try attempt("accept", valid: isNotNegative, accept(listenSocket, addr, &sockLen)) |
| 65 | + }) |
| 66 | + } |
| 67 | + |
| 68 | + func readData() throws -> String { |
| 69 | + var buffer = [UInt8](repeating: 0, count: 4096) |
| 70 | + _ = try attempt("read", valid: isNotNegative, CInt(read(connectionSocket, &buffer, 4096))) |
| 71 | + return String(cString: &buffer) |
| 72 | + } |
| 73 | + |
| 74 | + func writeData(data: String) throws { |
| 75 | + var bytes = Array(data.utf8) |
| 76 | + _ = try attempt("write", valid: isNotNegative, CInt(write(connectionSocket, &bytes, data.utf8.count))) |
| 77 | + } |
| 78 | + |
| 79 | + func shutdown() { |
| 80 | + close(connectionSocket) |
| 81 | + close(listenSocket) |
| 82 | + } |
| 83 | +} |
| 84 | + |
| 85 | +class _HTTPServer { |
| 86 | + |
| 87 | + let socket: _TCPSocket |
| 88 | + |
| 89 | + init(port: UInt16) throws { |
| 90 | + socket = try _TCPSocket(port: port) |
| 91 | + } |
| 92 | + |
| 93 | + public class func create(port: UInt16) throws -> _HTTPServer { |
| 94 | + return try _HTTPServer(port: port) |
| 95 | + } |
| 96 | + |
| 97 | + public func listen(notify: DispatchSemaphore) throws { |
| 98 | + try socket.acceptConnection(notify: notify) |
| 99 | + } |
| 100 | + |
| 101 | + public func stop() { |
| 102 | + socket.shutdown() |
| 103 | + } |
| 104 | + |
| 105 | + public func request() throws -> _HTTPRequest { |
| 106 | + return _HTTPRequest(request: try socket.readData()) |
| 107 | + } |
| 108 | + |
| 109 | + public func respond(with response: _HTTPResponse) throws { |
| 110 | + try socket.writeData(data: response.description) |
| 111 | + } |
| 112 | +} |
| 113 | + |
| 114 | +struct _HTTPRequest { |
| 115 | + enum Method : String { |
| 116 | + case GET |
| 117 | + case POST |
| 118 | + case PUT |
| 119 | + } |
| 120 | + let method: Method |
| 121 | + let uri: String |
| 122 | + let body: String |
| 123 | + let headers: [String] |
| 124 | + |
| 125 | + public init(request: String) { |
| 126 | + let lines = request.components(separatedBy: _HTTPUtils.CRLF2)[0].components(separatedBy: _HTTPUtils.CRLF) |
| 127 | + headers = Array(lines[0...lines.count-2]) |
| 128 | + method = Method(rawValue: headers[0].components(separatedBy: " ")[0])! |
| 129 | + uri = headers[0].components(separatedBy: " ")[1] |
| 130 | + body = lines.last! |
| 131 | + } |
| 132 | + |
| 133 | +} |
| 134 | + |
| 135 | +struct _HTTPResponse { |
| 136 | + enum Response : Int { |
| 137 | + case OK = 200 |
| 138 | + } |
| 139 | + private let responseCode: Response |
| 140 | + private let headers: String |
| 141 | + private let body: String |
| 142 | + |
| 143 | + public init(response: Response, headers: String = "", body: String) { |
| 144 | + self.responseCode = response |
| 145 | + self.headers = headers |
| 146 | + self.body = body |
| 147 | + } |
| 148 | + |
| 149 | + public var description: String { |
| 150 | + let statusLine = _HTTPUtils.VERSION + _HTTPUtils.SPACE + "\(responseCode.rawValue)" + _HTTPUtils.SPACE + "\(responseCode)" |
| 151 | + return statusLine + _HTTPUtils.CRLF2 + body |
| 152 | + } |
| 153 | +} |
| 154 | + |
| 155 | +public class TestURLSessionServer { |
| 156 | + let capitals: [String:String] = ["Nepal":"Kathmandu", "Peru":"Lima", "Italy":"Rome", "USA":"Washington, D.C."] |
| 157 | + let httpServer: _HTTPServer |
| 158 | + |
| 159 | + public init (port: UInt16) throws { |
| 160 | + httpServer = try _HTTPServer.create(port: port) |
| 161 | + } |
| 162 | + public func start(started: DispatchSemaphore) throws { |
| 163 | + started.signal() |
| 164 | + try httpServer.listen(notify: started) |
| 165 | + } |
| 166 | + |
| 167 | + public func readAndRespond() throws { |
| 168 | + try httpServer.respond(with: process(request: httpServer.request())) |
| 169 | + } |
| 170 | + |
| 171 | + func process(request: _HTTPRequest) -> _HTTPResponse { |
| 172 | + if request.method == .GET { |
| 173 | + return getResponse(uri: request.uri) |
| 174 | + } else { |
| 175 | + fatalError("Unsupported method!") |
| 176 | + } |
| 177 | + } |
| 178 | + |
| 179 | + func getResponse(uri: String) -> _HTTPResponse { |
| 180 | + return _HTTPResponse(response: .OK, body: capitals[String(uri.characters.dropFirst())]!) |
| 181 | + } |
| 182 | + |
| 183 | + func stop() { |
| 184 | + httpServer.stop() |
| 185 | + } |
| 186 | +} |
| 187 | + |
| 188 | +struct ServerError : Error { |
| 189 | + let operation: String |
| 190 | + let errno: CInt |
| 191 | + let file: String |
| 192 | + let line: UInt |
| 193 | + var _code: Int { return Int(errno) } |
| 194 | + var _domain: String { return NSPOSIXErrorDomain } |
| 195 | +} |
| 196 | + |
| 197 | + |
| 198 | +extension ServerError : CustomStringConvertible { |
| 199 | + var description: String { |
| 200 | + let s = String(validatingUTF8: strerror(errno)) ?? "" |
| 201 | + return "\(operation) failed: \(s) (\(_code))" |
| 202 | + } |
| 203 | +} |
0 commit comments