Create & Init Project...

library/net/rpc/warden/resolver/BUILD

@@ -0,0 +1,45 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "resolver.go",
+        "util.go",
+    ],
+    importpath = "go-common/library/net/rpc/warden/resolver",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//library/conf/env:go_default_library",
+        "//library/log:go_default_library",
+        "//library/naming:go_default_library",
+        "//library/net/rpc/warden/metadata:go_default_library",
+        "//vendor/github.com/dgryski/go-farm:go_default_library",
+        "//vendor/github.com/pkg/errors:go_default_library",
+        "@org_golang_google_grpc//resolver:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [
+        ":package-srcs",
+        "//library/net/rpc/warden/resolver/direct:all-srcs",
+        "//library/net/rpc/warden/resolver/livezk:all-srcs",
+        "//library/net/rpc/warden/resolver/test:all-srcs",
+    ],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

library/net/rpc/warden/resolver/CHANGELOG.md

@@ -0,0 +1,14 @@
+### business/warden/resolver
+
+##### Version 1.1.0
+1. 增加了子集选择算法
+
+##### Version 1.0.2
+1. 增加GET接口
+
+##### Version 1.0.1
+1. 支持zone和clusters
+
+
+##### Version 1.0.0
+1. 实现了基本的服务发现功能

library/net/rpc/warden/resolver/CONTRIBUTORS.md

@@ -0,0 +1,8 @@
+# Owner
+caoguoliang
+
+# Author
+caoguoliang
+
+# Reviewer
+maojian

library/net/rpc/warden/resolver/OWNERS

@@ -0,0 +1,7 @@
+# See the OWNERS docs at https://go.k8s.io/owners
+
+approvers:
+- caoguoliang
+reviewers:
+- caoguoliang
+- maojian

library/net/rpc/warden/resolver/README.md

@@ -0,0 +1,13 @@
+#### business/warden/resolver
+
+##### 项目简介
+
+warden 的 服务发现模块，用于从底层的注册中心中获取Server节点列表并返回给GRPC
+
+##### 编译环境
+
+- **请只用 Golang v1.9.x 以上版本编译执行**
+
+##### 依赖包
+
+- [grpc](google.golang.org/grpc)

library/net/rpc/warden/resolver/direct/BUILD

@@ -0,0 +1,49 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["direct_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//library/net/netutil/breaker:go_default_library",
+        "//library/net/rpc/warden:go_default_library",
+        "//library/net/rpc/warden/proto/testproto:go_default_library",
+        "//library/net/rpc/warden/resolver:go_default_library",
+        "//library/time:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["direct.go"],
+    importpath = "go-common/library/net/rpc/warden/resolver/direct",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//library/conf/env:go_default_library",
+        "//library/naming:go_default_library",
+        "//library/net/rpc/warden/resolver:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

library/net/rpc/warden/resolver/direct/CHANGELOG.md

@@ -0,0 +1,6 @@
+### business/warden/resolver/direct
+
+
+##### Version 1.0.0
+
+1. 实现了基本的服务发现直连功能

library/net/rpc/warden/resolver/direct/README.md

@@ -0,0 +1,14 @@
+#### business/warden/resolver/direct
+
+##### 项目简介
+
+warden 的直连服务模块，用于通过IP地址列表直接连接后端服务
+连接字符串格式：　direct://default/192.168.1.1:8080,192.168.1.2:8081
+
+##### 编译环境
+
+- **请只用 Golang v1.9.x 以上版本编译执行**
+
+##### 依赖包
+
+- [grpc](google.golang.org/grpc)

library/net/rpc/warden/resolver/direct/direct.go

@@ -0,0 +1,77 @@
+package direct
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	"go-common/library/conf/env"
+	"go-common/library/naming"
+	"go-common/library/net/rpc/warden/resolver"
+)
+
+const (
+	// Name is the name of direct resolver
+	Name = "direct"
+)
+
+var _ naming.Resolver = &Direct{}
+
+// New return Direct
+func New() *Direct {
+	return &Direct{}
+}
+
+// Build build direct.
+func Build(id string) *Direct {
+	return &Direct{id: id}
+}
+
+// Direct is a resolver for conneting endpoints directly.
+// example format: direct://default/192.168.1.1:8080,192.168.1.2:8081
+type Direct struct {
+	id string
+}
+
+// Build direct build.
+func (d *Direct) Build(id string) naming.Resolver {
+	return &Direct{id: id}
+}
+
+// Scheme return the Scheme of Direct
+func (d *Direct) Scheme() string {
+	return Name
+}
+
+// Watch a tree
+func (d *Direct) Watch() <-chan struct{} {
+	ch := make(chan struct{}, 1)
+	ch <- struct{}{}
+	return ch
+}
+
+//Unwatch a tree
+func (d *Direct) Unwatch(id string) {
+}
+
+//Fetch fetch isntances
+func (d *Direct) Fetch(ctx context.Context) (insMap map[string][]*naming.Instance, found bool) {
+	var ins []*naming.Instance
+
+	addrs := strings.Split(d.id, ",")
+	for _, addr := range addrs {
+		ins = append(ins, &naming.Instance{
+			Addrs: []string{fmt.Sprintf("%s://%s", resolver.Scheme, addr)},
+		})
+	}
+	if len(ins) > 0 {
+		found = true
+	}
+	insMap = map[string][]*naming.Instance{env.Zone: ins}
+	return
+}
+
+//Close close Direct
+func (d *Direct) Close() error {
+	return nil
+}

