update vendor

Signed-off-by: Jess Frazelle <acidburn@microsoft.com>

vendor/google.golang.org/grpc/naming/dns_resolver.go

@@ -0,0 +1,290 @@
+/*
+ *
+ * Copyright 2017 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package naming
+
+import (
+	"errors"
+	"fmt"
+	"net"
+	"strconv"
+	"time"
+
+	"golang.org/x/net/context"
+	"google.golang.org/grpc/grpclog"
+)
+
+const (
+	defaultPort = "443"
+	defaultFreq = time.Minute * 30
+)
+
+var (
+	errMissingAddr  = errors.New("missing address")
+	errWatcherClose = errors.New("watcher has been closed")
+)
+
+// NewDNSResolverWithFreq creates a DNS Resolver that can resolve DNS names, and
+// create watchers that poll the DNS server using the frequency set by freq.
+func NewDNSResolverWithFreq(freq time.Duration) (Resolver, error) {
+	return &dnsResolver{freq: freq}, nil
+}
+
+// NewDNSResolver creates a DNS Resolver that can resolve DNS names, and create
+// watchers that poll the DNS server using the default frequency defined by defaultFreq.
+func NewDNSResolver() (Resolver, error) {
+	return NewDNSResolverWithFreq(defaultFreq)
+}
+
+// dnsResolver handles name resolution for names following the DNS scheme
+type dnsResolver struct {
+	// frequency of polling the DNS server that the watchers created by this resolver will use.
+	freq time.Duration
+}
+
+// formatIP returns ok = false if addr is not a valid textual representation of an IP address.
+// If addr is an IPv4 address, return the addr and ok = true.
+// If addr is an IPv6 address, return the addr enclosed in square brackets and ok = true.
+func formatIP(addr string) (addrIP string, ok bool) {
+	ip := net.ParseIP(addr)
+	if ip == nil {
+		return "", false
+	}
+	if ip.To4() != nil {
+		return addr, true
+	}
+	return "[" + addr + "]", true
+}
+
+// parseTarget takes the user input target string, returns formatted host and port info.
+// If target doesn't specify a port, set the port to be the defaultPort.
+// If target is in IPv6 format and host-name is enclosed in sqarue brackets, brackets
+// are strippd when setting the host.
+// examples:
+// target: "www.google.com" returns host: "www.google.com", port: "443"
+// target: "ipv4-host:80" returns host: "ipv4-host", port: "80"
+// target: "[ipv6-host]" returns host: "ipv6-host", port: "443"
+// target: ":80" returns host: "localhost", port: "80"
+// target: ":" returns host: "localhost", port: "443"
+func parseTarget(target string) (host, port string, err error) {
+	if target == "" {
+		return "", "", errMissingAddr
+	}
+
+	if ip := net.ParseIP(target); ip != nil {
+		// target is an IPv4 or IPv6(without brackets) address
+		return target, defaultPort, nil
+	}
+	if host, port, err := net.SplitHostPort(target); err == nil {
+		// target has port, i.e ipv4-host:port, [ipv6-host]:port, host-name:port
+		if host == "" {
+			// Keep consistent with net.Dial(): If the host is empty, as in ":80", the local system is assumed.
+			host = "localhost"
+		}
+		if port == "" {
+			// If the port field is empty(target ends with colon), e.g. "[::1]:", defaultPort is used.
+			port = defaultPort
+		}
+		return host, port, nil
+	}
+	if host, port, err := net.SplitHostPort(target + ":" + defaultPort); err == nil {
+		// target doesn't have port
+		return host, port, nil
+	}
+	return "", "", fmt.Errorf("invalid target address %v", target)
+}
+
+// Resolve creates a watcher that watches the name resolution of the target.
+func (r *dnsResolver) Resolve(target string) (Watcher, error) {
+	host, port, err := parseTarget(target)
+	if err != nil {
+		return nil, err
+	}
+
+	if net.ParseIP(host) != nil {
+		ipWatcher := &ipWatcher{
+			updateChan: make(chan *Update, 1),
+		}
+		host, _ = formatIP(host)
+		ipWatcher.updateChan <- &Update{Op: Add, Addr: host + ":" + port}
+		return ipWatcher, nil
+	}
+
+	ctx, cancel := context.WithCancel(context.Background())
+	return &dnsWatcher{
+		r:      r,
+		host:   host,
+		port:   port,
+		ctx:    ctx,
+		cancel: cancel,
+		t:      time.NewTimer(0),
+	}, nil
+}
+
+// dnsWatcher watches for the name resolution update for a specific target
+type dnsWatcher struct {
+	r    *dnsResolver
+	host string
+	port string
+	// The latest resolved address set
+	curAddrs map[string]*Update
+	ctx      context.Context
+	cancel   context.CancelFunc
+	t        *time.Timer
+}
+
+// ipWatcher watches for the name resolution update for an IP address.
+type ipWatcher struct {
+	updateChan chan *Update
+}
+
+// Next returns the address resolution Update for the target. For IP address,
+// the resolution is itself, thus polling name server is unnecessary. Therefore,
+// Next() will return an Update the first time it is called, and will be blocked
+// for all following calls as no Update exists until watcher is closed.
+func (i *ipWatcher) Next() ([]*Update, error) {
+	u, ok := <-i.updateChan
+	if !ok {
+		return nil, errWatcherClose
+	}
+	return []*Update{u}, nil
+}
+
+// Close closes the ipWatcher.
+func (i *ipWatcher) Close() {
+	close(i.updateChan)
+}
+
+// AddressType indicates the address type returned by name resolution.
+type AddressType uint8
+
+const (
+	// Backend indicates the server is a backend server.
+	Backend AddressType = iota
+	// GRPCLB indicates the server is a grpclb load balancer.
+	GRPCLB
+)
+
+// AddrMetadataGRPCLB contains the information the name resolver for grpclb should provide. The
+// name resolver used by the grpclb balancer is required to provide this type of metadata in
+// its address updates.
+type AddrMetadataGRPCLB struct {
+	// AddrType is the type of server (grpc load balancer or backend).
+	AddrType AddressType
+	// ServerName is the name of the grpc load balancer. Used for authentication.
+	ServerName string
+}
+
+// compileUpdate compares the old resolved addresses and newly resolved addresses,
+// and generates an update list
+func (w *dnsWatcher) compileUpdate(newAddrs map[string]*Update) []*Update {
+	var res []*Update
+	for a, u := range w.curAddrs {
+		if _, ok := newAddrs[a]; !ok {
+			u.Op = Delete
+			res = append(res, u)
+		}
+	}
+	for a, u := range newAddrs {
+		if _, ok := w.curAddrs[a]; !ok {
+			res = append(res, u)
+		}
+	}
+	return res
+}
+
+func (w *dnsWatcher) lookupSRV() map[string]*Update {
+	newAddrs := make(map[string]*Update)
+	_, srvs, err := lookupSRV(w.ctx, "grpclb", "tcp", w.host)
+	if err != nil {
+		grpclog.Infof("grpc: failed dns SRV record lookup due to %v.\n", err)
+		return nil
+	}
+	for _, s := range srvs {
+		lbAddrs, err := lookupHost(w.ctx, s.Target)
+		if err != nil {
+			grpclog.Warningf("grpc: failed load banlacer address dns lookup due to %v.\n", err)
+			continue
+		}
+		for _, a := range lbAddrs {
+			a, ok := formatIP(a)
+			if !ok {
+				grpclog.Errorf("grpc: failed IP parsing due to %v.\n", err)
+				continue
+			}
+			addr := a + ":" + strconv.Itoa(int(s.Port))
+			newAddrs[addr] = &Update{Addr: addr,
+				Metadata: AddrMetadataGRPCLB{AddrType: GRPCLB, ServerName: s.Target}}
+		}
+	}
+	return newAddrs
+}
+
+func (w *dnsWatcher) lookupHost() map[string]*Update {
+	newAddrs := make(map[string]*Update)
+	addrs, err := lookupHost(w.ctx, w.host)
+	if err != nil {
+		grpclog.Warningf("grpc: failed dns A record lookup due to %v.\n", err)
+		return nil
+	}
+	for _, a := range addrs {
+		a, ok := formatIP(a)
+		if !ok {
+			grpclog.Errorf("grpc: failed IP parsing due to %v.\n", err)
+			continue
+		}
+		addr := a + ":" + w.port
+		newAddrs[addr] = &Update{Addr: addr}
+	}
+	return newAddrs
+}
+
+func (w *dnsWatcher) lookup() []*Update {
+	newAddrs := w.lookupSRV()
+	if newAddrs == nil {
+		// If failed to get any balancer address (either no corresponding SRV for the
+		// target, or caused by failure during resolution/parsing of the balancer target),
+		// return any A record info available.
+		newAddrs = w.lookupHost()
+	}
+	result := w.compileUpdate(newAddrs)
+	w.curAddrs = newAddrs
+	return result
+}
+
+// Next returns the resolved address update(delta) for the target. If there's no
+// change, it will sleep for 30 mins and try to resolve again after that.
+func (w *dnsWatcher) Next() ([]*Update, error) {
+	for {
+		select {
+		case <-w.ctx.Done():
+			return nil, errWatcherClose
+		case <-w.t.C:
+		}
+		result := w.lookup()
+		// Next lookup should happen after an interval defined by w.r.freq.
+		w.t.Reset(w.r.freq)
+		if len(result) > 0 {
+			return result, nil
+		}
+	}
+}
+
+func (w *dnsWatcher) Close() {
+	w.cancel()
+}

vendor/google.golang.org/grpc/naming/dns_resolver_test.go

@@ -0,0 +1,315 @@
+/*
+ *
+ * Copyright 2017 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package naming
+
+import (
+	"fmt"
+	"net"
+	"reflect"
+	"sync"
+	"testing"
+	"time"
+)
+
+func newUpdateWithMD(op Operation, addr, lb string) *Update {
+	return &Update{
+		Op:       op,
+		Addr:     addr,
+		Metadata: AddrMetadataGRPCLB{AddrType: GRPCLB, ServerName: lb},
+	}
+}
+
+func toMap(u []*Update) map[string]*Update {
+	m := make(map[string]*Update)
+	for _, v := range u {
+		m[v.Addr] = v
+	}
+	return m
+}
+
+func TestCompileUpdate(t *testing.T) {
+	tests := []struct {
+		oldAddrs []string
+		newAddrs []string
+		want     []*Update
+	}{
+		{
+			[]string{},
+			[]string{"1.0.0.1"},
+			[]*Update{{Op: Add, Addr: "1.0.0.1"}},
+		},
+		{
+			[]string{"1.0.0.1"},
+			[]string{"1.0.0.1"},
+			[]*Update{},
+		},
+		{
+			[]string{"1.0.0.0"},
+			[]string{"1.0.0.1"},
+			[]*Update{{Op: Delete, Addr: "1.0.0.0"}, {Op: Add, Addr: "1.0.0.1"}},
+		},
+		{
+			[]string{"1.0.0.1"},
+			[]string{"1.0.0.0"},
+			[]*Update{{Op: Add, Addr: "1.0.0.0"}, {Op: Delete, Addr: "1.0.0.1"}},
+		},
+		{
+			[]string{"1.0.0.1"},
+			[]string{"1.0.0.1", "1.0.0.2", "1.0.0.3"},
+			[]*Update{{Op: Add, Addr: "1.0.0.2"}, {Op: Add, Addr: "1.0.0.3"}},
+		},
+		{
+			[]string{"1.0.0.1", "1.0.0.2", "1.0.0.3"},
+			[]string{"1.0.0.0"},
+			[]*Update{{Op: Add, Addr: "1.0.0.0"}, {Op: Delete, Addr: "1.0.0.1"}, {Op: Delete, Addr: "1.0.0.2"}, {Op: Delete, Addr: "1.0.0.3"}},
+		},
+		{
+			[]string{"1.0.0.1", "1.0.0.3", "1.0.0.5"},
+			[]string{"1.0.0.2", "1.0.0.3", "1.0.0.6"},
+			[]*Update{{Op: Delete, Addr: "1.0.0.1"}, {Op: Add, Addr: "1.0.0.2"}, {Op: Delete, Addr: "1.0.0.5"}, {Op: Add, Addr: "1.0.0.6"}},
+		},
+		{
+			[]string{"1.0.0.1", "1.0.0.1", "1.0.0.2"},
+			[]string{"1.0.0.1"},
+			[]*Update{{Op: Delete, Addr: "1.0.0.2"}},
+		},
+	}
+
+	var w dnsWatcher
+	for _, c := range tests {
+		w.curAddrs = make(map[string]*Update)
+		newUpdates := make(map[string]*Update)
+		for _, a := range c.oldAddrs {
+			w.curAddrs[a] = &Update{Addr: a}
+		}
+		for _, a := range c.newAddrs {
+			newUpdates[a] = &Update{Addr: a}
+		}
+		r := w.compileUpdate(newUpdates)
+		if !reflect.DeepEqual(toMap(c.want), toMap(r)) {
+			t.Errorf("w(%+v).compileUpdate(%+v) = %+v, want %+v", c.oldAddrs, c.newAddrs, updatesToSlice(r), updatesToSlice(c.want))
+		}
+	}
+}
+
+func TestResolveFunc(t *testing.T) {
+	tests := []struct {
+		addr string
+		want error
+	}{
+		// TODO(yuxuanli): More false cases?
+		{"www.google.com", nil},
+		{"foo.bar:12345", nil},
+		{"127.0.0.1", nil},
+		{"127.0.0.1:12345", nil},
+		{"[::1]:80", nil},
+		{"[2001:db8:a0b:12f0::1]:21", nil},
+		{":80", nil},
+		{"127.0.0...1:12345", nil},
+		{"[fe80::1%lo0]:80", nil},
+		{"golang.org:http", nil},
+		{"[2001:db8::1]:http", nil},
+		{":", nil},
+		{"", errMissingAddr},
+		{"[2001:db8:a0b:12f0::1", fmt.Errorf("invalid target address %v", "[2001:db8:a0b:12f0::1")},
+	}
+
+	r, err := NewDNSResolver()
+	if err != nil {
+		t.Errorf("%v", err)
+	}
+	for _, v := range tests {
+		_, err := r.Resolve(v.addr)
+		if !reflect.DeepEqual(err, v.want) {
+			t.Errorf("Resolve(%q) = %v, want %v", v.addr, err, v.want)
+		}
+	}
+}
+
+var hostLookupTbl = map[string][]string{
+	"foo.bar.com":      {"1.2.3.4", "5.6.7.8"},
+	"ipv4.single.fake": {"1.2.3.4"},
+	"ipv4.multi.fake":  {"1.2.3.4", "5.6.7.8", "9.10.11.12"},
+	"ipv6.single.fake": {"2607:f8b0:400a:801::1001"},
+	"ipv6.multi.fake":  {"2607:f8b0:400a:801::1001", "2607:f8b0:400a:801::1002", "2607:f8b0:400a:801::1003"},
+}
+
+func hostLookup(host string) ([]string, error) {
+	if addrs, ok := hostLookupTbl[host]; ok {
+		return addrs, nil
+	}
+	return nil, fmt.Errorf("failed to lookup host:%s resolution in hostLookupTbl", host)
+}
+
+var srvLookupTbl = map[string][]*net.SRV{
+	"_grpclb._tcp.srv.ipv4.single.fake": {&net.SRV{Target: "ipv4.single.fake", Port: 1234}},
+	"_grpclb._tcp.srv.ipv4.multi.fake":  {&net.SRV{Target: "ipv4.multi.fake", Port: 1234}},
+	"_grpclb._tcp.srv.ipv6.single.fake": {&net.SRV{Target: "ipv6.single.fake", Port: 1234}},
+	"_grpclb._tcp.srv.ipv6.multi.fake":  {&net.SRV{Target: "ipv6.multi.fake", Port: 1234}},
+}
+
+func srvLookup(service, proto, name string) (string, []*net.SRV, error) {
+	cname := "_" + service + "._" + proto + "." + name
+	if srvs, ok := srvLookupTbl[cname]; ok {
+		return cname, srvs, nil
+	}
+	return "", nil, fmt.Errorf("failed to lookup srv record for %s in srvLookupTbl", cname)
+}
+
+func updatesToSlice(updates []*Update) []Update {
+	res := make([]Update, len(updates))
+	for i, u := range updates {
+		res[i] = *u
+	}
+	return res
+}
+
+func testResolver(t *testing.T, freq time.Duration, slp time.Duration) {
+	tests := []struct {
+		target string
+		want   []*Update
+	}{
+		{
+			"foo.bar.com",
+			[]*Update{{Op: Add, Addr: "1.2.3.4" + colonDefaultPort}, {Op: Add, Addr: "5.6.7.8" + colonDefaultPort}},
+		},
+		{
+			"foo.bar.com:1234",
+			[]*Update{{Op: Add, Addr: "1.2.3.4:1234"}, {Op: Add, Addr: "5.6.7.8:1234"}},
+		},
+		{
+			"srv.ipv4.single.fake",
+			[]*Update{newUpdateWithMD(Add, "1.2.3.4:1234", "ipv4.single.fake")},
+		},
+		{
+			"srv.ipv4.multi.fake",
+			[]*Update{
+				newUpdateWithMD(Add, "1.2.3.4:1234", "ipv4.multi.fake"),
+				newUpdateWithMD(Add, "5.6.7.8:1234", "ipv4.multi.fake"),
+				newUpdateWithMD(Add, "9.10.11.12:1234", "ipv4.multi.fake")},
+		},
+		{
+			"srv.ipv6.single.fake",
+			[]*Update{newUpdateWithMD(Add, "[2607:f8b0:400a:801::1001]:1234", "ipv6.single.fake")},
+		},
+		{
+			"srv.ipv6.multi.fake",
+			[]*Update{
+				newUpdateWithMD(Add, "[2607:f8b0:400a:801::1001]:1234", "ipv6.multi.fake"),
+				newUpdateWithMD(Add, "[2607:f8b0:400a:801::1002]:1234", "ipv6.multi.fake"),
+				newUpdateWithMD(Add, "[2607:f8b0:400a:801::1003]:1234", "ipv6.multi.fake"),
+			},
+		},
+	}
+
+	for _, a := range tests {
+		r, err := NewDNSResolverWithFreq(freq)
+		if err != nil {
+			t.Fatalf("%v\n", err)
+		}
+		w, err := r.Resolve(a.target)
+		if err != nil {
+			t.Fatalf("%v\n", err)
+		}
+		updates, err := w.Next()
+		if err != nil {
+			t.Fatalf("%v\n", err)
+		}
+		if !reflect.DeepEqual(toMap(a.want), toMap(updates)) {
+			t.Errorf("Resolve(%q) = %+v, want %+v\n", a.target, updatesToSlice(updates), updatesToSlice(a.want))
+		}
+		var wg sync.WaitGroup
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			for {
+				_, err := w.Next()
+				if err != nil {
+					return
+				}
+				t.Error("Execution shouldn't reach here, since w.Next() should be blocked until close happen.")
+			}
+		}()
+		// Sleep for sometime to let watcher do more than one lookup
+		time.Sleep(slp)
+		w.Close()
+		wg.Wait()
+	}
+}
+
+func TestResolve(t *testing.T) {
+	defer replaceNetFunc()()
+	testResolver(t, time.Millisecond*5, time.Millisecond*10)
+}
+
+const colonDefaultPort = ":" + defaultPort
+
+func TestIPWatcher(t *testing.T) {
+	tests := []struct {
+		target string
+		want   []*Update
+	}{
+		{"127.0.0.1", []*Update{{Op: Add, Addr: "127.0.0.1" + colonDefaultPort}}},
+		{"127.0.0.1:12345", []*Update{{Op: Add, Addr: "127.0.0.1:12345"}}},
+		{"::1", []*Update{{Op: Add, Addr: "[::1]" + colonDefaultPort}}},
+		{"[::1]:12345", []*Update{{Op: Add, Addr: "[::1]:12345"}}},
+		{"[::1]:", []*Update{{Op: Add, Addr: "[::1]:443"}}},
+		{"2001:db8:85a3::8a2e:370:7334", []*Update{{Op: Add, Addr: "[2001:db8:85a3::8a2e:370:7334]" + colonDefaultPort}}},
+		{"[2001:db8:85a3::8a2e:370:7334]", []*Update{{Op: Add, Addr: "[2001:db8:85a3::8a2e:370:7334]" + colonDefaultPort}}},
+		{"[2001:db8:85a3::8a2e:370:7334]:12345", []*Update{{Op: Add, Addr: "[2001:db8:85a3::8a2e:370:7334]:12345"}}},
+		{"[2001:db8::1]:http", []*Update{{Op: Add, Addr: "[2001:db8::1]:http"}}},
+		// TODO(yuxuanli): zone support?
+	}
+
+	for _, v := range tests {
+		r, err := NewDNSResolverWithFreq(time.Millisecond * 5)
+		if err != nil {
+			t.Fatalf("%v\n", err)
+		}
+		w, err := r.Resolve(v.target)
+		if err != nil {
+			t.Fatalf("%v\n", err)
+		}
+		var updates []*Update
+		var wg sync.WaitGroup
+		wg.Add(1)
+		count := 0
+		go func() {
+			defer wg.Done()
+			for {
+				u, err := w.Next()
+				if err != nil {
+					return
+				}
+				updates = u
+				count++
+			}
+		}()
+		// Sleep for sometime to let watcher do more than one lookup
+		time.Sleep(time.Millisecond * 10)
+		w.Close()
+		wg.Wait()
+		if !reflect.DeepEqual(v.want, updates) {
+			t.Errorf("Resolve(%q) = %v, want %+v\n", v.target, updatesToSlice(updates), updatesToSlice(v.want))
+		}
+		if count != 1 {
+			t.Errorf("IPWatcher Next() should return only once, not %d times\n", count)
+		}
+	}
+}

vendor/google.golang.org/grpc/naming/go17.go

@@ -0,0 +1,34 @@
+// +build go1.6,!go1.8
+
+/*
+ *
+ * Copyright 2017 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package naming
+
+import (
+	"net"
+
+	"golang.org/x/net/context"
+)
+
+var (
+	lookupHost = func(ctx context.Context, host string) ([]string, error) { return net.LookupHost(host) }
+	lookupSRV  = func(ctx context.Context, service, proto, name string) (string, []*net.SRV, error) {
+		return net.LookupSRV(service, proto, name)
+	}
+)

vendor/google.golang.org/grpc/naming/go17_test.go

@@ -0,0 +1,42 @@
+// +build go1.6, !go1.8
+
+/*
+ *
+ * Copyright 2017 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package naming
+
+import (
+	"net"
+
+	"golang.org/x/net/context"
+)
+
+func replaceNetFunc() func() {
+	oldLookupHost := lookupHost
+	oldLookupSRV := lookupSRV
+	lookupHost = func(ctx context.Context, host string) ([]string, error) {
+		return hostLookup(host)
+	}
+	lookupSRV = func(ctx context.Context, service, proto, name string) (string, []*net.SRV, error) {
+		return srvLookup(service, proto, name)
+	}
+	return func() {
+		lookupHost = oldLookupHost
+		lookupSRV = oldLookupSRV
+	}
+}

vendor/google.golang.org/grpc/naming/go18.go

@@ -0,0 +1,28 @@
+// +build go1.8
+
+/*
+ *
+ * Copyright 2017 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package naming
+
+import "net"
+
+var (
+	lookupHost = net.DefaultResolver.LookupHost
+	lookupSRV  = net.DefaultResolver.LookupSRV
+)

vendor/google.golang.org/grpc/naming/go18_test.go

@@ -0,0 +1,41 @@
+// +build go1.8
+
+/*
+ *
+ * Copyright 2017 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package naming
+
+import (
+	"context"
+	"net"
+)
+
+func replaceNetFunc() func() {
+	oldLookupHost := lookupHost
+	oldLookupSRV := lookupSRV
+	lookupHost = func(ctx context.Context, host string) ([]string, error) {
+		return hostLookup(host)
+	}
+	lookupSRV = func(ctx context.Context, service, proto, name string) (string, []*net.SRV, error) {
+		return srvLookup(service, proto, name)
+	}
+	return func() {
+		lookupHost = oldLookupHost
+		lookupSRV = oldLookupSRV
+	}
+}

vendor/google.golang.org/grpc/naming/naming.go

@@ -0,0 +1,69 @@
+/*
+ *
+ * Copyright 2014 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// Package naming defines the naming API and related data structures for gRPC.
+// The interface is EXPERIMENTAL and may be suject to change.
+//
+// Deprecated: please use package resolver.
+package naming
+
+// Operation defines the corresponding operations for a name resolution change.
+//
+// Deprecated: please use package resolver.
+type Operation uint8
+
+const (
+	// Add indicates a new address is added.
+	Add Operation = iota
+	// Delete indicates an existing address is deleted.
+	Delete
+)
+
+// Update defines a name resolution update. Notice that it is not valid having both
+// empty string Addr and nil Metadata in an Update.
+//
+// Deprecated: please use package resolver.
+type Update struct {
+	// Op indicates the operation of the update.
+	Op Operation
+	// Addr is the updated address. It is empty string if there is no address update.
+	Addr string
+	// Metadata is the updated metadata. It is nil if there is no metadata update.
+	// Metadata is not required for a custom naming implementation.
+	Metadata interface{}
+}
+
+// Resolver creates a Watcher for a target to track its resolution changes.
+//
+// Deprecated: please use package resolver.
+type Resolver interface {
+	// Resolve creates a Watcher for target.
+	Resolve(target string) (Watcher, error)
+}
+
+// Watcher watches for the updates on the specified target.
+//
+// Deprecated: please use package resolver.
+type Watcher interface {
+	// Next blocks until an update or error happens. It may return one or more
+	// updates. The first call should get the full set of the results. It should
+	// return an error if and only if Watcher cannot recover.
+	Next() ([]*Update, error)
+	// Close closes the Watcher.
+	Close()
+}