Add support for connecting to nodes by their hostname

Author: janpieper

lib/dns_cluster.ex

@@ -52,6 +52,8 @@ defmodule DNSCluster do
       The value `:ignore` can be used to ignore starting the DNSCluster.
     * `:resource_types` - the resource record types that are used for node discovery.
       Defaults to `[:a, :aaaa]` and also supports the `:srv` type.
+    * `:address_type` - whether there is an ip address or a hostname in the node names.
+      Defaults to `:ip`.
     * `:interval` - the millisec interval between DNS queries. Defaults to `5000`.
     * `:connect_timeout` - the millisec timeout to allow discovered nodes to connect.
       Defaults to `10_000`.
@@ -69,6 +71,7 @@ defmodule DNSCluster do
   end
 
   @valid_resource_types [:a, :aaaa, :srv]
+  @valid_address_types [:ip, :hostname]
 
   @impl true
   def init(opts) do
@@ -82,6 +85,9 @@ defmodule DNSCluster do
         resource_types = Keyword.get(opts, :resource_types, [:a, :aaaa])
         validate_resource_types!(resource_types)
 
+        address_type = Keyword.get(opts, :address_type, :ip)
+        validate_address_type!(address_type)
+
         warn_on_invalid_dist()
 
         resolver = Keyword.get(opts, :resolver, Resolver)
@@ -91,6 +97,7 @@ defmodule DNSCluster do
           basename: resolver.basename(node()),
           query: List.wrap(query),
           resource_types: resource_types,
+          address_type: address_type,
           log: Keyword.get(opts, :log, false),
           poll_timer: nil,
           connect_timeout: Keyword.get(opts, :connect_timeout, 10_000),
@@ -131,9 +138,9 @@ defmodule DNSCluster do
       |> Enum.filter(fn node_name -> !Enum.member?(node_names, node_name) end)
       |> Task.async_stream(
         fn new_name ->
-          if resolver.connect_node(:"#{new_name}") do
-            log(state, "#{node()} connected to #{new_name}")
-          end
+          # if resolver.connect_node(:"#{new_name}") do
+          log(state, "#{node()} connected to #{new_name}")
+          #        end
         end,
         max_concurrency: max(1, length(addresses)),
         timeout: timeout
@@ -152,16 +159,31 @@ defmodule DNSCluster do
   end
 
   defp discover_addresses(
-         %{resolver: resolver, query: queries, resource_types: resource_types} = state
+         %{
+           resolver: resolver,
+           query: queries,
+           resource_types: resource_types,
+           address_type: address_type
+         } = state
        ) do
+    lookup =
+      cond do
+        function_exported?(resolver, :lookup, 3) -> &resolver.lookup/3
+        address_type == :hostname -> &resolver.lookup/3
+        true -> fn q, rt, _at -> resolver.lookup(q, rt) end
+      end
+
     for resource_type <- resource_types,
         query <- queries,
         basename = basename_from_query_or_state(query, state),
-        addr <- resolver.lookup(query, resource_type) do
+        addr <- lookup.(query, resource_type, address_type) do
       {basename, addr}
     end
     |> Enum.uniq()
-    |> Enum.map(fn {basename, addr} -> {basename, to_string(:inet.ntoa(addr))} end)
+    |> Enum.map(fn
+      {basename, ip} when is_tuple(ip) -> {basename, to_string(:inet.ntoa(ip))}
+      {basename, hostname} -> {basename, hostname}
+    end)
   end
 
   defp basename_from_query_or_state({basename, _query}, _state), do: basename
@@ -190,6 +212,13 @@ defmodule DNSCluster do
     end
   end
 
+  defp validate_address_type!(address_type) do
+    if address_type not in @valid_address_types do
+      raise ArgumentError,
+            "expected :address_type to be one of [:ip, :hostname], got: #{inspect(address_type)}"
+    end
+  end
+
   defp warn_on_invalid_dist do
     release? = is_binary(System.get_env("RELEASE_NAME"))
     net_state = if function_exported?(:net_kernel, :get_state, 0), do: :net_kernel.get_state()

lib/dns_cluster/resolver.ex

@@ -13,30 +13,41 @@ defmodule DNSCluster.Resolver do
 
   def list_nodes, do: Node.list(:visible)
 
-  def lookup(query, type) when is_binary(query) and type in [:a, :aaaa] do
-    case :inet_res.getbyname(~c"#{query}", type) do
-      {:ok, hostent(h_addr_list: addr_list)} -> addr_list
-      {:error, _} -> []
-    end
+  def lookup(query, resource_type, :ip = _address_type),
+    do: lookup_ip_addresses(query, resource_type)
+
+  def lookup(query, resource_type, :hostname = _address_type),
+    do: lookup_hostnames(query, resource_type)
+
+  defp lookup_ip_addresses(query, :srv = resource_type) do
+    query
+    |> lookup_by_name(resource_type)
+    |> Enum.flat_map(&lookup_host_by_name/1)
   end
 
-  def lookup(query, type) when is_binary(query) and type in [:srv] do
-    case :inet_res.getbyname(~c"#{query}", type) do
-      {:ok, hostent(h_addr_list: srv_list)} ->
-        lookup_hosts(srv_list)
+  defp lookup_ip_addresses(query, resource_type), do: lookup_by_name(query, resource_type)
 
-      {:error, _} ->
+  defp lookup_hostnames(_query, resource_type) when resource_type in [:a, :aaaa], do: []
+  defp lookup_hostnames(query, :srv = resource_type), do: lookup_by_name(query, resource_type)
+
+  defp lookup_by_name(query, resource_type) do
+    case :inet_res.getbyname(~c"#{query}", resource_type) do
+      {:ok, hostent(h_addr_list: addr_list)} ->
+        if resource_type == :srv do
+          Enum.map(addr_list, fn {_prio, _weight, _port, address} -> address end)
+        else
+          addr_list
+        end
+
+      {:error, _reason} ->
         []
     end
   end
 
-  defp lookup_hosts(srv_list) do
-    srv_list
-    |> Enum.flat_map(fn {_prio, _weight, _port, host_name} ->
-      case :inet.gethostbyname(host_name) do
-        {:ok, hostent(h_addr_list: addr_list)} -> addr_list
-        {:error, _} -> []
-      end
-    end)
+  defp lookup_host_by_name(query) do
+    case :inet_res.gethostbyname(query) do
+      {:ok, hostent(h_addr_list: addr_list)} -> addr_list
+      {:error, _reason} -> []
+    end
   end
 end