library/net/rpc/warden/resolver/direct/direct_test.go

@@ -0,0 +1,85 @@
+package direct
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"testing"
+	"time"
+
+	"go-common/library/net/netutil/breaker"
+	"go-common/library/net/rpc/warden"
+	pb "go-common/library/net/rpc/warden/proto/testproto"
+	"go-common/library/net/rpc/warden/resolver"
+	xtime "go-common/library/time"
+)
+
+type testServer struct {
+	name string
+}
+
+func (ts *testServer) SayHello(context.Context, *pb.HelloRequest) (*pb.HelloReply, error) {
+	return &pb.HelloReply{Message: ts.name, Success: true}, nil
+}
+
+func (ts *testServer) StreamHello(ss pb.Greeter_StreamHelloServer) error {
+	panic("not implement error")
+}
+
+func createServer(name, listen string) *warden.Server {
+	s := warden.NewServer(&warden.ServerConfig{Timeout: xtime.Duration(time.Second)})
+	ts := &testServer{name}
+	pb.RegisterGreeterServer(s.Server(), ts)
+	go func() {
+		if err := s.Run(listen); err != nil {
+			panic(fmt.Sprintf("run warden server fail! err: %s", err))
+		}
+	}()
+	return s
+}
+
+func TestMain(m *testing.M) {
+	resolver.Register(New())
+	ctx := context.TODO()
+	s1 := createServer("server1", "127.0.0.1:18081")
+	s2 := createServer("server2", "127.0.0.1:18082")
+	defer s1.Shutdown(ctx)
+	defer s2.Shutdown(ctx)
+	os.Exit(m.Run())
+}
+
+func createTestClient(t *testing.T, connStr string) pb.GreeterClient {
+	client := warden.NewClient(&warden.ClientConfig{
+		Dial:    xtime.Duration(time.Second * 10),
+		Timeout: xtime.Duration(time.Second * 10),
+		Breaker: &breaker.Config{
+			Window:  xtime.Duration(3 * time.Second),
+			Sleep:   xtime.Duration(3 * time.Second),
+			Bucket:  10,
+			Ratio:   0.3,
+			Request: 20,
+		},
+	})
+	conn, err := client.Dial(context.TODO(), connStr)
+	if err != nil {
+		t.Fatalf("create client fail!err%s", err)
+	}
+	return pb.NewGreeterClient(conn)
+}
+
+func TestDirect(t *testing.T) {
+	cli := createTestClient(t, "direct://default/127.0.0.1:18083,127.0.0.1:18082")
+	count := 0
+	for i := 0; i < 10; i++ {
+		if resp, err := cli.SayHello(context.TODO(), &pb.HelloRequest{Age: 1, Name: "hello"}); err != nil {
+			t.Fatalf("TestDirect: SayHello failed!err:=%v", err)
+		} else {
+			if resp.Message == "server2" {
+				count++
+			}
+		}
+	}
+	if count != 10 {
+		t.Fatalf("TestDirect: get server2 times must be 10")
+	}
+}

library/net/rpc/warden/resolver/livezk/BUILD

@@ -0,0 +1,33 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["helper.go"],
+    importpath = "go-common/library/net/rpc/warden/resolver/livezk",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//library/naming:go_default_library",
+        "//library/naming/livezk:go_default_library",
+        "//library/net/ip:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

library/net/rpc/warden/resolver/livezk/CHANGELOG.md

@@ -0,0 +1,5 @@
+# LiveZK
+
+### Version 1.0.0
+
+1. 基本功能

library/net/rpc/warden/resolver/livezk/README.md

