Add ability to provide DNS seeds

doc/config.example.yaml

@@ -57,6 +57,9 @@ network:
   # Supported value: IPv4, IPv6
   - http://192.168.1.42:2828
   - http://192.168.0.44:2828
+dns:
+  # Supported value: FQDN seed
+  - seed.bosagora.io
 
 ################################################################################
 ##                               Quorum slices                                ##

source/agora/common/Config.d

@@ -53,9 +53,12 @@ public struct Config
     /// The administrator interface config
     public AdminConfig admin;
 
-    /// The list of IPs / DNSes for use with network discovery
+    /// The list of IPs for use with network discovery
     public immutable string[] network;
 
+    /// The list of DNS FQDN seeds for use with network discovery
+    public immutable string[] dns_seeds;
+
     /// The quorum slice config
     public immutable QuorumConfig[] quorums;
 
@@ -193,23 +196,31 @@ private Config parseConfigFileImpl (CommandLine cmdln)
 
     Node root = Loader.fromFile(cmdln.config_path).load();
 
-    if (auto node = "network" in root)
-        enforce(root["network"].type == NodeType.sequence,
-                "`network` section must be a section");
-    else
-        throw new Exception("The 'network' section is mandatory and must specify at least one peer");
+    string[] parseSequence ( string section )
+    {
+        if (auto node = section in root)
+            enforce(root[section].type == NodeType.sequence,
+                format("`%s` section must be a sequence", section));
+        else
+            throw new Exception(
+                format("The '%s' section is mandatory and must " ~
+                    "specify at least one item", section));
 
-    string[] network;
-    foreach (string address; root["network"])
-        network ~= address;
+        string[] result;
+        foreach (string item; root[section])
+            result ~= item;
+
+        return result;
+    }
 
     enforce("node" in root, "The 'node' section is required");
     enforce("quorum" in root, "The 'quorum' section is required");
 
     Config conf =
     {
         node : parseNodeConfig(root["node"]),
-        network : assumeUnique(network),
+        network : assumeUnique(parseSequence("network")),
+        dns_seeds : assumeUnique(parseSequence("dns")),
         quorums : assumeUnique(parseQuorumSection(root["quorum"]))
     };
 

source/agora/node/Network.d

@@ -66,9 +66,12 @@ public class NetworkManager
     /// but never added again if they're already in known_addresses
     protected Set!Address todo_addresses;
 
+    /// DNS seeds
+    private const(string)[] dns_seeds;
+
 
     /// Ctor
-    public this (in NodeConfig node_config, in string[] peers)
+    public this (in NodeConfig node_config, in string[] peers, in string[] dns_seeds)
     in { assert(peers.length > 0, "No network option found"); }
     do {
         this.node_config = node_config;
@@ -78,12 +81,20 @@ public class NetworkManager
         // the node communicating with itself
         this.banned_addresses.put(
             format("http://%s:%s", this.node_config.address, this.node_config.port));
+
+        this.dns_seeds = dns_seeds;
     }
 
     /// try to discover the network until we found
     /// all the validator nodes from our quorum set.
     public void discover ()
     {
+        if (this.dns_seeds.length > 0)
+        {
+            logInfo("Resolving DNS from %s", this.dns_seeds);
+            this.addAddresses(resolveDNSSeeds(this.dns_seeds));
+        }
+
         logInfo("Discovering from %s", this.todo_addresses.byKey());
 
         while (!this.allPeersConnected())
@@ -242,3 +253,58 @@ public class NetworkManager
 
 // check up to 10 addresses at once
 private immutable MaxConnectingAddresses = 10;
+
+/*******************************************************************************
+
+    Resolves IPs out of a list of DNS seeds
+
+    Params:
+        addresses = the set of DNS seeds
+
+    Returns:
+        The resolved set of IPs
+
+*******************************************************************************/
+
+private Set!Address resolveDNSSeeds (in string[] dns_seeds)
+{
+    import std.conv;
+    import std.string;
+    import std.socket : getAddressInfo, AddressFamily, ProtocolType;
+
+    Set!Address resolved_ips;
+
+    foreach (host; dns_seeds)
+    try
+    {
+        logInfo("DNS: contacting seed '%s'..", host);
+        foreach (addr_info; getAddressInfo(host))
+        {
+            logTrace("DNS: checking address %s", addr_info);
+            if (addr_info.family != AddressFamily.INET &&
+                addr_info.family != AddressFamily.INET6)
+            {
+                logTrace("DNS: rejected non-IP family %s", addr_info.family);
+                continue;
+            }
+
+            // we only support TCP for now
+            if (addr_info.protocol != ProtocolType.TCP)
+            {
+                logTrace("DNS: rejected non-TCP node %s", addr_info);
+                continue;
+            }
+
+            // if the port is set to zero, assume default Boa port
+            auto ip = addr_info.address.to!string.replace(":0", ":2826");
+            logInfo("DNS: accepted IP %s", ip);
+            resolved_ips.put(ip);
+        }
+    }
+    catch (Exception ex)
+    {
+        logError("Error contacting DNS seed: %s", ex.message);
+    }
+
+    return resolved_ips;
+}

source/agora/node/Node.d

@@ -52,7 +52,7 @@ public class Node (Network) : API
     public this (const Config config)
     {
         this.config = config;
-        this.network = new Network(config.node, config.network);
+        this.network = new Network(config.node, config.network, config.dns_seeds);
         this.exception = new RestException(
             400, Json("The query was incorrect"), string.init, int.init);
     }

source/agora/test/Base.d

@@ -59,9 +59,9 @@ public class TestNetworkManager : NetworkManager
     public TestAPI[PublicKey] apis;
 
     /// Ctor
-    public this (NodeConfig config, in string[] peers)
+    public this (NodeConfig config, in string[] peers, in string[] dns_seeds)
     {
-        super(config, peers);
+        super(config, peers, dns_seeds);
         // NetworkManager assumes IP are used but we use pubkey
         this.banned_addresses.put(config.key_pair.address.toString());
     }
@@ -262,7 +262,7 @@ public NetworkT makeTestNetwork (NetworkT : TestNetworkManager)
 
 
         auto net = new NetworkT(NodeConfig.init, node_configs.map!(
-            c => c.key_pair.address.toString()).array);
+            c => c.key_pair.address.toString()).array, null);
 
         // Workaround https://issues.dlang.org/show_bug.cgi?id=20002
         TestNetworkManager base_net = net;