Upgrading server dependancies (#6984)

vendor/github.com/hashicorp/go-sockaddr/route_info_linux.go

@@ -5,10 +5,6 @@ import (
 	"os/exec"
 )
 
-var cmds map[string][]string = map[string][]string{
-	"ip": {"/sbin/ip", "route"},
-}
-
 type routeInfo struct {
 	cmds map[string][]string
 }
@@ -16,15 +12,22 @@ type routeInfo struct {
 // NewRouteInfo returns a Linux-specific implementation of the RouteInfo
 // interface.
 func NewRouteInfo() (routeInfo, error) {
+	// CoreOS Container Linux moved ip to /usr/bin/ip, so look it up on
+	// $PATH and fallback to /sbin/ip on error.
+	path, _ := exec.LookPath("ip")
+	if path == "" {
+		path = "/sbin/ip"
+	}
+
 	return routeInfo{
-		cmds: cmds,
+		cmds: map[string][]string{"ip": {path, "route"}},
 	}, nil
 }
 
 // GetDefaultInterfaceName returns the interface name attached to the default
 // route on the default interface.
 func (ri routeInfo) GetDefaultInterfaceName() (string, error) {
-	out, err := exec.Command(cmds["ip"][0], cmds["ip"][1:]...).Output()
+	out, err := exec.Command(ri.cmds["ip"][0], ri.cmds["ip"][1:]...).Output()
 	if err != nil {
 		return "", err
 	}

vendor/github.com/hashicorp/go-sockaddr/sockaddr.go

@@ -1,6 +1,7 @@
 package sockaddr
 
 import (
+	"encoding/json"
 	"fmt"
 	"strings"
 )
@@ -176,3 +177,30 @@ func sockAddrInit() {
 func SockAddrAttrs() []AttrName {
 	return sockAddrAttrs
 }
+
+// Although this is pretty trivial to do in a program, having the logic here is
+// useful all around. Note that this marshals into a *string* -- the underlying
+// string representation of the sockaddr. If you then unmarshal into this type
+// in Go, all will work as expected, but externally you can take what comes out
+// and use the string value directly.
+type SockAddrMarshaler struct {
+	SockAddr
+}
+
+func (s *SockAddrMarshaler) MarshalJSON() ([]byte, error) {
+	return json.Marshal(s.SockAddr.String())
+}
+
+func (s *SockAddrMarshaler) UnmarshalJSON(in []byte) error {
+	var str string
+	err := json.Unmarshal(in, &str)
+	if err != nil {
+		return err
+	}
+	sa, err := NewSockAddr(str)
+	if err != nil {
+		return err
+	}
+	s.SockAddr = sa
+	return nil
+}

vendor/github.com/hashicorp/go-sockaddr/sockaddr_test.go

@@ -1,6 +1,7 @@
 package sockaddr_test
 
 import (
+	"encoding/json"
 	"fmt"
 	"testing"
 
@@ -371,3 +372,69 @@ func TestToFoo(t *testing.T) {
 	}
 
 }
+
+func TestSockAddrMarshaler(t *testing.T) {
+	addr := "192.168.10.24/24"
+	sa, err := sockaddr.NewSockAddr(addr)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sam := &sockaddr.SockAddrMarshaler{
+		SockAddr: sa,
+	}
+	marshaled, err := json.Marshal(sam)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sam2 := &sockaddr.SockAddrMarshaler{}
+	err = json.Unmarshal(marshaled, sam2)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if sam.SockAddr.String() != sam2.SockAddr.String() {
+		t.Fatalf("mismatch after marshaling: %s vs %s", sam.SockAddr.String(), sam2.SockAddr.String())
+	}
+	if sam2.SockAddr.String() != addr {
+		t.Fatalf("mismatch after marshaling: %s vs %s", addr, sam2.SockAddr.String())
+	}
+}
+
+func TestSockAddrMultiMarshaler(t *testing.T) {
+	addr := "192.168.10.24/24"
+	type d struct {
+		Addr  *sockaddr.SockAddrMarshaler
+		Addrs []*sockaddr.SockAddrMarshaler
+	}
+	sa, err := sockaddr.NewSockAddr(addr)
+	if err != nil {
+		t.Fatal(err)
+	}
+	myD := &d{
+		Addr: &sockaddr.SockAddrMarshaler{SockAddr: sa},
+		Addrs: []*sockaddr.SockAddrMarshaler{
+			&sockaddr.SockAddrMarshaler{SockAddr: sa},
+			&sockaddr.SockAddrMarshaler{SockAddr: sa},
+			&sockaddr.SockAddrMarshaler{SockAddr: sa},
+		},
+	}
+	marshaled, err := json.Marshal(myD)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var myD2 d
+	err = json.Unmarshal(marshaled, &myD2)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if myD.Addr.String() != myD2.Addr.String() {
+		t.Fatalf("mismatch after marshaling: %s vs %s", myD.Addr.String(), myD2.Addr.String())
+	}
+	if len(myD.Addrs) != len(myD2.Addrs) {
+		t.Fatalf("mismatch after marshaling: %d vs %d", len(myD.Addrs), len(myD2.Addrs))
+	}
+	for i, v := range myD.Addrs {
+		if v.String() != myD2.Addrs[i].String() {
+			t.Fatalf("mismatch after marshaling: %s vs %s", v.String(), myD2.Addrs[i].String())
+		}
+	}
+}