DNS support for static nodes and discovery

cmd/bootnode/main.go

@@ -129,7 +129,7 @@ func main() {
 			PrivateKey:  nodeKey,
 			NetRestrict: restrictList,
 		}
-		if _, err := discover.ListenUDP(conn, ln, cfg); err != nil {
+		if _, err := discover.ListenUDPQuorum(conn, ln, cfg); err != nil {
 			utils.Fatalf("%v", err)
 		}
 	}

cmd/geth/config.go

@@ -217,6 +217,7 @@ func RegisterRaftService(stack *node.Node, ctx *cli.Context, cfg gethConfig, eth
 	blockTimeMillis := ctx.GlobalInt(utils.RaftBlockTimeFlag.Name)
 	datadir := ctx.GlobalString(utils.DataDirFlag.Name)
 	joinExistingId := ctx.GlobalInt(utils.RaftJoinExistingFlag.Name)
+	useDns := ctx.GlobalBool(utils.RaftDNSEnabledFlag.Name)
 
 	raftPort := uint16(ctx.GlobalInt(utils.RaftPortFlag.Name))
 
@@ -255,7 +256,7 @@ func RegisterRaftService(stack *node.Node, ctx *cli.Context, cfg gethConfig, eth
 		}
 
 		ethereum := <-ethChan
-		return raft.New(ctx, ethereum.ChainConfig(), myId, raftPort, joinExisting, blockTimeNanos, ethereum, peers, datadir)
+		return raft.New(ctx, ethereum.ChainConfig(), myId, raftPort, joinExisting, blockTimeNanos, ethereum, peers, datadir, useDns)
 	}); err != nil {
 		utils.Fatalf("Failed to register the Raft service: %v", err)
 	}

cmd/geth/main.go