@@ -0,0 +1,20 @@
+# livezk
+
+直播 zookeeper 注册工具
+
+### usage
+
+```go
+import (
+    "go-common/conf"
+    "go-common/business/warden/livezk"
+)
+
+func main() {
+    config := &conf.Zookeeper{/*...*/}
+    addr := ":5000" // grpc 监听的端口
+    appID := "test.test" // app_id
+    // 注册失败每隔1分钟会自动重试
+    live.DoRegister(config, addr, appID)
+}
+```

library/net/rpc/warden/resolver/livezk/helper.go

@@ -0,0 +1,29 @@
+package livezk
+
+import (
+	"context"
+	"fmt"
+	"net"
+
+	"go-common/library/naming"
+	lz "go-common/library/naming/livezk"
+	"go-common/library/net/ip"
+)
+
+// Register self grpc service to live zookeeper
+func Register(config *lz.Zookeeper, addr string, discoveryID string) (context.CancelFunc, error) {
+	_, port, err := net.SplitHostPort(addr)
+	if err != nil {
+		return nil, err
+	}
+	z, err := lz.New(config)
+	if err != nil {
+		return nil, err
+	}
+	internalIP := ip.InternalIP()
+	ins := &naming.Instance{
+		AppID: discoveryID,
+		Addrs: []string{fmt.Sprintf("grpc://%s:%s", internalIP, port)},
+	}
+	return z.Register(context.Background(), ins)
+}

library/net/rpc/warden/resolver/resolver.go

@@ -0,0 +1,201 @@
+package resolver
+
+import (
+	"context"
+	"math/rand"
+	"net/url"
+	"sort"
+	"strconv"
+	"strings"
+	"sync"
+
+	"go-common/library/conf/env"
+	"go-common/library/log"
+	"go-common/library/naming"
+	wmeta "go-common/library/net/rpc/warden/metadata"
+
+	"github.com/dgryski/go-farm"
+	"github.com/pkg/errors"
+	"google.golang.org/grpc/resolver"
+)
+
+const (
+	// Scheme is the scheme of discovery address
+	Scheme = "grpc"
+)
+
+var (
+	_  resolver.Resolver = &Resolver{}
+	_  resolver.Builder  = &Builder{}
+	mu sync.Mutex
+)
+
+// Register register resolver builder if nil.
+func Register(b naming.Builder) {
+	mu.Lock()
+	defer mu.Unlock()
+	if resolver.Get(b.Scheme()) == nil {
+		resolver.Register(&Builder{b})
+	}
+}
+
+// Set override any registered builder
+func Set(b naming.Builder) {
+	mu.Lock()
+	defer mu.Unlock()
+	resolver.Register(&Builder{b})
+}
+
+// Builder is also a resolver builder.
+// It's build() function always returns itself.
+type Builder struct {
+	naming.Builder
+}
+
+// Build returns itself for Resolver, because it's both a builder and a resolver.
+func (b *Builder) Build(target resolver.Target, cc resolver.ClientConn, opts resolver.BuildOption) (resolver.Resolver, error) {
+	var zone = env.Zone
+	ss := int64(50)
+	clusters := map[string]struct{}{}
+	str := strings.SplitN(target.Endpoint, "?", 2)
+	if len(str) == 0 {
+		return nil, errors.Errorf("warden resolver: parse target.Endpoint(%s) failed!err:=endpoint is empty", target.Endpoint)
+	} else if len(str) == 2 {
+		m, err := url.ParseQuery(str[1])
+		if err == nil {
+			for _, c := range m[naming.MetaCluster] {
+				clusters[c] = struct{}{}
+			}
+			zones := m[naming.MetaZone]
+			if len(zones) > 0 {
+				zone = zones[0]
+			}
+			if sub, ok := m["subset"]; ok {
+				if t, err := strconv.ParseInt(sub[0], 10, 64); err == nil {
+					ss = t
+				}
+
+			}
+		}
+	}
+	r := &Resolver{
+		nr:         b.Builder.Build(str[0]),
+		cc:         cc,
+		quit:       make(chan struct{}, 1),
+		clusters:   clusters,
+		zone:       zone,
+		subsetSize: ss,
+	}
+	go r.updateproc()
+	return r, nil
+}
+
+// Resolver watches for the updates on the specified target.
+// Updates include address updates and service config updates.
+type Resolver struct {
+	nr   naming.Resolver
+	cc   resolver.ClientConn
+	quit chan struct{}
+
+	clusters   map[string]struct{}
+	zone       string
+	subsetSize int64
+}
+
+// Close is a noop for Resolver.
+func (r *Resolver) Close() {
+	select {
+	case r.quit <- struct{}{}:
+		r.nr.Close()
+	default:
+	}
+}
+
+// ResolveNow is a noop for Resolver.
+func (r *Resolver) ResolveNow(o resolver.ResolveNowOption) {
+}
+
+func (r *Resolver) updateproc() {
+	event := r.nr.Watch()
+	for {
+		select {
+		case <-r.quit:
+			return
+		case _, ok := <-event:
+			if !ok {
+				return
+			}
+		}
+		if insMap, ok := r.nr.Fetch(context.Background()); ok {
+			instances, ok := insMap[r.zone]
+			if !ok {
+				for _, value := range insMap {
+					instances = append(instances, value...)
+				}
+			}
+			if r.subsetSize > 0 && len(instances) > 0 {
+				instances = r.subset(instances, env.Hostname, r.subsetSize)
+			}
+			r.newAddress(instances)
+		}
+	}
+}
+
+func (r *Resolver) subset(backends []*naming.Instance, clientID string, size int64) []*naming.Instance {
+	if len(backends) <= int(size) {
+		return backends
+	}
+	sort.Slice(backends, func(i, j int) bool {
+		return backends[i].Hostname < backends[j].Hostname
+	})
+	count := int64(len(backends)) / size
+
+	id := farm.Fingerprint64([]byte(clientID))
+	round := int64(id / uint64(count))
+
+	s := rand.NewSource(round)
+	ra := rand.New(s)
+	ra.Shuffle(len(backends), func(i, j int) {
+		backends[i], backends[j] = backends[j], backends[i]
+	})
+	start := (id % uint64(count)) * uint64(size)
+	return backends[int(start) : int(start)+int(size)]
+}
+
+func (r *Resolver) newAddress(instances []*naming.Instance) {
+	if len(instances) <= 0 {
+		return
+	}
+	addrs := make([]resolver.Address, 0, len(instances))
+	for _, ins := range instances {
+		if len(r.clusters) > 0 {
+			if _, ok := r.clusters[ins.Metadata[naming.MetaCluster]]; !ok {
+				continue
+			}
+		}
+
+		var weight int64
+		if weight, _ = strconv.ParseInt(ins.Metadata[naming.MetaWeight], 10, 64); weight <= 0 {
+			weight = 10
+		}
+		var rpc string
+		for _, a := range ins.Addrs {
+			u, err := url.Parse(a)
+			if err == nil && u.Scheme == Scheme {
+				rpc = u.Host
+			}
+		}
+		if rpc == "" {
+			log.Warn("warden/resolver: invalid rpc address(%s,%s,%v) found!", ins.AppID, ins.Hostname, ins.Addrs)
+			continue
+		}
+		addr := resolver.Address{
+			Addr:       rpc,
+			Type:       resolver.Backend,
+			ServerName: ins.AppID,
+			Metadata:   wmeta.MD{Weight: weight, Color: ins.Metadata[naming.MetaColor]},
+		}
+		addrs = append(addrs, addr)
+	}
+	r.cc.NewAddress(addrs)
+}

