There are no results.

type pub inline Resolver

A type for performing DNS queries.

Backends

The Resolver type uses a different backend/implementation depending on the underlying platform. These are as follows:

Due to the blocking nature of getaddrinfo(), it's possible for a call to this function to block the OS thread for a long period of time. While such threads are marked as blocking and are replaced with a backup thread whenever necessary, the number of available threads is fixed and thus it's possible to exhaust all these threads by performing many slow DNS queries.

In contrast, the systemd-resolve backend is able to take advantage of Inko's non-blocking network IO and thus doesn't suffer from the same problem. For this reason it's highly recommended to ensure systemd-resolve is available when deploying to a Linux environment. If systemd-resolve isn't available, the Linux implementation falls back to using getaddrinfo().

When using the getaddrinfo() backend, the following ai_flags flags are set:

• AI_ADDRCONFIG
• AI_V4MAPPED

These flags are set to ensure consistent behaviour across platforms and libc implementations.

Deadlines

A Resolver supports setting a deadline using Resolver.timeout_after=. However, this timeout might be ignored based on the backend in use. Most notably, getaddrinfo() backends don't support timeouts/deadlines and instead use a system-wide timeout, ignoring any deadlines set using Resolver.timeout_after=.

Examples

Resolving a hostname and using it to connect a socket:

import std.net.dns (Resolver)
import std.net.socket (TcpClient)

let dns = Resolver.new
let ips = dns.resolve('example.com').or_panic('DNS lookup failed')

ips.try(fn (ip) { TcpClient.new(ip, port: 80) }).or_panic('failed to connect')

Static methods

fn pub static new -> Resolver {
  Resolver(sys.resolver)
}

fn pub static new -> Resolver

Instance methods

fn pub mut reset_deadline {
  @inner.reset_deadline
}

fn pub mut reset_deadline

fn pub mut resolve(host: String) -> Result[Array[IpAddress], Error] {
  @inner.resolve(host)
}

fn pub mut resolve(host: String) -> Result[Array[IpAddress], Error]

import std.net.dns (Resolver)
import std.net.socket (TcpClient)

let dns = Resolver.new
let ips = dns.resolve('example.com').or_panic('DNS lookup failed')

ips
  .try(fn (ip) { TcpClient.new(ip, port: 80) })
  .or_panic('failed to connect')

fn pub mut timeout_after=[T: ToInstant](deadline: ref T) {
  @inner.timeout_after = deadline
}

fn pub mut timeout_after=[T: ToInstant](deadline: ref T)