@@ -135,14 +135,18 @@ var (
 		utils.EWASMInterpreterFlag,
 		utils.EVMInterpreterFlag,
 		configFileFlag,
+		// Quorum
 		utils.EnableNodePermissionFlag,
+		utils.HostnameFlag,
 		utils.RaftModeFlag,
 		utils.RaftBlockTimeFlag,
 		utils.RaftJoinExistingFlag,
 		utils.RaftPortFlag,
+		utils.RaftDNSEnabledFlag,
 		utils.EmitCheckpointsFlag,
 		utils.IstanbulRequestTimeoutFlag,
 		utils.IstanbulBlockPeriodFlag,
+		// End-Quorum
 	}
 
 	rpcFlags = []cli.Flag{

cmd/geth/usage.go

@@ -152,6 +152,7 @@ var AppHelpFlagGroups = []flagGroup{
 		Name: "QUORUM",
 		Flags: []cli.Flag{
 			utils.EnableNodePermissionFlag,
+			utils.HostnameFlag,
 		},
 	},
 	{
@@ -161,6 +162,7 @@ var AppHelpFlagGroups = []flagGroup{
 			utils.RaftBlockTimeFlag,
 			utils.RaftJoinExistingFlag,
 			utils.RaftPortFlag,
+			utils.RaftDNSEnabledFlag,
 		},
 	},
 	{

cmd/utils/flags.go

@@ -533,6 +533,13 @@ var (
 		Name:  "nodiscover",
 		Usage: "Disables the peer discovery mechanism (manual peer addition)",
 	}
+	// Quorum
+	HostnameFlag = cli.StringFlag{
+		Name:  "hostname",
+		Usage: "Sets the hostname to use for p2p",
+		Value: "",
+	}
+	// End-Quorum
 	DiscoveryV5Flag = cli.BoolFlag{
 		Name:  "v5disc",
 		Usage: "Enables the experimental RLPx V5 (Topic Discovery) mechanism",
@@ -603,6 +610,10 @@ var (
 		Usage: "The port to bind for the raft transport",
 		Value: 50400,
 	}
+	RaftDNSEnabledFlag = cli.BoolFlag{
+		Name: "raftdnsenable",
+		Usage: "Enable DNS resolution of peers",
+	}
 
 	// Quorum
 	EnableNodePermissionFlag = cli.BoolFlag{
@@ -987,6 +998,9 @@ func SetP2PConfig(ctx *cli.Context, cfg *p2p.Config) {
 	if ctx.GlobalIsSet(NoDiscoverFlag.Name) || lightClient {
 		cfg.NoDiscovery = true
 	}
+	if ctx.GlobalIsSet(HostnameFlag.Name) {
+		cfg.Hostname = ctx.GlobalString(HostnameFlag.Name)
+	}
 
 	// if we're running a light client or server, force enable the v5 peer discovery
 	// unless it is explicitly disabled with --nodiscover note that explicitly specifying

docs/Features/dns.md

@@ -0,0 +1,32 @@
+# DNS for Quorum
+
+DNS support in Quorum has two distinct areas, usage in the static nodes file and usage in the 
+node discovery protocol. You are free to use one and not the other, or to mix them as the use case
+requires.
+
+## Static nodes
+
+Static nodes are nodes we keep reference to even if the node is not alive, so that is the nodes comes alive, 
+then we can connect to it. Using DNS names in the static node definitions means that if the node is offline and
+it's IP changes, we will still be able to connect to it when it comes back online, unlike Ethereum. 
+
+## Discovery
+
+If using the DiscoveryV4 protocol with DNS resolution, then you will need to provide the hostname that you wish
+for others to see to use to connect to you. This is achieved with the `--hostname <hostname>` flag. If this 
+flag is set to something that does not resolve to your IP address, then other peers will try to connect to
+the wrong address and fail, so it is important that this value is correct.
+If you provide a value that does not resolve to any IP address, the node will fail to start up and emit an error
+notifying the node operator of such; but it cannot protect against valid but incorrect hostname being provided.
+
+Note: the hostname of connected peers can be seen in the `admin.peers` list, but only for outgoing connections. For 
+incoming connections, we don't know the hostname (if there even is one), so it will still display the remote IP address.
+
+## Compatibility
+For Raft, the whole network must be on version 2.3.1 of Quorum for DNS to function properly; because of this, DNS must 
+be explicitly enabled using the `--raftdnsenable` flag. 
+The network will support older nodes mixed with newer nodes if DNS is not enabled via this flag, and it is safe to 
+enable DNS only on some nodes if all nodes are on at least version 2.3.1. This allows for a clear upgrade path.
+
+For IBFT and Clique, nodes are compatible with all versions of Quorum (insofar as DNS), which means that DNS can 
+(and is) always enabled. Note that if performing discovery, older nodes will only propagate the IP address.

mkdocs.yml

@@ -75,7 +75,9 @@ nav:
         - Overview: Cakeshop/Overview.md
         - Getting Started: Cakeshop/Getting started.md
         - Cakeshop FAQ: Cakeshop/Cakeshop FAQ.md
-    - Product Roadmap: roadmap.md         
+    - Quorum Features:
+        - DNS: Features/dns.md
+    - Product Roadmap: roadmap.md
     - FAQ: FAQ.md
 
 theme:

p2p/dial.go

@@ -356,7 +356,7 @@ func (t *dialTask) dial(srv *Server, dest *enode.Node) error {
 
 func (t *dialTask) String() string {
 	id := t.dest.ID()
-	return fmt.Sprintf("%v %x %v:%d", t.flags, id[:8], t.dest.IP(), t.dest.TCP())
+	return fmt.Sprintf("%v %x %v:%d", t.flags, id[:8], t.dest.Host(), t.dest.TCP())
 }
 
 func (t *discoverTask) Do(srv *Server) {

p2p/discover/udp.go

@@ -268,6 +268,39 @@ func newUDP(c conn, ln *enode.LocalNode, cfg Config) (*Table, *udp, error) {
 	return udp.tab, udp, nil
 }
 
+// Quorum
+
+// ListenUDPExisting uses an existing table that listens for UDP packets on the connection.
+func ListenUDPExisting(c conn, ln *enode.LocalNode, cfg Config, tab *Table) (*Table, error) {
+	tab, _, err := newUDPExisting(c, ln, cfg, tab)
+	if err != nil {
+		return nil, err
+	}
+	return tab, nil
+}
+
+func newUDPExisting(c conn, ln *enode.LocalNode, cfg Config, tab *Table) (*Table, *udp, error) {
+	udp := &udp{
+		conn:        c,
+		priv:        cfg.PrivateKey,
+		netrestrict: cfg.NetRestrict,
+		localNode:   ln,
+		db:          ln.Database(),
+		closing:     make(chan struct{}),
+		gotreply:    make(chan reply),
+		addpending:  make(chan *pending),
+	}
+
+	udp.tab = tab
+
+	udp.wg.Add(2)
+	go udp.loop()
+	go udp.readLoop(cfg.Unhandled)
+	return udp.tab, udp, nil
+}
+
+// End-Quorum
+
 func (t *udp) self() *enode.Node {
 	return t.localNode.Node()
 }