library/net/rpc/warden/resolver/test/BUILD

@@ -0,0 +1,53 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["resovler_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//library/conf/env:go_default_library",
+        "//library/naming:go_default_library",
+        "//library/net/netutil/breaker:go_default_library",
+        "//library/net/rpc/warden:go_default_library",
+        "//library/net/rpc/warden/balancer/wrr:go_default_library",
+        "//library/net/rpc/warden/proto/testproto:go_default_library",
+        "//library/net/rpc/warden/resolver:go_default_library",
+        "//library/time:go_default_library",
+        "//vendor/github.com/stretchr/testify/assert:go_default_library",
+        "@org_golang_google_grpc//:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["mockdiscovery.go"],
+    importpath = "go-common/library/net/rpc/warden/resolver/test",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//library/conf/env:go_default_library",
+        "//library/naming:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

library/net/rpc/warden/resolver/test/mockdiscovery.go

@@ -0,0 +1,87 @@
+package resolver
+
+import (
+	"context"
+	"go-common/library/conf/env"
+	"go-common/library/naming"
+)
+
+type mockDiscoveryBuilder struct {
+	instances map[string]*naming.Instance
+	watchch   map[string][]*mockDiscoveryResolver
+}
+
+func (mb *mockDiscoveryBuilder) Build(id string) naming.Resolver {
+	mr := &mockDiscoveryResolver{
+		d:       mb,
+		watchch: make(chan struct{}, 1),
+	}
+	mb.watchch[id] = append(mb.watchch[id], mr)
+	mr.watchch <- struct{}{}
+	return mr
+}
+func (mb *mockDiscoveryBuilder) Scheme() string {
+	return "mockdiscovery"
+}
+
+type mockDiscoveryResolver struct {
+	//instances map[string]*naming.Instance
+	d       *mockDiscoveryBuilder
+	watchch chan struct{}
+}
+
+var _ naming.Resolver = &mockDiscoveryResolver{}
+
+func (md *mockDiscoveryResolver) Fetch(ctx context.Context) (map[string][]*naming.Instance, bool) {
+	zones := make(map[string][]*naming.Instance)
+	for _, v := range md.d.instances {
+		zones[v.Zone] = append(zones[v.Zone], v)
+	}
+	return zones, len(zones) > 0
+}
+
+func (md *mockDiscoveryResolver) Watch() <-chan struct{} {
+	return md.watchch
+}
+
+func (md *mockDiscoveryResolver) Close() error {
+	close(md.watchch)
+	return nil
+}
+
+func (md *mockDiscoveryResolver) Scheme() string {
+	return "mockdiscovery"
+}
+
+func (mb *mockDiscoveryBuilder) registry(appID string, hostname, rpc string, metadata map[string]string) {
+	ins := &naming.Instance{
+		AppID:    appID,
+		Env:      "hello=world",
+		Hostname: hostname,
+		Addrs:    []string{"grpc://" + rpc},
+		Version:  "1.1",
+		Zone:     env.Zone,
+		Metadata: metadata,
+	}
+	mb.instances[hostname] = ins
+	if ch, ok := mb.watchch[appID]; ok {
+		var bullet struct{}
+		for _, c := range ch {
+			c.watchch <- bullet
+		}
+	}
+}
+
+func (mb *mockDiscoveryBuilder) cancel(hostname string) {
+	ins, ok := mb.instances[hostname]
+	if !ok {
+		return
+	}
+	delete(mb.instances, hostname)
+	if ch, ok := mb.watchch[ins.AppID]; ok {
+		var bullet struct{}
+		for _, c := range ch {
+			c.watchch <- bullet
+		}
+	}
+}

library/net/rpc/warden/resolver/test/resovler_test.go

@@ -0,0 +1,314 @@
+package resolver
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"testing"
+	"time"
+
+	"go-common/library/conf/env"
+	"go-common/library/naming"
+	"go-common/library/net/netutil/breaker"
+	"go-common/library/net/rpc/warden"
+	"go-common/library/net/rpc/warden/balancer/wrr"
+	pb "go-common/library/net/rpc/warden/proto/testproto"
+	"go-common/library/net/rpc/warden/resolver"
+	xtime "go-common/library/time"
+
+	"github.com/stretchr/testify/assert"
+	"google.golang.org/grpc"
+)
+
+var testServerMap map[string]*testServer
+
+func init() {
+	testServerMap = make(map[string]*testServer)
+}
+
+const testAppID = "main.test"
+
+type testServer struct {
+	SayHelloCount int
+}
+
+func resetCount() {
+	for _, s := range testServerMap {
+		s.SayHelloCount = 0
+	}
+}
+
+func (ts *testServer) SayHello(context.Context, *pb.HelloRequest) (*pb.HelloReply, error) {
+	ts.SayHelloCount++
+	return &pb.HelloReply{Message: "hello", Success: true}, nil
+}
+
+func (ts *testServer) StreamHello(ss pb.Greeter_StreamHelloServer) error {
+	panic("not implement error")
+}
+
+func createServer(name, listen string) *warden.Server {
+	s := warden.NewServer(&warden.ServerConfig{Timeout: xtime.Duration(time.Second)})
+	ts := &testServer{}
+	testServerMap[name] = ts
+	pb.RegisterGreeterServer(s.Server(), ts)
+	go func() {
+		if err := s.Run(listen); err != nil {
+			panic(fmt.Sprintf("run warden server fail! err: %s", err))
+		}
+	}()
+	return s
+}
+
+func NSayHello(c pb.GreeterClient, n int) func(*testing.T) {
+	return func(t *testing.T) {
+		for i := 0; i < n; i++ {
+			if _, err := c.SayHello(context.TODO(), &pb.HelloRequest{Age: 1, Name: "hello"}); err != nil {
+				t.Fatalf("call sayhello fail! err: %s", err)
+			}
+		}
+	}
+}
+
+func createTestClient(t *testing.T) pb.GreeterClient {
+	client := warden.NewClient(&warden.ClientConfig{
+		Dial:    xtime.Duration(time.Second * 10),
+		Timeout: xtime.Duration(time.Second * 10),
+		Breaker: &breaker.Config{
+			Window:  xtime.Duration(3 * time.Second),
+			Sleep:   xtime.Duration(3 * time.Second),
+			Bucket:  10,
+			Ratio:   0.3,
+			Request: 20,
+		},
+	})
+	conn, err := client.Dial(context.TODO(), "mockdiscovery://authority/main.test")
+	if err != nil {
+		t.Fatalf("create client fail!err%s", err)
+	}
+	return pb.NewGreeterClient(conn)
+}
+
+var mockResolver *mockDiscoveryBuilder
+
+func newMockDiscoveryBuilder() *mockDiscoveryBuilder {
+	return &mockDiscoveryBuilder{
+		instances: make(map[string]*naming.Instance),
+		watchch:   make(map[string][]*mockDiscoveryResolver),
+	}
+}
+func TestMain(m *testing.M) {
+	ctx := context.TODO()
+	mockResolver = newMockDiscoveryBuilder()
+	resolver.Set(mockResolver)
+	s1 := createServer("server1", "127.0.0.1:18081")
+	s2 := createServer("server2", "127.0.0.1:18082")
+	s3 := createServer("server3", "127.0.0.1:18083")
+	s4 := createServer("server4", "127.0.0.1:18084")
+	s5 := createServer("server5", "127.0.0.1:18085")
+	defer s1.Shutdown(ctx)
+	defer s2.Shutdown(ctx)
+	defer s3.Shutdown(ctx)
+	defer s4.Shutdown(ctx)
+	defer s5.Shutdown(ctx)
+	os.Exit(m.Run())
+}
+
+func TestAddResolver(t *testing.T) {
+	mockResolver.registry(testAppID, "server1", "127.0.0.1:18081", map[string]string{})
+	c := createTestClient(t)
+	t.Run("test_say_hello", NSayHello(c, 10))
+	assert.Equal(t, 10, testServerMap["server1"].SayHelloCount)
+	resetCount()
+}
+
+func TestDeleteResolver(t *testing.T) {
+	mockResolver.registry(testAppID, "server1", "127.0.0.1:18081", map[string]string{})
+	mockResolver.registry(testAppID, "server2", "127.0.0.1:18082", map[string]string{})
+	c := createTestClient(t)
+	t.Run("test_say_hello", NSayHello(c, 10))
+	assert.Equal(t, 10, testServerMap["server1"].SayHelloCount+testServerMap["server2"].SayHelloCount)
+
+	mockResolver.cancel("server1")
+	resetCount()
+	time.Sleep(time.Millisecond * 10)
+	t.Run("test_say_hello", NSayHello(c, 10))
+	assert.Equal(t, 0, testServerMap["server1"].SayHelloCount)
+
+	resetCount()
+}
+
+func TestUpdateResolver(t *testing.T) {
+	mockResolver.registry(testAppID, "server1", "127.0.0.1:18081", map[string]string{})
+	mockResolver.registry(testAppID, "server2", "127.0.0.1:18082", map[string]string{})
+
+	c := createTestClient(t)
+	t.Run("test_say_hello", NSayHello(c, 10))
+	assert.Equal(t, 10, testServerMap["server1"].SayHelloCount+testServerMap["server2"].SayHelloCount)
+
+	mockResolver.registry(testAppID, "server1", "127.0.0.1:18083", map[string]string{})
+	mockResolver.registry(testAppID, "server2", "127.0.0.1:18084", map[string]string{})
+	resetCount()
+	time.Sleep(time.Millisecond * 10)
+	t.Run("test_say_hello", NSayHello(c, 10))
+	assert.Equal(t, 0, testServerMap["server1"].SayHelloCount+testServerMap["server2"].SayHelloCount)
+	assert.Equal(t, 10, testServerMap["server3"].SayHelloCount+testServerMap["server4"].SayHelloCount)
+
+	resetCount()
+}
+
+func TestErrorResolver(t *testing.T) {
+	mockResolver := newMockDiscoveryBuilder()
+	resolver.Set(mockResolver)
+	mockResolver.registry(testAppID, "server1", "127.0.0.1:18081", map[string]string{})
+	mockResolver.registry(testAppID, "server6", "127.0.0.1:18086", map[string]string{})
+
+	c := createTestClient(t)
+	t.Run("test_say_hello", NSayHello(c, 10))
+	assert.Equal(t, 10, testServerMap["server1"].SayHelloCount)
+
+	resetCount()
+}
+
+func TestClusterResolver(t *testing.T) {
+	mockResolver := newMockDiscoveryBuilder()
+	resolver.Set(mockResolver)
+	mockResolver.registry(testAppID, "server1", "127.0.0.1:18081", map[string]string{"cluster": "c1"})
+	mockResolver.registry(testAppID, "server2", "127.0.0.1:18082", map[string]string{"cluster": "c1"})
+	mockResolver.registry(testAppID, "server3", "127.0.0.1:18083", map[string]string{"cluster": "c2"})
+	mockResolver.registry(testAppID, "server4", "127.0.0.1:18084", map[string]string{})
+	mockResolver.registry(testAppID, "server5", "127.0.0.1:18084", map[string]string{})
+
+	client := warden.NewClient(&warden.ClientConfig{Clusters: []string{"c1"}}, grpc.WithBalancerName(wrr.Name))
+	conn, err := client.Dial(context.TODO(), "mockdiscovery://authority/main.test?cluster=c2")
+	if err != nil {
+		t.Fatalf("create client fail!err%s", err)
+	}
+	time.Sleep(time.Millisecond * 10)
+	cli := pb.NewGreeterClient(conn)
+	if _, err := cli.SayHello(context.TODO(), &pb.HelloRequest{Age: 1, Name: "hello"}); err != nil {
+		t.Fatalf("call sayhello fail! err: %s", err)
+	}
+	if _, err := cli.SayHello(context.TODO(), &pb.HelloRequest{Age: 1, Name: "hello"}); err != nil {
+		t.Fatalf("call sayhello fail! err: %s", err)
+	}
+	if _, err := cli.SayHello(context.TODO(), &pb.HelloRequest{Age: 1, Name: "hello"}); err != nil {
+		t.Fatalf("call sayhello fail! err: %s", err)
+	}
+	assert.Equal(t, 1, testServerMap["server1"].SayHelloCount)
+	assert.Equal(t, 1, testServerMap["server2"].SayHelloCount)
+	assert.Equal(t, 1, testServerMap["server3"].SayHelloCount)
+
+	resetCount()
+}
+
+func TestNoClusterResolver(t *testing.T) {
+	mockResolver := newMockDiscoveryBuilder()
+	resolver.Set(mockResolver)
+	mockResolver.registry(testAppID, "server1", "127.0.0.1:18081", map[string]string{"cluster": "c1"})
+	mockResolver.registry(testAppID, "server2", "127.0.0.1:18082", map[string]string{"cluster": "c1"})
+	mockResolver.registry(testAppID, "server3", "127.0.0.1:18083", map[string]string{"cluster": "c2"})
+	mockResolver.registry(testAppID, "server4", "127.0.0.1:18084", map[string]string{})
+	client := warden.NewClient(&warden.ClientConfig{}, grpc.WithBalancerName(wrr.Name))
+	conn, err := client.Dial(context.TODO(), "mockdiscovery://authority/main.test")
+	if err != nil {
+		t.Fatalf("create client fail!err%s", err)
+	}
+	time.Sleep(time.Millisecond * 20)
+	cli := pb.NewGreeterClient(conn)
+	if _, err := cli.SayHello(context.TODO(), &pb.HelloRequest{Age: 1, Name: "hello"}); err != nil {
+		t.Fatalf("call sayhello fail! err: %s", err)
+	}
+	if _, err := cli.SayHello(context.TODO(), &pb.HelloRequest{Age: 1, Name: "hello"}); err != nil {
+		t.Fatalf("call sayhello fail! err: %s", err)
+	}
+	if _, err := cli.SayHello(context.TODO(), &pb.HelloRequest{Age: 1, Name: "hello"}); err != nil {
+		t.Fatalf("call sayhello fail! err: %s", err)
+	}
+	if _, err := cli.SayHello(context.TODO(), &pb.HelloRequest{Age: 1, Name: "hello"}); err != nil {
+		t.Fatalf("call sayhello fail! err: %s", err)
+	}
+	assert.Equal(t, 1, testServerMap["server1"].SayHelloCount)
+	assert.Equal(t, 1, testServerMap["server2"].SayHelloCount)
+	assert.Equal(t, 1, testServerMap["server3"].SayHelloCount)
+	assert.Equal(t, 1, testServerMap["server4"].SayHelloCount)
+
+	resetCount()
+}
+
+func TestZoneResolver(t *testing.T) {
+	mockResolver := newMockDiscoveryBuilder()
+	resolver.Set(mockResolver)
+	mockResolver.registry(testAppID, "server1", "127.0.0.1:18081", map[string]string{})
+	env.Zone = "testsh"
+	mockResolver.registry(testAppID, "server2", "127.0.0.1:18082", map[string]string{})
+	env.Zone = "hhhh"
+	client := warden.NewClient(&warden.ClientConfig{Zone: "testsh"}, grpc.WithBalancerName(wrr.Name))
+	conn, err := client.Dial(context.TODO(), "mockdiscovery://authority/main.test")
+	if err != nil {
+		t.Fatalf("create client fail!err%s", err)
+	}
+	time.Sleep(time.Millisecond * 10)
+	cli := pb.NewGreeterClient(conn)
+	if _, err := cli.SayHello(context.TODO(), &pb.HelloRequest{Age: 1, Name: "hello"}); err != nil {
+		t.Fatalf("call sayhello fail! err: %s", err)
+	}
+	if _, err := cli.SayHello(context.TODO(), &pb.HelloRequest{Age: 1, Name: "hello"}); err != nil {
+		t.Fatalf("call sayhello fail! err: %s", err)
+	}
+	if _, err := cli.SayHello(context.TODO(), &pb.HelloRequest{Age: 1, Name: "hello"}); err != nil {
+		t.Fatalf("call sayhello fail! err: %s", err)
+	}
+	assert.Equal(t, 0, testServerMap["server1"].SayHelloCount)
+	assert.Equal(t, 3, testServerMap["server2"].SayHelloCount)
+
+	resetCount()
+}
+
+func TestSubsetConn(t *testing.T) {
+	mockResolver := newMockDiscoveryBuilder()
+	resolver.Set(mockResolver)
+	mockResolver.registry(testAppID, "server1", "127.0.0.1:18081", map[string]string{})
+	mockResolver.registry(testAppID, "server2", "127.0.0.1:18082", map[string]string{})
+	mockResolver.registry(testAppID, "server3", "127.0.0.1:18083", map[string]string{})
+	mockResolver.registry(testAppID, "server4", "127.0.0.1:18084", map[string]string{})
+	mockResolver.registry(testAppID, "server5", "127.0.0.1:18085", map[string]string{})
+
+	client := warden.NewClient(nil)
+	conn, err := client.Dial(context.TODO(), "mockdiscovery://authority/main.test?subset=3")
+	if err != nil {
+		t.Fatalf("create client fail!err%s", err)
+	}
+	time.Sleep(time.Millisecond * 20)
+	cli := pb.NewGreeterClient(conn)
+	for i := 0; i < 6; i++ {
+		if _, err := cli.SayHello(context.TODO(), &pb.HelloRequest{Age: 1, Name: "hello"}); err != nil {
+			t.Fatalf("call sayhello fail! err: %s", err)
+		}
+	}
+	assert.Equal(t, 2, testServerMap["server2"].SayHelloCount)
+	assert.Equal(t, 2, testServerMap["server5"].SayHelloCount)
+	assert.Equal(t, 2, testServerMap["server4"].SayHelloCount)
+	resetCount()
+	mockResolver.cancel("server4")
+	time.Sleep(time.Millisecond * 20)
+	for i := 0; i < 6; i++ {
+		if _, err := cli.SayHello(context.TODO(), &pb.HelloRequest{Age: 1, Name: "hello"}); err != nil {
+			t.Fatalf("call sayhello fail! err: %s", err)
+		}
+	}
+	assert.Equal(t, 2, testServerMap["server5"].SayHelloCount)
+	assert.Equal(t, 2, testServerMap["server2"].SayHelloCount)
+	assert.Equal(t, 2, testServerMap["server3"].SayHelloCount)
+	resetCount()
+	mockResolver.registry(testAppID, "server4", "127.0.0.1:18084", map[string]string{})
+	time.Sleep(time.Millisecond * 20)
+	for i := 0; i < 6; i++ {
+		if _, err := cli.SayHello(context.TODO(), &pb.HelloRequest{Age: 1, Name: "hello"}); err != nil {
+			t.Fatalf("call sayhello fail! err: %s", err)
+		}
+	}
+	assert.Equal(t, 2, testServerMap["server2"].SayHelloCount)
+	assert.Equal(t, 2, testServerMap["server5"].SayHelloCount)
+	assert.Equal(t, 2, testServerMap["server4"].SayHelloCount)
+}

library/net/rpc/warden/resolver/util.go

@@ -0,0 +1,16 @@
+package resolver
+
+import (
+	"flag"
+	"fmt"
+)
+
+// RegisterTarget will register grpc discovery mock address flag
+func RegisterTarget(target *string, discoveryID string) {
+	flag.CommandLine.StringVar(
+		target,
+		fmt.Sprintf("grpc.%s", discoveryID),
+		fmt.Sprintf("discovery://default/%s", discoveryID),
+		fmt.Sprintf("App's grpc target.\n example: -grpc.%s=\"127.0.0.1:9090\"", discoveryID),
+	)
+}