Add ability to specify DNS seeds

It's currently part of a separate config field to
cleanly separate between Agora nodes and DNS seeds.

It may later be merged into a common section if necessary.

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
+seed:
+  # Supported value: FQDN seed
+  - seed.bosagora.io
 
 ################################################################################
 ##                               Quorum slices                                ##

source/agora/common/Config.d

@@ -41,6 +41,9 @@ public void verifyConfigFile ( Config config )
     getAllValidators(config.quorums, all_validators);
     enforce(config.node.key_pair.address !in all_validators,
         format("Cannot have our own key as a validator node: %s", config.node.key_pair.address));
+
+    enforce(config.network.length > 0 || config.seed.length > 0,
+        "Config file must specify the seed IPs or seed nodes");
 }
 
 // extract the set of all validators as configured in the quorum config
@@ -79,6 +82,9 @@ public struct Config
     /// The list of IPs for use with network discovery
     public immutable Address[] network;
 
+    /// The list of FQDN seeds for use with network discovery
+    public immutable string[] seed;
+
     /// The quorum slice config
     public immutable QuorumConfig[] quorums;
 
@@ -172,20 +178,31 @@ public Config parseConfigFile (CommandLine cmdln)
 
     Node root = Loader.fromFile(cmdln.config_path).load();
 
-    enforce("network" in root && root["network"].isSequence,
-        "The 'network' section is mandatory and must specify at least one peer");
+    string[] parseSequence ( string name )
+    {
+        string[] result;
 
-    Address[] network;
-    foreach (string address; root["network"])
-        network ~= Address.fromString(address);
+        if (auto sequence = name in root)
+        {
+            enforce(sequence.isSequence, format("%s config section must be a sequence", name));
+            foreach (string address; *sequence)
+                result ~= address;
+        }
+
+        return result;
+    }
 
+    Address[] network = parseSequence("network")
+        .map!(a => Address.fromString(a)).array;
+    string[] seed = parseSequence("seed");
     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),
+        seed : assumeUnique(seed),
         quorums : assumeUnique(parseQuorumSection(root["quorum"]))
     };
 

source/agora/node/Network.d

@@ -90,6 +90,8 @@ class Network
     {
         logInfo("Discovering from %s", this.config.network);
         this.addAddresses(Set!Address.from(this.config.network));
+        logInfo("Resolving DNS from %s", this.config.seed);
+        this.addAddresses(resolveDnsSeeds(this.config.seed));
 
         while (!this.allQuorumNodesFound())
         {
@@ -241,3 +243,58 @@ class Network
             this.known_addresses);
     }
 }
+
+/*******************************************************************************
+
+    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[] seed )
+{
+    import std.conv;
+    import std.string;
+    import std.socket : getAddressInfo, AddressFamily, ProtocolType;
+
+    Set!Address resolved_ips;
+
+    foreach (host; seed)
+    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(Address.fromString(ip));
+        }
+    }
+    catch (Exception ex)
+    {
+        logError("Error: %s", ex);
+    }
+
+    return resolved_ips;
+}