This module implements a simple HTTP client that can be used to retrieve webpages and other data.

Retrieving a website

This example uses HTTP GET to retrieve http://google.com:

import httpClient
var client = newHttpClient()
echo client.getContent("http://google.com")

The same action can also be performed asynchronously, simply use the AsyncHttpClient:

import httpClient
var client = newAsyncHttpClient()
echo await client.getContent("http://google.com")

The functionality implemented by HttpClient and AsyncHttpClient is the same, so you can use whichever one suits you best in the examples shown here.

Note: You will need to run asynchronous examples in an async proc otherwise you will get an Undeclared identifier: 'await' error.

Using HTTP POST

This example demonstrates the usage of the W3 HTML Validator, it uses multipart/form-data as the Content-Type to send the HTML to be validated to the server.

var client = newHttpClient()
var data = newMultipartData()
data["output"] = "soap12"
data["uploaded_file"] = ("test.html", "text/html",
  "<html><head></head><body><p>test</p></body></html>")

echo client.postContent("http://validator.w3.org/check", multipart=data)

You can also make post requests with custom headers. This example sets Content-Type to application/json and uses a json object for the body

import httpclient, json

let client = newHttpClient()
client.headers = newHttpHeaders({ "Content-Type": "application/json" })
let body = %*{
    "data": "some text"
}
let response = client.request("http://some.api", httpMethod = HttpPost, body = $body)
echo response.status

Progress reporting

You may specify a callback procedure to be called during an HTTP request. This callback will be executed every second with information about the progress of the HTTP request.

import asyncdispatch, httpclient

proc onProgressChanged(total, progress, speed: BiggestInt) {.async.} =
  echo("Downloaded ", progress, " of ", total)
  echo("Current rate: ", speed div 1000, "kb/s")

proc asyncProc() {.async.} =
  var client = newAsyncHttpClient()
  client.onProgressChanged = onProgressChanged
  discard await client.getContent("http://speedtest-ams2.digitalocean.com/100mb.test")

waitFor asyncProc()

If you would like to remove the callback simply set it to nil.

client.onProgressChanged = nil

Warning: The total reported by httpclient may be 0 in some cases.

SSL/TLS support

This requires the OpenSSL library, fortunately it's widely used and installed on many operating systems. httpclient will use SSL automatically if you give any of the functions a url with the https schema, for example: https://github.com/.

You will also have to compile with ssl defined like so: nim c -d:ssl ....

Timeouts

Currently only the synchronous functions support a timeout. The timeout is measured in milliseconds, once it is set any call on a socket which may block will be susceptible to this timeout.

It may be surprising but the function as a whole can take longer than the specified timeout, only individual internal calls on the socket are affected. In practice this means that as long as the server is sending data an exception will not be raised, if however data does not reach the client within the specified timeout a TimeoutError exception will be raised.

Here is how to set a timeout when creating an HttpClient instance:

import httpclient

let client = newHttpClient(timeout = 42)

Proxy

A proxy can be specified as a param to any of the procedures defined in this module. To do this, use the newProxy constructor. Unfortunately, only basic authentication is supported at the moment.

Some examples on how to configure a Proxy for HttpClient:

import httpclient

let myProxy = newProxy("http://myproxy.network")
let client = newHttpClient(proxy = myProxy)

Get Proxy URL from environment variables:

import httpclient

var url = ""
try:
  if existsEnv("http_proxy"):
    url = getEnv("http_proxy")
  elif existsEnv("https_proxy"):
    url = getEnv("https_proxy")
except ValueError:
  echo "Unable to parse proxy from environment variables."

let myProxy = newProxy(url = url)
let client = newHttpClient(proxy = myProxy)

Redirects

The maximum redirects can be set with the maxRedirects of int type, it specifies the maximum amount of redirects to follow, it defaults to 5, you can set it to 0 to disable redirects.

Here you can see an example about how to set the maxRedirects of HttpClient:

import httpclient

let client = newHttpClient(maxRedirects = 0)

Imports

net, strutils, uri, parseutils, base64, os, mimetypes, math, random, httpcore, times, tables, streams, monotimes, asyncnet, asyncdispatch, asyncfile, nativesockets

Types

Response = ref object version*: string status*: string headers*: HttpHeaders body: string bodyStream*: Stream: Source Edit
AsyncResponse = ref object version*: string status*: string headers*: HttpHeaders body: string bodyStream*: FutureStream[string]: Source Edit
Proxy = ref object url*: Uri auth*: string: Source Edit
MultipartEntries = openArray[tuple[name, content: string]]: Source Edit
MultipartData = ref object content: seq[string]: Source Edit
ProtocolError = object of IOError: exception that is raised when server does not conform to the implemented protocol Source Edit
HttpRequestError = object of IOError: Thrown in the getContent proc and postContent proc, when the server returns an error Source Edit
ProgressChangedProc[ReturnType] = proc (total, progress, speed: BiggestInt): ReturnType {...}{. closure, gcsafe.}: Source Edit
HttpClientBase[SocketType] = ref object socket: SocketType connected: bool currentURL: Uri ## Where we are currently connected. headers*: HttpHeaders ## Headers to send in requests. maxRedirects: int userAgent: string timeout*: int ## Only used for blocking HttpClient for now. proxy: Proxy ## ``nil`` or the callback to call when request progress changes. when SocketType is Socket: onProgressChanged else: onProgressChanged when false: sslContext contentTotal: BiggestInt contentProgress: BiggestInt oneSecondProgress: BiggestInt lastProgressReport: MonoTime when SocketType is AsyncSocket: bodyStream parseBodyFut else: bodyStream getBody: bool ## When `false`, the body is never read in requestAux.: Source Edit
HttpClient = HttpClientBase[Socket]: Source Edit
AsyncHttpClient = HttpClientBase[AsyncSocket]: Source Edit

Consts

defUserAgent = "Nim httpclient/1.0.0": Source Edit

Procs

proc code(response: Response | AsyncResponse): HttpCode {...}{. raises: [ValueError, OverflowError].}

Retrieves the specified response's HttpCode.

Raises a ValueError if the response's status does not have a corresponding HttpCode.