Don't resolve any addresses

This makes working with systems like Kubernetes difficult. rqlite should
probably never have worked liked this. If IP addresses are still
perferred they can be passed in explicitly as command line arguments.

cluster/client.go

@@ -44,16 +44,10 @@ func NewClient(dl Dialer) *Client {
 // SetLocal informs the client instance of the node address for the node
 // using this client. Along with the Service instance it allows this
 // client to serve requests for this node locally without the network hop.
-// Because Raft resolves advertised addresses, this function must too.
 func (c *Client) SetLocal(nodeAddr string, serv *Service) error {
 	c.lMu.Lock()
 	defer c.lMu.Unlock()
-
-	adv, err := net.ResolveTCPAddr("tcp", nodeAddr)
-	if err != nil {
-		return fmt.Errorf("failed to resolve advertise address %s: %s", nodeAddr, err.Error())
-	}
-	c.localNodeAddr = adv.String()
+	c.localNodeAddr = nodeAddr
 	c.localServ = serv
 	return nil
 }

cluster/join.go

@@ -114,19 +114,13 @@ func (j *Joiner) Do(joinAddrs []string, id, addr string, voter bool) (string, er
 }
 
 func (j *Joiner) join(joinAddr, id, addr string, voter bool) (string, error) {
-	// Join using IP address, as that is what Hashicorp Raft works in.
-	resv, err := net.ResolveTCPAddr("tcp", addr)
-	if err != nil {
-		return "", err
-	}
-
 	// Check for protocol scheme, and insert default if necessary.
 	fullAddr := httpd.NormalizeAddr(fmt.Sprintf("%s/join", joinAddr))
 
 	for {
 		b, err := json.Marshal(map[string]interface{}{
 			"id":    id,
-			"addr":  resv.String(),
+			"addr":  addr,
 			"voter": voter,
 		})
 		if err != nil {

cluster/service_test.go

@@ -130,28 +130,6 @@ func Test_NewServiceSetGetNodeAPIAddrLocal(t *testing.T) {
 	if stats.Get(numGetNodeAPIRequestLocal).String() != "1" {
 		t.Fatalf("failed to confirm request served locally")
 	}
-
-	// Ensure it still works when hostname passed in.
-	_, port, err := net.SplitHostPort(s.Addr())
-	if err != nil {
-		t.Fatalf("failed to split host and port: %s", err)
-	}
-	if err := c.SetLocal(net.JoinHostPort("localhost", port), s); err != nil {
-		t.Fatalf("failed to set cluster client local parameters: %s", err)
-	}
-	addr, err = c.GetNodeAPIAddr(s.Addr(), 5*time.Second)
-	if err != nil {
-		t.Fatalf("failed to get node API address locally: %s", err)
-	}
-	if addr != "http://foo" {
-		t.Fatalf("failed to get correct node API address locally, exp %s, got %s", "http://foo", addr)
-	}
-
-	// Check stats to confirm local response.
-	if stats.Get(numGetNodeAPIRequestLocal).String() != "2" {
-		t.Fatalf("failed to confirm request served locally")
-	}
-
 }
 
 func Test_NewServiceSetGetNodeAPIAddrTLS(t *testing.T) {

cmd/rqlited/main.go

@@ -270,17 +270,12 @@ func startNodeMux(cfg *Config, ln net.Listener) (*tcp.Mux, error) {
 	var adv net.Addr
 	var err error
 
-	adv, err = net.ResolveTCPAddr("tcp", cfg.RaftAdv)
-	if err != nil {
-		return nil, fmt.Errorf("failed to resolve advertise address %s: %s", cfg.RaftAdv, err.Error())
-	}
-
 	var mux *tcp.Mux
 	if cfg.NodeEncrypt {
 		log.Printf("enabling node-to-node encryption with cert: %s, key: %s", cfg.NodeX509Cert, cfg.NodeX509Key)
 		mux, err = tcp.NewTLSMux(ln, adv, cfg.NodeX509Cert, cfg.NodeX509Key, cfg.NodeX509CACert)
 	} else {
-		mux, err = tcp.NewMux(ln, adv)
+		mux, err = tcp.NewMux(ln, tcp.NameAddress{cfg.RaftAdv})
 	}
 	if err != nil {
 		return nil, fmt.Errorf("failed to create node-to-node mux: %s", err.Error())
@@ -325,7 +320,7 @@ func createCluster(cfg *Config, tlsConfig *tls.Config, hasPeers bool, str *store
 	if joins == nil && cfg.DiscoMode == "" && !hasPeers {
 		// Brand new node, told to bootstrap itself. So do it.
 		log.Println("bootstraping single new node")
-		if err := str.Bootstrap(store.NewServer(str.ID(), str.Addr(), true)); err != nil {
+		if err := str.Bootstrap(store.NewServer(str.ID(), cfg.RaftAdv, true)); err != nil {
 			return fmt.Errorf("failed to bootstrap single new node: %s", err.Error())
 		}
 		return nil