dns: use getbyname

Author: isaacharrisholt

CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## v2.0.0 - 2024-12-07
+
+- Use the more permissive `inet_res:getbyname` function for DNS lookups.
+
+  - This uses the `search` option, which will allow things like `service.namespace`
+    to be used in Kubernetes, as opposed to `service.namespace.svc.cluster.local`.
+    Thanks to @tsoughter in #3.
+
+- Exposes the `barnacle/dns` and `barnacle/local_epmd` modules.
+  - Users can now use the functions in these modules to create custom strategies.
+
 ## v1.1.0 - 2024-10-25
 
 - Add `run_once` function for when polling is not needed.

README.md

@@ -159,13 +159,16 @@ Barnacle provides a helper function to get the basename of the current node.
 
 ```gleam
 import barnacle
+import gleam/option
 
 pub fn main() {
   let assert Ok(basename) = barnacle.get_node_basename(node.self())
   barnacle.dns(
     basename,
     // The hostname to query against
     "my_app.example.com",
+    // An optional timeout for the DNS lookup
+    option.Some(7500),
   )
   |> barnacle.start
 }

demo/Dockerfile

@@ -1,4 +1,4 @@
-FROM ghcr.io/gleam-lang/gleam:v1.5.1-erlang-alpine
+FROM ghcr.io/gleam-lang/gleam:v1.6.3-erlang-alpine
 
 COPY gleam.toml manifest.toml /build/
 

src/barnacle.gleam

@@ -1,5 +1,5 @@
-import barnacle/internal/dns
-import barnacle/internal/local_epmd
+import barnacle/dns
+import barnacle/local_epmd
 import gleam/erlang/atom
 import gleam/erlang/node
 import gleam/erlang/process.{type Subject}
@@ -198,13 +198,24 @@ pub fn epmd(nodes: List(atom.Atom)) -> Barnacle(Nil) {
 /// with the same basename.
 ///
 /// The second argument is the hostname to query against. Both A and AAAA records
-/// will be queried.
-pub fn dns(basename: String, hostname_query: String) -> Barnacle(Nil) {
+/// will be queried. The final argument is an optional timeout for the DNS
+/// lookup. This defaults to 5000ms if not supplied.
+pub fn dns(
+  basename: String,
+  hostname_query: String,
+  timeout: Option(Int),
+) -> Barnacle(dns.LookupError) {
   Barnacle(
     ..default_barnacle(),
     strategy: Strategy(
       ..default_strategy(),
-      discover_nodes: fn() { dns.discover_nodes(basename, hostname_query) },
+      discover_nodes: fn() {
+        dns.discover_nodes(
+          basename,
+          hostname_query,
+          option.unwrap(timeout, 5000),
+        )
+      },
     ),
   )
 }

src/barnacle/dns.gleam

@@ -0,0 +1,105 @@
+import gleam/erlang/atom
+import gleam/int
+import gleam/list
+import gleam/result
+import gleam/string
+
+/// A DNS error that can occur when discovering nodes.
+pub type LookupError {
+  FormatError
+  QueryFormatError
+  ServerFailure
+  NoSuchDomain
+  Timeout
+  NotImplemented
+  Refused
+  BadVersion
+  PosixError(String)
+  Unknown
+}
+
+@external(erlang, "barnacle_ffi", "lookup_a")
+fn lookup_a(
+  hostname: String,
+  timeout: Int,
+) -> Result(List(#(Int, Int, Int, Int)), LookupError)
+
+@external(erlang, "barnacle_ffi", "lookup_aaaa")
+fn lookup_aaaa(
+  hostname: String,
+  timeout: Int,
+) -> Result(List(#(Int, Int, Int, Int, Int, Int, Int, Int)), LookupError)
+
+pub type IpAddress {
+  IpV4(Int, Int, Int, Int)
+  IpV6(Int, Int, Int, Int, Int, Int, Int, Int)
+}
+
+/// Perform a DNS lookup against a hostname. This will return a list of IP
+/// addresses. Queries will be performed using the `A` and `AAAA` record types.
+pub fn dns_lookup(
+  hostname: String,
+  timeout: Int,
+) -> Result(List(IpAddress), LookupError) {
+  use a_records <- result.try(lookup_a(hostname, timeout))
+
+  let a_records =
+    a_records
+    |> list.map(fn(ip) {
+      let #(a, b, c, d) = ip
+      IpV4(a, b, c, d)
+    })
+
+  use aaaa_records <- result.try(lookup_aaaa(hostname, timeout))
+
+  let aaaa_records =
+    aaaa_records
+    |> list.map(fn(ip) {
+      let #(a, b, c, d, e, f, g, h) = ip
+      IpV6(a, b, c, d, e, f, g, h)
+    })
+
+  Ok(list.concat([a_records, aaaa_records]))
+}
+
+fn format_ip_address(ip: IpAddress) -> String {
+  case ip {
+    IpV4(a, b, c, d) -> {
+      [a, b, c, d]
+      |> list.map(int.to_string)
+      |> string.join(".")
+    }
+    IpV6(a, b, c, d, e, f, g, h) -> {
+      [a, b, c, d, e, f, g, h]
+      |> list.map(fn(value) {
+        case value {
+          0 -> ""
+          _ -> int.to_base16(value)
+        }
+      })
+      |> string.join(":")
+      |> string.lowercase
+    }
+  }
+}
+
+/// Discover nodes using DNS. The first argument is the basename of the nodes.
+/// Currently, Barnacle only supports connecting to nodes with the same basename.
+///
+/// The second argument is the hostname to query against. Both A and AAAA records
+/// will be queried. The final argument is an optional timeout for the DNS
+/// lookup. This defaults to 5000ms if not supplied.
+pub fn discover_nodes(
+  basename: String,
+  hostname_query: String,
+  timeout: Int,
+) -> Result(List(atom.Atom), LookupError) {
+  use ip_addresses <- result.try(dns_lookup(hostname_query, timeout))
+
+  ip_addresses
+  |> list.map(fn(ip) {
+    let ip_string = format_ip_address(ip)
+    { basename <> "@" <> ip_string } |> atom.create_from_string
+  })
+  |> Ok
+}

src/barnacle/internal/dns.gleam

@@ -17,6 +17,8 @@ fn get_hostname() -> String {
   hostname
 }
 
+/// Discover nodes using the local EPMD. This will discover nodes on the same
+/// hostname as the current node.
 pub fn discover_nodes() -> Result(List(atom.Atom), Nil) {
   let hostname = get_hostname()
   list_local_nodes()

src/barnacle/internal/local_epmd.gleam src/barnacle/local_epmd.gleamsrc/barnacle/internal/local_epmd.gleam renamed to src/barnacle/local_epmd.gleam

@@ -1,6 +1,8 @@
 -module(barnacle_ffi).
 
--export([list_local_nodes/0, disconnect_from_node/1, lookup_a/1, lookup_aaaa/1]).
+-export([list_local_nodes/0, disconnect_from_node/1, lookup_a/2, lookup_aaaa/2]).
+
+-include_lib("kernel/include/inet.hrl").
 
 disconnect_from_node(Node) ->
   case disconnect_node(Node) of
@@ -24,8 +26,48 @@ list_local_nodes() ->
 
 %% DNS functions
 
-lookup_a(Name) when is_binary(Name) ->
-  inet_res:lookup(binary_to_list(Name), in, a).
+lookup_a(Name, Timeout) when is_binary(Name) ->
+  lookup(Name, a, Timeout).
+
+lookup_aaaa(Name, Timeout) when is_binary(Name) ->
+  lookup(Name, aaaa, Timeout).
 
-lookup_aaaa(Name) when is_binary(Name) ->
-  inet_res:lookup(binary_to_list(Name), in, aaaa).
+%% Erlang's internal DNS function throw with some inputs like
+%% "ssssrtrssssssssstrtrtrtrdededuddmdidudmdidudmdidudmdidudmddfwddf.com"
+%% so we just catch the error and return an unknown error. I'm not sure
+%% what causes these.
+lookup(Name, Type, Timeout) when is_binary(Name) ->
+  try lookup_throws(Name, Type, Timeout) of
+    Result ->
+      Result
+  catch
+    _:_ ->
+      {error, unknown}
+  end.
+
+lookup_throws(Name, Type, Timeout) when is_binary(Name) ->
+  io:format("Name: ~p~n", [Name]),
+  case inet_res:getbyname(binary_to_list(Name), Type, Timeout) of
+    {ok, #hostent{h_addr_list = Addrs}} ->
+      {ok, Addrs};
+    {error, formerr} ->
+      {error, format_error};
+    {error, qfmterror} ->
+      {error, query_format_error};
+    {error, servfail} ->
+      {error, server_failure};
+    {error, nxdomain} ->
+      {error, no_such_domain};
+    {error, timeout} ->
+      {error, timeout};
+    {error, notimp} ->
+      {error, not_implemented};
+    {error, refused} ->
+      {error, refused};
+    {error, badvers} ->
+      {error, bad_version};
+    {error, PosixError} when is_atom(PosixError) ->
+      {error, {posix_error, atom_to_binary(PosixError, utf8)}};
+    _ ->
+      {error, unknown}
+  end.