Getting Started

Adding the dependency

.package(url:"https://github.com/swift-server/async-http-client.git", from:"1.9.0")

.target(name:"MyApp", dependencies:[.product(name:"AsyncHTTPClient",package:"async-http-client")]),

Request-Response API

import AsyncHTTPClient/// MARK: - Using Swift Concurrencyletrequest=HTTPClientRequest(url:"https://apple.com/")letresponse=tryawaitHTTPClient.shared.execute(request, timeout:.seconds(30))print("HTTP head", response)if response.status==.ok{letbody=tryawait response.body.collect(upTo:1024*1024) // 1 MB    // handle body}else{    // handle remote error}/// MARK: - Using SwiftNIO EventLoopFutureHTTPClient.shared.get(url:"https://apple.com/").whenComplete{ resultinswitch result{case.failure(let error):        // process error    case.success(let response):if response.status==.ok{            // handle response}else{            // handle remote error}}}

async/await examples

Usage guide

Using Swift Concurrency

import AsyncHTTPClientdo{varrequest=HTTPClientRequest(url:"https://apple.com/")    request.method=.POST    request.headers.add(name:"User-Agent", value:"Swift HTTPClient")    request.body=.bytes(ByteBuffer(string:"some data"))letresponse=tryawaitHTTPClient.shared.execute(request, timeout:.seconds(30))if response.status==.ok{        // handle response}else{        // handle remote error}}catch{    // handle error}

Using SwiftNIO EventLoopFuture

import AsyncHTTPClientvarrequest=tryHTTPClient.Request(url:"https://apple.com/", method:.POST)request.headers.add(name:"User-Agent", value:"Swift HTTPClient")request.body=.string("some-body")HTTPClient.shared.execute(request: request).whenComplete{ resultinswitch result{case.failure(let error):        // process error    case.success(let response):if response.status==.ok{            // handle response}else{            // handle remote error}}}

Redirects following

lethttpClient=HTTPClient(eventLoopGroupProvider:.singleton,                            configuration:HTTPClient.Configuration(followRedirects:true))

Timeouts

lettimeout=HTTPClient.Configuration.Timeout(connect:.seconds(1), read:.seconds(1))lethttpClient=HTTPClient(eventLoopGroupProvider:.singleton,                            configuration:HTTPClient.Configuration(timeout: timeout))

httpClient.execute(request: request, deadline:.now()+.milliseconds(1))

Streaming

Using Swift Concurrency

do{letrequest=HTTPClientRequest(url:"https://apple.com/")letresponse=tryawaitHTTPClient.shared.execute(request, timeout:.seconds(30))print("HTTP head", response)    // if defined, the content-length headers announces the size of the bodyletexpectedBytes= response.headers.first(name:"content-length").flatMap(Int.init)varreceivedBytes=0    // asynchronously iterates over all body fragments    // this loop will automatically propagate backpressure correctlyfortryawaitbufferin response.body{        // for this example, we are just interested in the size of the fragment        receivedBytes+= buffer.readableBytesiflet expectedBytes= expectedBytes{            // if the body size is known, we calculate a progress indicatorletprogress=Double(receivedBytes)/ Double(expectedBytes)print("progress:\(Int(progress*100))%")}}print("did receive\(receivedBytes) bytes")}catch{print("request failed:", error)}

Using HTTPClientResponseDelegate and SwiftNIO EventLoopFuture

import NIOCoreimport NIOHTTP1classCountingDelegate:HTTPClientResponseDelegate{typealiasResponse=Intvarcount=0func didSendRequestHead(task:HTTPClient.Task<Response>, _ head:HTTPRequestHead){        // this is executed right after request head was sent, called once}func didSendRequestPart(task:HTTPClient.Task<Response>, _ part:IOData){        // this is executed when request body part is sent, could be called zero or more times}func didSendRequest(task:HTTPClient.Task<Response>){        // this is executed when request is fully sent, called once}func didReceiveHead(        task:HTTPClient.Task<Response>,        _ head:HTTPResponseHead)->EventLoopFuture<Void>{        // this is executed when we receive HTTP response head part of the request        // (it contains response code and headers), called once in case backpressure        // is needed, all reads will be paused until returned future is resolvedreturn task.eventLoop.makeSucceededFuture(())}func didReceiveBodyPart(        task:HTTPClient.Task<Response>,        _ buffer:ByteBuffer)->EventLoopFuture<Void>{        // this is executed when we receive parts of the response body, could be called zero or more times        count+= buffer.readableBytes        // in case backpressure is needed, all reads will be paused until returned future is resolvedreturn task.eventLoop.makeSucceededFuture(())}func didFinishRequest(task:HTTPClient.Task<Response>)throws->Int{        // this is called when the request is fully read, called once        // this is where you return a result or throw any errors you require to propagate to the clientreturn count}func didReceiveError(task:HTTPClient.Task<Response>, _ error:Error){        // this is called when we receive any network-related error, called once}}letrequest=tryHTTPClient.Request(url:"https://apple.com/")letdelegate=CountingDelegate()HTTPClient.shared.execute(request: request, delegate: delegate).futureResult.whenSuccess{ countinprint(count)}

File downloads

letrequest=tryHTTPClient.Request(    url:"https://swift.org/builds/development/ubuntu1804/latest-build.yml")letdelegate=tryFileDownloadDelegate(path:"/tmp/latest-build.yml", reportProgress:{iflet totalBytes= $0.totalBytes{print("Total bytes count:\(totalBytes)")}print("Downloaded\($0.receivedBytes) bytes so far")})HTTPClient.shared.execute(request: request, delegate: delegate).futureResult.whenSuccess{ progressiniflet totalBytes= progress.totalBytes{print("Final total bytes count:\(totalBytes)")}print("Downloaded finished with\(progress.receivedBytes) bytes downloaded")}

Unix Domain Socket Paths

HTTPClient.shared.execute(.GET,    socketPath:"/tmp/myServer.socket",    urlPath:"/path/to/resource").whenComplete(...)

HTTPClient.shared.execute(.POST,    secureSocketPath:"/tmp/myServer.socket",    urlPath:"/path/to/resource",    body:.string("hello")).whenComplete(...)

letsocketPathBasedURL=URL(    httpURLWithSocketPath:"/tmp/myServer.socket",    uri:"/path/to/resource")letsecureSocketPathBasedURL=URL(    httpsURLWithSocketPath:"/tmp/myServer.socket",    uri:"/path/to/resource")

Disabling HTTP/2

varconfiguration=HTTPClient.Configuration()configuration.httpVersion=.http1Onlyletclient=HTTPClient(    eventLoopGroupProvider:.singleton,    configuration: configuration)

Security

Supported Versions