From fabfc8fd0960ba6b58052fc657dff40d47af5013 Mon Sep 17 00:00:00 2001
From: gmhdbjd <gmhdbjd@gmail.com>
Date: Fri, 8 May 2020 22:49:35 +0800
Subject: [PATCH 01/17] add get-leader command

---
 dm/ctl/ctl.go               |   1 +
 dm/ctl/master/get_leader.go |  56 ++++
 dm/master/server.go         |  21 ++
 dm/master/server_test.go    |  83 +++++
 dm/pb/dmmaster.pb.go        | 653 +++++++++++++++++++++++++++++++-----
 dm/proto/dmmaster.proto     |  13 +
 6 files changed, 740 insertions(+), 87 deletions(-)
 create mode 100644 dm/ctl/master/get_leader.go

diff --git a/dm/ctl/ctl.go b/dm/ctl/ctl.go
index 460aa36f33..b11794d08e 100644
--- a/dm/ctl/ctl.go
+++ b/dm/ctl/ctl.go
@@ -76,6 +76,7 @@ func NewRootCmd() *cobra.Command {
 		master.NewMigrateRelayCmd(),
 		master.NewOperateSourceCmd(),
 		master.NewOfflineWorkerCmd(),
+		master.NewGetLeaderCmd(),
 	)
 	return cmd
 }
diff --git a/dm/ctl/master/get_leader.go b/dm/ctl/master/get_leader.go
new file mode 100644
index 0000000000..84488e7b7f
--- /dev/null
+++ b/dm/ctl/master/get_leader.go
@@ -0,0 +1,56 @@
+// Copyright 2019 PingCAP, Inc.
+//
+// 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,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package master
+
+import (
+	"context"
+	"os"
+
+	"github.com/pingcap/dm/dm/ctl/common"
+	"github.com/pingcap/dm/dm/pb"
+
+	"github.com/pingcap/errors"
+	"github.com/spf13/cobra"
+)
+
+// NewGetLeaderCmd creates an GetLeader command
+func NewGetLeaderCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "get-leader",
+		Short: "get master leader",
+		Run:   getLeaderFunc,
+	}
+	return cmd
+}
+
+// getLeaderFunc does get leader request
+func getLeaderFunc(cmd *cobra.Command, _ []string) {
+	if len(cmd.Flags().Args()) > 0 {
+		cmd.SetOut(os.Stdout)
+		cmd.Usage()
+		return
+	}
+
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	cli := common.MasterClient()
+	resp, err := cli.GetLeader(ctx, &pb.GetLeaderRequest{})
+	if err != nil {
+		common.PrintLines("get leader failed, error:\n%v", errors.ErrorStack(err))
+		return
+	}
+
+	common.PrettyPrintResponse(resp)
+}
diff --git a/dm/master/server.go b/dm/master/server.go
index bbd82283fb..a3e0759e3f 100644
--- a/dm/master/server.go
+++ b/dm/master/server.go
@@ -1559,3 +1559,24 @@ func (s *Server) getSourceRespsAfterOperation(ctx context.Context, taskName stri
 	wg.Wait()
 	return sortCommonWorkerResults(sourceRespCh)
 }
+
+// GetLeader get master leader
+func (s *Server) GetLeader(ctx context.Context, req *pb.GetLeaderRequest) (*pb.GetLeaderResponse, error) {
+	log.L().Info("", zap.Stringer("payload", req), zap.String("request", "GetLeader"))
+
+	_, leaderID, addr, err := s.election.LeaderInfo(ctx)
+
+	if err != nil {
+		return &pb.GetLeaderResponse{
+			Result: false,
+			Msg:    errors.ErrorStack(err),
+		}, nil
+	}
+
+	log.L().Info("get leader successfully", zap.String("leaderId", leaderID))
+	return &pb.GetLeaderResponse{
+		Result: true,
+		Name:   leaderID,
+		Addr:   addr,
+	}, nil
+}
diff --git a/dm/master/server_test.go b/dm/master/server_test.go
index 895cda7a42..4fd2b0d02f 100644
--- a/dm/master/server_test.go
+++ b/dm/master/server_test.go
@@ -1141,3 +1141,86 @@ func mockRevelantWorkerClient(mockWorkerClient *pbmock.MockWorkerClient, taskNam
 		},
 	).Return(queryResp, nil).MaxTimes(maxRetryNum)
 }
+
+func (t *testMaster) TestGetLeader(c *check.C) {
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+	// create a new cluster
+	cfg1 := NewConfig()
+	c.Assert(cfg1.Parse([]string{"-config=./dm-master.toml"}), check.IsNil)
+	cfg1.Name = "dm-master-1"
+	cfg1.DataDir = c.MkDir()
+	cfg1.MasterAddr = tempurl.Alloc()[len("http://"):]
+	cfg1.PeerUrls = tempurl.Alloc()
+	cfg1.AdvertisePeerUrls = cfg1.PeerUrls
+	cfg1.InitialCluster = fmt.Sprintf("%s=%s", cfg1.Name, cfg1.AdvertisePeerUrls)
+
+	s1 := NewServer(cfg1)
+	c.Assert(s1.Start(ctx), check.IsNil)
+
+	// wait the first one become the leader
+	c.Assert(utils.WaitSomething(30, 100*time.Millisecond, func() bool {
+		return s1.election.IsLeader()
+	}), check.IsTrue)
+
+	{
+		res, err := s1.GetLeader(ctx, &pb.GetLeaderRequest{})
+		c.Assert(err, check.IsNil)
+		c.Assert(res.Name, check.Equals, cfg1.Name)
+		c.Assert(res.Addr, check.Equals, cfg1.AdvertiseAddr)
+	}
+
+	// join to an existing cluster
+	cfg2 := NewConfig()
+	c.Assert(cfg2.Parse([]string{"-config=./dm-master.toml"}), check.IsNil)
+	cfg2.Name = "dm-master-2"
+	cfg2.DataDir = c.MkDir()
+	cfg2.MasterAddr = tempurl.Alloc()[len("http://"):]
+	cfg2.PeerUrls = tempurl.Alloc()
+	cfg2.AdvertisePeerUrls = cfg2.PeerUrls
+	cfg2.Join = cfg1.MasterAddr // join to an existing cluster
+
+	s2 := NewServer(cfg2)
+	c.Assert(s2.Start(ctx), check.IsNil)
+	defer s2.Close()
+
+	{
+		res, err := s1.GetLeader(ctx, &pb.GetLeaderRequest{})
+		c.Assert(err, check.IsNil)
+		c.Assert(res.Name, check.Equals, cfg1.Name)
+		c.Assert(res.Addr, check.Equals, cfg1.AdvertiseAddr)
+	}
+	{
+		res, err := s2.GetLeader(ctx, &pb.GetLeaderRequest{})
+		c.Assert(err, check.IsNil)
+		c.Assert(res.Name, check.Equals, cfg1.Name)
+		c.Assert(res.Addr, check.Equals, cfg1.AdvertiseAddr)
+	}
+
+	s1.Close()
+	{
+		res, err := s2.GetLeader(ctx, &pb.GetLeaderRequest{})
+		c.Assert(err, check.IsNil)
+		c.Assert(res.Name, check.Equals, "")
+		c.Assert(res.Addr, check.Equals, "")
+	}
+
+	/*
+		It seems that if we kill leader in 2 masters cluster,
+		the second one wouldn't be the leader so follow cases would not be passed.
+		But I fail to create 3 masters cluster...
+
+		// wait the second one become the leader
+		c.Assert(utils.WaitSomething(30, 100*time.Millisecond, func() bool {
+			return s2.election.IsLeader()
+		}), check.IsTrue)
+
+		{
+			res, err := s2.GetLeader(ctx, &pb.GetLeaderRequest{})
+			c.Assert(err, check.IsNil)
+			c.Assert(res.Name, check.Equals, cfg2.Name)
+			c.Assert(res.Addr, check.Equals, cfg2.AdvertiseAddr)
+		}
+
+	*/
+}
diff --git a/dm/pb/dmmaster.pb.go b/dm/pb/dmmaster.pb.go
index 9a0bde3413..a347eed969 100644
--- a/dm/pb/dmmaster.pb.go
+++ b/dm/pb/dmmaster.pb.go
@@ -2127,6 +2127,110 @@ func (m *OfflineWorkerResponse) GetMsg() string {
 	return ""
 }
 
+type GetLeaderRequest struct {
+}
+
+func (m *GetLeaderRequest) Reset()         { *m = GetLeaderRequest{} }
+func (m *GetLeaderRequest) String() string { return proto.CompactTextString(m) }
+func (*GetLeaderRequest) ProtoMessage()    {}
+func (*GetLeaderRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_f9bef11f2a341f03, []int{35}
+}
+func (m *GetLeaderRequest) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *GetLeaderRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_GetLeaderRequest.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *GetLeaderRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_GetLeaderRequest.Merge(m, src)
+}
+func (m *GetLeaderRequest) XXX_Size() int {
+	return m.Size()
+}
+func (m *GetLeaderRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_GetLeaderRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GetLeaderRequest proto.InternalMessageInfo
+
+type GetLeaderResponse struct {
+	Result bool   `protobuf:"varint,1,opt,name=result,proto3" json:"result,omitempty"`
+	Name   string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
+	Addr   string `protobuf:"bytes,3,opt,name=addr,proto3" json:"addr,omitempty"`
+	Msg    string `protobuf:"bytes,4,opt,name=msg,proto3" json:"msg,omitempty"`
+}
+
+func (m *GetLeaderResponse) Reset()         { *m = GetLeaderResponse{} }
+func (m *GetLeaderResponse) String() string { return proto.CompactTextString(m) }
+func (*GetLeaderResponse) ProtoMessage()    {}
+func (*GetLeaderResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_f9bef11f2a341f03, []int{36}
+}
+func (m *GetLeaderResponse) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *GetLeaderResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_GetLeaderResponse.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *GetLeaderResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_GetLeaderResponse.Merge(m, src)
+}
+func (m *GetLeaderResponse) XXX_Size() int {
+	return m.Size()
+}
+func (m *GetLeaderResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_GetLeaderResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GetLeaderResponse proto.InternalMessageInfo
+
+func (m *GetLeaderResponse) GetResult() bool {
+	if m != nil {
+		return m.Result
+	}
+	return false
+}
+
+func (m *GetLeaderResponse) GetName() string {
+	if m != nil {
+		return m.Name
+	}
+	return ""
+}
+
+func (m *GetLeaderResponse) GetAddr() string {
+	if m != nil {
+		return m.Addr
+	}
+	return ""
+}
+
+func (m *GetLeaderResponse) GetMsg() string {
+	if m != nil {
+		return m.Msg
+	}
+	return ""
+}
+
 func init() {
 	proto.RegisterEnum("pb.SourceOp", SourceOp_name, SourceOp_value)
 	proto.RegisterType((*MigrateWorkerRelayRequest)(nil), "pb.MigrateWorkerRelayRequest")
@@ -2164,99 +2268,104 @@ func init() {
 	proto.RegisterType((*RegisterWorkerResponse)(nil), "pb.RegisterWorkerResponse")
 	proto.RegisterType((*OfflineWorkerRequest)(nil), "pb.OfflineWorkerRequest")
 	proto.RegisterType((*OfflineWorkerResponse)(nil), "pb.OfflineWorkerResponse")
+	proto.RegisterType((*GetLeaderRequest)(nil), "pb.GetLeaderRequest")
+	proto.RegisterType((*GetLeaderResponse)(nil), "pb.GetLeaderResponse")
 }
 
 func init() { proto.RegisterFile("dmmaster.proto", fileDescriptor_f9bef11f2a341f03) }
 
 var fileDescriptor_f9bef11f2a341f03 = []byte{
-	// 1387 bytes of a gzipped FileDescriptorProto
+	// 1433 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x58, 0xcd, 0x6e, 0xdb, 0x46,
-	0x10, 0x16, 0x29, 0xff, 0x8e, 0x1c, 0x47, 0xde, 0xc8, 0x12, 0xc5, 0x38, 0x8a, 0xcb, 0x16, 0x81,
-	0x91, 0x43, 0xdc, 0x38, 0xb7, 0x00, 0x01, 0x9a, 0x58, 0x0e, 0x6a, 0x40, 0xa9, 0x1d, 0xaa, 0x41,
-	0x91, 0x4b, 0x01, 0x5a, 0x5a, 0xc9, 0x84, 0x29, 0x2e, 0x4d, 0x52, 0x76, 0x8d, 0xa2, 0x28, 0xd0,
-	0x17, 0x68, 0x81, 0x1e, 0x72, 0xec, 0x63, 0xf4, 0x15, 0x72, 0x0c, 0xd0, 0x4b, 0x8f, 0x45, 0xd2,
-	0x07, 0x29, 0xf6, 0x87, 0xe4, 0xf2, 0x47, 0x6a, 0xe4, 0xa2, 0xba, 0xed, 0xce, 0x72, 0x67, 0xbe,
-	0x9d, 0x99, 0x9d, 0xf9, 0x96, 0xb0, 0xde, 0x1f, 0x8d, 0xac, 0x20, 0xc4, 0xfe, 0x03, 0xcf, 0x27,
-	0x21, 0x41, 0xaa, 0x77, 0xa2, 0xaf, 0xf7, 0x47, 0x97, 0xc4, 0x3f, 0x8b, 0x64, 0xfa, 0xd6, 0x90,
-	0x90, 0xa1, 0x83, 0x77, 0x2d, 0xcf, 0xde, 0xb5, 0x5c, 0x97, 0x84, 0x56, 0x68, 0x13, 0x37, 0xe0,
-	0xab, 0xc6, 0x39, 0x34, 0x5f, 0xd8, 0x43, 0xdf, 0x0a, 0xf1, 0x37, 0x6c, 0x93, 0x89, 0x1d, 0xeb,
-	0xca, 0xc4, 0xe7, 0x63, 0x1c, 0x84, 0xa8, 0x05, 0xf0, 0xcc, 0x76, 0x1d, 0x32, 0xfc, 0xca, 0x1a,
-	0x61, 0x4d, 0xd9, 0x56, 0x76, 0x56, 0x4d, 0x49, 0x82, 0xb6, 0x60, 0x95, 0xcf, 0x8e, 0x49, 0xa0,
-	0xa9, 0xdb, 0xca, 0xce, 0x0d, 0x33, 0x11, 0xa0, 0x3a, 0x2c, 0x05, 0x64, 0xec, 0xf7, 0xb0, 0x56,
-	0x66, 0x3b, 0xc5, 0xcc, 0x38, 0x86, 0xd6, 0x2b, 0xaf, 0x9f, 0xb6, 0xb8, 0x4f, 0xdc, 0x81, 0x3d,
-	0x8c, 0xec, 0xd6, 0x61, 0xa9, 0xc7, 0x04, 0xc2, 0xa6, 0x98, 0x49, 0x1a, 0xd5, 0x94, 0xc6, 0x2f,
-	0xa0, 0xda, 0x0d, 0x2d, 0x3f, 0xfc, 0xda, 0x0a, 0xce, 0x22, 0x1d, 0x08, 0x16, 0x42, 0x2b, 0x38,
-	0x13, 0x1a, 0xd8, 0x18, 0x69, 0xb0, 0xcc, 0x77, 0x50, 0xb4, 0xe5, 0x9d, 0x55, 0x33, 0x9a, 0x1a,
-	0xe7, 0xb0, 0x21, 0x69, 0x08, 0x3c, 0xe2, 0x06, 0x98, 0x9a, 0xf3, 0x71, 0x30, 0x76, 0x42, 0xa6,
-	0x64, 0xc5, 0x14, 0x33, 0x54, 0x85, 0xf2, 0x28, 0x18, 0x0a, 0x0c, 0x74, 0x88, 0xf6, 0x12, 0xc5,
-	0xe5, 0xed, 0xf2, 0x4e, 0x65, 0x4f, 0x7b, 0xe0, 0x9d, 0x3c, 0xd8, 0x27, 0xa3, 0x11, 0x71, 0xa3,
-	0x53, 0x72, 0xa5, 0x89, 0xc9, 0x47, 0xd0, 0xe4, 0x6e, 0x78, 0xc1, 0x22, 0xf8, 0x51, 0x1e, 0x30,
-	0xae, 0x40, 0x2f, 0xda, 0x34, 0x33, 0xe0, 0x87, 0x59, 0xc0, 0x0d, 0x0a, 0xf8, 0xe5, 0x18, 0xfb,
-	0x57, 0xdd, 0xd0, 0x0a, 0xc7, 0x41, 0x1e, 0xef, 0xb7, 0x80, 0x8e, 0x3c, 0x4c, 0x33, 0x45, 0x76,
-	0xb3, 0x0e, 0x2a, 0xf1, 0x98, 0xb9, 0xf5, 0x3d, 0xa0, 0x3a, 0xe8, 0xe2, 0x91, 0x67, 0xaa, 0xc4,
-	0xa3, 0x21, 0x70, 0x69, 0xe2, 0x70, 0xbb, 0x6c, 0x2c, 0x87, 0xa0, 0x9c, 0x0e, 0xc1, 0xcf, 0x0a,
-	0xdc, 0x4a, 0x19, 0x10, 0x87, 0x9a, 0x66, 0x21, 0x39, 0xb0, 0x5a, 0x74, 0xe0, 0x72, 0x61, 0x84,
-	0x16, 0x3e, 0x36, 0x42, 0x4f, 0x61, 0x83, 0x3b, 0xfb, 0xfa, 0x79, 0xe5, 0x03, 0x92, 0x55, 0xcc,
-	0x25, 0xb1, 0x9e, 0x43, 0x5d, 0x0a, 0x64, 0xc7, 0x0e, 0x42, 0x09, 0xbb, 0x9b, 0xdc, 0xe4, 0x5c,
-	0x40, 0x32, 0xd8, 0x2f, 0xa0, 0x91, 0xd3, 0x33, 0x8f, 0x44, 0x3b, 0x80, 0x4d, 0xb6, 0x7e, 0xe0,
-	0xfb, 0xc4, 0xbf, 0x3e, 0xfc, 0x50, 0xb8, 0x41, 0x52, 0x33, 0x33, 0xfa, 0xcf, 0xb3, 0xe8, 0xeb,
-	0x31, 0x7a, 0xa6, 0x36, 0x0f, 0x7e, 0x1f, 0x6e, 0x75, 0x4f, 0xc9, 0x65, 0xbb, 0xdd, 0xe9, 0x90,
-	0xde, 0x59, 0x70, 0xbd, 0xac, 0xf9, 0x4d, 0x81, 0x65, 0xa1, 0x01, 0xad, 0x83, 0x7a, 0xd8, 0x16,
-	0xfb, 0xd4, 0xc3, 0x76, 0xac, 0x49, 0x95, 0x34, 0x21, 0x58, 0x18, 0x91, 0x7e, 0x54, 0x67, 0xd9,
-	0x18, 0xd5, 0x60, 0x91, 0x5c, 0xba, 0xd8, 0xd7, 0x16, 0x98, 0x90, 0x4f, 0xe8, 0x97, 0xed, 0x76,
-	0x27, 0xd0, 0x16, 0x99, 0x41, 0x36, 0x66, 0x55, 0xf5, 0xca, 0xed, 0xe1, 0xbe, 0xb6, 0xc4, 0xa4,
-	0x62, 0x86, 0x74, 0x58, 0x19, 0xbb, 0x62, 0x65, 0x99, 0xad, 0xc4, 0x73, 0xa3, 0x07, 0xb5, 0xf4,
-	0x31, 0x67, 0x76, 0xed, 0x27, 0xb0, 0xe8, 0xd0, 0xad, 0xc2, 0xb1, 0x15, 0xea, 0x58, 0xa1, 0xce,
-	0xe4, 0x2b, 0x86, 0x03, 0xb5, 0x57, 0x2e, 0x1d, 0x46, 0x72, 0xe1, 0xcc, 0xac, 0x4b, 0x0c, 0x58,
-	0xf3, 0xb1, 0xe7, 0x58, 0x3d, 0x7c, 0xc4, 0x4e, 0xcc, 0xad, 0xa4, 0x64, 0x68, 0x1b, 0x2a, 0x03,
-	0xe2, 0xf7, 0xb0, 0x89, 0x47, 0xe4, 0x82, 0x7b, 0x6a, 0xc5, 0x94, 0x45, 0xc6, 0x53, 0xd8, 0xcc,
-	0x58, 0x9b, 0xf5, 0x4c, 0xc6, 0x63, 0x68, 0x75, 0x2f, 0xed, 0xb0, 0x77, 0x2a, 0x75, 0x36, 0x5e,
-	0xa8, 0x23, 0xe8, 0x52, 0xcc, 0x95, 0x74, 0xcc, 0x7f, 0x84, 0xbb, 0x13, 0xf7, 0xce, 0xa5, 0x6c,
-	0x98, 0xd0, 0x14, 0xe5, 0xb7, 0x80, 0x09, 0xdc, 0x96, 0x8a, 0x30, 0x0b, 0x15, 0x5b, 0x15, 0x55,
-	0x78, 0x72, 0x22, 0xbf, 0x51, 0x40, 0x2f, 0x52, 0x2a, 0x0e, 0x34, 0x55, 0xeb, 0xff, 0x5b, 0xdb,
-	0xdf, 0x2a, 0xb0, 0xf1, 0xa5, 0xe5, 0xf6, 0x1d, 0xdc, 0x7d, 0xd9, 0x09, 0xa6, 0x55, 0x98, 0x26,
-	0x03, 0xa9, 0x32, 0x90, 0xab, 0x54, 0x71, 0xf7, 0x65, 0x27, 0x69, 0x70, 0x96, 0x3f, 0x8c, 0x3a,
-	0x19, 0x1b, 0x53, 0x4e, 0x74, 0x12, 0x73, 0x22, 0x7e, 0xf7, 0x12, 0x81, 0xc4, 0x60, 0x16, 0x65,
-	0x06, 0x43, 0x99, 0x56, 0x70, 0xee, 0x1c, 0x5b, 0x61, 0x88, 0x7d, 0x57, 0x5b, 0xe2, 0x4c, 0x2b,
-	0x91, 0xd0, 0xbb, 0x18, 0x9c, 0x5a, 0x7e, 0xdf, 0x76, 0x87, 0xda, 0x32, 0x73, 0x47, 0x3c, 0xa7,
-	0x3d, 0x46, 0x3e, 0xc9, 0x5c, 0x92, 0xe5, 0x8d, 0x02, 0x8d, 0xe3, 0xb1, 0x3f, 0x2c, 0xca, 0x95,
-	0x89, 0x39, 0x4e, 0x4f, 0x61, 0xbb, 0x56, 0x2f, 0xb4, 0x2f, 0xb0, 0x08, 0x6a, 0x3c, 0x67, 0x75,
-	0xcd, 0x1e, 0xf1, 0x9b, 0x59, 0x36, 0xd9, 0x98, 0x7e, 0x3f, 0xb0, 0x1d, 0xcc, 0x42, 0xc2, 0x5d,
-	0x19, 0xcf, 0x99, 0x27, 0xc7, 0x27, 0x6d, 0xdb, 0x8f, 0x3d, 0xc9, 0x66, 0xc6, 0x77, 0xa0, 0xe5,
-	0x81, 0xcd, 0xc5, 0x27, 0xf7, 0xa0, 0xba, 0x7f, 0x8a, 0x7b, 0x67, 0xff, 0xc2, 0x16, 0x8c, 0x27,
-	0xb0, 0x21, 0x7d, 0x37, 0x73, 0x91, 0xe9, 0x40, 0x4d, 0x5c, 0xa9, 0x2e, 0x33, 0x1c, 0x99, 0xda,
-	0x92, 0x2e, 0xd3, 0x1a, 0xcb, 0x53, 0xb6, 0x9c, 0xdc, 0x26, 0x41, 0x28, 0xd5, 0x14, 0xa1, 0x1c,
-	0xc3, 0x66, 0x46, 0xdb, 0x5c, 0x7c, 0x75, 0x00, 0x9b, 0x26, 0x1e, 0xda, 0xb4, 0xbc, 0x45, 0x9f,
-	0x4c, 0xed, 0xf1, 0x56, 0xbf, 0xef, 0xe3, 0x20, 0x10, 0x66, 0xa3, 0xa9, 0xf1, 0x0c, 0xea, 0x59,
-	0x35, 0x33, 0xfb, 0xb3, 0x0d, 0xb5, 0xa3, 0xc1, 0xc0, 0xb1, 0x5d, 0xfc, 0x5f, 0x90, 0x3c, 0x85,
-	0xcd, 0x8c, 0x96, 0x59, 0x81, 0xdc, 0x37, 0x61, 0x25, 0x0a, 0x19, 0xba, 0x05, 0x37, 0x0f, 0xdd,
-	0x0b, 0xcb, 0xb1, 0xfb, 0x91, 0xa8, 0x5a, 0x42, 0x37, 0xa1, 0xc2, 0x1e, 0x29, 0x5c, 0x54, 0x55,
-	0x50, 0x15, 0xd6, 0x38, 0xbb, 0x14, 0x12, 0x15, 0xad, 0x03, 0x74, 0x43, 0xe2, 0x89, 0x79, 0x79,
-	0xef, 0xf7, 0x0a, 0x2c, 0xf1, 0x2e, 0x82, 0x5e, 0xc3, 0x6a, 0xfc, 0xc4, 0x41, 0x35, 0x96, 0x20,
-	0x99, 0x37, 0x93, 0xbe, 0x99, 0x91, 0xf2, 0x23, 0x18, 0x77, 0x7f, 0xfa, 0xe3, 0xef, 0x5f, 0xd5,
-	0xa6, 0x51, 0xa3, 0x6f, 0xc8, 0x60, 0xf7, 0xe2, 0xa1, 0xe5, 0x78, 0xa7, 0xd6, 0xc3, 0x5d, 0x9a,
-	0xcd, 0xc1, 0x63, 0xe5, 0x3e, 0x1a, 0x40, 0x45, 0x62, 0xee, 0x88, 0x91, 0xa4, 0xfc, 0x5b, 0x41,
-	0x6f, 0xe4, 0xe4, 0xc2, 0xc0, 0x3d, 0x66, 0x60, 0x5b, 0xbf, 0x5d, 0x64, 0x60, 0xf7, 0x7b, 0xea,
-	0xfa, 0x1f, 0xa8, 0x9d, 0x27, 0x00, 0x09, 0x9b, 0x46, 0x0c, 0x6d, 0x8e, 0xa0, 0xeb, 0xf5, 0xac,
-	0x58, 0x18, 0x29, 0x21, 0x07, 0x2a, 0x12, 0xf1, 0x44, 0x7a, 0x86, 0x89, 0x4a, 0x54, 0x53, 0xbf,
-	0x5d, 0xb8, 0x26, 0x34, 0x7d, 0xc6, 0xe0, 0xb6, 0xd0, 0x56, 0x06, 0x6e, 0xc0, 0x3e, 0x15, 0x78,
-	0xd1, 0x01, 0x40, 0x42, 0x14, 0x51, 0x33, 0x4d, 0x1c, 0x65, 0x5b, 0x7a, 0xd1, 0x52, 0x0c, 0x7a,
-	0x1f, 0xd6, 0x64, 0xa6, 0x85, 0x98, 0x13, 0x0b, 0x28, 0xa6, 0xae, 0xe5, 0x17, 0x62, 0x25, 0xcf,
-	0xe1, 0x46, 0x8a, 0xdb, 0x20, 0xf6, 0x71, 0x11, 0xb9, 0xd2, 0x9b, 0x05, 0x2b, 0xb1, 0x9e, 0x57,
-	0xd1, 0x73, 0x46, 0x7e, 0x7e, 0xa2, 0x3b, 0x89, 0xc7, 0x0b, 0xde, 0xb2, 0x7a, 0x6b, 0xd2, 0x72,
-	0xac, 0xf6, 0x35, 0x34, 0x26, 0xfc, 0x11, 0x40, 0x46, 0xb2, 0x79, 0xd2, 0xef, 0x02, 0x7d, 0x62,
-	0xbd, 0x31, 0x4a, 0x34, 0x65, 0x92, 0xe6, 0xc8, 0x53, 0x26, 0xd7, 0xf6, 0x79, 0xca, 0xe4, 0x7b,
-	0xa8, 0x51, 0x42, 0x7d, 0x68, 0x4c, 0x60, 0x65, 0x1c, 0xd9, 0x74, 0xba, 0xa7, 0x7f, 0x3a, 0xf5,
-	0x1b, 0xe9, 0xfc, 0xf5, 0x3c, 0x4b, 0x62, 0x39, 0x7e, 0x47, 0xba, 0x32, 0xf9, 0x56, 0xcb, 0x5d,
-	0x3b, 0x99, 0x60, 0x19, 0x25, 0x74, 0x04, 0xd5, 0x6c, 0x3b, 0x44, 0x2c, 0xb9, 0x27, 0x74, 0x6f,
-	0x7d, 0xab, 0x78, 0x51, 0x52, 0x88, 0xf2, 0x3f, 0x8c, 0x38, 0xce, 0x89, 0x3f, 0x92, 0xa6, 0x46,
-	0xe8, 0x31, 0xac, 0xc6, 0xed, 0x90, 0xd7, 0xa5, 0x6c, 0x17, 0xe5, 0x75, 0x29, 0xd7, 0x33, 0x79,
-	0x5e, 0xa7, 0xba, 0x17, 0xcf, 0xeb, 0xa2, 0xf6, 0xc8, 0xf3, 0xba, 0xb0, 0xd5, 0x19, 0x25, 0x74,
-	0x08, 0xeb, 0xe9, 0x3e, 0xc2, 0xef, 0x6b, 0x61, 0x8b, 0xe2, 0xf7, 0xb5, 0xb8, 0xed, 0x08, 0x48,
-	0x72, 0x23, 0x10, 0x90, 0x0a, 0x3a, 0x8c, 0x80, 0x54, 0xd4, 0x35, 0x8c, 0xd2, 0x33, 0xed, 0xed,
-	0xfb, 0x96, 0xf2, 0xee, 0x7d, 0x4b, 0xf9, 0xeb, 0x7d, 0x4b, 0xf9, 0xe5, 0x43, 0xab, 0xf4, 0xee,
-	0x43, 0xab, 0xf4, 0xe7, 0x87, 0x56, 0xe9, 0x64, 0x89, 0xfd, 0xb9, 0x7b, 0xf4, 0x4f, 0x00, 0x00,
-	0x00, 0xff, 0xff, 0x95, 0x5b, 0xbc, 0xa9, 0xfd, 0x13, 0x00, 0x00,
+	0x10, 0x16, 0x29, 0xff, 0x8e, 0x1c, 0x47, 0xde, 0xc8, 0x32, 0xc5, 0x38, 0x8a, 0xcb, 0x16, 0x81,
+	0x91, 0x43, 0xdc, 0x38, 0xb7, 0x00, 0x01, 0x9a, 0x58, 0x4e, 0x6b, 0x40, 0xa9, 0x1d, 0xaa, 0x41,
+	0x91, 0x4b, 0x01, 0x5a, 0x5c, 0xcb, 0x84, 0x29, 0x2e, 0x4d, 0x52, 0x76, 0x8d, 0xa2, 0x28, 0xd0,
+	0x17, 0x68, 0x81, 0x1e, 0x72, 0xec, 0xeb, 0xe4, 0x18, 0xa0, 0x97, 0x1e, 0x8b, 0xa4, 0x6f, 0xd0,
+	0x17, 0x28, 0xf6, 0x87, 0xe4, 0xf2, 0x47, 0x4a, 0x94, 0xa2, 0xba, 0xed, 0xce, 0x72, 0x67, 0xbe,
+	0x9d, 0x99, 0x9d, 0xf9, 0x96, 0xb0, 0x6a, 0x0f, 0x87, 0x56, 0x18, 0xe1, 0xe0, 0x9e, 0x1f, 0x90,
+	0x88, 0x20, 0xd5, 0x3f, 0xd6, 0x57, 0xed, 0xe1, 0x25, 0x09, 0xce, 0x62, 0x99, 0xbe, 0x39, 0x20,
+	0x64, 0xe0, 0xe2, 0x1d, 0xcb, 0x77, 0x76, 0x2c, 0xcf, 0x23, 0x91, 0x15, 0x39, 0xc4, 0x0b, 0xf9,
+	0xaa, 0x71, 0x0e, 0xad, 0x67, 0xce, 0x20, 0xb0, 0x22, 0xfc, 0x2d, 0xdb, 0x64, 0x62, 0xd7, 0xba,
+	0x32, 0xf1, 0xf9, 0x08, 0x87, 0x11, 0x6a, 0x03, 0x3c, 0x71, 0x3c, 0x97, 0x0c, 0xbe, 0xb6, 0x86,
+	0x58, 0x53, 0xb6, 0x94, 0xed, 0x65, 0x53, 0x92, 0xa0, 0x4d, 0x58, 0xe6, 0xb3, 0x23, 0x12, 0x6a,
+	0xea, 0x96, 0xb2, 0x7d, 0xcd, 0x4c, 0x05, 0xa8, 0x09, 0x0b, 0x21, 0x19, 0x05, 0x7d, 0xac, 0x55,
+	0xd9, 0x4e, 0x31, 0x33, 0x8e, 0xa0, 0xfd, 0xc2, 0xb7, 0xb3, 0x16, 0xf7, 0x88, 0x77, 0xe2, 0x0c,
+	0x62, 0xbb, 0x4d, 0x58, 0xe8, 0x33, 0x81, 0xb0, 0x29, 0x66, 0x92, 0x46, 0x35, 0xa3, 0xf1, 0x0b,
+	0xa8, 0xf7, 0x22, 0x2b, 0x88, 0xbe, 0xb1, 0xc2, 0xb3, 0x58, 0x07, 0x82, 0xb9, 0xc8, 0x0a, 0xcf,
+	0x84, 0x06, 0x36, 0x46, 0x1a, 0x2c, 0xf2, 0x1d, 0x14, 0x6d, 0x75, 0x7b, 0xd9, 0x8c, 0xa7, 0xc6,
+	0x39, 0xac, 0x49, 0x1a, 0x42, 0x9f, 0x78, 0x21, 0xa6, 0xe6, 0x02, 0x1c, 0x8e, 0xdc, 0x88, 0x29,
+	0x59, 0x32, 0xc5, 0x0c, 0xd5, 0xa1, 0x3a, 0x0c, 0x07, 0x02, 0x03, 0x1d, 0xa2, 0xdd, 0x54, 0x71,
+	0x75, 0xab, 0xba, 0x5d, 0xdb, 0xd5, 0xee, 0xf9, 0xc7, 0xf7, 0xf6, 0xc8, 0x70, 0x48, 0xbc, 0xf8,
+	0x94, 0x5c, 0x69, 0x6a, 0xf2, 0x01, 0xb4, 0xb8, 0x1b, 0x9e, 0xb1, 0x08, 0x7e, 0x90, 0x07, 0x8c,
+	0x2b, 0xd0, 0xcb, 0x36, 0x4d, 0x0d, 0xf8, 0x7e, 0x1e, 0xf0, 0x06, 0x05, 0xfc, 0x7c, 0x84, 0x83,
+	0xab, 0x5e, 0x64, 0x45, 0xa3, 0xb0, 0x88, 0xf7, 0x3b, 0x40, 0x87, 0x3e, 0xa6, 0x99, 0x22, 0xbb,
+	0x59, 0x07, 0x95, 0xf8, 0xcc, 0xdc, 0xea, 0x2e, 0x50, 0x1d, 0x74, 0xf1, 0xd0, 0x37, 0x55, 0xe2,
+	0xd3, 0x10, 0x78, 0x34, 0x71, 0xb8, 0x5d, 0x36, 0x96, 0x43, 0x50, 0xcd, 0x86, 0xe0, 0x17, 0x05,
+	0x6e, 0x64, 0x0c, 0x88, 0x43, 0x4d, 0xb2, 0x90, 0x1e, 0x58, 0x2d, 0x3b, 0x70, 0xb5, 0x34, 0x42,
+	0x73, 0x1f, 0x1a, 0xa1, 0xc7, 0xb0, 0xc6, 0x9d, 0xfd, 0xf1, 0x79, 0x15, 0x00, 0x92, 0x55, 0xcc,
+	0x24, 0xb1, 0x9e, 0x42, 0x53, 0x0a, 0x64, 0xd7, 0x09, 0x23, 0x09, 0xbb, 0x97, 0xde, 0xe4, 0x42,
+	0x40, 0x72, 0xd8, 0x2f, 0x60, 0xa3, 0xa0, 0x67, 0x16, 0x89, 0xb6, 0x0f, 0xeb, 0x6c, 0x7d, 0x3f,
+	0x08, 0x48, 0xf0, 0xf1, 0xf0, 0x23, 0xe1, 0x06, 0x49, 0xcd, 0xd4, 0xe8, 0x3f, 0xcf, 0xa3, 0x6f,
+	0x26, 0xe8, 0x99, 0xda, 0x22, 0xf8, 0x3d, 0xb8, 0xd1, 0x3b, 0x25, 0x97, 0x9d, 0x4e, 0xb7, 0x4b,
+	0xfa, 0x67, 0xe1, 0xc7, 0x65, 0xcd, 0xef, 0x0a, 0x2c, 0x0a, 0x0d, 0x68, 0x15, 0xd4, 0x83, 0x8e,
+	0xd8, 0xa7, 0x1e, 0x74, 0x12, 0x4d, 0xaa, 0xa4, 0x09, 0xc1, 0xdc, 0x90, 0xd8, 0x71, 0x9d, 0x65,
+	0x63, 0xd4, 0x80, 0x79, 0x72, 0xe9, 0xe1, 0x40, 0x9b, 0x63, 0x42, 0x3e, 0xa1, 0x5f, 0x76, 0x3a,
+	0xdd, 0x50, 0x9b, 0x67, 0x06, 0xd9, 0x98, 0x55, 0xd5, 0x2b, 0xaf, 0x8f, 0x6d, 0x6d, 0x81, 0x49,
+	0xc5, 0x0c, 0xe9, 0xb0, 0x34, 0xf2, 0xc4, 0xca, 0x22, 0x5b, 0x49, 0xe6, 0x46, 0x1f, 0x1a, 0xd9,
+	0x63, 0x4e, 0xed, 0xda, 0x4f, 0x60, 0xde, 0xa5, 0x5b, 0x85, 0x63, 0x6b, 0xd4, 0xb1, 0x42, 0x9d,
+	0xc9, 0x57, 0x0c, 0x17, 0x1a, 0x2f, 0x3c, 0x3a, 0x8c, 0xe5, 0xc2, 0x99, 0x79, 0x97, 0x18, 0xb0,
+	0x12, 0x60, 0xdf, 0xb5, 0xfa, 0xf8, 0x90, 0x9d, 0x98, 0x5b, 0xc9, 0xc8, 0xd0, 0x16, 0xd4, 0x4e,
+	0x48, 0xd0, 0xc7, 0x26, 0x1e, 0x92, 0x0b, 0xee, 0xa9, 0x25, 0x53, 0x16, 0x19, 0x8f, 0x61, 0x3d,
+	0x67, 0x6d, 0xda, 0x33, 0x19, 0x0f, 0xa1, 0xdd, 0xbb, 0x74, 0xa2, 0xfe, 0xa9, 0xd4, 0xd9, 0x78,
+	0xa1, 0x8e, 0xa1, 0x4b, 0x31, 0x57, 0xb2, 0x31, 0xff, 0x09, 0x6e, 0x8f, 0xdd, 0x3b, 0x93, 0xb2,
+	0x61, 0x42, 0x4b, 0x94, 0xdf, 0x12, 0x26, 0x70, 0x53, 0x2a, 0xc2, 0x2c, 0x54, 0x6c, 0x55, 0x54,
+	0xe1, 0xf1, 0x89, 0xfc, 0x4a, 0x01, 0xbd, 0x4c, 0xa9, 0x38, 0xd0, 0x44, 0xad, 0xff, 0x6f, 0x6d,
+	0x7f, 0xad, 0xc0, 0xda, 0x57, 0x96, 0x67, 0xbb, 0xb8, 0xf7, 0xbc, 0x1b, 0x4e, 0xaa, 0x30, 0x2d,
+	0x06, 0x52, 0x65, 0x20, 0x97, 0xa9, 0xe2, 0xde, 0xf3, 0x6e, 0xda, 0xe0, 0xac, 0x60, 0x10, 0x77,
+	0x32, 0x36, 0xa6, 0x9c, 0xe8, 0x38, 0xe1, 0x44, 0xfc, 0xee, 0xa5, 0x02, 0x89, 0xc1, 0xcc, 0xcb,
+	0x0c, 0x86, 0x32, 0xad, 0xf0, 0xdc, 0x3d, 0xb2, 0xa2, 0x08, 0x07, 0x9e, 0xb6, 0xc0, 0x99, 0x56,
+	0x2a, 0xa1, 0x77, 0x31, 0x3c, 0xb5, 0x02, 0xdb, 0xf1, 0x06, 0xda, 0x22, 0x73, 0x47, 0x32, 0xa7,
+	0x3d, 0x46, 0x3e, 0xc9, 0x4c, 0x92, 0xe5, 0x95, 0x02, 0x1b, 0x47, 0xa3, 0x60, 0x50, 0x96, 0x2b,
+	0x63, 0x73, 0x9c, 0x9e, 0xc2, 0xf1, 0xac, 0x7e, 0xe4, 0x5c, 0x60, 0x11, 0xd4, 0x64, 0xce, 0xea,
+	0x9a, 0x33, 0xe4, 0x37, 0xb3, 0x6a, 0xb2, 0x31, 0xfd, 0xfe, 0xc4, 0x71, 0x31, 0x0b, 0x09, 0x77,
+	0x65, 0x32, 0x67, 0x9e, 0x1c, 0x1d, 0x77, 0x9c, 0x20, 0xf1, 0x24, 0x9b, 0x19, 0xdf, 0x83, 0x56,
+	0x04, 0x36, 0x13, 0x9f, 0xdc, 0x81, 0xfa, 0xde, 0x29, 0xee, 0x9f, 0xbd, 0x87, 0x2d, 0x18, 0x8f,
+	0x60, 0x4d, 0xfa, 0x6e, 0xea, 0x22, 0xd3, 0x85, 0x86, 0xb8, 0x52, 0x3d, 0x66, 0x38, 0x36, 0xb5,
+	0x29, 0x5d, 0xa6, 0x15, 0x96, 0xa7, 0x6c, 0x39, 0xbd, 0x4d, 0x82, 0x50, 0xaa, 0x19, 0x42, 0x39,
+	0x82, 0xf5, 0x9c, 0xb6, 0x99, 0xf8, 0x6a, 0x1f, 0xd6, 0x4d, 0x3c, 0x70, 0x68, 0x79, 0x8b, 0x3f,
+	0x99, 0xd8, 0xe3, 0x2d, 0xdb, 0x0e, 0x70, 0x18, 0x0a, 0xb3, 0xf1, 0xd4, 0x78, 0x02, 0xcd, 0xbc,
+	0x9a, 0xa9, 0xfd, 0xd9, 0x81, 0xc6, 0xe1, 0xc9, 0x89, 0xeb, 0x78, 0xf8, 0xbf, 0x20, 0x79, 0x0c,
+	0xeb, 0x39, 0x2d, 0x53, 0x03, 0x41, 0x50, 0xff, 0x12, 0x47, 0x5d, 0x6c, 0xd9, 0x09, 0x08, 0x03,
+	0xc3, 0x9a, 0x24, 0x7b, 0x8f, 0xca, 0x32, 0xbe, 0x4d, 0x4b, 0x94, 0x6d, 0x07, 0x31, 0x35, 0xa0,
+	0xe3, 0xd8, 0xf4, 0x5c, 0x62, 0xfa, 0xae, 0x09, 0x4b, 0x71, 0xb6, 0xa0, 0x1b, 0x70, 0xfd, 0xc0,
+	0xbb, 0xb0, 0x5c, 0xc7, 0x8e, 0x45, 0xf5, 0x0a, 0xba, 0x0e, 0x35, 0xf6, 0x3e, 0xe2, 0xa2, 0xba,
+	0x82, 0xea, 0xb0, 0xc2, 0x89, 0xad, 0x90, 0xa8, 0x68, 0x15, 0xa0, 0x17, 0x11, 0x5f, 0xcc, 0xab,
+	0xbb, 0xff, 0xd4, 0x60, 0x81, 0x37, 0x30, 0xf4, 0x12, 0x96, 0x93, 0xd7, 0x15, 0x6a, 0xb0, 0xdc,
+	0xcc, 0x3d, 0xd7, 0xf4, 0xf5, 0x9c, 0x94, 0x1f, 0xd5, 0xb8, 0xfd, 0xf3, 0x1f, 0x7f, 0xff, 0xa6,
+	0xb6, 0x8c, 0x06, 0x7d, 0xbe, 0x86, 0x3b, 0x17, 0xf7, 0x2d, 0xd7, 0x3f, 0xb5, 0xee, 0xef, 0xd0,
+	0x8b, 0x14, 0x3e, 0x54, 0xee, 0xa2, 0x13, 0xa8, 0x49, 0x8f, 0x06, 0xc4, 0xf8, 0x59, 0xf1, 0x99,
+	0xa2, 0x6f, 0x14, 0xe4, 0xc2, 0xc0, 0x1d, 0x66, 0x60, 0x4b, 0xbf, 0x59, 0x66, 0x60, 0xe7, 0x07,
+	0xea, 0xc3, 0x1f, 0xa9, 0x9d, 0x47, 0x00, 0x29, 0x91, 0x47, 0x0c, 0x6d, 0xe1, 0x6d, 0xa0, 0x37,
+	0xf3, 0x62, 0x61, 0xa4, 0x82, 0x5c, 0xa8, 0x49, 0x9c, 0x17, 0xe9, 0x39, 0x12, 0x2c, 0xb1, 0x5c,
+	0xfd, 0x66, 0xe9, 0x9a, 0xd0, 0xf4, 0x19, 0x83, 0xdb, 0x46, 0x9b, 0x39, 0xb8, 0x21, 0xfb, 0x54,
+	0xe0, 0x45, 0xfb, 0x00, 0x29, 0x47, 0x45, 0xad, 0x2c, 0x67, 0x95, 0x6d, 0xe9, 0x65, 0x4b, 0x09,
+	0xe8, 0x3d, 0x58, 0x91, 0x49, 0x1e, 0x62, 0x4e, 0x2c, 0x61, 0xb7, 0xba, 0x56, 0x5c, 0x48, 0x94,
+	0x3c, 0x85, 0x6b, 0x19, 0x5a, 0x85, 0xd8, 0xc7, 0x65, 0xbc, 0x4e, 0x6f, 0x95, 0xac, 0x24, 0x7a,
+	0x5e, 0xc4, 0x2f, 0x29, 0xf9, 0xe5, 0x8b, 0x6e, 0xa5, 0x1e, 0x2f, 0x79, 0x46, 0xeb, 0xed, 0x71,
+	0xcb, 0x89, 0xda, 0x97, 0xb0, 0x31, 0xe6, 0x67, 0x04, 0x32, 0xd2, 0xcd, 0xe3, 0xfe, 0x54, 0xe8,
+	0x63, 0x4b, 0x9d, 0x51, 0xa1, 0x29, 0x93, 0xf6, 0x65, 0x9e, 0x32, 0x05, 0xc6, 0xc1, 0x53, 0xa6,
+	0xd8, 0xbe, 0x8d, 0x0a, 0xb2, 0x61, 0x63, 0x0c, 0x21, 0xe4, 0xc8, 0x26, 0x33, 0x4d, 0xfd, 0xd3,
+	0x89, 0xdf, 0x48, 0xe7, 0x6f, 0x16, 0x09, 0x1a, 0xcb, 0xf1, 0x5b, 0xd2, 0x95, 0x29, 0x76, 0x79,
+	0xee, 0xda, 0xf1, 0xdc, 0xce, 0xa8, 0xa0, 0x43, 0xa8, 0xe7, 0x3b, 0x31, 0x62, 0xc9, 0x3d, 0x86,
+	0x38, 0xe8, 0x9b, 0xe5, 0x8b, 0x92, 0x42, 0x54, 0xfc, 0x57, 0xc5, 0x71, 0x8e, 0xfd, 0x87, 0x35,
+	0x31, 0x42, 0x0f, 0x61, 0x39, 0xe9, 0xc4, 0xbc, 0x2e, 0xe5, 0x1b, 0x38, 0xaf, 0x4b, 0x85, 0x76,
+	0xcd, 0xf3, 0x3a, 0xd3, 0x38, 0x79, 0x5e, 0x97, 0x75, 0x66, 0x9e, 0xd7, 0xa5, 0x5d, 0xd6, 0xa8,
+	0xa0, 0x03, 0x58, 0xcd, 0xb6, 0x30, 0x7e, 0x5f, 0x4b, 0xbb, 0x23, 0xbf, 0xaf, 0xe5, 0x1d, 0x4f,
+	0x40, 0x92, 0x7b, 0x90, 0x80, 0x54, 0xd2, 0xdc, 0x04, 0xa4, 0xb2, 0x86, 0xc5, 0xdd, 0x92, 0x34,
+	0x1d, 0xee, 0x96, 0x7c, 0x5f, 0xe2, 0x6e, 0x29, 0x74, 0x26, 0xa3, 0xf2, 0x44, 0x7b, 0xfd, 0xb6,
+	0xad, 0xbc, 0x79, 0xdb, 0x56, 0xfe, 0x7a, 0xdb, 0x56, 0x7e, 0x7d, 0xd7, 0xae, 0xbc, 0x79, 0xd7,
+	0xae, 0xfc, 0xf9, 0xae, 0x5d, 0x39, 0x5e, 0x60, 0x3f, 0x1c, 0x1f, 0xfc, 0x1b, 0x00, 0x00, 0xff,
+	0xff, 0xdc, 0xaa, 0x67, 0x01, 0xb4, 0x14, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -2299,6 +2408,8 @@ type MasterClient interface {
 	RegisterWorker(ctx context.Context, in *RegisterWorkerRequest, opts ...grpc.CallOption) (*RegisterWorkerResponse, error)
 	// OfflineWorker offline the dm-workers.
 	OfflineWorker(ctx context.Context, in *OfflineWorkerRequest, opts ...grpc.CallOption) (*OfflineWorkerResponse, error)
+	// GetLeader get master leader.
+	GetLeader(ctx context.Context, in *GetLeaderRequest, opts ...grpc.CallOption) (*GetLeaderResponse, error)
 }
 
 type masterClient struct {
@@ -2471,6 +2582,15 @@ func (c *masterClient) OfflineWorker(ctx context.Context, in *OfflineWorkerReque
 	return out, nil
 }
 
+func (c *masterClient) GetLeader(ctx context.Context, in *GetLeaderRequest, opts ...grpc.CallOption) (*GetLeaderResponse, error) {
+	out := new(GetLeaderResponse)
+	err := c.cc.Invoke(ctx, "/pb.Master/GetLeader", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 // MasterServer is the server API for Master service.
 type MasterServer interface {
 	StartTask(context.Context, *StartTaskRequest) (*StartTaskResponse, error)
@@ -2501,6 +2621,8 @@ type MasterServer interface {
 	RegisterWorker(context.Context, *RegisterWorkerRequest) (*RegisterWorkerResponse, error)
 	// OfflineWorker offline the dm-workers.
 	OfflineWorker(context.Context, *OfflineWorkerRequest) (*OfflineWorkerResponse, error)
+	// GetLeader get master leader.
+	GetLeader(context.Context, *GetLeaderRequest) (*GetLeaderResponse, error)
 }
 
 // UnimplementedMasterServer can be embedded to have forward compatible implementations.
@@ -2561,6 +2683,9 @@ func (*UnimplementedMasterServer) RegisterWorker(ctx context.Context, req *Regis
 func (*UnimplementedMasterServer) OfflineWorker(ctx context.Context, req *OfflineWorkerRequest) (*OfflineWorkerResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method OfflineWorker not implemented")
 }
+func (*UnimplementedMasterServer) GetLeader(ctx context.Context, req *GetLeaderRequest) (*GetLeaderResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method GetLeader not implemented")
+}
 
 func RegisterMasterServer(s *grpc.Server, srv MasterServer) {
 	s.RegisterService(&_Master_serviceDesc, srv)
@@ -2890,6 +3015,24 @@ func _Master_OfflineWorker_Handler(srv interface{}, ctx context.Context, dec fun
 	return interceptor(ctx, in, info, handler)
 }
 
+func _Master_GetLeader_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(GetLeaderRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(MasterServer).GetLeader(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/pb.Master/GetLeader",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(MasterServer).GetLeader(ctx, req.(*GetLeaderRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 var _Master_serviceDesc = grpc.ServiceDesc{
 	ServiceName: "pb.Master",
 	HandlerType: (*MasterServer)(nil),
@@ -2966,6 +3109,10 @@ var _Master_serviceDesc = grpc.ServiceDesc{
 			MethodName: "OfflineWorker",
 			Handler:    _Master_OfflineWorker_Handler,
 		},
+		{
+			MethodName: "GetLeader",
+			Handler:    _Master_GetLeader_Handler,
+		},
 	},
 	Streams:  []grpc.StreamDesc{},
 	Metadata: "dmmaster.proto",
@@ -4606,6 +4753,83 @@ func (m *OfflineWorkerResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
+func (m *GetLeaderRequest) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *GetLeaderRequest) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *GetLeaderRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	return len(dAtA) - i, nil
+}
+
+func (m *GetLeaderResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *GetLeaderResponse) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *GetLeaderResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if len(m.Msg) > 0 {
+		i -= len(m.Msg)
+		copy(dAtA[i:], m.Msg)
+		i = encodeVarintDmmaster(dAtA, i, uint64(len(m.Msg)))
+		i--
+		dAtA[i] = 0x22
+	}
+	if len(m.Addr) > 0 {
+		i -= len(m.Addr)
+		copy(dAtA[i:], m.Addr)
+		i = encodeVarintDmmaster(dAtA, i, uint64(len(m.Addr)))
+		i--
+		dAtA[i] = 0x1a
+	}
+	if len(m.Name) > 0 {
+		i -= len(m.Name)
+		copy(dAtA[i:], m.Name)
+		i = encodeVarintDmmaster(dAtA, i, uint64(len(m.Name)))
+		i--
+		dAtA[i] = 0x12
+	}
+	if m.Result {
+		i--
+		if m.Result {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i--
+		dAtA[i] = 0x8
+	}
+	return len(dAtA) - i, nil
+}
+
 func encodeVarintDmmaster(dAtA []byte, offset int, v uint64) int {
 	offset -= sovDmmaster(v)
 	base := offset
@@ -5343,6 +5567,39 @@ func (m *OfflineWorkerResponse) Size() (n int) {
 	return n
 }
 
+func (m *GetLeaderRequest) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	return n
+}
+
+func (m *GetLeaderResponse) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.Result {
+		n += 2
+	}
+	l = len(m.Name)
+	if l > 0 {
+		n += 1 + l + sovDmmaster(uint64(l))
+	}
+	l = len(m.Addr)
+	if l > 0 {
+		n += 1 + l + sovDmmaster(uint64(l))
+	}
+	l = len(m.Msg)
+	if l > 0 {
+		n += 1 + l + sovDmmaster(uint64(l))
+	}
+	return n
+}
+
 func sovDmmaster(x uint64) (n int) {
 	return (math_bits.Len64(x|1) + 6) / 7
 }
@@ -10000,6 +10257,228 @@ func (m *OfflineWorkerResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
+func (m *GetLeaderRequest) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowDmmaster
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: GetLeaderRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: GetLeaderRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		default:
+			iNdEx = preIndex
+			skippy, err := skipDmmaster(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthDmmaster
+			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthDmmaster
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *GetLeaderResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowDmmaster
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: GetLeaderResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: GetLeaderResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowDmmaster
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.Result = bool(v != 0)
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowDmmaster
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthDmmaster
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthDmmaster
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Name = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Addr", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowDmmaster
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthDmmaster
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthDmmaster
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Addr = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 4:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Msg", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowDmmaster
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthDmmaster
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthDmmaster
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Msg = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipDmmaster(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthDmmaster
+			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthDmmaster
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
 func skipDmmaster(dAtA []byte) (n int, err error) {
 	l := len(dAtA)
 	iNdEx := 0
diff --git a/dm/proto/dmmaster.proto b/dm/proto/dmmaster.proto
index e74c19875b..8d1faf9a38 100644
--- a/dm/proto/dmmaster.proto
+++ b/dm/proto/dmmaster.proto
@@ -62,6 +62,9 @@ service Master {
 
     // OfflineWorker offline the dm-workers.
     rpc OfflineWorker(OfflineWorkerRequest) returns(OfflineWorkerResponse) {}
+
+    // GetLeader get master leader.
+    rpc GetLeader(GetLeaderRequest) returns(GetLeaderResponse) {}
 }
 
 message MigrateWorkerRelayRequest {
@@ -306,3 +309,13 @@ message OfflineWorkerResponse {
     bool result = 1;
     string msg = 2;
 }
+
+message GetLeaderRequest {
+}
+
+message GetLeaderResponse {
+    bool result = 1;
+    string name = 2;
+    string addr = 3;    
+    string msg = 4;
+}
\ No newline at end of file

From 3c6afe7869de29cc20fa2f6a3ac7eb4622426428 Mon Sep 17 00:00:00 2001
From: gmhdbjd <gmhdbjd@gmail.com>
Date: Sat, 9 May 2020 15:36:59 +0800
Subject: [PATCH 02/17] change help_cnt

---
 tests/dmctl_command/run.sh | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/tests/dmctl_command/run.sh b/tests/dmctl_command/run.sh
index c5938bd0fc..3e5aaeb85a 100644
--- a/tests/dmctl_command/run.sh
+++ b/tests/dmctl_command/run.sh
@@ -6,6 +6,8 @@ cur=$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )
 source $cur/../_utils/test_prepare
 WORK_DIR=$TEST_DIR/$TEST_NAME
 
+help_cnt=35
+
 function run() {
     # check dmctl alone output
     # it should usage for root command
@@ -13,7 +15,7 @@ function run() {
     $PWD/bin/dmctl.test DEVEL > $WORK_DIR/help.log
     help_msg=$(cat $WORK_DIR/help.log)
     help_msg_cnt=$(echo "${help_msg}" | wc -l |xargs)
-    if [ "$help_msg_cnt" != 34 ]; then
+    if [ "$help_msg_cnt" != $help_cnt ]; then
         echo "dmctl case 1 help failed: $help_msg"
         echo $help_msg_cnt
         exit 1
@@ -24,7 +26,7 @@ function run() {
     $PWD/bin/dmctl.test DEVEL --help > $WORK_DIR/help.log
     help_msg=$(cat $WORK_DIR/help.log)
     help_msg_cnt=$(echo "${help_msg}" | wc -l |xargs)
-    if [ "$help_msg_cnt" != 34 ]; then
+    if [ "$help_msg_cnt" != $help_cnt ]; then
         echo "dmctl case 2 help failed: $help_msg"
         exit 1
     fi

From f1428ef7a4d828dadbb94326aae3ce679b9ecd21 Mon Sep 17 00:00:00 2001
From: gmhdbjd <gmhdbjd@gmail.com>
Date: Sat, 9 May 2020 20:21:45 +0800
Subject: [PATCH 03/17] add get-leader tool

---
 tests/_utils/get_leader | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100755 tests/_utils/get_leader

diff --git a/tests/_utils/get_leader b/tests/_utils/get_leader
new file mode 100755
index 0000000000..101fd4d87d
--- /dev/null
+++ b/tests/_utils/get_leader
@@ -0,0 +1,15 @@
+#!/bin/bash
+# tools to run get-leader command by dmctl and echo leader's name
+# parameter 1: work directory
+# parameter 2: master-addr port
+
+workdir=$1
+master_addr=$2
+
+PWD=$(pwd)
+binary=$PWD/bin/dmctl.test
+ts=$(date +"%s")
+dmctl_log=$workdir/dmctl.$ts.log
+pid=$$
+
+echo $($binary -test.coverprofile="$TEST_DIR/cov.$TEST_NAME.dmctl.$ts.$pid.out" DEVEL -master-addr=$master_addr get-leader | grep name | gawk 'match($2,/"(.*)",/,a) {print a[1]}')
\ No newline at end of file

From 42f4e760a3f5ae9ef8418345c51d30c2dd74df16 Mon Sep 17 00:00:00 2001
From: gmhdbjd <gmhdbjd@gmail.com>
Date: Sat, 9 May 2020 20:23:09 +0800
Subject: [PATCH 04/17] add get-leader integration test

---
 tests/ha_master/run.sh | 97 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 97 insertions(+)

diff --git a/tests/ha_master/run.sh b/tests/ha_master/run.sh
index 98e1debb14..d619c432f7 100755
--- a/tests/ha_master/run.sh
+++ b/tests/ha_master/run.sh
@@ -12,6 +12,101 @@ MASTER_PORT3=8461
 MASTER_PORT4=8561
 MASTER_PORT5=8661
 
+function test_get_leader() {
+    echo "[$(date)] <<<<<< start test_get_leader_command >>>>>>"
+
+    master_ports=(0 $MASTER_PORT1 $MASTER_PORT2 $MASTER_PORT3 $MASTER_PORT4 $MASTER_PORT5)
+
+    alive=(1 2 3 4 5)
+    leaders=()
+
+    # get leader in all masters
+    for idx in ${alive[@]}; do
+        leaders+=($(get_leader $WORK_DIR 127.0.0.1:${master_ports[$idx]}))
+    done
+
+    # check leader is same for every master
+    leader=${leaders[0]}
+    leader_idx=${leader:6}
+    echo "current leader is" $leader
+    for ld in ${leaders[@]}; do
+        if [ "$leader" != "$ld" ]; then
+            echo "leader not consisent"
+            exit 1
+        fi
+    done
+
+    # kill leader
+    echo "kill leader" $leader
+    ps aux | grep $leader |awk '{print $2}'|xargs kill || true
+    check_port_offline ${master_ports[$leader_idx]} 20
+
+    # test again
+    alive=( "${alive[@]/$leader_idx}" )
+    leaders=()
+    for idx in ${alive[@]}; do
+        leaders+=($(get_leader $WORK_DIR 127.0.0.1:${master_ports[$idx]}))
+    done
+    leader=${leaders[0]}
+    leader_idx=${leader:6}
+    echo "current leader is" $leader
+    for ld in ${leaders[@]}; do
+        if [ "$leader" != "$ld" ]; then
+            echo "leader not consisent"
+            exit 1
+        fi
+    done
+    echo "kill leader" $leader
+    ps aux | grep $leader |awk '{print $2}'|xargs kill || true
+    check_port_offline ${master_ports[$leader_idx]} 20
+
+    # test again
+    alive=( "${alive[@]/$leader_idx}" )
+    leaders=()
+    for idx in ${alive[@]}; do
+        leaders+=($(get_leader $WORK_DIR 127.0.0.1:${master_ports[$idx]}))
+    done
+    leader=${leaders[0]}
+    leader_idx=${leader:6}
+    echo "current leader is" $leader
+    for ld in ${leaders[@]}; do
+        if [ "$leader" != "$ld" ]; then
+            echo "leader not consisent"
+            exit 1
+        fi
+    done
+    echo "kill leader" $leader
+    ps aux | grep $leader |awk '{print $2}'|xargs kill || true
+    check_port_offline ${master_ports[$leader_idx]} 20
+    
+    # join master which has been killed
+    alive=( "${alive[@]/$leader_idx}" )
+    for idx in $(seq 1 5); do
+        if [[ ! " ${alive[@]} " =~ " ${idx} " ]]; then
+            run_dm_master $WORK_DIR/master${idx} ${master_ports[$idx]} $cur/conf/dm-master${idx}.toml
+            check_rpc_alive $cur/../bin/check_master_online 127.0.0.1:${master_ports[$idx]}
+        fi
+    done
+
+    # check leader is same for every master
+    alive=(1 2 3 4 5)
+    leaders=()
+    for idx in ${alive[@]}; do
+        leaders+=($(get_leader $WORK_DIR 127.0.0.1:${master_ports[$idx]}))
+    done
+    leader=${leaders[0]}
+    leader_idx=${leader:6}
+    echo "current leader is" $leader
+    for ld in ${leaders[@]}; do
+        if [ "$leader" != "$ld" ]; then
+            echo "leader not consisent"
+            exit 1
+        fi
+    done
+
+    echo "[$(date)] <<<<<< finish test_get_leader_command >>>>>>"
+}
+
 function run() {
     run_sql_file $cur/data/db1.prepare.sql $MYSQL_HOST1 $MYSQL_PORT1 $MYSQL_PASSWORD1
     check_contains 'Query OK, 2 rows affected'
@@ -31,6 +126,8 @@ function run() {
     check_rpc_alive $cur/../bin/check_master_online 127.0.0.1:$MASTER_PORT4
     check_rpc_alive $cur/../bin/check_master_online 127.0.0.1:$MASTER_PORT5
 
+    test_get_leader
+
     # kill dm-master1 and dm-master2 to simulate the first two dm-master addr in join config are invalid
     echo "kill dm-master1 and kill dm-master2"
     ps aux | grep dm-master1 |awk '{print $2}'|xargs kill || true

From 6a57c434f1bb304dad314be212f235167e2880e8 Mon Sep 17 00:00:00 2001
From: gmhdbjd <gmhdbjd@gmail.com>
Date: Tue, 12 May 2020 18:25:26 +0800
Subject: [PATCH 05/17] add list-member command

---
 dm/ctl/master/list_member.go | 86 ++++++++++++++++++++++++++++++++++++
 1 file changed, 86 insertions(+)
 create mode 100644 dm/ctl/master/list_member.go

diff --git a/dm/ctl/master/list_member.go b/dm/ctl/master/list_member.go
new file mode 100644
index 0000000000..627eeba1c2
--- /dev/null
+++ b/dm/ctl/master/list_member.go
@@ -0,0 +1,86 @@
+// Copyright 2019 PingCAP, Inc.
+//
+// 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,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package master
+
+import (
+	"context"
+	"os"
+
+	"github.com/gogo/protobuf/proto"
+	"github.com/pingcap/dm/dm/ctl/common"
+	"github.com/pingcap/dm/dm/pb"
+
+	"github.com/pingcap/errors"
+	"github.com/spf13/cobra"
+)
+
+// NewListMemberCmd creates an ListMember command
+func NewListMemberCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "list-member master/worker/leader",
+		Short: "list member information of master/worker/leader",
+		Run:   listMemberFunc,
+	}
+	return cmd
+}
+
+func convertMemberType(t string) pb.MemberType {
+	switch t {
+	case "master":
+		return pb.MemberType_MasterType
+	case "worker":
+		return pb.MemberType_WorkerType
+	case "leader":
+		return pb.MemberType_LeaderType
+	default:
+		return pb.MemberType_InvalidType
+	}
+}
+
+// listMemberFunc does list member request
+func listMemberFunc(cmd *cobra.Command, _ []string) {
+	if len(cmd.Flags().Args()) != 1 {
+		cmd.SetOut(os.Stdout)
+		cmd.Usage()
+		return
+	}
+
+	memberType := cmd.Flags().Arg(0)
+	member := convertMemberType(memberType)
+	if member == pb.MemberType_InvalidType {
+		common.PrintLines("invalid arg '%s'", memberType)
+		return
+	}
+
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	cli := common.MasterClient()
+	var resp proto.Message
+	var err error
+	switch member {
+	case pb.MemberType_MasterType:
+		resp, err = cli.ListMemberMaster(ctx, &pb.ListMemberRequest{})
+	case pb.MemberType_WorkerType:
+		resp, err = cli.ListMemberWorker(ctx, &pb.ListMemberRequest{})
+	case pb.MemberType_LeaderType:
+		resp, err = cli.ListMemberLeader(ctx, &pb.ListMemberRequest{})
+	}
+
+	if err != nil {
+		common.PrintLines("list member failed, error:\n%v", errors.ErrorStack(err))
+		return
+	}
+	common.PrettyPrintResponse(resp)
+}

From e79f07cc3ebad7692484705556080d3dd224d34b Mon Sep 17 00:00:00 2001
From: gmhdbjd <gmhdbjd@gmail.com>
Date: Tue, 12 May 2020 18:27:33 +0800
Subject: [PATCH 06/17] add list-member command

---
 dm/ctl/ctl.go                    |    2 +-
 dm/ctl/master/get_leader.go      |   56 -
 dm/master/scheduler/scheduler.go |   11 +
 dm/master/server.go              |  134 ++-
 dm/master/server_test.go         |   83 --
 dm/pb/dmmaster.pb.go             | 1895 ++++++++++++++++++++++++++----
 dm/pbmock/dmmaster.go            |  105 ++
 dm/proto/dmmaster.proto          |   57 +-
 tests/_utils/get_leader          |    2 +-
 tests/ha_master/run.sh           |   87 +-
 10 files changed, 2062 insertions(+), 370 deletions(-)
 delete mode 100644 dm/ctl/master/get_leader.go

diff --git a/dm/ctl/ctl.go b/dm/ctl/ctl.go
index b11794d08e..e76b0e847f 100644
--- a/dm/ctl/ctl.go
+++ b/dm/ctl/ctl.go
@@ -76,7 +76,7 @@ func NewRootCmd() *cobra.Command {
 		master.NewMigrateRelayCmd(),
 		master.NewOperateSourceCmd(),
 		master.NewOfflineWorkerCmd(),
-		master.NewGetLeaderCmd(),
+		master.NewListMemberCmd(),
 	)
 	return cmd
 }
diff --git a/dm/ctl/master/get_leader.go b/dm/ctl/master/get_leader.go
deleted file mode 100644
index 84488e7b7f..0000000000
--- a/dm/ctl/master/get_leader.go
+++ /dev/null
@@ -1,56 +0,0 @@
-// Copyright 2019 PingCAP, Inc.
-//
-// 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,
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package master
-
-import (
-	"context"
-	"os"
-
-	"github.com/pingcap/dm/dm/ctl/common"
-	"github.com/pingcap/dm/dm/pb"
-
-	"github.com/pingcap/errors"
-	"github.com/spf13/cobra"
-)
-
-// NewGetLeaderCmd creates an GetLeader command
-func NewGetLeaderCmd() *cobra.Command {
-	cmd := &cobra.Command{
-		Use:   "get-leader",
-		Short: "get master leader",
-		Run:   getLeaderFunc,
-	}
-	return cmd
-}
-
-// getLeaderFunc does get leader request
-func getLeaderFunc(cmd *cobra.Command, _ []string) {
-	if len(cmd.Flags().Args()) > 0 {
-		cmd.SetOut(os.Stdout)
-		cmd.Usage()
-		return
-	}
-
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	cli := common.MasterClient()
-	resp, err := cli.GetLeader(ctx, &pb.GetLeaderRequest{})
-	if err != nil {
-		common.PrintLines("get leader failed, error:\n%v", errors.ErrorStack(err))
-		return
-	}
-
-	common.PrettyPrintResponse(resp)
-}
diff --git a/dm/master/scheduler/scheduler.go b/dm/master/scheduler/scheduler.go
index be0ca35b82..346ea1efe3 100644
--- a/dm/master/scheduler/scheduler.go
+++ b/dm/master/scheduler/scheduler.go
@@ -573,6 +573,17 @@ func (s *Scheduler) RemoveWorker(name string) error {
 	return nil
 }
 
+// GetWorker gets all worker agent.
+func (s *Scheduler) GetWorker() []*Worker {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	workers := make([]*Worker, 0, len(s.workers))
+	for _, value := range s.workers {
+		workers = append(workers, value)
+	}
+	return workers
+}
+
 // GetWorkerByName gets worker agent by worker name.
 func (s *Scheduler) GetWorkerByName(name string) *Worker {
 	s.mu.RLock()
diff --git a/dm/master/server.go b/dm/master/server.go
index a3e0759e3f..d787af4ca1 100644
--- a/dm/master/server.go
+++ b/dm/master/server.go
@@ -1560,23 +1560,129 @@ func (s *Server) getSourceRespsAfterOperation(ctx context.Context, taskName stri
 	return sortCommonWorkerResults(sourceRespCh)
 }
 
-// GetLeader get master leader
-func (s *Server) GetLeader(ctx context.Context, req *pb.GetLeaderRequest) (*pb.GetLeaderResponse, error) {
-	log.L().Info("", zap.Stringer("payload", req), zap.String("request", "GetLeader"))
+// ListMemberMaster list member master information
+func (s *Server) ListMemberMaster(ctx context.Context, req *pb.ListMemberRequest) (*pb.ListMemberMasterResponse, error) {
+	log.L().Info("", zap.Stringer("payload", req), zap.String("request", "ListMemberMaster"))
+	resp := &pb.ListMemberMasterResponse{}
 
-	_, leaderID, addr, err := s.election.LeaderInfo(ctx)
+	isLeader, needForward := s.isLeaderAndNeedForward()
+	if !isLeader {
+		if needForward {
+			return s.leaderClient.ListMemberMaster(ctx, req)
+		}
+		return nil, terror.ErrMasterRequestIsNotForwardToLeader
+	}
 
+	memberList, err := s.etcdClient.MemberList(ctx)
 	if err != nil {
-		return &pb.GetLeaderResponse{
-			Result: false,
-			Msg:    errors.ErrorStack(err),
-		}, nil
+		resp.Msg = errors.ErrorStack(err)
+		return resp, nil
 	}
 
-	log.L().Info("get leader successfully", zap.String("leaderId", leaderID))
-	return &pb.GetLeaderResponse{
-		Result: true,
-		Name:   leaderID,
-		Addr:   addr,
-	}, nil
+	etcdMembers := memberList.Members
+	members := make([]*pb.MemberMasterResponse, 0, len(etcdMembers))
+	client := http.Client{
+		Timeout: 1 * time.Second,
+	}
+
+	for _, etcdMember := range etcdMembers {
+		alive := true
+		_, err := client.Get(etcdMember.ClientURLs[0] + "/health")
+		if err != nil {
+			alive = false
+		}
+
+		members = append(members, &pb.MemberMasterResponse{
+			Name:       etcdMember.Name,
+			MemberID:   etcdMember.ID,
+			Alive:      alive,
+			ClientURLs: etcdMember.ClientURLs,
+			PeerURLs:   etcdMember.PeerURLs,
+		})
+	}
+
+	resp.Result = true
+	resp.Members = members
+	return resp, nil
+}
+
+// ListMemberWorker list member worker information
+func (s *Server) ListMemberWorker(ctx context.Context, req *pb.ListMemberRequest) (*pb.ListMemberWorkerResponse, error) {
+	log.L().Info("", zap.Stringer("payload", req), zap.String("request", "ListMemberWorker"))
+	resp := &pb.ListMemberWorkerResponse{}
+
+	isLeader, needForward := s.isLeaderAndNeedForward()
+	if !isLeader {
+		if needForward {
+			return s.leaderClient.ListMemberWorker(ctx, req)
+		}
+		return nil, terror.ErrMasterRequestIsNotForwardToLeader
+	}
+
+	workers := s.scheduler.GetWorker()
+	members := make([]*pb.MemberWorkerResponse, 0, len(workers))
+
+	for _, worker := range workers {
+		members = append(members, &pb.MemberWorkerResponse{
+			Name:   worker.BaseInfo().Name,
+			Addr:   worker.BaseInfo().Addr,
+			Stage:  string(worker.Stage()),
+			Source: worker.Bound().Source,
+		})
+	}
+
+	resp.Result = true
+	resp.Members = members
+	return resp, nil
+}
+
+// ListMemberLeader list member leader information
+func (s *Server) ListMemberLeader(ctx context.Context, req *pb.ListMemberRequest) (*pb.ListMemberLeaderResponse, error) {
+	log.L().Info("", zap.Stringer("payload", req), zap.String("request", "ListMemberLeader"))
+	resp := &pb.ListMemberLeaderResponse{}
+
+	isLeader, needForward := s.isLeaderAndNeedForward()
+	if !isLeader {
+		if needForward {
+			return s.leaderClient.ListMemberLeader(ctx, req)
+		}
+		return nil, terror.ErrMasterRequestIsNotForwardToLeader
+	}
+
+	memberList, err := s.etcdClient.MemberList(ctx)
+	if err != nil {
+		resp.Msg = errors.ErrorStack(err)
+		return resp, nil
+	}
+
+	_, leaderName, _, err := s.election.LeaderInfo(ctx)
+	if err != nil {
+		resp.Msg = errors.ErrorStack(err)
+		return resp, nil
+	}
+
+	etcdMembers := memberList.Members
+	client := http.Client{
+		Timeout: 1 * time.Second,
+	}
+
+	for _, etcdMember := range etcdMembers {
+		if leaderName != etcdMember.Name {
+			continue
+		}
+		alive := true
+		_, err := client.Get(etcdMember.ClientURLs[0] + "/health")
+		if err != nil {
+			alive = false
+		}
+
+		resp.Name = etcdMember.Name
+		resp.MemberID = etcdMember.ID
+		resp.Alive = alive
+		resp.ClientURLs = etcdMember.ClientURLs
+		resp.PeerURLs = etcdMember.PeerURLs
+	}
+
+	resp.Result = true
+	return resp, nil
 }
diff --git a/dm/master/server_test.go b/dm/master/server_test.go
index 4fd2b0d02f..895cda7a42 100644
--- a/dm/master/server_test.go
+++ b/dm/master/server_test.go
@@ -1141,86 +1141,3 @@ func mockRevelantWorkerClient(mockWorkerClient *pbmock.MockWorkerClient, taskNam
 		},
 	).Return(queryResp, nil).MaxTimes(maxRetryNum)
 }
-
-func (t *testMaster) TestGetLeader(c *check.C) {
-	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
-	defer cancel()
-	// create a new cluster
-	cfg1 := NewConfig()
-	c.Assert(cfg1.Parse([]string{"-config=./dm-master.toml"}), check.IsNil)
-	cfg1.Name = "dm-master-1"
-	cfg1.DataDir = c.MkDir()
-	cfg1.MasterAddr = tempurl.Alloc()[len("http://"):]
-	cfg1.PeerUrls = tempurl.Alloc()
-	cfg1.AdvertisePeerUrls = cfg1.PeerUrls
-	cfg1.InitialCluster = fmt.Sprintf("%s=%s", cfg1.Name, cfg1.AdvertisePeerUrls)
-
-	s1 := NewServer(cfg1)
-	c.Assert(s1.Start(ctx), check.IsNil)
-
-	// wait the first one become the leader
-	c.Assert(utils.WaitSomething(30, 100*time.Millisecond, func() bool {
-		return s1.election.IsLeader()
-	}), check.IsTrue)
-
-	{
-		res, err := s1.GetLeader(ctx, &pb.GetLeaderRequest{})
-		c.Assert(err, check.IsNil)
-		c.Assert(res.Name, check.Equals, cfg1.Name)
-		c.Assert(res.Addr, check.Equals, cfg1.AdvertiseAddr)
-	}
-
-	// join to an existing cluster
-	cfg2 := NewConfig()
-	c.Assert(cfg2.Parse([]string{"-config=./dm-master.toml"}), check.IsNil)
-	cfg2.Name = "dm-master-2"
-	cfg2.DataDir = c.MkDir()
-	cfg2.MasterAddr = tempurl.Alloc()[len("http://"):]
-	cfg2.PeerUrls = tempurl.Alloc()
-	cfg2.AdvertisePeerUrls = cfg2.PeerUrls
-	cfg2.Join = cfg1.MasterAddr // join to an existing cluster
-
-	s2 := NewServer(cfg2)
-	c.Assert(s2.Start(ctx), check.IsNil)
-	defer s2.Close()
-
-	{
-		res, err := s1.GetLeader(ctx, &pb.GetLeaderRequest{})
-		c.Assert(err, check.IsNil)
-		c.Assert(res.Name, check.Equals, cfg1.Name)
-		c.Assert(res.Addr, check.Equals, cfg1.AdvertiseAddr)
-	}
-	{
-		res, err := s2.GetLeader(ctx, &pb.GetLeaderRequest{})
-		c.Assert(err, check.IsNil)
-		c.Assert(res.Name, check.Equals, cfg1.Name)
-		c.Assert(res.Addr, check.Equals, cfg1.AdvertiseAddr)
-	}
-
-	s1.Close()
-	{
-		res, err := s2.GetLeader(ctx, &pb.GetLeaderRequest{})
-		c.Assert(err, check.IsNil)
-		c.Assert(res.Name, check.Equals, "")
-		c.Assert(res.Addr, check.Equals, "")
-	}
-
-	/*
-		It seems that if we kill leader in 2 masters cluster,
-		the second one wouldn't be the leader so follow cases would not be passed.
-		But I fail to create 3 masters cluster...
-
-		// wait the second one become the leader
-		c.Assert(utils.WaitSomething(30, 100*time.Millisecond, func() bool {
-			return s2.election.IsLeader()
-		}), check.IsTrue)
-
-		{
-			res, err := s2.GetLeader(ctx, &pb.GetLeaderRequest{})
-			c.Assert(err, check.IsNil)
-			c.Assert(res.Name, check.Equals, cfg2.Name)
-			c.Assert(res.Addr, check.Equals, cfg2.AdvertiseAddr)
-		}
-
-	*/
-}
diff --git a/dm/pb/dmmaster.pb.go b/dm/pb/dmmaster.pb.go
index a347eed969..1e2186789b 100644
--- a/dm/pb/dmmaster.pb.go
+++ b/dm/pb/dmmaster.pb.go
@@ -28,6 +28,37 @@ var _ = math.Inf
 // proto package needs to be updated.
 const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
 
+type MemberType int32
+
+const (
+	MemberType_InvalidType MemberType = 0
+	MemberType_MasterType  MemberType = 1
+	MemberType_WorkerType  MemberType = 2
+	MemberType_LeaderType  MemberType = 3
+)
+
+var MemberType_name = map[int32]string{
+	0: "InvalidType",
+	1: "MasterType",
+	2: "WorkerType",
+	3: "LeaderType",
+}
+
+var MemberType_value = map[string]int32{
+	"InvalidType": 0,
+	"MasterType":  1,
+	"WorkerType":  2,
+	"LeaderType":  3,
+}
+
+func (x MemberType) String() string {
+	return proto.EnumName(MemberType_name, int32(x))
+}
+
+func (MemberType) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor_f9bef11f2a341f03, []int{0}
+}
+
 type SourceOp int32
 
 const (
@@ -56,7 +87,7 @@ func (x SourceOp) String() string {
 }
 
 func (SourceOp) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_f9bef11f2a341f03, []int{0}
+	return fileDescriptor_f9bef11f2a341f03, []int{1}
 }
 
 type MigrateWorkerRelayRequest struct {
@@ -2127,21 +2158,26 @@ func (m *OfflineWorkerResponse) GetMsg() string {
 	return ""
 }
 
-type GetLeaderRequest struct {
+type MemberMasterResponse struct {
+	Name       string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
+	MemberID   uint64   `protobuf:"varint,2,opt,name=memberID,proto3" json:"memberID,omitempty"`
+	Alive      bool     `protobuf:"varint,3,opt,name=alive,proto3" json:"alive,omitempty"`
+	PeerURLs   []string `protobuf:"bytes,4,rep,name=peerURLs,proto3" json:"peerURLs,omitempty"`
+	ClientURLs []string `protobuf:"bytes,5,rep,name=clientURLs,proto3" json:"clientURLs,omitempty"`
 }
 
-func (m *GetLeaderRequest) Reset()         { *m = GetLeaderRequest{} }
-func (m *GetLeaderRequest) String() string { return proto.CompactTextString(m) }
-func (*GetLeaderRequest) ProtoMessage()    {}
-func (*GetLeaderRequest) Descriptor() ([]byte, []int) {
+func (m *MemberMasterResponse) Reset()         { *m = MemberMasterResponse{} }
+func (m *MemberMasterResponse) String() string { return proto.CompactTextString(m) }
+func (*MemberMasterResponse) ProtoMessage()    {}
+func (*MemberMasterResponse) Descriptor() ([]byte, []int) {
 	return fileDescriptor_f9bef11f2a341f03, []int{35}
 }
-func (m *GetLeaderRequest) XXX_Unmarshal(b []byte) error {
+func (m *MemberMasterResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
 }
-func (m *GetLeaderRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+func (m *MemberMasterResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	if deterministic {
-		return xxx_messageInfo_GetLeaderRequest.Marshal(b, m, deterministic)
+		return xxx_messageInfo_MemberMasterResponse.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
 		n, err := m.MarshalToSizedBuffer(b)
@@ -2151,37 +2187,175 @@ func (m *GetLeaderRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, er
 		return b[:n], nil
 	}
 }
-func (m *GetLeaderRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_GetLeaderRequest.Merge(m, src)
+func (m *MemberMasterResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_MemberMasterResponse.Merge(m, src)
 }
-func (m *GetLeaderRequest) XXX_Size() int {
+func (m *MemberMasterResponse) XXX_Size() int {
 	return m.Size()
 }
-func (m *GetLeaderRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_GetLeaderRequest.DiscardUnknown(m)
+func (m *MemberMasterResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_MemberMasterResponse.DiscardUnknown(m)
 }
 
-var xxx_messageInfo_GetLeaderRequest proto.InternalMessageInfo
+var xxx_messageInfo_MemberMasterResponse proto.InternalMessageInfo
 
-type GetLeaderResponse struct {
-	Result bool   `protobuf:"varint,1,opt,name=result,proto3" json:"result,omitempty"`
-	Name   string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
-	Addr   string `protobuf:"bytes,3,opt,name=addr,proto3" json:"addr,omitempty"`
-	Msg    string `protobuf:"bytes,4,opt,name=msg,proto3" json:"msg,omitempty"`
+func (m *MemberMasterResponse) GetName() string {
+	if m != nil {
+		return m.Name
+	}
+	return ""
+}
+
+func (m *MemberMasterResponse) GetMemberID() uint64 {
+	if m != nil {
+		return m.MemberID
+	}
+	return 0
+}
+
+func (m *MemberMasterResponse) GetAlive() bool {
+	if m != nil {
+		return m.Alive
+	}
+	return false
+}
+
+func (m *MemberMasterResponse) GetPeerURLs() []string {
+	if m != nil {
+		return m.PeerURLs
+	}
+	return nil
+}
+
+func (m *MemberMasterResponse) GetClientURLs() []string {
+	if m != nil {
+		return m.ClientURLs
+	}
+	return nil
+}
+
+type MemberWorkerResponse struct {
+	Name   string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
+	Addr   string `protobuf:"bytes,2,opt,name=addr,proto3" json:"addr,omitempty"`
+	Stage  string `protobuf:"bytes,3,opt,name=stage,proto3" json:"stage,omitempty"`
+	Source string `protobuf:"bytes,4,opt,name=source,proto3" json:"source,omitempty"`
 }
 
-func (m *GetLeaderResponse) Reset()         { *m = GetLeaderResponse{} }
-func (m *GetLeaderResponse) String() string { return proto.CompactTextString(m) }
-func (*GetLeaderResponse) ProtoMessage()    {}
-func (*GetLeaderResponse) Descriptor() ([]byte, []int) {
+func (m *MemberWorkerResponse) Reset()         { *m = MemberWorkerResponse{} }
+func (m *MemberWorkerResponse) String() string { return proto.CompactTextString(m) }
+func (*MemberWorkerResponse) ProtoMessage()    {}
+func (*MemberWorkerResponse) Descriptor() ([]byte, []int) {
 	return fileDescriptor_f9bef11f2a341f03, []int{36}
 }
-func (m *GetLeaderResponse) XXX_Unmarshal(b []byte) error {
+func (m *MemberWorkerResponse) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *MemberWorkerResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_MemberWorkerResponse.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *MemberWorkerResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_MemberWorkerResponse.Merge(m, src)
+}
+func (m *MemberWorkerResponse) XXX_Size() int {
+	return m.Size()
+}
+func (m *MemberWorkerResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_MemberWorkerResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MemberWorkerResponse proto.InternalMessageInfo
+
+func (m *MemberWorkerResponse) GetName() string {
+	if m != nil {
+		return m.Name
+	}
+	return ""
+}
+
+func (m *MemberWorkerResponse) GetAddr() string {
+	if m != nil {
+		return m.Addr
+	}
+	return ""
+}
+
+func (m *MemberWorkerResponse) GetStage() string {
+	if m != nil {
+		return m.Stage
+	}
+	return ""
+}
+
+func (m *MemberWorkerResponse) GetSource() string {
+	if m != nil {
+		return m.Source
+	}
+	return ""
+}
+
+type ListMemberRequest struct {
+}
+
+func (m *ListMemberRequest) Reset()         { *m = ListMemberRequest{} }
+func (m *ListMemberRequest) String() string { return proto.CompactTextString(m) }
+func (*ListMemberRequest) ProtoMessage()    {}
+func (*ListMemberRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_f9bef11f2a341f03, []int{37}
+}
+func (m *ListMemberRequest) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *ListMemberRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_ListMemberRequest.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *ListMemberRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ListMemberRequest.Merge(m, src)
+}
+func (m *ListMemberRequest) XXX_Size() int {
+	return m.Size()
+}
+func (m *ListMemberRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_ListMemberRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ListMemberRequest proto.InternalMessageInfo
+
+type ListMemberMasterResponse struct {
+	Result  bool                    `protobuf:"varint,1,opt,name=result,proto3" json:"result,omitempty"`
+	Msg     string                  `protobuf:"bytes,2,opt,name=msg,proto3" json:"msg,omitempty"`
+	Members []*MemberMasterResponse `protobuf:"bytes,3,rep,name=members,proto3" json:"members,omitempty"`
+}
+
+func (m *ListMemberMasterResponse) Reset()         { *m = ListMemberMasterResponse{} }
+func (m *ListMemberMasterResponse) String() string { return proto.CompactTextString(m) }
+func (*ListMemberMasterResponse) ProtoMessage()    {}
+func (*ListMemberMasterResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_f9bef11f2a341f03, []int{38}
+}
+func (m *ListMemberMasterResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
 }
-func (m *GetLeaderResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+func (m *ListMemberMasterResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	if deterministic {
-		return xxx_messageInfo_GetLeaderResponse.Marshal(b, m, deterministic)
+		return xxx_messageInfo_ListMemberMasterResponse.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
 		n, err := m.MarshalToSizedBuffer(b)
@@ -2191,47 +2365,193 @@ func (m *GetLeaderResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, e
 		return b[:n], nil
 	}
 }
-func (m *GetLeaderResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_GetLeaderResponse.Merge(m, src)
+func (m *ListMemberMasterResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ListMemberMasterResponse.Merge(m, src)
 }
-func (m *GetLeaderResponse) XXX_Size() int {
+func (m *ListMemberMasterResponse) XXX_Size() int {
 	return m.Size()
 }
-func (m *GetLeaderResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_GetLeaderResponse.DiscardUnknown(m)
+func (m *ListMemberMasterResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_ListMemberMasterResponse.DiscardUnknown(m)
 }
 
-var xxx_messageInfo_GetLeaderResponse proto.InternalMessageInfo
+var xxx_messageInfo_ListMemberMasterResponse proto.InternalMessageInfo
 
-func (m *GetLeaderResponse) GetResult() bool {
+func (m *ListMemberMasterResponse) GetResult() bool {
 	if m != nil {
 		return m.Result
 	}
 	return false
 }
 
-func (m *GetLeaderResponse) GetName() string {
+func (m *ListMemberMasterResponse) GetMsg() string {
 	if m != nil {
-		return m.Name
+		return m.Msg
 	}
 	return ""
 }
 
-func (m *GetLeaderResponse) GetAddr() string {
+func (m *ListMemberMasterResponse) GetMembers() []*MemberMasterResponse {
 	if m != nil {
-		return m.Addr
+		return m.Members
+	}
+	return nil
+}
+
+type ListMemberLeaderResponse struct {
+	Result     bool     `protobuf:"varint,1,opt,name=result,proto3" json:"result,omitempty"`
+	Msg        string   `protobuf:"bytes,2,opt,name=msg,proto3" json:"msg,omitempty"`
+	Name       string   `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"`
+	MemberID   uint64   `protobuf:"varint,4,opt,name=memberID,proto3" json:"memberID,omitempty"`
+	Alive      bool     `protobuf:"varint,5,opt,name=alive,proto3" json:"alive,omitempty"`
+	PeerURLs   []string `protobuf:"bytes,6,rep,name=peerURLs,proto3" json:"peerURLs,omitempty"`
+	ClientURLs []string `protobuf:"bytes,7,rep,name=clientURLs,proto3" json:"clientURLs,omitempty"`
+}
+
+func (m *ListMemberLeaderResponse) Reset()         { *m = ListMemberLeaderResponse{} }
+func (m *ListMemberLeaderResponse) String() string { return proto.CompactTextString(m) }
+func (*ListMemberLeaderResponse) ProtoMessage()    {}
+func (*ListMemberLeaderResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_f9bef11f2a341f03, []int{39}
+}
+func (m *ListMemberLeaderResponse) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *ListMemberLeaderResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_ListMemberLeaderResponse.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *ListMemberLeaderResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ListMemberLeaderResponse.Merge(m, src)
+}
+func (m *ListMemberLeaderResponse) XXX_Size() int {
+	return m.Size()
+}
+func (m *ListMemberLeaderResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_ListMemberLeaderResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ListMemberLeaderResponse proto.InternalMessageInfo
+
+func (m *ListMemberLeaderResponse) GetResult() bool {
+	if m != nil {
+		return m.Result
+	}
+	return false
+}
+
+func (m *ListMemberLeaderResponse) GetMsg() string {
+	if m != nil {
+		return m.Msg
+	}
+	return ""
+}
+
+func (m *ListMemberLeaderResponse) GetName() string {
+	if m != nil {
+		return m.Name
 	}
 	return ""
 }
 
-func (m *GetLeaderResponse) GetMsg() string {
+func (m *ListMemberLeaderResponse) GetMemberID() uint64 {
+	if m != nil {
+		return m.MemberID
+	}
+	return 0
+}
+
+func (m *ListMemberLeaderResponse) GetAlive() bool {
+	if m != nil {
+		return m.Alive
+	}
+	return false
+}
+
+func (m *ListMemberLeaderResponse) GetPeerURLs() []string {
+	if m != nil {
+		return m.PeerURLs
+	}
+	return nil
+}
+
+func (m *ListMemberLeaderResponse) GetClientURLs() []string {
+	if m != nil {
+		return m.ClientURLs
+	}
+	return nil
+}
+
+type ListMemberWorkerResponse struct {
+	Result  bool                    `protobuf:"varint,1,opt,name=result,proto3" json:"result,omitempty"`
+	Msg     string                  `protobuf:"bytes,2,opt,name=msg,proto3" json:"msg,omitempty"`
+	Members []*MemberWorkerResponse `protobuf:"bytes,3,rep,name=members,proto3" json:"members,omitempty"`
+}
+
+func (m *ListMemberWorkerResponse) Reset()         { *m = ListMemberWorkerResponse{} }
+func (m *ListMemberWorkerResponse) String() string { return proto.CompactTextString(m) }
+func (*ListMemberWorkerResponse) ProtoMessage()    {}
+func (*ListMemberWorkerResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_f9bef11f2a341f03, []int{40}
+}
+func (m *ListMemberWorkerResponse) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *ListMemberWorkerResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_ListMemberWorkerResponse.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *ListMemberWorkerResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ListMemberWorkerResponse.Merge(m, src)
+}
+func (m *ListMemberWorkerResponse) XXX_Size() int {
+	return m.Size()
+}
+func (m *ListMemberWorkerResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_ListMemberWorkerResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ListMemberWorkerResponse proto.InternalMessageInfo
+
+func (m *ListMemberWorkerResponse) GetResult() bool {
+	if m != nil {
+		return m.Result
+	}
+	return false
+}
+
+func (m *ListMemberWorkerResponse) GetMsg() string {
 	if m != nil {
 		return m.Msg
 	}
 	return ""
 }
 
+func (m *ListMemberWorkerResponse) GetMembers() []*MemberWorkerResponse {
+	if m != nil {
+		return m.Members
+	}
+	return nil
+}
+
 func init() {
+	proto.RegisterEnum("pb.MemberType", MemberType_name, MemberType_value)
 	proto.RegisterEnum("pb.SourceOp", SourceOp_name, SourceOp_value)
 	proto.RegisterType((*MigrateWorkerRelayRequest)(nil), "pb.MigrateWorkerRelayRequest")
 	proto.RegisterType((*UpdateWorkerRelayConfigRequest)(nil), "pb.UpdateWorkerRelayConfigRequest")
@@ -2268,104 +2588,119 @@ func init() {
 	proto.RegisterType((*RegisterWorkerResponse)(nil), "pb.RegisterWorkerResponse")
 	proto.RegisterType((*OfflineWorkerRequest)(nil), "pb.OfflineWorkerRequest")
 	proto.RegisterType((*OfflineWorkerResponse)(nil), "pb.OfflineWorkerResponse")
-	proto.RegisterType((*GetLeaderRequest)(nil), "pb.GetLeaderRequest")
-	proto.RegisterType((*GetLeaderResponse)(nil), "pb.GetLeaderResponse")
+	proto.RegisterType((*MemberMasterResponse)(nil), "pb.MemberMasterResponse")
+	proto.RegisterType((*MemberWorkerResponse)(nil), "pb.MemberWorkerResponse")
+	proto.RegisterType((*ListMemberRequest)(nil), "pb.ListMemberRequest")
+	proto.RegisterType((*ListMemberMasterResponse)(nil), "pb.ListMemberMasterResponse")
+	proto.RegisterType((*ListMemberLeaderResponse)(nil), "pb.ListMemberLeaderResponse")
+	proto.RegisterType((*ListMemberWorkerResponse)(nil), "pb.ListMemberWorkerResponse")
 }
 
 func init() { proto.RegisterFile("dmmaster.proto", fileDescriptor_f9bef11f2a341f03) }
 
 var fileDescriptor_f9bef11f2a341f03 = []byte{
-	// 1433 bytes of a gzipped FileDescriptorProto
+	// 1608 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x58, 0xcd, 0x6e, 0xdb, 0x46,
-	0x10, 0x16, 0x29, 0xff, 0x8e, 0x1c, 0x47, 0xde, 0xc8, 0x32, 0xc5, 0x38, 0x8a, 0xcb, 0x16, 0x81,
-	0x91, 0x43, 0xdc, 0x38, 0xb7, 0x00, 0x01, 0x9a, 0x58, 0x4e, 0x6b, 0x40, 0xa9, 0x1d, 0xaa, 0x41,
-	0x91, 0x4b, 0x01, 0x5a, 0x5c, 0xcb, 0x84, 0x29, 0x2e, 0x4d, 0x52, 0x76, 0x8d, 0xa2, 0x28, 0xd0,
-	0x17, 0x68, 0x81, 0x1e, 0x72, 0xec, 0xeb, 0xe4, 0x18, 0xa0, 0x97, 0x1e, 0x8b, 0xa4, 0x6f, 0xd0,
-	0x17, 0x28, 0xf6, 0x87, 0xe4, 0xf2, 0x47, 0x4a, 0x94, 0xa2, 0xba, 0xed, 0xce, 0x72, 0x67, 0xbe,
-	0x9d, 0x99, 0x9d, 0xf9, 0x96, 0xb0, 0x6a, 0x0f, 0x87, 0x56, 0x18, 0xe1, 0xe0, 0x9e, 0x1f, 0x90,
-	0x88, 0x20, 0xd5, 0x3f, 0xd6, 0x57, 0xed, 0xe1, 0x25, 0x09, 0xce, 0x62, 0x99, 0xbe, 0x39, 0x20,
-	0x64, 0xe0, 0xe2, 0x1d, 0xcb, 0x77, 0x76, 0x2c, 0xcf, 0x23, 0x91, 0x15, 0x39, 0xc4, 0x0b, 0xf9,
-	0xaa, 0x71, 0x0e, 0xad, 0x67, 0xce, 0x20, 0xb0, 0x22, 0xfc, 0x2d, 0xdb, 0x64, 0x62, 0xd7, 0xba,
-	0x32, 0xf1, 0xf9, 0x08, 0x87, 0x11, 0x6a, 0x03, 0x3c, 0x71, 0x3c, 0x97, 0x0c, 0xbe, 0xb6, 0x86,
-	0x58, 0x53, 0xb6, 0x94, 0xed, 0x65, 0x53, 0x92, 0xa0, 0x4d, 0x58, 0xe6, 0xb3, 0x23, 0x12, 0x6a,
-	0xea, 0x96, 0xb2, 0x7d, 0xcd, 0x4c, 0x05, 0xa8, 0x09, 0x0b, 0x21, 0x19, 0x05, 0x7d, 0xac, 0x55,
-	0xd9, 0x4e, 0x31, 0x33, 0x8e, 0xa0, 0xfd, 0xc2, 0xb7, 0xb3, 0x16, 0xf7, 0x88, 0x77, 0xe2, 0x0c,
-	0x62, 0xbb, 0x4d, 0x58, 0xe8, 0x33, 0x81, 0xb0, 0x29, 0x66, 0x92, 0x46, 0x35, 0xa3, 0xf1, 0x0b,
-	0xa8, 0xf7, 0x22, 0x2b, 0x88, 0xbe, 0xb1, 0xc2, 0xb3, 0x58, 0x07, 0x82, 0xb9, 0xc8, 0x0a, 0xcf,
-	0x84, 0x06, 0x36, 0x46, 0x1a, 0x2c, 0xf2, 0x1d, 0x14, 0x6d, 0x75, 0x7b, 0xd9, 0x8c, 0xa7, 0xc6,
-	0x39, 0xac, 0x49, 0x1a, 0x42, 0x9f, 0x78, 0x21, 0xa6, 0xe6, 0x02, 0x1c, 0x8e, 0xdc, 0x88, 0x29,
-	0x59, 0x32, 0xc5, 0x0c, 0xd5, 0xa1, 0x3a, 0x0c, 0x07, 0x02, 0x03, 0x1d, 0xa2, 0xdd, 0x54, 0x71,
-	0x75, 0xab, 0xba, 0x5d, 0xdb, 0xd5, 0xee, 0xf9, 0xc7, 0xf7, 0xf6, 0xc8, 0x70, 0x48, 0xbc, 0xf8,
-	0x94, 0x5c, 0x69, 0x6a, 0xf2, 0x01, 0xb4, 0xb8, 0x1b, 0x9e, 0xb1, 0x08, 0x7e, 0x90, 0x07, 0x8c,
-	0x2b, 0xd0, 0xcb, 0x36, 0x4d, 0x0d, 0xf8, 0x7e, 0x1e, 0xf0, 0x06, 0x05, 0xfc, 0x7c, 0x84, 0x83,
-	0xab, 0x5e, 0x64, 0x45, 0xa3, 0xb0, 0x88, 0xf7, 0x3b, 0x40, 0x87, 0x3e, 0xa6, 0x99, 0x22, 0xbb,
-	0x59, 0x07, 0x95, 0xf8, 0xcc, 0xdc, 0xea, 0x2e, 0x50, 0x1d, 0x74, 0xf1, 0xd0, 0x37, 0x55, 0xe2,
-	0xd3, 0x10, 0x78, 0x34, 0x71, 0xb8, 0x5d, 0x36, 0x96, 0x43, 0x50, 0xcd, 0x86, 0xe0, 0x17, 0x05,
-	0x6e, 0x64, 0x0c, 0x88, 0x43, 0x4d, 0xb2, 0x90, 0x1e, 0x58, 0x2d, 0x3b, 0x70, 0xb5, 0x34, 0x42,
-	0x73, 0x1f, 0x1a, 0xa1, 0xc7, 0xb0, 0xc6, 0x9d, 0xfd, 0xf1, 0x79, 0x15, 0x00, 0x92, 0x55, 0xcc,
-	0x24, 0xb1, 0x9e, 0x42, 0x53, 0x0a, 0x64, 0xd7, 0x09, 0x23, 0x09, 0xbb, 0x97, 0xde, 0xe4, 0x42,
-	0x40, 0x72, 0xd8, 0x2f, 0x60, 0xa3, 0xa0, 0x67, 0x16, 0x89, 0xb6, 0x0f, 0xeb, 0x6c, 0x7d, 0x3f,
-	0x08, 0x48, 0xf0, 0xf1, 0xf0, 0x23, 0xe1, 0x06, 0x49, 0xcd, 0xd4, 0xe8, 0x3f, 0xcf, 0xa3, 0x6f,
-	0x26, 0xe8, 0x99, 0xda, 0x22, 0xf8, 0x3d, 0xb8, 0xd1, 0x3b, 0x25, 0x97, 0x9d, 0x4e, 0xb7, 0x4b,
-	0xfa, 0x67, 0xe1, 0xc7, 0x65, 0xcd, 0xef, 0x0a, 0x2c, 0x0a, 0x0d, 0x68, 0x15, 0xd4, 0x83, 0x8e,
-	0xd8, 0xa7, 0x1e, 0x74, 0x12, 0x4d, 0xaa, 0xa4, 0x09, 0xc1, 0xdc, 0x90, 0xd8, 0x71, 0x9d, 0x65,
-	0x63, 0xd4, 0x80, 0x79, 0x72, 0xe9, 0xe1, 0x40, 0x9b, 0x63, 0x42, 0x3e, 0xa1, 0x5f, 0x76, 0x3a,
-	0xdd, 0x50, 0x9b, 0x67, 0x06, 0xd9, 0x98, 0x55, 0xd5, 0x2b, 0xaf, 0x8f, 0x6d, 0x6d, 0x81, 0x49,
-	0xc5, 0x0c, 0xe9, 0xb0, 0x34, 0xf2, 0xc4, 0xca, 0x22, 0x5b, 0x49, 0xe6, 0x46, 0x1f, 0x1a, 0xd9,
-	0x63, 0x4e, 0xed, 0xda, 0x4f, 0x60, 0xde, 0xa5, 0x5b, 0x85, 0x63, 0x6b, 0xd4, 0xb1, 0x42, 0x9d,
-	0xc9, 0x57, 0x0c, 0x17, 0x1a, 0x2f, 0x3c, 0x3a, 0x8c, 0xe5, 0xc2, 0x99, 0x79, 0x97, 0x18, 0xb0,
-	0x12, 0x60, 0xdf, 0xb5, 0xfa, 0xf8, 0x90, 0x9d, 0x98, 0x5b, 0xc9, 0xc8, 0xd0, 0x16, 0xd4, 0x4e,
-	0x48, 0xd0, 0xc7, 0x26, 0x1e, 0x92, 0x0b, 0xee, 0xa9, 0x25, 0x53, 0x16, 0x19, 0x8f, 0x61, 0x3d,
-	0x67, 0x6d, 0xda, 0x33, 0x19, 0x0f, 0xa1, 0xdd, 0xbb, 0x74, 0xa2, 0xfe, 0xa9, 0xd4, 0xd9, 0x78,
-	0xa1, 0x8e, 0xa1, 0x4b, 0x31, 0x57, 0xb2, 0x31, 0xff, 0x09, 0x6e, 0x8f, 0xdd, 0x3b, 0x93, 0xb2,
-	0x61, 0x42, 0x4b, 0x94, 0xdf, 0x12, 0x26, 0x70, 0x53, 0x2a, 0xc2, 0x2c, 0x54, 0x6c, 0x55, 0x54,
-	0xe1, 0xf1, 0x89, 0xfc, 0x4a, 0x01, 0xbd, 0x4c, 0xa9, 0x38, 0xd0, 0x44, 0xad, 0xff, 0x6f, 0x6d,
-	0x7f, 0xad, 0xc0, 0xda, 0x57, 0x96, 0x67, 0xbb, 0xb8, 0xf7, 0xbc, 0x1b, 0x4e, 0xaa, 0x30, 0x2d,
-	0x06, 0x52, 0x65, 0x20, 0x97, 0xa9, 0xe2, 0xde, 0xf3, 0x6e, 0xda, 0xe0, 0xac, 0x60, 0x10, 0x77,
-	0x32, 0x36, 0xa6, 0x9c, 0xe8, 0x38, 0xe1, 0x44, 0xfc, 0xee, 0xa5, 0x02, 0x89, 0xc1, 0xcc, 0xcb,
-	0x0c, 0x86, 0x32, 0xad, 0xf0, 0xdc, 0x3d, 0xb2, 0xa2, 0x08, 0x07, 0x9e, 0xb6, 0xc0, 0x99, 0x56,
-	0x2a, 0xa1, 0x77, 0x31, 0x3c, 0xb5, 0x02, 0xdb, 0xf1, 0x06, 0xda, 0x22, 0x73, 0x47, 0x32, 0xa7,
-	0x3d, 0x46, 0x3e, 0xc9, 0x4c, 0x92, 0xe5, 0x95, 0x02, 0x1b, 0x47, 0xa3, 0x60, 0x50, 0x96, 0x2b,
-	0x63, 0x73, 0x9c, 0x9e, 0xc2, 0xf1, 0xac, 0x7e, 0xe4, 0x5c, 0x60, 0x11, 0xd4, 0x64, 0xce, 0xea,
-	0x9a, 0x33, 0xe4, 0x37, 0xb3, 0x6a, 0xb2, 0x31, 0xfd, 0xfe, 0xc4, 0x71, 0x31, 0x0b, 0x09, 0x77,
-	0x65, 0x32, 0x67, 0x9e, 0x1c, 0x1d, 0x77, 0x9c, 0x20, 0xf1, 0x24, 0x9b, 0x19, 0xdf, 0x83, 0x56,
-	0x04, 0x36, 0x13, 0x9f, 0xdc, 0x81, 0xfa, 0xde, 0x29, 0xee, 0x9f, 0xbd, 0x87, 0x2d, 0x18, 0x8f,
-	0x60, 0x4d, 0xfa, 0x6e, 0xea, 0x22, 0xd3, 0x85, 0x86, 0xb8, 0x52, 0x3d, 0x66, 0x38, 0x36, 0xb5,
-	0x29, 0x5d, 0xa6, 0x15, 0x96, 0xa7, 0x6c, 0x39, 0xbd, 0x4d, 0x82, 0x50, 0xaa, 0x19, 0x42, 0x39,
-	0x82, 0xf5, 0x9c, 0xb6, 0x99, 0xf8, 0x6a, 0x1f, 0xd6, 0x4d, 0x3c, 0x70, 0x68, 0x79, 0x8b, 0x3f,
-	0x99, 0xd8, 0xe3, 0x2d, 0xdb, 0x0e, 0x70, 0x18, 0x0a, 0xb3, 0xf1, 0xd4, 0x78, 0x02, 0xcd, 0xbc,
-	0x9a, 0xa9, 0xfd, 0xd9, 0x81, 0xc6, 0xe1, 0xc9, 0x89, 0xeb, 0x78, 0xf8, 0xbf, 0x20, 0x79, 0x0c,
-	0xeb, 0x39, 0x2d, 0x53, 0x03, 0x41, 0x50, 0xff, 0x12, 0x47, 0x5d, 0x6c, 0xd9, 0x09, 0x08, 0x03,
-	0xc3, 0x9a, 0x24, 0x7b, 0x8f, 0xca, 0x32, 0xbe, 0x4d, 0x4b, 0x94, 0x6d, 0x07, 0x31, 0x35, 0xa0,
-	0xe3, 0xd8, 0xf4, 0x5c, 0x62, 0xfa, 0xae, 0x09, 0x4b, 0x71, 0xb6, 0xa0, 0x1b, 0x70, 0xfd, 0xc0,
-	0xbb, 0xb0, 0x5c, 0xc7, 0x8e, 0x45, 0xf5, 0x0a, 0xba, 0x0e, 0x35, 0xf6, 0x3e, 0xe2, 0xa2, 0xba,
-	0x82, 0xea, 0xb0, 0xc2, 0x89, 0xad, 0x90, 0xa8, 0x68, 0x15, 0xa0, 0x17, 0x11, 0x5f, 0xcc, 0xab,
-	0xbb, 0xff, 0xd4, 0x60, 0x81, 0x37, 0x30, 0xf4, 0x12, 0x96, 0x93, 0xd7, 0x15, 0x6a, 0xb0, 0xdc,
-	0xcc, 0x3d, 0xd7, 0xf4, 0xf5, 0x9c, 0x94, 0x1f, 0xd5, 0xb8, 0xfd, 0xf3, 0x1f, 0x7f, 0xff, 0xa6,
-	0xb6, 0x8c, 0x06, 0x7d, 0xbe, 0x86, 0x3b, 0x17, 0xf7, 0x2d, 0xd7, 0x3f, 0xb5, 0xee, 0xef, 0xd0,
-	0x8b, 0x14, 0x3e, 0x54, 0xee, 0xa2, 0x13, 0xa8, 0x49, 0x8f, 0x06, 0xc4, 0xf8, 0x59, 0xf1, 0x99,
-	0xa2, 0x6f, 0x14, 0xe4, 0xc2, 0xc0, 0x1d, 0x66, 0x60, 0x4b, 0xbf, 0x59, 0x66, 0x60, 0xe7, 0x07,
-	0xea, 0xc3, 0x1f, 0xa9, 0x9d, 0x47, 0x00, 0x29, 0x91, 0x47, 0x0c, 0x6d, 0xe1, 0x6d, 0xa0, 0x37,
-	0xf3, 0x62, 0x61, 0xa4, 0x82, 0x5c, 0xa8, 0x49, 0x9c, 0x17, 0xe9, 0x39, 0x12, 0x2c, 0xb1, 0x5c,
-	0xfd, 0x66, 0xe9, 0x9a, 0xd0, 0xf4, 0x19, 0x83, 0xdb, 0x46, 0x9b, 0x39, 0xb8, 0x21, 0xfb, 0x54,
-	0xe0, 0x45, 0xfb, 0x00, 0x29, 0x47, 0x45, 0xad, 0x2c, 0x67, 0x95, 0x6d, 0xe9, 0x65, 0x4b, 0x09,
-	0xe8, 0x3d, 0x58, 0x91, 0x49, 0x1e, 0x62, 0x4e, 0x2c, 0x61, 0xb7, 0xba, 0x56, 0x5c, 0x48, 0x94,
-	0x3c, 0x85, 0x6b, 0x19, 0x5a, 0x85, 0xd8, 0xc7, 0x65, 0xbc, 0x4e, 0x6f, 0x95, 0xac, 0x24, 0x7a,
-	0x5e, 0xc4, 0x2f, 0x29, 0xf9, 0xe5, 0x8b, 0x6e, 0xa5, 0x1e, 0x2f, 0x79, 0x46, 0xeb, 0xed, 0x71,
-	0xcb, 0x89, 0xda, 0x97, 0xb0, 0x31, 0xe6, 0x67, 0x04, 0x32, 0xd2, 0xcd, 0xe3, 0xfe, 0x54, 0xe8,
-	0x63, 0x4b, 0x9d, 0x51, 0xa1, 0x29, 0x93, 0xf6, 0x65, 0x9e, 0x32, 0x05, 0xc6, 0xc1, 0x53, 0xa6,
-	0xd8, 0xbe, 0x8d, 0x0a, 0xb2, 0x61, 0x63, 0x0c, 0x21, 0xe4, 0xc8, 0x26, 0x33, 0x4d, 0xfd, 0xd3,
-	0x89, 0xdf, 0x48, 0xe7, 0x6f, 0x16, 0x09, 0x1a, 0xcb, 0xf1, 0x5b, 0xd2, 0x95, 0x29, 0x76, 0x79,
-	0xee, 0xda, 0xf1, 0xdc, 0xce, 0xa8, 0xa0, 0x43, 0xa8, 0xe7, 0x3b, 0x31, 0x62, 0xc9, 0x3d, 0x86,
-	0x38, 0xe8, 0x9b, 0xe5, 0x8b, 0x92, 0x42, 0x54, 0xfc, 0x57, 0xc5, 0x71, 0x8e, 0xfd, 0x87, 0x35,
-	0x31, 0x42, 0x0f, 0x61, 0x39, 0xe9, 0xc4, 0xbc, 0x2e, 0xe5, 0x1b, 0x38, 0xaf, 0x4b, 0x85, 0x76,
-	0xcd, 0xf3, 0x3a, 0xd3, 0x38, 0x79, 0x5e, 0x97, 0x75, 0x66, 0x9e, 0xd7, 0xa5, 0x5d, 0xd6, 0xa8,
-	0xa0, 0x03, 0x58, 0xcd, 0xb6, 0x30, 0x7e, 0x5f, 0x4b, 0xbb, 0x23, 0xbf, 0xaf, 0xe5, 0x1d, 0x4f,
-	0x40, 0x92, 0x7b, 0x90, 0x80, 0x54, 0xd2, 0xdc, 0x04, 0xa4, 0xb2, 0x86, 0xc5, 0xdd, 0x92, 0x34,
-	0x1d, 0xee, 0x96, 0x7c, 0x5f, 0xe2, 0x6e, 0x29, 0x74, 0x26, 0xa3, 0xf2, 0x44, 0x7b, 0xfd, 0xb6,
-	0xad, 0xbc, 0x79, 0xdb, 0x56, 0xfe, 0x7a, 0xdb, 0x56, 0x7e, 0x7d, 0xd7, 0xae, 0xbc, 0x79, 0xd7,
-	0xae, 0xfc, 0xf9, 0xae, 0x5d, 0x39, 0x5e, 0x60, 0x3f, 0x1c, 0x1f, 0xfc, 0x1b, 0x00, 0x00, 0xff,
-	0xff, 0xdc, 0xaa, 0x67, 0x01, 0xb4, 0x14, 0x00, 0x00,
+	0x10, 0x16, 0x25, 0x59, 0xb6, 0xc6, 0x8e, 0x23, 0xaf, 0x65, 0x99, 0x62, 0x1c, 0xc5, 0x65, 0x8b,
+	0xc0, 0xc8, 0x21, 0x6e, 0x9c, 0x5b, 0x80, 0x00, 0x4d, 0x2c, 0x07, 0x35, 0x20, 0xd7, 0x0e, 0x15,
+	0xa3, 0xc8, 0xa5, 0x00, 0x2d, 0xae, 0x65, 0xc2, 0x14, 0x49, 0x93, 0x94, 0x5d, 0xa3, 0x28, 0x0a,
+	0xf4, 0x05, 0x5a, 0xa0, 0x87, 0xe4, 0xd6, 0xb7, 0x29, 0x72, 0x0c, 0xd0, 0x4b, 0x8f, 0x45, 0xd2,
+	0x07, 0x29, 0xf6, 0x87, 0xe4, 0xf2, 0x4f, 0xb5, 0x1c, 0xd4, 0xb7, 0x9d, 0xd9, 0xdd, 0x99, 0x6f,
+	0x67, 0x66, 0x67, 0x67, 0x16, 0x16, 0x8d, 0xd1, 0x48, 0xf7, 0x03, 0xec, 0x3d, 0x74, 0x3d, 0x27,
+	0x70, 0x50, 0xd9, 0x3d, 0x52, 0x16, 0x8d, 0xd1, 0x85, 0xe3, 0x9d, 0x86, 0x3c, 0x65, 0x6d, 0xe8,
+	0x38, 0x43, 0x0b, 0x6f, 0xea, 0xae, 0xb9, 0xa9, 0xdb, 0xb6, 0x13, 0xe8, 0x81, 0xe9, 0xd8, 0x3e,
+	0x9b, 0x55, 0xcf, 0xa0, 0xbd, 0x67, 0x0e, 0x3d, 0x3d, 0xc0, 0xdf, 0xd2, 0x4d, 0x1a, 0xb6, 0xf4,
+	0x4b, 0x0d, 0x9f, 0x8d, 0xb1, 0x1f, 0xa0, 0x0e, 0xc0, 0x73, 0xd3, 0xb6, 0x9c, 0xe1, 0x37, 0xfa,
+	0x08, 0xcb, 0xd2, 0xba, 0xb4, 0x51, 0xd7, 0x04, 0x0e, 0x5a, 0x83, 0x3a, 0xa3, 0x0e, 0x1c, 0x5f,
+	0x2e, 0xaf, 0x4b, 0x1b, 0xb7, 0xb4, 0x98, 0x81, 0x5a, 0x50, 0xf3, 0x9d, 0xb1, 0x37, 0xc0, 0x72,
+	0x85, 0xee, 0xe4, 0x94, 0x7a, 0x00, 0x9d, 0x43, 0xd7, 0x48, 0x6a, 0xdc, 0x76, 0xec, 0x63, 0x73,
+	0x18, 0xea, 0x6d, 0x41, 0x6d, 0x40, 0x19, 0x5c, 0x27, 0xa7, 0x04, 0x89, 0xe5, 0x84, 0xc4, 0xaf,
+	0xa0, 0xd1, 0x0f, 0x74, 0x2f, 0x78, 0xa5, 0xfb, 0xa7, 0xa1, 0x0c, 0x04, 0xd5, 0x40, 0xf7, 0x4f,
+	0xb9, 0x04, 0x3a, 0x46, 0x32, 0xcc, 0xb2, 0x1d, 0x04, 0x6d, 0x65, 0xa3, 0xae, 0x85, 0xa4, 0x7a,
+	0x06, 0x4b, 0x82, 0x04, 0xdf, 0x75, 0x6c, 0x1f, 0x13, 0x75, 0x1e, 0xf6, 0xc7, 0x56, 0x40, 0x85,
+	0xcc, 0x69, 0x9c, 0x42, 0x0d, 0xa8, 0x8c, 0xfc, 0x21, 0xc7, 0x40, 0x86, 0x68, 0x2b, 0x16, 0x5c,
+	0x59, 0xaf, 0x6c, 0xcc, 0x6f, 0xc9, 0x0f, 0xdd, 0xa3, 0x87, 0xdb, 0xce, 0x68, 0xe4, 0xd8, 0xe1,
+	0x29, 0x99, 0xd0, 0x58, 0xe5, 0x63, 0x68, 0x33, 0x33, 0xec, 0x51, 0x0f, 0x5e, 0xc9, 0x02, 0xea,
+	0x25, 0x28, 0x79, 0x9b, 0xa6, 0x06, 0xfc, 0x28, 0x0d, 0x78, 0x95, 0x00, 0x7e, 0x39, 0xc6, 0xde,
+	0x65, 0x3f, 0xd0, 0x83, 0xb1, 0x9f, 0xc5, 0xfb, 0x1d, 0xa0, 0x7d, 0x17, 0x93, 0x48, 0x11, 0xcd,
+	0xac, 0x40, 0xd9, 0x71, 0xa9, 0xba, 0xc5, 0x2d, 0x20, 0x32, 0xc8, 0xe4, 0xbe, 0xab, 0x95, 0x1d,
+	0x97, 0xb8, 0xc0, 0x26, 0x81, 0xc3, 0xf4, 0xd2, 0xb1, 0xe8, 0x82, 0x4a, 0xd2, 0x05, 0xbf, 0x48,
+	0xb0, 0x9c, 0x50, 0xc0, 0x0f, 0x35, 0x49, 0x43, 0x7c, 0xe0, 0x72, 0xde, 0x81, 0x2b, 0xb9, 0x1e,
+	0xaa, 0x5e, 0xd5, 0x43, 0xcf, 0x60, 0x89, 0x19, 0xfb, 0xfa, 0x71, 0xe5, 0x01, 0x12, 0x45, 0xdc,
+	0x48, 0x60, 0xbd, 0x80, 0x96, 0xe0, 0xc8, 0x9e, 0xe9, 0x07, 0x02, 0x76, 0x3b, 0xbe, 0xc9, 0x19,
+	0x87, 0xa4, 0xb0, 0x9f, 0xc3, 0x6a, 0x46, 0xce, 0x4d, 0x04, 0xda, 0x0e, 0xac, 0xd0, 0xf9, 0x1d,
+	0xcf, 0x73, 0xbc, 0xeb, 0xc3, 0x0f, 0xb8, 0x19, 0x04, 0x31, 0x53, 0xa3, 0xff, 0x32, 0x8d, 0xbe,
+	0x15, 0xa1, 0xa7, 0x62, 0xb3, 0xe0, 0xb7, 0x61, 0xb9, 0x7f, 0xe2, 0x5c, 0x74, 0xbb, 0xbd, 0x9e,
+	0x33, 0x38, 0xf5, 0xaf, 0x17, 0x35, 0xbf, 0x4b, 0x30, 0xcb, 0x25, 0xa0, 0x45, 0x28, 0xef, 0x76,
+	0xf9, 0xbe, 0xf2, 0x6e, 0x37, 0x92, 0x54, 0x16, 0x24, 0x21, 0xa8, 0x8e, 0x1c, 0x23, 0xcc, 0xb3,
+	0x74, 0x8c, 0x9a, 0x30, 0xe3, 0x5c, 0xd8, 0xd8, 0x93, 0xab, 0x94, 0xc9, 0x08, 0xb2, 0xb2, 0xdb,
+	0xed, 0xf9, 0xf2, 0x0c, 0x55, 0x48, 0xc7, 0x34, 0xab, 0x5e, 0xda, 0x03, 0x6c, 0xc8, 0x35, 0xca,
+	0xe5, 0x14, 0x52, 0x60, 0x6e, 0x6c, 0xf3, 0x99, 0x59, 0x3a, 0x13, 0xd1, 0xea, 0x00, 0x9a, 0xc9,
+	0x63, 0x4e, 0x6d, 0xda, 0xcf, 0x60, 0xc6, 0x22, 0x5b, 0xb9, 0x61, 0xe7, 0x89, 0x61, 0xb9, 0x38,
+	0x8d, 0xcd, 0xa8, 0x16, 0x34, 0x0f, 0x6d, 0x32, 0x0c, 0xf9, 0xdc, 0x98, 0x69, 0x93, 0xa8, 0xb0,
+	0xe0, 0x61, 0xd7, 0xd2, 0x07, 0x78, 0x9f, 0x9e, 0x98, 0x69, 0x49, 0xf0, 0xd0, 0x3a, 0xcc, 0x1f,
+	0x3b, 0xde, 0x00, 0x6b, 0x78, 0xe4, 0x9c, 0x33, 0x4b, 0xcd, 0x69, 0x22, 0x4b, 0x7d, 0x06, 0x2b,
+	0x29, 0x6d, 0xd3, 0x9e, 0x49, 0x7d, 0x02, 0x9d, 0xfe, 0x85, 0x19, 0x0c, 0x4e, 0x84, 0x97, 0x8d,
+	0x25, 0xea, 0x10, 0xba, 0xe0, 0x73, 0x29, 0xe9, 0xf3, 0x9f, 0xe0, 0x5e, 0xe1, 0xde, 0x1b, 0x49,
+	0x1b, 0x1a, 0xb4, 0x79, 0xfa, 0xcd, 0xa9, 0x04, 0xee, 0x08, 0x49, 0x98, 0xba, 0x8a, 0xce, 0xf2,
+	0x2c, 0x5c, 0x1c, 0xc8, 0x6f, 0x24, 0x50, 0xf2, 0x84, 0xf2, 0x03, 0x4d, 0x94, 0xfa, 0xff, 0xe6,
+	0xf6, 0x77, 0x12, 0x2c, 0x7d, 0xad, 0xdb, 0x86, 0x85, 0xfb, 0x2f, 0x7b, 0xfe, 0xa4, 0x0c, 0xd3,
+	0xa6, 0x20, 0xcb, 0x14, 0x64, 0x9d, 0x08, 0xee, 0xbf, 0xec, 0xc5, 0x0f, 0x9c, 0xee, 0x0d, 0xc3,
+	0x97, 0x8c, 0x8e, 0x49, 0x4d, 0x74, 0x14, 0xd5, 0x44, 0xec, 0xee, 0xc5, 0x0c, 0xa1, 0x82, 0x99,
+	0x11, 0x2b, 0x18, 0x52, 0x69, 0xf9, 0x67, 0xd6, 0x81, 0x1e, 0x04, 0xd8, 0xb3, 0xe5, 0x1a, 0xab,
+	0xb4, 0x62, 0x0e, 0xb9, 0x8b, 0xfe, 0x89, 0xee, 0x19, 0xa6, 0x3d, 0x94, 0x67, 0xa9, 0x39, 0x22,
+	0x9a, 0xbc, 0x31, 0xe2, 0x49, 0x6e, 0x24, 0x58, 0xde, 0x48, 0xb0, 0x7a, 0x30, 0xf6, 0x86, 0x79,
+	0xb1, 0x52, 0x18, 0xe3, 0xe4, 0x14, 0xa6, 0xad, 0x0f, 0x02, 0xf3, 0x1c, 0x73, 0xa7, 0x46, 0x34,
+	0xcd, 0x6b, 0xe6, 0x88, 0xdd, 0xcc, 0x8a, 0x46, 0xc7, 0x64, 0xfd, 0xb1, 0x69, 0x61, 0xea, 0x12,
+	0x66, 0xca, 0x88, 0xa6, 0x96, 0x1c, 0x1f, 0x75, 0x4d, 0x2f, 0xb2, 0x24, 0xa5, 0xd4, 0xef, 0x41,
+	0xce, 0x02, 0xbb, 0x11, 0x9b, 0xdc, 0x87, 0xc6, 0xf6, 0x09, 0x1e, 0x9c, 0xfe, 0x47, 0xb5, 0xa0,
+	0x3e, 0x85, 0x25, 0x61, 0xdd, 0xd4, 0x49, 0xa6, 0x07, 0x4d, 0x7e, 0xa5, 0xfa, 0x54, 0x71, 0xa8,
+	0x6a, 0x4d, 0xb8, 0x4c, 0x0b, 0x34, 0x4e, 0xe9, 0x74, 0x7c, 0x9b, 0x78, 0x41, 0x59, 0x4e, 0x14,
+	0x94, 0x63, 0x58, 0x49, 0x49, 0xbb, 0x11, 0x5b, 0xed, 0xc0, 0x8a, 0x86, 0x87, 0x26, 0x49, 0x6f,
+	0xe1, 0x92, 0x89, 0x6f, 0xbc, 0x6e, 0x18, 0x1e, 0xf6, 0x7d, 0xae, 0x36, 0x24, 0xd5, 0xe7, 0xd0,
+	0x4a, 0x8b, 0x99, 0xda, 0x9e, 0x5d, 0x68, 0xee, 0x1f, 0x1f, 0x5b, 0xa6, 0x8d, 0x3f, 0x05, 0xc9,
+	0x33, 0x58, 0x49, 0x49, 0x99, 0x1a, 0xc8, 0x5b, 0x09, 0x9a, 0x7b, 0x78, 0x74, 0x84, 0xbd, 0x54,
+	0xde, 0xcf, 0x43, 0xa2, 0xc0, 0xdc, 0x88, 0xae, 0xdd, 0xed, 0x52, 0x19, 0x55, 0x2d, 0xa2, 0xc9,
+	0xd3, 0xaf, 0x5b, 0x66, 0xf4, 0xca, 0x31, 0x82, 0xec, 0x70, 0x31, 0xf6, 0x0e, 0xb5, 0x1e, 0x4b,
+	0x93, 0x75, 0x2d, 0xa2, 0x49, 0xfa, 0x19, 0x58, 0x26, 0xb6, 0x03, 0x3a, 0xcb, 0x8a, 0x03, 0x81,
+	0x43, 0x5e, 0x62, 0x86, 0x2c, 0x75, 0xb8, 0x3c, 0x64, 0x24, 0x29, 0x1a, 0x46, 0xf8, 0x0a, 0xd3,
+	0x31, 0x41, 0xe4, 0x07, 0xfa, 0x30, 0xac, 0x50, 0x18, 0x21, 0x24, 0xc3, 0x6a, 0xa2, 0x9d, 0x5b,
+	0x86, 0x25, 0x52, 0xaf, 0x31, 0x8d, 0xdc, 0x1d, 0xe4, 0x5e, 0xc7, 0xcc, 0x4f, 0x79, 0x18, 0x99,
+	0x99, 0x12, 0xb1, 0x9a, 0x27, 0x54, 0x0b, 0x17, 0xaa, 0x7f, 0x48, 0xa2, 0xea, 0x1e, 0xd6, 0x8d,
+	0x6b, 0xa9, 0x0e, 0x6d, 0x55, 0x29, 0xf0, 0x62, 0xb5, 0xc8, 0x8b, 0x33, 0x45, 0x5e, 0xac, 0x4d,
+	0xf4, 0xe2, 0x6c, 0xc6, 0x8b, 0x09, 0x13, 0x5e, 0x37, 0x4c, 0x27, 0x9a, 0x30, 0x7d, 0xdd, 0xf9,
+	0xc2, 0x07, 0x7b, 0x00, 0x6c, 0xc1, 0xab, 0x4b, 0x17, 0xa3, 0xdb, 0x30, 0xbf, 0x6b, 0x9f, 0xeb,
+	0x96, 0x69, 0x10, 0xb2, 0x51, 0x42, 0x8b, 0x00, 0xcc, 0xf8, 0x94, 0x96, 0x08, 0xcd, 0x24, 0x51,
+	0xba, 0x4c, 0x68, 0x66, 0x76, 0x4a, 0x57, 0x1e, 0x68, 0x30, 0x17, 0x26, 0x37, 0xb4, 0x0c, 0xb7,
+	0xb9, 0xb0, 0x90, 0xd5, 0x28, 0x11, 0x0d, 0xb4, 0x9d, 0x67, 0xac, 0x86, 0x84, 0x1a, 0xb0, 0xc0,
+	0xfa, 0x30, 0xce, 0xa1, 0x32, 0xfb, 0x81, 0xe3, 0x72, 0xba, 0xb2, 0xf5, 0xf6, 0x16, 0xd4, 0x18,
+	0x08, 0xf4, 0x1a, 0xea, 0xd1, 0x67, 0x00, 0x6a, 0xd2, 0x54, 0x9a, 0xfa, 0x5d, 0x50, 0x56, 0x52,
+	0x5c, 0x76, 0x60, 0xf5, 0xde, 0xcf, 0x7f, 0xfe, 0xf3, 0x5b, 0xb9, 0xad, 0x36, 0x37, 0x75, 0xd7,
+	0xf4, 0x37, 0xcf, 0x1f, 0xe9, 0x96, 0x7b, 0xa2, 0x3f, 0xda, 0x24, 0x79, 0xdf, 0x7f, 0x22, 0x3d,
+	0x40, 0xc7, 0x30, 0x2f, 0xf4, 0xb8, 0x88, 0xb6, 0x13, 0xd9, 0xae, 0x5a, 0x59, 0xcd, 0xf0, 0xb9,
+	0x82, 0xfb, 0x54, 0xc1, 0xba, 0x72, 0x27, 0x4f, 0xc1, 0xe6, 0x0f, 0x24, 0xa8, 0x7e, 0x24, 0x7a,
+	0x9e, 0x02, 0xc4, 0x7d, 0x27, 0xa2, 0x68, 0x33, 0xad, 0xac, 0xd2, 0x4a, 0xb3, 0xb9, 0x92, 0x12,
+	0xb2, 0x60, 0x5e, 0x68, 0xd1, 0x90, 0x92, 0xea, 0xd9, 0x84, 0xa6, 0x4c, 0xb9, 0x93, 0x3b, 0xc7,
+	0x25, 0x7d, 0x41, 0xe1, 0x76, 0xd0, 0x5a, 0x0a, 0xae, 0x4f, 0x97, 0x72, 0xbc, 0x68, 0x07, 0x20,
+	0x6e, 0xa9, 0x50, 0x3b, 0xd9, 0x62, 0x89, 0xba, 0x94, 0xbc, 0xa9, 0x08, 0xf4, 0x36, 0x2c, 0x88,
+	0x3d, 0x09, 0xa2, 0x46, 0xcc, 0x69, 0xc6, 0x14, 0x39, 0x3b, 0x11, 0x09, 0x79, 0x01, 0xb7, 0x12,
+	0x5d, 0x00, 0xa2, 0x8b, 0xf3, 0xda, 0x10, 0xa5, 0x9d, 0x33, 0x13, 0xc9, 0x39, 0x0c, 0x1b, 0x7f,
+	0xf1, 0xa3, 0x06, 0xdd, 0x8d, 0x2d, 0x9e, 0xf3, 0xeb, 0xa3, 0x74, 0x8a, 0xa6, 0x23, 0xb1, 0xaf,
+	0x61, 0xb5, 0xe0, 0xef, 0x0c, 0xa9, 0xf1, 0xe6, 0xa2, 0x8f, 0x35, 0xa5, 0xf0, 0x65, 0x56, 0x4b,
+	0x24, 0x64, 0xe2, 0x32, 0x92, 0x85, 0x4c, 0xa6, 0x40, 0x66, 0x21, 0x93, 0xad, 0x36, 0xd5, 0x12,
+	0x32, 0x60, 0xb5, 0xa0, 0x7f, 0x61, 0xc8, 0x26, 0x37, 0x46, 0xca, 0xe7, 0x13, 0xd7, 0x08, 0xe7,
+	0x6f, 0x65, 0xfb, 0x09, 0x1a, 0xe3, 0x77, 0x85, 0x2b, 0x93, 0x2d, 0x4a, 0x99, 0x69, 0x8b, 0x5b,
+	0x11, 0xb5, 0x84, 0xf6, 0xa1, 0x91, 0x2e, 0x1c, 0x11, 0x0d, 0xee, 0x82, 0x3a, 0x57, 0x59, 0xcb,
+	0x9f, 0x14, 0x04, 0xa2, 0xec, 0xd7, 0x2a, 0xc3, 0x59, 0xf8, 0xe5, 0x3a, 0xd1, 0x43, 0x4f, 0xa0,
+	0x1e, 0x15, 0x8e, 0x2c, 0x2f, 0xa5, 0xeb, 0x4d, 0x96, 0x97, 0x32, 0xd5, 0x25, 0x8b, 0xeb, 0x44,
+	0x9d, 0xc7, 0xe2, 0x3a, 0xaf, 0x90, 0x64, 0x71, 0x9d, 0x5b, 0x14, 0xaa, 0x25, 0xb4, 0x0b, 0x8b,
+	0xc9, 0x8a, 0x8b, 0xdd, 0xd7, 0xdc, 0x62, 0x8e, 0xdd, 0xd7, 0xfc, 0x02, 0x8d, 0x43, 0x12, 0x4b,
+	0x26, 0x0e, 0x29, 0xa7, 0x16, 0xe3, 0x90, 0xf2, 0xea, 0x2b, 0x0a, 0xa9, 0x91, 0xae, 0x0c, 0x58,
+	0xf8, 0x66, 0x8a, 0x08, 0xe6, 0xb2, 0xa2, 0x32, 0x22, 0x2d, 0x8a, 0xa3, 0xba, 0x9a, 0xa8, 0xc9,
+	0xa8, 0xd8, 0xeb, 0x75, 0x45, 0x51, 0xc9, 0x0a, 0x43, 0x2d, 0x3d, 0x97, 0xdf, 0x7d, 0xe8, 0x48,
+	0xef, 0x3f, 0x74, 0xa4, 0xbf, 0x3f, 0x74, 0xa4, 0x5f, 0x3f, 0x76, 0x4a, 0xef, 0x3f, 0x76, 0x4a,
+	0x7f, 0x7d, 0xec, 0x94, 0x8e, 0x6a, 0xf4, 0x13, 0xff, 0xf1, 0xbf, 0x01, 0x00, 0x00, 0xff, 0xff,
+	0x28, 0x6a, 0xf8, 0xf2, 0x08, 0x18, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -2408,8 +2743,12 @@ type MasterClient interface {
 	RegisterWorker(ctx context.Context, in *RegisterWorkerRequest, opts ...grpc.CallOption) (*RegisterWorkerResponse, error)
 	// OfflineWorker offline the dm-workers.
 	OfflineWorker(ctx context.Context, in *OfflineWorkerRequest, opts ...grpc.CallOption) (*OfflineWorkerResponse, error)
-	// GetLeader get master leader.
-	GetLeader(ctx context.Context, in *GetLeaderRequest, opts ...grpc.CallOption) (*GetLeaderResponse, error)
+	// ListMember list member master information
+	ListMemberMaster(ctx context.Context, in *ListMemberRequest, opts ...grpc.CallOption) (*ListMemberMasterResponse, error)
+	// ListMember list member worker information
+	ListMemberWorker(ctx context.Context, in *ListMemberRequest, opts ...grpc.CallOption) (*ListMemberWorkerResponse, error)
+	// ListMember list member leader information
+	ListMemberLeader(ctx context.Context, in *ListMemberRequest, opts ...grpc.CallOption) (*ListMemberLeaderResponse, error)
 }
 
 type masterClient struct {
@@ -2582,9 +2921,27 @@ func (c *masterClient) OfflineWorker(ctx context.Context, in *OfflineWorkerReque
 	return out, nil
 }
 
-func (c *masterClient) GetLeader(ctx context.Context, in *GetLeaderRequest, opts ...grpc.CallOption) (*GetLeaderResponse, error) {
-	out := new(GetLeaderResponse)
-	err := c.cc.Invoke(ctx, "/pb.Master/GetLeader", in, out, opts...)
+func (c *masterClient) ListMemberMaster(ctx context.Context, in *ListMemberRequest, opts ...grpc.CallOption) (*ListMemberMasterResponse, error) {
+	out := new(ListMemberMasterResponse)
+	err := c.cc.Invoke(ctx, "/pb.Master/ListMemberMaster", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *masterClient) ListMemberWorker(ctx context.Context, in *ListMemberRequest, opts ...grpc.CallOption) (*ListMemberWorkerResponse, error) {
+	out := new(ListMemberWorkerResponse)
+	err := c.cc.Invoke(ctx, "/pb.Master/ListMemberWorker", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *masterClient) ListMemberLeader(ctx context.Context, in *ListMemberRequest, opts ...grpc.CallOption) (*ListMemberLeaderResponse, error) {
+	out := new(ListMemberLeaderResponse)
+	err := c.cc.Invoke(ctx, "/pb.Master/ListMemberLeader", in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
@@ -2621,8 +2978,12 @@ type MasterServer interface {
 	RegisterWorker(context.Context, *RegisterWorkerRequest) (*RegisterWorkerResponse, error)
 	// OfflineWorker offline the dm-workers.
 	OfflineWorker(context.Context, *OfflineWorkerRequest) (*OfflineWorkerResponse, error)
-	// GetLeader get master leader.
-	GetLeader(context.Context, *GetLeaderRequest) (*GetLeaderResponse, error)
+	// ListMember list member master information
+	ListMemberMaster(context.Context, *ListMemberRequest) (*ListMemberMasterResponse, error)
+	// ListMember list member worker information
+	ListMemberWorker(context.Context, *ListMemberRequest) (*ListMemberWorkerResponse, error)
+	// ListMember list member leader information
+	ListMemberLeader(context.Context, *ListMemberRequest) (*ListMemberLeaderResponse, error)
 }
 
 // UnimplementedMasterServer can be embedded to have forward compatible implementations.
@@ -2683,8 +3044,14 @@ func (*UnimplementedMasterServer) RegisterWorker(ctx context.Context, req *Regis
 func (*UnimplementedMasterServer) OfflineWorker(ctx context.Context, req *OfflineWorkerRequest) (*OfflineWorkerResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method OfflineWorker not implemented")
 }
-func (*UnimplementedMasterServer) GetLeader(ctx context.Context, req *GetLeaderRequest) (*GetLeaderResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method GetLeader not implemented")
+func (*UnimplementedMasterServer) ListMemberMaster(ctx context.Context, req *ListMemberRequest) (*ListMemberMasterResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method ListMemberMaster not implemented")
+}
+func (*UnimplementedMasterServer) ListMemberWorker(ctx context.Context, req *ListMemberRequest) (*ListMemberWorkerResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method ListMemberWorker not implemented")
+}
+func (*UnimplementedMasterServer) ListMemberLeader(ctx context.Context, req *ListMemberRequest) (*ListMemberLeaderResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method ListMemberLeader not implemented")
 }
 
 func RegisterMasterServer(s *grpc.Server, srv MasterServer) {
@@ -3015,20 +3382,56 @@ func _Master_OfflineWorker_Handler(srv interface{}, ctx context.Context, dec fun
 	return interceptor(ctx, in, info, handler)
 }
 
-func _Master_GetLeader_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(GetLeaderRequest)
+func _Master_ListMemberMaster_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(ListMemberRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(MasterServer).ListMemberMaster(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/pb.Master/ListMemberMaster",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(MasterServer).ListMemberMaster(ctx, req.(*ListMemberRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Master_ListMemberWorker_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(ListMemberRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(MasterServer).ListMemberWorker(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/pb.Master/ListMemberWorker",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(MasterServer).ListMemberWorker(ctx, req.(*ListMemberRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Master_ListMemberLeader_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(ListMemberRequest)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
-		return srv.(MasterServer).GetLeader(ctx, in)
+		return srv.(MasterServer).ListMemberLeader(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/pb.Master/GetLeader",
+		FullMethod: "/pb.Master/ListMemberLeader",
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(MasterServer).GetLeader(ctx, req.(*GetLeaderRequest))
+		return srv.(MasterServer).ListMemberLeader(ctx, req.(*ListMemberRequest))
 	}
 	return interceptor(ctx, in, info, handler)
 }
@@ -3110,8 +3513,16 @@ var _Master_serviceDesc = grpc.ServiceDesc{
 			Handler:    _Master_OfflineWorker_Handler,
 		},
 		{
-			MethodName: "GetLeader",
-			Handler:    _Master_GetLeader_Handler,
+			MethodName: "ListMemberMaster",
+			Handler:    _Master_ListMemberMaster_Handler,
+		},
+		{
+			MethodName: "ListMemberWorker",
+			Handler:    _Master_ListMemberWorker_Handler,
+		},
+		{
+			MethodName: "ListMemberLeader",
+			Handler:    _Master_ListMemberLeader_Handler,
 		},
 	},
 	Streams:  []grpc.StreamDesc{},
@@ -4753,7 +5164,7 @@ func (m *OfflineWorkerResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
-func (m *GetLeaderRequest) Marshal() (dAtA []byte, err error) {
+func (m *MemberMasterResponse) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -4763,58 +5174,306 @@ func (m *GetLeaderRequest) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *GetLeaderRequest) MarshalTo(dAtA []byte) (int, error) {
+func (m *MemberMasterResponse) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *GetLeaderRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *MemberMasterResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	return len(dAtA) - i, nil
-}
-
-func (m *GetLeaderResponse) Marshal() (dAtA []byte, err error) {
-	size := m.Size()
-	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if len(m.ClientURLs) > 0 {
+		for iNdEx := len(m.ClientURLs) - 1; iNdEx >= 0; iNdEx-- {
+			i -= len(m.ClientURLs[iNdEx])
+			copy(dAtA[i:], m.ClientURLs[iNdEx])
+			i = encodeVarintDmmaster(dAtA, i, uint64(len(m.ClientURLs[iNdEx])))
+			i--
+			dAtA[i] = 0x2a
+		}
+	}
+	if len(m.PeerURLs) > 0 {
+		for iNdEx := len(m.PeerURLs) - 1; iNdEx >= 0; iNdEx-- {
+			i -= len(m.PeerURLs[iNdEx])
+			copy(dAtA[i:], m.PeerURLs[iNdEx])
+			i = encodeVarintDmmaster(dAtA, i, uint64(len(m.PeerURLs[iNdEx])))
+			i--
+			dAtA[i] = 0x22
+		}
+	}
+	if m.Alive {
+		i--
+		if m.Alive {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i--
+		dAtA[i] = 0x18
+	}
+	if m.MemberID != 0 {
+		i = encodeVarintDmmaster(dAtA, i, uint64(m.MemberID))
+		i--
+		dAtA[i] = 0x10
+	}
+	if len(m.Name) > 0 {
+		i -= len(m.Name)
+		copy(dAtA[i:], m.Name)
+		i = encodeVarintDmmaster(dAtA, i, uint64(len(m.Name)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *MemberWorkerResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 	if err != nil {
 		return nil, err
 	}
 	return dAtA[:n], nil
 }
 
-func (m *GetLeaderResponse) MarshalTo(dAtA []byte) (int, error) {
+func (m *MemberWorkerResponse) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *GetLeaderResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *MemberWorkerResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if len(m.Msg) > 0 {
-		i -= len(m.Msg)
-		copy(dAtA[i:], m.Msg)
-		i = encodeVarintDmmaster(dAtA, i, uint64(len(m.Msg)))
+	if len(m.Source) > 0 {
+		i -= len(m.Source)
+		copy(dAtA[i:], m.Source)
+		i = encodeVarintDmmaster(dAtA, i, uint64(len(m.Source)))
 		i--
 		dAtA[i] = 0x22
 	}
+	if len(m.Stage) > 0 {
+		i -= len(m.Stage)
+		copy(dAtA[i:], m.Stage)
+		i = encodeVarintDmmaster(dAtA, i, uint64(len(m.Stage)))
+		i--
+		dAtA[i] = 0x1a
+	}
 	if len(m.Addr) > 0 {
 		i -= len(m.Addr)
 		copy(dAtA[i:], m.Addr)
 		i = encodeVarintDmmaster(dAtA, i, uint64(len(m.Addr)))
 		i--
-		dAtA[i] = 0x1a
+		dAtA[i] = 0x12
+	}
+	if len(m.Name) > 0 {
+		i -= len(m.Name)
+		copy(dAtA[i:], m.Name)
+		i = encodeVarintDmmaster(dAtA, i, uint64(len(m.Name)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *ListMemberRequest) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *ListMemberRequest) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *ListMemberRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	return len(dAtA) - i, nil
+}
+
+func (m *ListMemberMasterResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *ListMemberMasterResponse) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *ListMemberMasterResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if len(m.Members) > 0 {
+		for iNdEx := len(m.Members) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.Members[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintDmmaster(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0x1a
+		}
+	}
+	if len(m.Msg) > 0 {
+		i -= len(m.Msg)
+		copy(dAtA[i:], m.Msg)
+		i = encodeVarintDmmaster(dAtA, i, uint64(len(m.Msg)))
+		i--
+		dAtA[i] = 0x12
+	}
+	if m.Result {
+		i--
+		if m.Result {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i--
+		dAtA[i] = 0x8
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *ListMemberLeaderResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *ListMemberLeaderResponse) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *ListMemberLeaderResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if len(m.ClientURLs) > 0 {
+		for iNdEx := len(m.ClientURLs) - 1; iNdEx >= 0; iNdEx-- {
+			i -= len(m.ClientURLs[iNdEx])
+			copy(dAtA[i:], m.ClientURLs[iNdEx])
+			i = encodeVarintDmmaster(dAtA, i, uint64(len(m.ClientURLs[iNdEx])))
+			i--
+			dAtA[i] = 0x3a
+		}
+	}
+	if len(m.PeerURLs) > 0 {
+		for iNdEx := len(m.PeerURLs) - 1; iNdEx >= 0; iNdEx-- {
+			i -= len(m.PeerURLs[iNdEx])
+			copy(dAtA[i:], m.PeerURLs[iNdEx])
+			i = encodeVarintDmmaster(dAtA, i, uint64(len(m.PeerURLs[iNdEx])))
+			i--
+			dAtA[i] = 0x32
+		}
+	}
+	if m.Alive {
+		i--
+		if m.Alive {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i--
+		dAtA[i] = 0x28
+	}
+	if m.MemberID != 0 {
+		i = encodeVarintDmmaster(dAtA, i, uint64(m.MemberID))
+		i--
+		dAtA[i] = 0x20
 	}
 	if len(m.Name) > 0 {
 		i -= len(m.Name)
 		copy(dAtA[i:], m.Name)
 		i = encodeVarintDmmaster(dAtA, i, uint64(len(m.Name)))
 		i--
+		dAtA[i] = 0x1a
+	}
+	if len(m.Msg) > 0 {
+		i -= len(m.Msg)
+		copy(dAtA[i:], m.Msg)
+		i = encodeVarintDmmaster(dAtA, i, uint64(len(m.Msg)))
+		i--
+		dAtA[i] = 0x12
+	}
+	if m.Result {
+		i--
+		if m.Result {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i--
+		dAtA[i] = 0x8
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *ListMemberWorkerResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *ListMemberWorkerResponse) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *ListMemberWorkerResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if len(m.Members) > 0 {
+		for iNdEx := len(m.Members) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.Members[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintDmmaster(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0x1a
+		}
+	}
+	if len(m.Msg) > 0 {
+		i -= len(m.Msg)
+		copy(dAtA[i:], m.Msg)
+		i = encodeVarintDmmaster(dAtA, i, uint64(len(m.Msg)))
+		i--
 		dAtA[i] = 0x12
 	}
 	if m.Result {
@@ -5567,24 +6226,43 @@ func (m *OfflineWorkerResponse) Size() (n int) {
 	return n
 }
 
-func (m *GetLeaderRequest) Size() (n int) {
+func (m *MemberMasterResponse) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
+	l = len(m.Name)
+	if l > 0 {
+		n += 1 + l + sovDmmaster(uint64(l))
+	}
+	if m.MemberID != 0 {
+		n += 1 + sovDmmaster(uint64(m.MemberID))
+	}
+	if m.Alive {
+		n += 2
+	}
+	if len(m.PeerURLs) > 0 {
+		for _, s := range m.PeerURLs {
+			l = len(s)
+			n += 1 + l + sovDmmaster(uint64(l))
+		}
+	}
+	if len(m.ClientURLs) > 0 {
+		for _, s := range m.ClientURLs {
+			l = len(s)
+			n += 1 + l + sovDmmaster(uint64(l))
+		}
+	}
 	return n
 }
 
-func (m *GetLeaderResponse) Size() (n int) {
+func (m *MemberWorkerResponse) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	if m.Result {
-		n += 2
-	}
 	l = len(m.Name)
 	if l > 0 {
 		n += 1 + l + sovDmmaster(uint64(l))
@@ -5593,29 +6271,124 @@ func (m *GetLeaderResponse) Size() (n int) {
 	if l > 0 {
 		n += 1 + l + sovDmmaster(uint64(l))
 	}
-	l = len(m.Msg)
+	l = len(m.Stage)
+	if l > 0 {
+		n += 1 + l + sovDmmaster(uint64(l))
+	}
+	l = len(m.Source)
 	if l > 0 {
 		n += 1 + l + sovDmmaster(uint64(l))
 	}
 	return n
 }
 
-func sovDmmaster(x uint64) (n int) {
-	return (math_bits.Len64(x|1) + 6) / 7
-}
-func sozDmmaster(x uint64) (n int) {
-	return sovDmmaster(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+func (m *ListMemberRequest) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	return n
 }
-func (m *MigrateWorkerRelayRequest) Unmarshal(dAtA []byte) error {
-	l := len(dAtA)
-	iNdEx := 0
-	for iNdEx < l {
-		preIndex := iNdEx
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return ErrIntOverflowDmmaster
-			}
+
+func (m *ListMemberMasterResponse) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.Result {
+		n += 2
+	}
+	l = len(m.Msg)
+	if l > 0 {
+		n += 1 + l + sovDmmaster(uint64(l))
+	}
+	if len(m.Members) > 0 {
+		for _, e := range m.Members {
+			l = e.Size()
+			n += 1 + l + sovDmmaster(uint64(l))
+		}
+	}
+	return n
+}
+
+func (m *ListMemberLeaderResponse) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.Result {
+		n += 2
+	}
+	l = len(m.Msg)
+	if l > 0 {
+		n += 1 + l + sovDmmaster(uint64(l))
+	}
+	l = len(m.Name)
+	if l > 0 {
+		n += 1 + l + sovDmmaster(uint64(l))
+	}
+	if m.MemberID != 0 {
+		n += 1 + sovDmmaster(uint64(m.MemberID))
+	}
+	if m.Alive {
+		n += 2
+	}
+	if len(m.PeerURLs) > 0 {
+		for _, s := range m.PeerURLs {
+			l = len(s)
+			n += 1 + l + sovDmmaster(uint64(l))
+		}
+	}
+	if len(m.ClientURLs) > 0 {
+		for _, s := range m.ClientURLs {
+			l = len(s)
+			n += 1 + l + sovDmmaster(uint64(l))
+		}
+	}
+	return n
+}
+
+func (m *ListMemberWorkerResponse) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.Result {
+		n += 2
+	}
+	l = len(m.Msg)
+	if l > 0 {
+		n += 1 + l + sovDmmaster(uint64(l))
+	}
+	if len(m.Members) > 0 {
+		for _, e := range m.Members {
+			l = e.Size()
+			n += 1 + l + sovDmmaster(uint64(l))
+		}
+	}
+	return n
+}
+
+func sovDmmaster(x uint64) (n int) {
+	return (math_bits.Len64(x|1) + 6) / 7
+}
+func sozDmmaster(x uint64) (n int) {
+	return sovDmmaster(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+func (m *MigrateWorkerRelayRequest) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowDmmaster
+			}
 			if iNdEx >= l {
 				return io.ErrUnexpectedEOF
 			}
@@ -10257,7 +11030,7 @@ func (m *OfflineWorkerResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *GetLeaderRequest) Unmarshal(dAtA []byte) error {
+func (m *MemberMasterResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -10280,12 +11053,147 @@ func (m *GetLeaderRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: GetLeaderRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: MemberMasterResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: GetLeaderRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: MemberMasterResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowDmmaster
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthDmmaster
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthDmmaster
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Name = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field MemberID", wireType)
+			}
+			m.MemberID = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowDmmaster
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.MemberID |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Alive", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowDmmaster
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.Alive = bool(v != 0)
+		case 4:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field PeerURLs", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowDmmaster
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthDmmaster
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthDmmaster
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.PeerURLs = append(m.PeerURLs, string(dAtA[iNdEx:postIndex]))
+			iNdEx = postIndex
+		case 5:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ClientURLs", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowDmmaster
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthDmmaster
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthDmmaster
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.ClientURLs = append(m.ClientURLs, string(dAtA[iNdEx:postIndex]))
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipDmmaster(dAtA[iNdEx:])
@@ -10310,7 +11218,7 @@ func (m *GetLeaderRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *GetLeaderResponse) Unmarshal(dAtA []byte) error {
+func (m *MemberWorkerResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -10333,17 +11241,17 @@ func (m *GetLeaderResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: GetLeaderResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: MemberWorkerResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: GetLeaderResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: MemberWorkerResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType)
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
 			}
-			var v int
+			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowDmmaster
@@ -10353,15 +11261,27 @@ func (m *GetLeaderResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				v |= int(b&0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			m.Result = bool(v != 0)
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthDmmaster
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthDmmaster
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Name = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
 		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Addr", wireType)
 			}
 			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
@@ -10389,11 +11309,11 @@ func (m *GetLeaderResponse) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Name = string(dAtA[iNdEx:postIndex])
+			m.Addr = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
 		case 3:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Addr", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Stage", wireType)
 			}
 			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
@@ -10421,11 +11341,11 @@ func (m *GetLeaderResponse) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Addr = string(dAtA[iNdEx:postIndex])
+			m.Stage = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
 		case 4:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Msg", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Source", wireType)
 			}
 			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
@@ -10453,7 +11373,578 @@ func (m *GetLeaderResponse) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Msg = string(dAtA[iNdEx:postIndex])
+			m.Source = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipDmmaster(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthDmmaster
+			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthDmmaster
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *ListMemberRequest) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowDmmaster
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: ListMemberRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: ListMemberRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		default:
+			iNdEx = preIndex
+			skippy, err := skipDmmaster(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthDmmaster
+			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthDmmaster
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *ListMemberMasterResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowDmmaster
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: ListMemberMasterResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: ListMemberMasterResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowDmmaster
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.Result = bool(v != 0)
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Msg", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowDmmaster
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthDmmaster
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthDmmaster
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Msg = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Members", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowDmmaster
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthDmmaster
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthDmmaster
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Members = append(m.Members, &MemberMasterResponse{})
+			if err := m.Members[len(m.Members)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipDmmaster(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthDmmaster
+			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthDmmaster
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *ListMemberLeaderResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowDmmaster
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: ListMemberLeaderResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: ListMemberLeaderResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowDmmaster
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.Result = bool(v != 0)
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Msg", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowDmmaster
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthDmmaster
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthDmmaster
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Msg = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowDmmaster
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthDmmaster
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthDmmaster
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Name = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 4:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field MemberID", wireType)
+			}
+			m.MemberID = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowDmmaster
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.MemberID |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 5:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Alive", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowDmmaster
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.Alive = bool(v != 0)
+		case 6:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field PeerURLs", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowDmmaster
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthDmmaster
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthDmmaster
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.PeerURLs = append(m.PeerURLs, string(dAtA[iNdEx:postIndex]))
+			iNdEx = postIndex
+		case 7:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ClientURLs", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowDmmaster
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthDmmaster
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthDmmaster
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.ClientURLs = append(m.ClientURLs, string(dAtA[iNdEx:postIndex]))
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipDmmaster(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthDmmaster
+			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthDmmaster
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *ListMemberWorkerResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowDmmaster
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: ListMemberWorkerResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: ListMemberWorkerResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowDmmaster
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.Result = bool(v != 0)
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Msg", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowDmmaster
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthDmmaster
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthDmmaster
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Msg = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Members", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowDmmaster
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthDmmaster
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthDmmaster
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Members = append(m.Members, &MemberWorkerResponse{})
+			if err := m.Members[len(m.Members)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
diff --git a/dm/pbmock/dmmaster.go b/dm/pbmock/dmmaster.go
index 1a0bb7823e..b674235ea5 100644
--- a/dm/pbmock/dmmaster.go
+++ b/dm/pbmock/dmmaster.go
@@ -75,6 +75,66 @@ func (mr *MockMasterClientMockRecorder) HandleSQLs(arg0, arg1 interface{}, arg2
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleSQLs", reflect.TypeOf((*MockMasterClient)(nil).HandleSQLs), varargs...)
 }
 
+// ListMemberLeader mocks base method
+func (m *MockMasterClient) ListMemberLeader(arg0 context.Context, arg1 *pb.ListMemberRequest, arg2 ...grpc.CallOption) (*pb.ListMemberLeaderResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ListMemberLeader", varargs...)
+	ret0, _ := ret[0].(*pb.ListMemberLeaderResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListMemberLeader indicates an expected call of ListMemberLeader
+func (mr *MockMasterClientMockRecorder) ListMemberLeader(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMemberLeader", reflect.TypeOf((*MockMasterClient)(nil).ListMemberLeader), varargs...)
+}
+
+// ListMemberMaster mocks base method
+func (m *MockMasterClient) ListMemberMaster(arg0 context.Context, arg1 *pb.ListMemberRequest, arg2 ...grpc.CallOption) (*pb.ListMemberMasterResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ListMemberMaster", varargs...)
+	ret0, _ := ret[0].(*pb.ListMemberMasterResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListMemberMaster indicates an expected call of ListMemberMaster
+func (mr *MockMasterClientMockRecorder) ListMemberMaster(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMemberMaster", reflect.TypeOf((*MockMasterClient)(nil).ListMemberMaster), varargs...)
+}
+
+// ListMemberWorker mocks base method
+func (m *MockMasterClient) ListMemberWorker(arg0 context.Context, arg1 *pb.ListMemberRequest, arg2 ...grpc.CallOption) (*pb.ListMemberWorkerResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ListMemberWorker", varargs...)
+	ret0, _ := ret[0].(*pb.ListMemberWorkerResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListMemberWorker indicates an expected call of ListMemberWorker
+func (mr *MockMasterClientMockRecorder) ListMemberWorker(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMemberWorker", reflect.TypeOf((*MockMasterClient)(nil).ListMemberWorker), varargs...)
+}
+
 // MigrateWorkerRelay mocks base method
 func (m *MockMasterClient) MigrateWorkerRelay(arg0 context.Context, arg1 *pb.MigrateWorkerRelayRequest, arg2 ...grpc.CallOption) (*pb.CommonWorkerResponse, error) {
 	m.ctrl.T.Helper()
@@ -448,6 +508,51 @@ func (mr *MockMasterServerMockRecorder) HandleSQLs(arg0, arg1 interface{}) *gomo
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleSQLs", reflect.TypeOf((*MockMasterServer)(nil).HandleSQLs), arg0, arg1)
 }
 
+// ListMemberLeader mocks base method
+func (m *MockMasterServer) ListMemberLeader(arg0 context.Context, arg1 *pb.ListMemberRequest) (*pb.ListMemberLeaderResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListMemberLeader", arg0, arg1)
+	ret0, _ := ret[0].(*pb.ListMemberLeaderResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListMemberLeader indicates an expected call of ListMemberLeader
+func (mr *MockMasterServerMockRecorder) ListMemberLeader(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMemberLeader", reflect.TypeOf((*MockMasterServer)(nil).ListMemberLeader), arg0, arg1)
+}
+
+// ListMemberMaster mocks base method
+func (m *MockMasterServer) ListMemberMaster(arg0 context.Context, arg1 *pb.ListMemberRequest) (*pb.ListMemberMasterResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListMemberMaster", arg0, arg1)
+	ret0, _ := ret[0].(*pb.ListMemberMasterResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListMemberMaster indicates an expected call of ListMemberMaster
+func (mr *MockMasterServerMockRecorder) ListMemberMaster(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMemberMaster", reflect.TypeOf((*MockMasterServer)(nil).ListMemberMaster), arg0, arg1)
+}
+
+// ListMemberWorker mocks base method
+func (m *MockMasterServer) ListMemberWorker(arg0 context.Context, arg1 *pb.ListMemberRequest) (*pb.ListMemberWorkerResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListMemberWorker", arg0, arg1)
+	ret0, _ := ret[0].(*pb.ListMemberWorkerResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListMemberWorker indicates an expected call of ListMemberWorker
+func (mr *MockMasterServerMockRecorder) ListMemberWorker(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMemberWorker", reflect.TypeOf((*MockMasterServer)(nil).ListMemberWorker), arg0, arg1)
+}
+
 // MigrateWorkerRelay mocks base method
 func (m *MockMasterServer) MigrateWorkerRelay(arg0 context.Context, arg1 *pb.MigrateWorkerRelayRequest) (*pb.CommonWorkerResponse, error) {
 	m.ctrl.T.Helper()
diff --git a/dm/proto/dmmaster.proto b/dm/proto/dmmaster.proto
index 8d1faf9a38..a84e91615a 100644
--- a/dm/proto/dmmaster.proto
+++ b/dm/proto/dmmaster.proto
@@ -63,8 +63,21 @@ service Master {
     // OfflineWorker offline the dm-workers.
     rpc OfflineWorker(OfflineWorkerRequest) returns(OfflineWorkerResponse) {}
 
-    // GetLeader get master leader.
-    rpc GetLeader(GetLeaderRequest) returns(GetLeaderResponse) {}
+    // ListMember list member master information
+    rpc ListMemberMaster(ListMemberRequest) returns(ListMemberMasterResponse) {}
+
+    // ListMember list member worker information
+    rpc ListMemberWorker(ListMemberRequest) returns(ListMemberWorkerResponse) {}
+
+    // ListMember list member leader information
+    rpc ListMemberLeader(ListMemberRequest) returns(ListMemberLeaderResponse) {}
+}
+
+enum MemberType {
+    InvalidType = 0;  // placeholder
+    MasterType = 1;
+    WorkerType = 2;
+    LeaderType = 3;
 }
 
 message MigrateWorkerRelayRequest {
@@ -310,12 +323,42 @@ message OfflineWorkerResponse {
     string msg = 2;
 }
 
-message GetLeaderRequest {
+message MemberMasterResponse {
+    string name = 1;
+    uint64 memberID = 2;
+    bool alive = 3;
+    repeated string peerURLs = 4;
+    repeated string clientURLs = 5;
+}
+
+message MemberWorkerResponse {
+    string name = 1;
+    string addr = 2;
+    string stage = 3;
+    string source = 4;
+}
+
+message ListMemberRequest {
 }
 
-message GetLeaderResponse {
+message ListMemberMasterResponse {
     bool result = 1;
-    string name = 2;
-    string addr = 3;    
-    string msg = 4;
+    string msg = 2;
+    repeated MemberMasterResponse members = 3;
+}
+
+message ListMemberLeaderResponse {
+    bool result = 1;
+    string msg = 2;
+    string name = 3;
+    uint64 memberID = 4;
+    bool alive = 5;
+    repeated string peerURLs = 6;
+    repeated string clientURLs = 7;
+}
+
+message ListMemberWorkerResponse {
+    bool result = 1;
+    string msg = 2;
+    repeated MemberWorkerResponse members = 3;
 }
\ No newline at end of file
diff --git a/tests/_utils/get_leader b/tests/_utils/get_leader
index 101fd4d87d..f0289355f5 100755
--- a/tests/_utils/get_leader
+++ b/tests/_utils/get_leader
@@ -12,4 +12,4 @@ ts=$(date +"%s")
 dmctl_log=$workdir/dmctl.$ts.log
 pid=$$
 
-echo $($binary -test.coverprofile="$TEST_DIR/cov.$TEST_NAME.dmctl.$ts.$pid.out" DEVEL -master-addr=$master_addr get-leader | grep name | gawk 'match($2,/"(.*)",/,a) {print a[1]}')
\ No newline at end of file
+echo $($binary -test.coverprofile="$TEST_DIR/cov.$TEST_NAME.dmctl.$ts.$pid.out" DEVEL -master-addr=$master_addr list-member leader | grep name | gawk 'match($2,/"(.*)",/,a) {print a[1]}')
\ No newline at end of file
diff --git a/tests/ha_master/run.sh b/tests/ha_master/run.sh
index d619c432f7..1d18551ad1 100755
--- a/tests/ha_master/run.sh
+++ b/tests/ha_master/run.sh
@@ -12,8 +12,8 @@ MASTER_PORT3=8461
 MASTER_PORT4=8561
 MASTER_PORT5=8661
 
-function test_get_leader() {
-    echo "[$(date)] <<<<<< start test_get_leader_command >>>>>>"
+function test_list_member() {
+    echo "[$(date)] <<<<<< start test_list_member_command >>>>>>"
 
     master_ports=(0 $MASTER_PORT1 $MASTER_PORT2 $MASTER_PORT3 $MASTER_PORT4 $MASTER_PORT5)
 
@@ -36,10 +36,16 @@ function test_get_leader() {
         fi
     done
 
+    # check list-member master
+    run_dm_ctl $WORK_DIR "127.0.0.1:$MASTER_PORT" \
+        "list-member master" \
+        "\"alive\": true" 5
+
     # kill leader
     echo "kill leader" $leader
     ps aux | grep $leader |awk '{print $2}'|xargs kill || true
     check_port_offline ${master_ports[$leader_idx]} 20
+    sleep 5
 
     # test again
     alive=( "${alive[@]/$leader_idx}" )
@@ -56,9 +62,13 @@ function test_get_leader() {
             exit 1
         fi
     done
+    run_dm_ctl $WORK_DIR "127.0.0.1:$MASTER_PORT" \
+        "list-member master" \
+        "\"alive\": true" 4
     echo "kill leader" $leader
     ps aux | grep $leader |awk '{print $2}'|xargs kill || true
     check_port_offline ${master_ports[$leader_idx]} 20
+    sleep 5
 
     # test again
     alive=( "${alive[@]/$leader_idx}" )
@@ -75,9 +85,13 @@ function test_get_leader() {
             exit 1
         fi
     done
+    run_dm_ctl $WORK_DIR "127.0.0.1:$MASTER_PORT" \
+        "list-member master" \
+        "\"alive\": true" 3
     echo "kill leader" $leader
     ps aux | grep $leader |awk '{print $2}'|xargs kill || true
     check_port_offline ${master_ports[$leader_idx]} 20
+    sleep 5
     
     # join master which has been killed
     alive=( "${alive[@]/$leader_idx}" )
@@ -103,8 +117,70 @@ function test_get_leader() {
             exit 1
         fi
     done
+    run_dm_ctl $WORK_DIR "127.0.0.1:$MASTER_PORT" \
+        "list-member master" \
+        "\"alive\": true" 5
+    
+    # check list-member worker
+    run_dm_ctl $WORK_DIR "127.0.0.1:$MASTER_PORT" \
+        "list-member worker" \
+        "\"stage\": \"bound\"" 2
+    
+    dmctl_operate_source stop $WORK_DIR/source1.toml $SOURCE_ID1
+    sleep 5
+
+    run_dm_ctl $WORK_DIR "127.0.0.1:$MASTER_PORT" \
+        "list-member worker" \
+        "\"stage\": \"bound\"" 1 \
+        "\"stage\": \"free\"" 1
+ 
+    dmctl_operate_source stop $WORK_DIR/source2.toml $SOURCE_ID2
+    sleep 5
+
+    run_dm_ctl $WORK_DIR "127.0.0.1:$MASTER_PORT" \
+        "list-member worker" \
+        "\"stage\": \"free\"" 2
+ 
+    dmctl_operate_source create $WORK_DIR/source1.toml $SOURCE_ID1
+    dmctl_operate_source create $WORK_DIR/source2.toml $SOURCE_ID2
+    sleep 5
+
+    run_dm_ctl $WORK_DIR "127.0.0.1:$MASTER_PORT" \
+        "list-member worker" \
+        "\"stage\": \"bound\"" 2
+
+    # kill worker
+    echo "kill worker1"
+    ps aux | grep dm-worker1 |awk '{print $2}'|xargs kill || true
+    check_port_offline $WORKER1_PORT 20
+    sleep 5
+
+    run_dm_ctl $WORK_DIR "127.0.0.1:$MASTER_PORT" \
+        "list-member worker" \
+        "\"stage\": \"bound\"" 1 \
+        "\"stage\": \"offline\"" 1
 
-    echo "[$(date)] <<<<<< finish test_get_leader_command >>>>>>"
+    # kill worker
+    echo "kill worker2"
+    ps aux | grep dm-worker2 |awk '{print $2}'|xargs kill || true
+    check_port_offline $WORKER2_PORT 20
+    sleep 5
+
+    run_dm_ctl $WORK_DIR "127.0.0.1:$MASTER_PORT" \
+        "list-member worker" \
+        "\"stage\": \"offline\"" 2
+
+    run_dm_worker $WORK_DIR/worker1 $WORKER1_PORT $cur/conf/dm-worker1.toml
+    check_rpc_alive $cur/../bin/check_worker_online 127.0.0.1:$WORKER1_PORT
+    run_dm_worker $WORK_DIR/worker2 $WORKER2_PORT $cur/conf/dm-worker2.toml
+    check_rpc_alive $cur/../bin/check_worker_online 127.0.0.1:$WORKER2_PORT
+    sleep 5
+
+    run_dm_ctl $WORK_DIR "127.0.0.1:$MASTER_PORT" \
+        "list-member worker" \
+        "\"stage\": \"bound\"" 2
+
+    echo "[$(date)] <<<<<< finish test_list_member_command >>>>>>"
 }
 
 function run() {
@@ -126,8 +202,6 @@ function run() {
     check_rpc_alive $cur/../bin/check_master_online 127.0.0.1:$MASTER_PORT4
     check_rpc_alive $cur/../bin/check_master_online 127.0.0.1:$MASTER_PORT5
 
-    test_get_leader
-
     # kill dm-master1 and dm-master2 to simulate the first two dm-master addr in join config are invalid
     echo "kill dm-master1 and kill dm-master2"
     ps aux | grep dm-master1 |awk '{print $2}'|xargs kill || true
@@ -155,6 +229,7 @@ function run() {
     dmctl_operate_source create $WORK_DIR/source1.toml $SOURCE_ID1
     dmctl_operate_source create $WORK_DIR/source2.toml $SOURCE_ID2
 
+    test_list_member
 
     echo "start DM task"
     dmctl_start_task
@@ -180,7 +255,7 @@ function run() {
 
     run_sql_file $cur/data/db1.increment.sql $MYSQL_HOST1 $MYSQL_PORT1 $MYSQL_PASSWORD1
     run_sql_file $cur/data/db2.increment.sql $MYSQL_HOST2 $MYSQL_PORT2 $MYSQL_PASSWORD2
-    sleep 2
+    sleep 10
 
     echo "use sync_diff_inspector to check data now!"
     check_sync_diff $WORK_DIR $cur/conf/diff_config.toml

From 3a1fd0396a3817716bdd54c4907f913c4e85ccfe Mon Sep 17 00:00:00 2001
From: gmhdbjd <gmhdbjd@gmail.com>
Date: Tue, 12 May 2020 18:34:04 +0800
Subject: [PATCH 07/17] fix useless change

---
 tests/ha_master/run.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/ha_master/run.sh b/tests/ha_master/run.sh
index 1d18551ad1..a4c0042047 100755
--- a/tests/ha_master/run.sh
+++ b/tests/ha_master/run.sh
@@ -255,7 +255,7 @@ function run() {
 
     run_sql_file $cur/data/db1.increment.sql $MYSQL_HOST1 $MYSQL_PORT1 $MYSQL_PASSWORD1
     run_sql_file $cur/data/db2.increment.sql $MYSQL_HOST2 $MYSQL_PORT2 $MYSQL_PASSWORD2
-    sleep 10
+    sleep 2
 
     echo "use sync_diff_inspector to check data now!"
     check_sync_diff $WORK_DIR $cur/conf/diff_config.toml

From 5fe7d6b0c5758c60e5b8b3229dc6e6c373a90b0f Mon Sep 17 00:00:00 2001
From: gmhdbjd <gmhdbjd@gmail.com>
Date: Wed, 13 May 2020 17:28:24 +0800
Subject: [PATCH 08/17] change inferface

---
 dm/ctl/master/list_member.go |   69 +-
 dm/master/server.go          |  145 +--
 dm/pb/dmmaster.pb.go         | 1630 ++++++++++++++++++++++------------
 dm/pbmock/dmmaster.go        |   98 +-
 dm/proto/dmmaster.proto      |   63 +-
 tests/_utils/get_leader      |    2 +-
 tests/ha_master/run.sh       |   22 +-
 7 files changed, 1227 insertions(+), 802 deletions(-)

diff --git a/dm/ctl/master/list_member.go b/dm/ctl/master/list_member.go
index 627eeba1c2..4dcb8d98e6 100644
--- a/dm/ctl/master/list_member.go
+++ b/dm/ctl/master/list_member.go
@@ -17,49 +17,61 @@ import (
 	"context"
 	"os"
 
-	"github.com/gogo/protobuf/proto"
-	"github.com/pingcap/dm/dm/ctl/common"
-	"github.com/pingcap/dm/dm/pb"
-
 	"github.com/pingcap/errors"
 	"github.com/spf13/cobra"
+
+	"github.com/pingcap/dm/dm/ctl/common"
+	"github.com/pingcap/dm/dm/pb"
 )
 
 // NewListMemberCmd creates an ListMember command
 func NewListMemberCmd() *cobra.Command {
 	cmd := &cobra.Command{
-		Use:   "list-member master/worker/leader",
-		Short: "list member information of master/worker/leader",
+		Use:   "list-member [--master] [--worker] [--leader]",
+		Short: "list member information",
 		Run:   listMemberFunc,
 	}
+	cmd.Flags().BoolP("master", "", false, "only to list master")
+	cmd.Flags().BoolP("worker", "", false, "only to list worker")
+	cmd.Flags().BoolP("leader", "", false, "only to list leader")
 	return cmd
 }
 
-func convertMemberType(t string) pb.MemberType {
-	switch t {
-	case "master":
-		return pb.MemberType_MasterType
-	case "worker":
-		return pb.MemberType_WorkerType
-	case "leader":
-		return pb.MemberType_LeaderType
-	default:
-		return pb.MemberType_InvalidType
+func extractListMemberFlag(cmd *cobra.Command) (bool, bool, bool, error) {
+	master, err := cmd.Flags().GetBool("master")
+	if err != nil {
+		return false, false, false, errors.Trace(err)
 	}
+
+	worker, err := cmd.Flags().GetBool("worker")
+	if err != nil {
+		return false, false, false, errors.Trace(err)
+	}
+
+	leader, err := cmd.Flags().GetBool("leader")
+	if err != nil {
+		return false, false, false, errors.Trace(err)
+	}
+
+	if !master && !worker && !leader {
+		master = true
+		worker = true
+		leader = true
+	}
+	return master, worker, leader, nil
 }
 
 // listMemberFunc does list member request
 func listMemberFunc(cmd *cobra.Command, _ []string) {
-	if len(cmd.Flags().Args()) != 1 {
+	if len(cmd.Flags().Args()) != 0 {
 		cmd.SetOut(os.Stdout)
 		cmd.Usage()
 		return
 	}
 
-	memberType := cmd.Flags().Arg(0)
-	member := convertMemberType(memberType)
-	if member == pb.MemberType_InvalidType {
-		common.PrintLines("invalid arg '%s'", memberType)
+	master, worker, leader, err := extractListMemberFlag(cmd)
+	if err != nil {
+		common.PrintLines("%s", err.Error())
 		return
 	}
 
@@ -67,16 +79,11 @@ func listMemberFunc(cmd *cobra.Command, _ []string) {
 	defer cancel()
 
 	cli := common.MasterClient()
-	var resp proto.Message
-	var err error
-	switch member {
-	case pb.MemberType_MasterType:
-		resp, err = cli.ListMemberMaster(ctx, &pb.ListMemberRequest{})
-	case pb.MemberType_WorkerType:
-		resp, err = cli.ListMemberWorker(ctx, &pb.ListMemberRequest{})
-	case pb.MemberType_LeaderType:
-		resp, err = cli.ListMemberLeader(ctx, &pb.ListMemberRequest{})
-	}
+	resp, err := cli.ListMember(ctx, &pb.ListMemberRequest{
+		Master: master,
+		Worker: worker,
+		Leader: leader,
+	})
 
 	if err != nil {
 		common.PrintLines("list member failed, error:\n%v", errors.ErrorStack(err))
diff --git a/dm/master/server.go b/dm/master/server.go
index d787af4ca1..c9343ec722 100644
--- a/dm/master/server.go
+++ b/dm/master/server.go
@@ -1560,27 +1560,19 @@ func (s *Server) getSourceRespsAfterOperation(ctx context.Context, taskName stri
 	return sortCommonWorkerResults(sourceRespCh)
 }
 
-// ListMemberMaster list member master information
-func (s *Server) ListMemberMaster(ctx context.Context, req *pb.ListMemberRequest) (*pb.ListMemberMasterResponse, error) {
-	log.L().Info("", zap.Stringer("payload", req), zap.String("request", "ListMemberMaster"))
-	resp := &pb.ListMemberMasterResponse{}
+func (s *Server) listMemberMaster(ctx context.Context) (*pb.Members_Master, error) {
 
-	isLeader, needForward := s.isLeaderAndNeedForward()
-	if !isLeader {
-		if needForward {
-			return s.leaderClient.ListMemberMaster(ctx, req)
-		}
-		return nil, terror.ErrMasterRequestIsNotForwardToLeader
+	resp := &pb.Members_Master{
+		Master: &pb.ListMasterMember{},
 	}
 
 	memberList, err := s.etcdClient.MemberList(ctx)
 	if err != nil {
-		resp.Msg = errors.ErrorStack(err)
+		resp.Master.Msg = errors.ErrorStack(err)
 		return resp, nil
 	}
-
 	etcdMembers := memberList.Members
-	members := make([]*pb.MemberMasterResponse, 0, len(etcdMembers))
+	masters := make([]*pb.MasterInfo, 0, len(etcdMembers))
 	client := http.Client{
 		Timeout: 1 * time.Second,
 	}
@@ -1592,7 +1584,7 @@ func (s *Server) ListMemberMaster(ctx context.Context, req *pb.ListMemberRequest
 			alive = false
 		}
 
-		members = append(members, &pb.MemberMasterResponse{
+		masters = append(masters, &pb.MasterInfo{
 			Name:       etcdMember.Name,
 			MemberID:   etcdMember.ID,
 			Alive:      alive,
@@ -1601,88 +1593,107 @@ func (s *Server) ListMemberMaster(ctx context.Context, req *pb.ListMemberRequest
 		})
 	}
 
-	resp.Result = true
-	resp.Members = members
+	resp.Master.Masters = masters
 	return resp, nil
 }
 
-// ListMemberWorker list member worker information
-func (s *Server) ListMemberWorker(ctx context.Context, req *pb.ListMemberRequest) (*pb.ListMemberWorkerResponse, error) {
-	log.L().Info("", zap.Stringer("payload", req), zap.String("request", "ListMemberWorker"))
-	resp := &pb.ListMemberWorkerResponse{}
-
-	isLeader, needForward := s.isLeaderAndNeedForward()
-	if !isLeader {
-		if needForward {
-			return s.leaderClient.ListMemberWorker(ctx, req)
-		}
-		return nil, terror.ErrMasterRequestIsNotForwardToLeader
+func (s *Server) listMemberWorker(ctx context.Context) (*pb.Members_Worker, error) {
+	resp := &pb.Members_Worker{
+		Worker: &pb.ListWorkerMember{},
 	}
 
-	workers := s.scheduler.GetWorker()
-	members := make([]*pb.MemberWorkerResponse, 0, len(workers))
+	workerAgents := s.scheduler.GetWorker()
+	workers := make([]*pb.WorkerInfo, 0, len(workerAgents))
 
-	for _, worker := range workers {
-		members = append(members, &pb.MemberWorkerResponse{
-			Name:   worker.BaseInfo().Name,
-			Addr:   worker.BaseInfo().Addr,
-			Stage:  string(worker.Stage()),
-			Source: worker.Bound().Source,
+	for _, workerAgent := range workerAgents {
+		workers = append(workers, &pb.WorkerInfo{
+			Name:   workerAgent.BaseInfo().Name,
+			Addr:   workerAgent.BaseInfo().Addr,
+			Stage:  string(workerAgent.Stage()),
+			Source: workerAgent.Bound().Source,
 		})
 	}
 
-	resp.Result = true
-	resp.Members = members
+	resp.Worker.Workers = workers
 	return resp, nil
 }
 
-// ListMemberLeader list member leader information
-func (s *Server) ListMemberLeader(ctx context.Context, req *pb.ListMemberRequest) (*pb.ListMemberLeaderResponse, error) {
-	log.L().Info("", zap.Stringer("payload", req), zap.String("request", "ListMemberLeader"))
-	resp := &pb.ListMemberLeaderResponse{}
-
-	isLeader, needForward := s.isLeaderAndNeedForward()
-	if !isLeader {
-		if needForward {
-			return s.leaderClient.ListMemberLeader(ctx, req)
-		}
-		return nil, terror.ErrMasterRequestIsNotForwardToLeader
+func (s *Server) listMemberLeader(ctx context.Context) (*pb.Members_Leader, error) {
+	resp := &pb.Members_Leader{
+		Leader: &pb.ListLeaderMember{},
 	}
 
-	memberList, err := s.etcdClient.MemberList(ctx)
+	_, name, addr, err := s.election.LeaderInfo(ctx)
 	if err != nil {
-		resp.Msg = errors.ErrorStack(err)
+		resp.Leader.Msg = errors.ErrorStack(err)
 		return resp, nil
 	}
 
-	_, leaderName, _, err := s.election.LeaderInfo(ctx)
+	client := http.Client{
+		Timeout: 1 * time.Second,
+	}
+
+	alive := true
+	_, err = client.Get("http://" + addr + "/health")
 	if err != nil {
-		resp.Msg = errors.ErrorStack(err)
-		return resp, nil
+		alive = false
 	}
 
-	etcdMembers := memberList.Members
-	client := http.Client{
-		Timeout: 1 * time.Second,
+	resp.Leader.Name = name
+	resp.Leader.Addr = addr
+	resp.Leader.Alive = alive
+	return resp, nil
+}
+
+// ListMember list member information
+func (s *Server) ListMember(ctx context.Context, req *pb.ListMemberRequest) (*pb.ListMemberResponse, error) {
+	log.L().Info("", zap.Stringer("payload", req), zap.String("request", "ListMember"))
+
+	isLeader, needForward := s.isLeaderAndNeedForward()
+	if !isLeader {
+		if needForward {
+			return s.leaderClient.ListMember(ctx, req)
+		}
+		return nil, terror.ErrMasterRequestIsNotForwardToLeader
 	}
 
-	for _, etcdMember := range etcdMembers {
-		if leaderName != etcdMember.Name {
-			continue
+	resp := &pb.ListMemberResponse{}
+	members := make([]*pb.Members, 0)
+
+	if req.Master {
+		res, err := s.listMemberMaster(ctx)
+		if err != nil {
+			resp.Msg = errors.ErrorStack(err)
+			return resp, nil
 		}
-		alive := true
-		_, err := client.Get(etcdMember.ClientURLs[0] + "/health")
+		members = append(members, &pb.Members{
+			Member: res,
+		})
+	}
+
+	if req.Worker {
+		res, err := s.listMemberWorker(ctx)
 		if err != nil {
-			alive = false
+			resp.Msg = errors.ErrorStack(err)
+			return resp, nil
 		}
+		members = append(members, &pb.Members{
+			Member: res,
+		})
+	}
 
-		resp.Name = etcdMember.Name
-		resp.MemberID = etcdMember.ID
-		resp.Alive = alive
-		resp.ClientURLs = etcdMember.ClientURLs
-		resp.PeerURLs = etcdMember.PeerURLs
+	if req.Leader {
+		res, err := s.listMemberLeader(ctx)
+		if err != nil {
+			resp.Msg = errors.ErrorStack(err)
+			return resp, nil
+		}
+		members = append(members, &pb.Members{
+			Member: res,
+		})
 	}
 
 	resp.Result = true
+	resp.Members = members
 	return resp, nil
 }
diff --git a/dm/pb/dmmaster.pb.go b/dm/pb/dmmaster.pb.go
index 1e2186789b..17d7bdb32d 100644
--- a/dm/pb/dmmaster.pb.go
+++ b/dm/pb/dmmaster.pb.go
@@ -28,37 +28,6 @@ var _ = math.Inf
 // proto package needs to be updated.
 const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
 
-type MemberType int32
-
-const (
-	MemberType_InvalidType MemberType = 0
-	MemberType_MasterType  MemberType = 1
-	MemberType_WorkerType  MemberType = 2
-	MemberType_LeaderType  MemberType = 3
-)
-
-var MemberType_name = map[int32]string{
-	0: "InvalidType",
-	1: "MasterType",
-	2: "WorkerType",
-	3: "LeaderType",
-}
-
-var MemberType_value = map[string]int32{
-	"InvalidType": 0,
-	"MasterType":  1,
-	"WorkerType":  2,
-	"LeaderType":  3,
-}
-
-func (x MemberType) String() string {
-	return proto.EnumName(MemberType_name, int32(x))
-}
-
-func (MemberType) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_f9bef11f2a341f03, []int{0}
-}
-
 type SourceOp int32
 
 const (
@@ -87,7 +56,7 @@ func (x SourceOp) String() string {
 }
 
 func (SourceOp) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_f9bef11f2a341f03, []int{1}
+	return fileDescriptor_f9bef11f2a341f03, []int{0}
 }
 
 type MigrateWorkerRelayRequest struct {
@@ -2158,7 +2127,7 @@ func (m *OfflineWorkerResponse) GetMsg() string {
 	return ""
 }
 
-type MemberMasterResponse struct {
+type MasterInfo struct {
 	Name       string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
 	MemberID   uint64   `protobuf:"varint,2,opt,name=memberID,proto3" json:"memberID,omitempty"`
 	Alive      bool     `protobuf:"varint,3,opt,name=alive,proto3" json:"alive,omitempty"`
@@ -2166,18 +2135,18 @@ type MemberMasterResponse struct {
 	ClientURLs []string `protobuf:"bytes,5,rep,name=clientURLs,proto3" json:"clientURLs,omitempty"`
 }
 
-func (m *MemberMasterResponse) Reset()         { *m = MemberMasterResponse{} }
-func (m *MemberMasterResponse) String() string { return proto.CompactTextString(m) }
-func (*MemberMasterResponse) ProtoMessage()    {}
-func (*MemberMasterResponse) Descriptor() ([]byte, []int) {
+func (m *MasterInfo) Reset()         { *m = MasterInfo{} }
+func (m *MasterInfo) String() string { return proto.CompactTextString(m) }
+func (*MasterInfo) ProtoMessage()    {}
+func (*MasterInfo) Descriptor() ([]byte, []int) {
 	return fileDescriptor_f9bef11f2a341f03, []int{35}
 }
-func (m *MemberMasterResponse) XXX_Unmarshal(b []byte) error {
+func (m *MasterInfo) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
 }
-func (m *MemberMasterResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+func (m *MasterInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	if deterministic {
-		return xxx_messageInfo_MemberMasterResponse.Marshal(b, m, deterministic)
+		return xxx_messageInfo_MasterInfo.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
 		n, err := m.MarshalToSizedBuffer(b)
@@ -2187,72 +2156,72 @@ func (m *MemberMasterResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte
 		return b[:n], nil
 	}
 }
-func (m *MemberMasterResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_MemberMasterResponse.Merge(m, src)
+func (m *MasterInfo) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_MasterInfo.Merge(m, src)
 }
-func (m *MemberMasterResponse) XXX_Size() int {
+func (m *MasterInfo) XXX_Size() int {
 	return m.Size()
 }
-func (m *MemberMasterResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_MemberMasterResponse.DiscardUnknown(m)
+func (m *MasterInfo) XXX_DiscardUnknown() {
+	xxx_messageInfo_MasterInfo.DiscardUnknown(m)
 }
 
-var xxx_messageInfo_MemberMasterResponse proto.InternalMessageInfo
+var xxx_messageInfo_MasterInfo proto.InternalMessageInfo
 
-func (m *MemberMasterResponse) GetName() string {
+func (m *MasterInfo) GetName() string {
 	if m != nil {
 		return m.Name
 	}
 	return ""
 }
 
-func (m *MemberMasterResponse) GetMemberID() uint64 {
+func (m *MasterInfo) GetMemberID() uint64 {
 	if m != nil {
 		return m.MemberID
 	}
 	return 0
 }
 
-func (m *MemberMasterResponse) GetAlive() bool {
+func (m *MasterInfo) GetAlive() bool {
 	if m != nil {
 		return m.Alive
 	}
 	return false
 }
 
-func (m *MemberMasterResponse) GetPeerURLs() []string {
+func (m *MasterInfo) GetPeerURLs() []string {
 	if m != nil {
 		return m.PeerURLs
 	}
 	return nil
 }
 
-func (m *MemberMasterResponse) GetClientURLs() []string {
+func (m *MasterInfo) GetClientURLs() []string {
 	if m != nil {
 		return m.ClientURLs
 	}
 	return nil
 }
 
-type MemberWorkerResponse struct {
+type WorkerInfo struct {
 	Name   string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
 	Addr   string `protobuf:"bytes,2,opt,name=addr,proto3" json:"addr,omitempty"`
 	Stage  string `protobuf:"bytes,3,opt,name=stage,proto3" json:"stage,omitempty"`
 	Source string `protobuf:"bytes,4,opt,name=source,proto3" json:"source,omitempty"`
 }
 
-func (m *MemberWorkerResponse) Reset()         { *m = MemberWorkerResponse{} }
-func (m *MemberWorkerResponse) String() string { return proto.CompactTextString(m) }
-func (*MemberWorkerResponse) ProtoMessage()    {}
-func (*MemberWorkerResponse) Descriptor() ([]byte, []int) {
+func (m *WorkerInfo) Reset()         { *m = WorkerInfo{} }
+func (m *WorkerInfo) String() string { return proto.CompactTextString(m) }
+func (*WorkerInfo) ProtoMessage()    {}
+func (*WorkerInfo) Descriptor() ([]byte, []int) {
 	return fileDescriptor_f9bef11f2a341f03, []int{36}
 }
-func (m *MemberWorkerResponse) XXX_Unmarshal(b []byte) error {
+func (m *WorkerInfo) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
 }
-func (m *MemberWorkerResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+func (m *WorkerInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	if deterministic {
-		return xxx_messageInfo_MemberWorkerResponse.Marshal(b, m, deterministic)
+		return xxx_messageInfo_WorkerInfo.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
 		n, err := m.MarshalToSizedBuffer(b)
@@ -2262,61 +2231,65 @@ func (m *MemberWorkerResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte
 		return b[:n], nil
 	}
 }
-func (m *MemberWorkerResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_MemberWorkerResponse.Merge(m, src)
+func (m *WorkerInfo) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_WorkerInfo.Merge(m, src)
 }
-func (m *MemberWorkerResponse) XXX_Size() int {
+func (m *WorkerInfo) XXX_Size() int {
 	return m.Size()
 }
-func (m *MemberWorkerResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_MemberWorkerResponse.DiscardUnknown(m)
+func (m *WorkerInfo) XXX_DiscardUnknown() {
+	xxx_messageInfo_WorkerInfo.DiscardUnknown(m)
 }
 
-var xxx_messageInfo_MemberWorkerResponse proto.InternalMessageInfo
+var xxx_messageInfo_WorkerInfo proto.InternalMessageInfo
 
-func (m *MemberWorkerResponse) GetName() string {
+func (m *WorkerInfo) GetName() string {
 	if m != nil {
 		return m.Name
 	}
 	return ""
 }
 
-func (m *MemberWorkerResponse) GetAddr() string {
+func (m *WorkerInfo) GetAddr() string {
 	if m != nil {
 		return m.Addr
 	}
 	return ""
 }
 
-func (m *MemberWorkerResponse) GetStage() string {
+func (m *WorkerInfo) GetStage() string {
 	if m != nil {
 		return m.Stage
 	}
 	return ""
 }
 
-func (m *MemberWorkerResponse) GetSource() string {
+func (m *WorkerInfo) GetSource() string {
 	if m != nil {
 		return m.Source
 	}
 	return ""
 }
 
-type ListMemberRequest struct {
+type ListLeaderMember struct {
+	Msg   string `protobuf:"bytes,1,opt,name=msg,proto3" json:"msg,omitempty"`
+	Name  string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
+	Alive bool   `protobuf:"varint,3,opt,name=alive,proto3" json:"alive,omitempty"`
+	Addr  string `protobuf:"bytes,4,opt,name=addr,proto3" json:"addr,omitempty"`
 }
 
-func (m *ListMemberRequest) Reset()         { *m = ListMemberRequest{} }
-func (m *ListMemberRequest) String() string { return proto.CompactTextString(m) }
-func (*ListMemberRequest) ProtoMessage()    {}
-func (*ListMemberRequest) Descriptor() ([]byte, []int) {
+func (m *ListLeaderMember) Reset()         { *m = ListLeaderMember{} }
+func (m *ListLeaderMember) String() string { return proto.CompactTextString(m) }
+func (*ListLeaderMember) ProtoMessage()    {}
+func (*ListLeaderMember) Descriptor() ([]byte, []int) {
 	return fileDescriptor_f9bef11f2a341f03, []int{37}
 }
-func (m *ListMemberRequest) XXX_Unmarshal(b []byte) error {
+func (m *ListLeaderMember) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
 }
-func (m *ListMemberRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+func (m *ListLeaderMember) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	if deterministic {
-		return xxx_messageInfo_ListMemberRequest.Marshal(b, m, deterministic)
+		return xxx_messageInfo_ListLeaderMember.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
 		n, err := m.MarshalToSizedBuffer(b)
@@ -2326,36 +2299,63 @@ func (m *ListMemberRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, e
 		return b[:n], nil
 	}
 }
-func (m *ListMemberRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ListMemberRequest.Merge(m, src)
+func (m *ListLeaderMember) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ListLeaderMember.Merge(m, src)
 }
-func (m *ListMemberRequest) XXX_Size() int {
+func (m *ListLeaderMember) XXX_Size() int {
 	return m.Size()
 }
-func (m *ListMemberRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_ListMemberRequest.DiscardUnknown(m)
+func (m *ListLeaderMember) XXX_DiscardUnknown() {
+	xxx_messageInfo_ListLeaderMember.DiscardUnknown(m)
 }
 
-var xxx_messageInfo_ListMemberRequest proto.InternalMessageInfo
+var xxx_messageInfo_ListLeaderMember proto.InternalMessageInfo
 
-type ListMemberMasterResponse struct {
-	Result  bool                    `protobuf:"varint,1,opt,name=result,proto3" json:"result,omitempty"`
-	Msg     string                  `protobuf:"bytes,2,opt,name=msg,proto3" json:"msg,omitempty"`
-	Members []*MemberMasterResponse `protobuf:"bytes,3,rep,name=members,proto3" json:"members,omitempty"`
+func (m *ListLeaderMember) GetMsg() string {
+	if m != nil {
+		return m.Msg
+	}
+	return ""
+}
+
+func (m *ListLeaderMember) GetName() string {
+	if m != nil {
+		return m.Name
+	}
+	return ""
+}
+
+func (m *ListLeaderMember) GetAlive() bool {
+	if m != nil {
+		return m.Alive
+	}
+	return false
+}
+
+func (m *ListLeaderMember) GetAddr() string {
+	if m != nil {
+		return m.Addr
+	}
+	return ""
+}
+
+type ListMasterMember struct {
+	Msg     string        `protobuf:"bytes,1,opt,name=msg,proto3" json:"msg,omitempty"`
+	Masters []*MasterInfo `protobuf:"bytes,2,rep,name=masters,proto3" json:"masters,omitempty"`
 }
 
-func (m *ListMemberMasterResponse) Reset()         { *m = ListMemberMasterResponse{} }
-func (m *ListMemberMasterResponse) String() string { return proto.CompactTextString(m) }
-func (*ListMemberMasterResponse) ProtoMessage()    {}
-func (*ListMemberMasterResponse) Descriptor() ([]byte, []int) {
+func (m *ListMasterMember) Reset()         { *m = ListMasterMember{} }
+func (m *ListMasterMember) String() string { return proto.CompactTextString(m) }
+func (*ListMasterMember) ProtoMessage()    {}
+func (*ListMasterMember) Descriptor() ([]byte, []int) {
 	return fileDescriptor_f9bef11f2a341f03, []int{38}
 }
-func (m *ListMemberMasterResponse) XXX_Unmarshal(b []byte) error {
+func (m *ListMasterMember) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
 }
-func (m *ListMemberMasterResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+func (m *ListMasterMember) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	if deterministic {
-		return xxx_messageInfo_ListMemberMasterResponse.Marshal(b, m, deterministic)
+		return xxx_messageInfo_ListMasterMember.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
 		n, err := m.MarshalToSizedBuffer(b)
@@ -2365,61 +2365,104 @@ func (m *ListMemberMasterResponse) XXX_Marshal(b []byte, deterministic bool) ([]
 		return b[:n], nil
 	}
 }
-func (m *ListMemberMasterResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ListMemberMasterResponse.Merge(m, src)
+func (m *ListMasterMember) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ListMasterMember.Merge(m, src)
 }
-func (m *ListMemberMasterResponse) XXX_Size() int {
+func (m *ListMasterMember) XXX_Size() int {
 	return m.Size()
 }
-func (m *ListMemberMasterResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_ListMemberMasterResponse.DiscardUnknown(m)
+func (m *ListMasterMember) XXX_DiscardUnknown() {
+	xxx_messageInfo_ListMasterMember.DiscardUnknown(m)
 }
 
-var xxx_messageInfo_ListMemberMasterResponse proto.InternalMessageInfo
+var xxx_messageInfo_ListMasterMember proto.InternalMessageInfo
 
-func (m *ListMemberMasterResponse) GetResult() bool {
+func (m *ListMasterMember) GetMsg() string {
 	if m != nil {
-		return m.Result
+		return m.Msg
 	}
-	return false
+	return ""
+}
+
+func (m *ListMasterMember) GetMasters() []*MasterInfo {
+	if m != nil {
+		return m.Masters
+	}
+	return nil
 }
 
-func (m *ListMemberMasterResponse) GetMsg() string {
+type ListWorkerMember struct {
+	Msg     string        `protobuf:"bytes,1,opt,name=msg,proto3" json:"msg,omitempty"`
+	Workers []*WorkerInfo `protobuf:"bytes,2,rep,name=workers,proto3" json:"workers,omitempty"`
+}
+
+func (m *ListWorkerMember) Reset()         { *m = ListWorkerMember{} }
+func (m *ListWorkerMember) String() string { return proto.CompactTextString(m) }
+func (*ListWorkerMember) ProtoMessage()    {}
+func (*ListWorkerMember) Descriptor() ([]byte, []int) {
+	return fileDescriptor_f9bef11f2a341f03, []int{39}
+}
+func (m *ListWorkerMember) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *ListWorkerMember) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_ListWorkerMember.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *ListWorkerMember) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ListWorkerMember.Merge(m, src)
+}
+func (m *ListWorkerMember) XXX_Size() int {
+	return m.Size()
+}
+func (m *ListWorkerMember) XXX_DiscardUnknown() {
+	xxx_messageInfo_ListWorkerMember.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ListWorkerMember proto.InternalMessageInfo
+
+func (m *ListWorkerMember) GetMsg() string {
 	if m != nil {
 		return m.Msg
 	}
 	return ""
 }
 
-func (m *ListMemberMasterResponse) GetMembers() []*MemberMasterResponse {
+func (m *ListWorkerMember) GetWorkers() []*WorkerInfo {
 	if m != nil {
-		return m.Members
+		return m.Workers
 	}
 	return nil
 }
 
-type ListMemberLeaderResponse struct {
-	Result     bool     `protobuf:"varint,1,opt,name=result,proto3" json:"result,omitempty"`
-	Msg        string   `protobuf:"bytes,2,opt,name=msg,proto3" json:"msg,omitempty"`
-	Name       string   `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"`
-	MemberID   uint64   `protobuf:"varint,4,opt,name=memberID,proto3" json:"memberID,omitempty"`
-	Alive      bool     `protobuf:"varint,5,opt,name=alive,proto3" json:"alive,omitempty"`
-	PeerURLs   []string `protobuf:"bytes,6,rep,name=peerURLs,proto3" json:"peerURLs,omitempty"`
-	ClientURLs []string `protobuf:"bytes,7,rep,name=clientURLs,proto3" json:"clientURLs,omitempty"`
+type Members struct {
+	// Types that are valid to be assigned to Member:
+	//	*Members_Leader
+	//	*Members_Master
+	//	*Members_Worker
+	Member isMembers_Member `protobuf_oneof:"member"`
 }
 
-func (m *ListMemberLeaderResponse) Reset()         { *m = ListMemberLeaderResponse{} }
-func (m *ListMemberLeaderResponse) String() string { return proto.CompactTextString(m) }
-func (*ListMemberLeaderResponse) ProtoMessage()    {}
-func (*ListMemberLeaderResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_f9bef11f2a341f03, []int{39}
+func (m *Members) Reset()         { *m = Members{} }
+func (m *Members) String() string { return proto.CompactTextString(m) }
+func (*Members) ProtoMessage()    {}
+func (*Members) Descriptor() ([]byte, []int) {
+	return fileDescriptor_f9bef11f2a341f03, []int{40}
 }
-func (m *ListMemberLeaderResponse) XXX_Unmarshal(b []byte) error {
+func (m *Members) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
 }
-func (m *ListMemberLeaderResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+func (m *Members) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	if deterministic {
-		return xxx_messageInfo_ListMemberLeaderResponse.Marshal(b, m, deterministic)
+		return xxx_messageInfo_Members.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
 		n, err := m.MarshalToSizedBuffer(b)
@@ -2429,85 +2472,153 @@ func (m *ListMemberLeaderResponse) XXX_Marshal(b []byte, deterministic bool) ([]
 		return b[:n], nil
 	}
 }
-func (m *ListMemberLeaderResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ListMemberLeaderResponse.Merge(m, src)
+func (m *Members) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Members.Merge(m, src)
 }
-func (m *ListMemberLeaderResponse) XXX_Size() int {
+func (m *Members) XXX_Size() int {
 	return m.Size()
 }
-func (m *ListMemberLeaderResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_ListMemberLeaderResponse.DiscardUnknown(m)
+func (m *Members) XXX_DiscardUnknown() {
+	xxx_messageInfo_Members.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Members proto.InternalMessageInfo
+
+type isMembers_Member interface {
+	isMembers_Member()
+	MarshalTo([]byte) (int, error)
+	Size() int
+}
+
+type Members_Leader struct {
+	Leader *ListLeaderMember `protobuf:"bytes,1,opt,name=leader,proto3,oneof" json:"leader,omitempty"`
+}
+type Members_Master struct {
+	Master *ListMasterMember `protobuf:"bytes,2,opt,name=master,proto3,oneof" json:"master,omitempty"`
+}
+type Members_Worker struct {
+	Worker *ListWorkerMember `protobuf:"bytes,3,opt,name=worker,proto3,oneof" json:"worker,omitempty"`
 }
 
-var xxx_messageInfo_ListMemberLeaderResponse proto.InternalMessageInfo
+func (*Members_Leader) isMembers_Member() {}
+func (*Members_Master) isMembers_Member() {}
+func (*Members_Worker) isMembers_Member() {}
 
-func (m *ListMemberLeaderResponse) GetResult() bool {
+func (m *Members) GetMember() isMembers_Member {
 	if m != nil {
-		return m.Result
+		return m.Member
 	}
-	return false
+	return nil
 }
 
-func (m *ListMemberLeaderResponse) GetMsg() string {
-	if m != nil {
-		return m.Msg
+func (m *Members) GetLeader() *ListLeaderMember {
+	if x, ok := m.GetMember().(*Members_Leader); ok {
+		return x.Leader
 	}
-	return ""
+	return nil
 }
 
-func (m *ListMemberLeaderResponse) GetName() string {
-	if m != nil {
-		return m.Name
+func (m *Members) GetMaster() *ListMasterMember {
+	if x, ok := m.GetMember().(*Members_Master); ok {
+		return x.Master
 	}
-	return ""
+	return nil
 }
 
-func (m *ListMemberLeaderResponse) GetMemberID() uint64 {
-	if m != nil {
-		return m.MemberID
+func (m *Members) GetWorker() *ListWorkerMember {
+	if x, ok := m.GetMember().(*Members_Worker); ok {
+		return x.Worker
 	}
-	return 0
+	return nil
+}
+
+// XXX_OneofWrappers is for the internal use of the proto package.
+func (*Members) XXX_OneofWrappers() []interface{} {
+	return []interface{}{
+		(*Members_Leader)(nil),
+		(*Members_Master)(nil),
+		(*Members_Worker)(nil),
+	}
+}
+
+type ListMemberRequest struct {
+	Master bool `protobuf:"varint,1,opt,name=master,proto3" json:"master,omitempty"`
+	Worker bool `protobuf:"varint,2,opt,name=worker,proto3" json:"worker,omitempty"`
+	Leader bool `protobuf:"varint,3,opt,name=leader,proto3" json:"leader,omitempty"`
+}
+
+func (m *ListMemberRequest) Reset()         { *m = ListMemberRequest{} }
+func (m *ListMemberRequest) String() string { return proto.CompactTextString(m) }
+func (*ListMemberRequest) ProtoMessage()    {}
+func (*ListMemberRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_f9bef11f2a341f03, []int{41}
+}
+func (m *ListMemberRequest) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *ListMemberRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_ListMemberRequest.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *ListMemberRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ListMemberRequest.Merge(m, src)
+}
+func (m *ListMemberRequest) XXX_Size() int {
+	return m.Size()
 }
+func (m *ListMemberRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_ListMemberRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ListMemberRequest proto.InternalMessageInfo
 
-func (m *ListMemberLeaderResponse) GetAlive() bool {
+func (m *ListMemberRequest) GetMaster() bool {
 	if m != nil {
-		return m.Alive
+		return m.Master
 	}
 	return false
 }
 
-func (m *ListMemberLeaderResponse) GetPeerURLs() []string {
+func (m *ListMemberRequest) GetWorker() bool {
 	if m != nil {
-		return m.PeerURLs
+		return m.Worker
 	}
-	return nil
+	return false
 }
 
-func (m *ListMemberLeaderResponse) GetClientURLs() []string {
+func (m *ListMemberRequest) GetLeader() bool {
 	if m != nil {
-		return m.ClientURLs
+		return m.Leader
 	}
-	return nil
+	return false
 }
 
-type ListMemberWorkerResponse struct {
-	Result  bool                    `protobuf:"varint,1,opt,name=result,proto3" json:"result,omitempty"`
-	Msg     string                  `protobuf:"bytes,2,opt,name=msg,proto3" json:"msg,omitempty"`
-	Members []*MemberWorkerResponse `protobuf:"bytes,3,rep,name=members,proto3" json:"members,omitempty"`
+type ListMemberResponse struct {
+	Result  bool       `protobuf:"varint,1,opt,name=result,proto3" json:"result,omitempty"`
+	Msg     string     `protobuf:"bytes,2,opt,name=msg,proto3" json:"msg,omitempty"`
+	Members []*Members `protobuf:"bytes,3,rep,name=members,proto3" json:"members,omitempty"`
 }
 
-func (m *ListMemberWorkerResponse) Reset()         { *m = ListMemberWorkerResponse{} }
-func (m *ListMemberWorkerResponse) String() string { return proto.CompactTextString(m) }
-func (*ListMemberWorkerResponse) ProtoMessage()    {}
-func (*ListMemberWorkerResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_f9bef11f2a341f03, []int{40}
+func (m *ListMemberResponse) Reset()         { *m = ListMemberResponse{} }
+func (m *ListMemberResponse) String() string { return proto.CompactTextString(m) }
+func (*ListMemberResponse) ProtoMessage()    {}
+func (*ListMemberResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_f9bef11f2a341f03, []int{42}
 }
-func (m *ListMemberWorkerResponse) XXX_Unmarshal(b []byte) error {
+func (m *ListMemberResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
 }
-func (m *ListMemberWorkerResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+func (m *ListMemberResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	if deterministic {
-		return xxx_messageInfo_ListMemberWorkerResponse.Marshal(b, m, deterministic)
+		return xxx_messageInfo_ListMemberResponse.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
 		n, err := m.MarshalToSizedBuffer(b)
@@ -2517,33 +2628,33 @@ func (m *ListMemberWorkerResponse) XXX_Marshal(b []byte, deterministic bool) ([]
 		return b[:n], nil
 	}
 }
-func (m *ListMemberWorkerResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ListMemberWorkerResponse.Merge(m, src)
+func (m *ListMemberResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ListMemberResponse.Merge(m, src)
 }
-func (m *ListMemberWorkerResponse) XXX_Size() int {
+func (m *ListMemberResponse) XXX_Size() int {
 	return m.Size()
 }
-func (m *ListMemberWorkerResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_ListMemberWorkerResponse.DiscardUnknown(m)
+func (m *ListMemberResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_ListMemberResponse.DiscardUnknown(m)
 }
 
-var xxx_messageInfo_ListMemberWorkerResponse proto.InternalMessageInfo
+var xxx_messageInfo_ListMemberResponse proto.InternalMessageInfo
 
-func (m *ListMemberWorkerResponse) GetResult() bool {
+func (m *ListMemberResponse) GetResult() bool {
 	if m != nil {
 		return m.Result
 	}
 	return false
 }
 
-func (m *ListMemberWorkerResponse) GetMsg() string {
+func (m *ListMemberResponse) GetMsg() string {
 	if m != nil {
 		return m.Msg
 	}
 	return ""
 }
 
-func (m *ListMemberWorkerResponse) GetMembers() []*MemberWorkerResponse {
+func (m *ListMemberResponse) GetMembers() []*Members {
 	if m != nil {
 		return m.Members
 	}
@@ -2551,7 +2662,6 @@ func (m *ListMemberWorkerResponse) GetMembers() []*MemberWorkerResponse {
 }
 
 func init() {
-	proto.RegisterEnum("pb.MemberType", MemberType_name, MemberType_value)
 	proto.RegisterEnum("pb.SourceOp", SourceOp_name, SourceOp_value)
 	proto.RegisterType((*MigrateWorkerRelayRequest)(nil), "pb.MigrateWorkerRelayRequest")
 	proto.RegisterType((*UpdateWorkerRelayConfigRequest)(nil), "pb.UpdateWorkerRelayConfigRequest")
@@ -2588,119 +2698,125 @@ func init() {
 	proto.RegisterType((*RegisterWorkerResponse)(nil), "pb.RegisterWorkerResponse")
 	proto.RegisterType((*OfflineWorkerRequest)(nil), "pb.OfflineWorkerRequest")
 	proto.RegisterType((*OfflineWorkerResponse)(nil), "pb.OfflineWorkerResponse")
-	proto.RegisterType((*MemberMasterResponse)(nil), "pb.MemberMasterResponse")
-	proto.RegisterType((*MemberWorkerResponse)(nil), "pb.MemberWorkerResponse")
+	proto.RegisterType((*MasterInfo)(nil), "pb.MasterInfo")
+	proto.RegisterType((*WorkerInfo)(nil), "pb.WorkerInfo")
+	proto.RegisterType((*ListLeaderMember)(nil), "pb.ListLeaderMember")
+	proto.RegisterType((*ListMasterMember)(nil), "pb.ListMasterMember")
+	proto.RegisterType((*ListWorkerMember)(nil), "pb.ListWorkerMember")
+	proto.RegisterType((*Members)(nil), "pb.Members")
 	proto.RegisterType((*ListMemberRequest)(nil), "pb.ListMemberRequest")
-	proto.RegisterType((*ListMemberMasterResponse)(nil), "pb.ListMemberMasterResponse")
-	proto.RegisterType((*ListMemberLeaderResponse)(nil), "pb.ListMemberLeaderResponse")
-	proto.RegisterType((*ListMemberWorkerResponse)(nil), "pb.ListMemberWorkerResponse")
+	proto.RegisterType((*ListMemberResponse)(nil), "pb.ListMemberResponse")
 }
 
 func init() { proto.RegisterFile("dmmaster.proto", fileDescriptor_f9bef11f2a341f03) }
 
 var fileDescriptor_f9bef11f2a341f03 = []byte{
-	// 1608 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x58, 0xcd, 0x6e, 0xdb, 0x46,
-	0x10, 0x16, 0x25, 0x59, 0xb6, 0xc6, 0x8e, 0x23, 0xaf, 0x65, 0x99, 0x62, 0x1c, 0xc5, 0x65, 0x8b,
-	0xc0, 0xc8, 0x21, 0x6e, 0x9c, 0x5b, 0x80, 0x00, 0x4d, 0x2c, 0x07, 0x35, 0x20, 0xd7, 0x0e, 0x15,
-	0xa3, 0xc8, 0xa5, 0x00, 0x2d, 0xae, 0x65, 0xc2, 0x14, 0x49, 0x93, 0x94, 0x5d, 0xa3, 0x28, 0x0a,
-	0xf4, 0x05, 0x5a, 0xa0, 0x87, 0xe4, 0xd6, 0xb7, 0x29, 0x72, 0x0c, 0xd0, 0x4b, 0x8f, 0x45, 0xd2,
-	0x07, 0x29, 0xf6, 0x87, 0xe4, 0xf2, 0x4f, 0xb5, 0x1c, 0xd4, 0xb7, 0x9d, 0xd9, 0xdd, 0x99, 0x6f,
-	0x67, 0x66, 0x67, 0x67, 0x16, 0x16, 0x8d, 0xd1, 0x48, 0xf7, 0x03, 0xec, 0x3d, 0x74, 0x3d, 0x27,
-	0x70, 0x50, 0xd9, 0x3d, 0x52, 0x16, 0x8d, 0xd1, 0x85, 0xe3, 0x9d, 0x86, 0x3c, 0x65, 0x6d, 0xe8,
-	0x38, 0x43, 0x0b, 0x6f, 0xea, 0xae, 0xb9, 0xa9, 0xdb, 0xb6, 0x13, 0xe8, 0x81, 0xe9, 0xd8, 0x3e,
-	0x9b, 0x55, 0xcf, 0xa0, 0xbd, 0x67, 0x0e, 0x3d, 0x3d, 0xc0, 0xdf, 0xd2, 0x4d, 0x1a, 0xb6, 0xf4,
-	0x4b, 0x0d, 0x9f, 0x8d, 0xb1, 0x1f, 0xa0, 0x0e, 0xc0, 0x73, 0xd3, 0xb6, 0x9c, 0xe1, 0x37, 0xfa,
-	0x08, 0xcb, 0xd2, 0xba, 0xb4, 0x51, 0xd7, 0x04, 0x0e, 0x5a, 0x83, 0x3a, 0xa3, 0x0e, 0x1c, 0x5f,
-	0x2e, 0xaf, 0x4b, 0x1b, 0xb7, 0xb4, 0x98, 0x81, 0x5a, 0x50, 0xf3, 0x9d, 0xb1, 0x37, 0xc0, 0x72,
-	0x85, 0xee, 0xe4, 0x94, 0x7a, 0x00, 0x9d, 0x43, 0xd7, 0x48, 0x6a, 0xdc, 0x76, 0xec, 0x63, 0x73,
-	0x18, 0xea, 0x6d, 0x41, 0x6d, 0x40, 0x19, 0x5c, 0x27, 0xa7, 0x04, 0x89, 0xe5, 0x84, 0xc4, 0xaf,
-	0xa0, 0xd1, 0x0f, 0x74, 0x2f, 0x78, 0xa5, 0xfb, 0xa7, 0xa1, 0x0c, 0x04, 0xd5, 0x40, 0xf7, 0x4f,
-	0xb9, 0x04, 0x3a, 0x46, 0x32, 0xcc, 0xb2, 0x1d, 0x04, 0x6d, 0x65, 0xa3, 0xae, 0x85, 0xa4, 0x7a,
-	0x06, 0x4b, 0x82, 0x04, 0xdf, 0x75, 0x6c, 0x1f, 0x13, 0x75, 0x1e, 0xf6, 0xc7, 0x56, 0x40, 0x85,
-	0xcc, 0x69, 0x9c, 0x42, 0x0d, 0xa8, 0x8c, 0xfc, 0x21, 0xc7, 0x40, 0x86, 0x68, 0x2b, 0x16, 0x5c,
-	0x59, 0xaf, 0x6c, 0xcc, 0x6f, 0xc9, 0x0f, 0xdd, 0xa3, 0x87, 0xdb, 0xce, 0x68, 0xe4, 0xd8, 0xe1,
-	0x29, 0x99, 0xd0, 0x58, 0xe5, 0x63, 0x68, 0x33, 0x33, 0xec, 0x51, 0x0f, 0x5e, 0xc9, 0x02, 0xea,
-	0x25, 0x28, 0x79, 0x9b, 0xa6, 0x06, 0xfc, 0x28, 0x0d, 0x78, 0x95, 0x00, 0x7e, 0x39, 0xc6, 0xde,
-	0x65, 0x3f, 0xd0, 0x83, 0xb1, 0x9f, 0xc5, 0xfb, 0x1d, 0xa0, 0x7d, 0x17, 0x93, 0x48, 0x11, 0xcd,
-	0xac, 0x40, 0xd9, 0x71, 0xa9, 0xba, 0xc5, 0x2d, 0x20, 0x32, 0xc8, 0xe4, 0xbe, 0xab, 0x95, 0x1d,
-	0x97, 0xb8, 0xc0, 0x26, 0x81, 0xc3, 0xf4, 0xd2, 0xb1, 0xe8, 0x82, 0x4a, 0xd2, 0x05, 0xbf, 0x48,
-	0xb0, 0x9c, 0x50, 0xc0, 0x0f, 0x35, 0x49, 0x43, 0x7c, 0xe0, 0x72, 0xde, 0x81, 0x2b, 0xb9, 0x1e,
-	0xaa, 0x5e, 0xd5, 0x43, 0xcf, 0x60, 0x89, 0x19, 0xfb, 0xfa, 0x71, 0xe5, 0x01, 0x12, 0x45, 0xdc,
-	0x48, 0x60, 0xbd, 0x80, 0x96, 0xe0, 0xc8, 0x9e, 0xe9, 0x07, 0x02, 0x76, 0x3b, 0xbe, 0xc9, 0x19,
-	0x87, 0xa4, 0xb0, 0x9f, 0xc3, 0x6a, 0x46, 0xce, 0x4d, 0x04, 0xda, 0x0e, 0xac, 0xd0, 0xf9, 0x1d,
-	0xcf, 0x73, 0xbc, 0xeb, 0xc3, 0x0f, 0xb8, 0x19, 0x04, 0x31, 0x53, 0xa3, 0xff, 0x32, 0x8d, 0xbe,
-	0x15, 0xa1, 0xa7, 0x62, 0xb3, 0xe0, 0xb7, 0x61, 0xb9, 0x7f, 0xe2, 0x5c, 0x74, 0xbb, 0xbd, 0x9e,
-	0x33, 0x38, 0xf5, 0xaf, 0x17, 0x35, 0xbf, 0x4b, 0x30, 0xcb, 0x25, 0xa0, 0x45, 0x28, 0xef, 0x76,
-	0xf9, 0xbe, 0xf2, 0x6e, 0x37, 0x92, 0x54, 0x16, 0x24, 0x21, 0xa8, 0x8e, 0x1c, 0x23, 0xcc, 0xb3,
-	0x74, 0x8c, 0x9a, 0x30, 0xe3, 0x5c, 0xd8, 0xd8, 0x93, 0xab, 0x94, 0xc9, 0x08, 0xb2, 0xb2, 0xdb,
-	0xed, 0xf9, 0xf2, 0x0c, 0x55, 0x48, 0xc7, 0x34, 0xab, 0x5e, 0xda, 0x03, 0x6c, 0xc8, 0x35, 0xca,
-	0xe5, 0x14, 0x52, 0x60, 0x6e, 0x6c, 0xf3, 0x99, 0x59, 0x3a, 0x13, 0xd1, 0xea, 0x00, 0x9a, 0xc9,
-	0x63, 0x4e, 0x6d, 0xda, 0xcf, 0x60, 0xc6, 0x22, 0x5b, 0xb9, 0x61, 0xe7, 0x89, 0x61, 0xb9, 0x38,
-	0x8d, 0xcd, 0xa8, 0x16, 0x34, 0x0f, 0x6d, 0x32, 0x0c, 0xf9, 0xdc, 0x98, 0x69, 0x93, 0xa8, 0xb0,
-	0xe0, 0x61, 0xd7, 0xd2, 0x07, 0x78, 0x9f, 0x9e, 0x98, 0x69, 0x49, 0xf0, 0xd0, 0x3a, 0xcc, 0x1f,
-	0x3b, 0xde, 0x00, 0x6b, 0x78, 0xe4, 0x9c, 0x33, 0x4b, 0xcd, 0x69, 0x22, 0x4b, 0x7d, 0x06, 0x2b,
-	0x29, 0x6d, 0xd3, 0x9e, 0x49, 0x7d, 0x02, 0x9d, 0xfe, 0x85, 0x19, 0x0c, 0x4e, 0x84, 0x97, 0x8d,
-	0x25, 0xea, 0x10, 0xba, 0xe0, 0x73, 0x29, 0xe9, 0xf3, 0x9f, 0xe0, 0x5e, 0xe1, 0xde, 0x1b, 0x49,
-	0x1b, 0x1a, 0xb4, 0x79, 0xfa, 0xcd, 0xa9, 0x04, 0xee, 0x08, 0x49, 0x98, 0xba, 0x8a, 0xce, 0xf2,
-	0x2c, 0x5c, 0x1c, 0xc8, 0x6f, 0x24, 0x50, 0xf2, 0x84, 0xf2, 0x03, 0x4d, 0x94, 0xfa, 0xff, 0xe6,
-	0xf6, 0x77, 0x12, 0x2c, 0x7d, 0xad, 0xdb, 0x86, 0x85, 0xfb, 0x2f, 0x7b, 0xfe, 0xa4, 0x0c, 0xd3,
-	0xa6, 0x20, 0xcb, 0x14, 0x64, 0x9d, 0x08, 0xee, 0xbf, 0xec, 0xc5, 0x0f, 0x9c, 0xee, 0x0d, 0xc3,
-	0x97, 0x8c, 0x8e, 0x49, 0x4d, 0x74, 0x14, 0xd5, 0x44, 0xec, 0xee, 0xc5, 0x0c, 0xa1, 0x82, 0x99,
-	0x11, 0x2b, 0x18, 0x52, 0x69, 0xf9, 0x67, 0xd6, 0x81, 0x1e, 0x04, 0xd8, 0xb3, 0xe5, 0x1a, 0xab,
-	0xb4, 0x62, 0x0e, 0xb9, 0x8b, 0xfe, 0x89, 0xee, 0x19, 0xa6, 0x3d, 0x94, 0x67, 0xa9, 0x39, 0x22,
-	0x9a, 0xbc, 0x31, 0xe2, 0x49, 0x6e, 0x24, 0x58, 0xde, 0x48, 0xb0, 0x7a, 0x30, 0xf6, 0x86, 0x79,
-	0xb1, 0x52, 0x18, 0xe3, 0xe4, 0x14, 0xa6, 0xad, 0x0f, 0x02, 0xf3, 0x1c, 0x73, 0xa7, 0x46, 0x34,
-	0xcd, 0x6b, 0xe6, 0x88, 0xdd, 0xcc, 0x8a, 0x46, 0xc7, 0x64, 0xfd, 0xb1, 0x69, 0x61, 0xea, 0x12,
-	0x66, 0xca, 0x88, 0xa6, 0x96, 0x1c, 0x1f, 0x75, 0x4d, 0x2f, 0xb2, 0x24, 0xa5, 0xd4, 0xef, 0x41,
-	0xce, 0x02, 0xbb, 0x11, 0x9b, 0xdc, 0x87, 0xc6, 0xf6, 0x09, 0x1e, 0x9c, 0xfe, 0x47, 0xb5, 0xa0,
-	0x3e, 0x85, 0x25, 0x61, 0xdd, 0xd4, 0x49, 0xa6, 0x07, 0x4d, 0x7e, 0xa5, 0xfa, 0x54, 0x71, 0xa8,
-	0x6a, 0x4d, 0xb8, 0x4c, 0x0b, 0x34, 0x4e, 0xe9, 0x74, 0x7c, 0x9b, 0x78, 0x41, 0x59, 0x4e, 0x14,
-	0x94, 0x63, 0x58, 0x49, 0x49, 0xbb, 0x11, 0x5b, 0xed, 0xc0, 0x8a, 0x86, 0x87, 0x26, 0x49, 0x6f,
-	0xe1, 0x92, 0x89, 0x6f, 0xbc, 0x6e, 0x18, 0x1e, 0xf6, 0x7d, 0xae, 0x36, 0x24, 0xd5, 0xe7, 0xd0,
-	0x4a, 0x8b, 0x99, 0xda, 0x9e, 0x5d, 0x68, 0xee, 0x1f, 0x1f, 0x5b, 0xa6, 0x8d, 0x3f, 0x05, 0xc9,
-	0x33, 0x58, 0x49, 0x49, 0x99, 0x1a, 0xc8, 0x5b, 0x09, 0x9a, 0x7b, 0x78, 0x74, 0x84, 0xbd, 0x54,
-	0xde, 0xcf, 0x43, 0xa2, 0xc0, 0xdc, 0x88, 0xae, 0xdd, 0xed, 0x52, 0x19, 0x55, 0x2d, 0xa2, 0xc9,
-	0xd3, 0xaf, 0x5b, 0x66, 0xf4, 0xca, 0x31, 0x82, 0xec, 0x70, 0x31, 0xf6, 0x0e, 0xb5, 0x1e, 0x4b,
-	0x93, 0x75, 0x2d, 0xa2, 0x49, 0xfa, 0x19, 0x58, 0x26, 0xb6, 0x03, 0x3a, 0xcb, 0x8a, 0x03, 0x81,
-	0x43, 0x5e, 0x62, 0x86, 0x2c, 0x75, 0xb8, 0x3c, 0x64, 0x24, 0x29, 0x1a, 0x46, 0xf8, 0x0a, 0xd3,
-	0x31, 0x41, 0xe4, 0x07, 0xfa, 0x30, 0xac, 0x50, 0x18, 0x21, 0x24, 0xc3, 0x6a, 0xa2, 0x9d, 0x5b,
-	0x86, 0x25, 0x52, 0xaf, 0x31, 0x8d, 0xdc, 0x1d, 0xe4, 0x5e, 0xc7, 0xcc, 0x4f, 0x79, 0x18, 0x99,
-	0x99, 0x12, 0xb1, 0x9a, 0x27, 0x54, 0x0b, 0x17, 0xaa, 0x7f, 0x48, 0xa2, 0xea, 0x1e, 0xd6, 0x8d,
-	0x6b, 0xa9, 0x0e, 0x6d, 0x55, 0x29, 0xf0, 0x62, 0xb5, 0xc8, 0x8b, 0x33, 0x45, 0x5e, 0xac, 0x4d,
-	0xf4, 0xe2, 0x6c, 0xc6, 0x8b, 0x09, 0x13, 0x5e, 0x37, 0x4c, 0x27, 0x9a, 0x30, 0x7d, 0xdd, 0xf9,
-	0xc2, 0x07, 0x7b, 0x00, 0x6c, 0xc1, 0xab, 0x4b, 0x17, 0xa3, 0xdb, 0x30, 0xbf, 0x6b, 0x9f, 0xeb,
-	0x96, 0x69, 0x10, 0xb2, 0x51, 0x42, 0x8b, 0x00, 0xcc, 0xf8, 0x94, 0x96, 0x08, 0xcd, 0x24, 0x51,
-	0xba, 0x4c, 0x68, 0x66, 0x76, 0x4a, 0x57, 0x1e, 0x68, 0x30, 0x17, 0x26, 0x37, 0xb4, 0x0c, 0xb7,
-	0xb9, 0xb0, 0x90, 0xd5, 0x28, 0x11, 0x0d, 0xb4, 0x9d, 0x67, 0xac, 0x86, 0x84, 0x1a, 0xb0, 0xc0,
-	0xfa, 0x30, 0xce, 0xa1, 0x32, 0xfb, 0x81, 0xe3, 0x72, 0xba, 0xb2, 0xf5, 0xf6, 0x16, 0xd4, 0x18,
-	0x08, 0xf4, 0x1a, 0xea, 0xd1, 0x67, 0x00, 0x6a, 0xd2, 0x54, 0x9a, 0xfa, 0x5d, 0x50, 0x56, 0x52,
-	0x5c, 0x76, 0x60, 0xf5, 0xde, 0xcf, 0x7f, 0xfe, 0xf3, 0x5b, 0xb9, 0xad, 0x36, 0x37, 0x75, 0xd7,
-	0xf4, 0x37, 0xcf, 0x1f, 0xe9, 0x96, 0x7b, 0xa2, 0x3f, 0xda, 0x24, 0x79, 0xdf, 0x7f, 0x22, 0x3d,
-	0x40, 0xc7, 0x30, 0x2f, 0xf4, 0xb8, 0x88, 0xb6, 0x13, 0xd9, 0xae, 0x5a, 0x59, 0xcd, 0xf0, 0xb9,
-	0x82, 0xfb, 0x54, 0xc1, 0xba, 0x72, 0x27, 0x4f, 0xc1, 0xe6, 0x0f, 0x24, 0xa8, 0x7e, 0x24, 0x7a,
-	0x9e, 0x02, 0xc4, 0x7d, 0x27, 0xa2, 0x68, 0x33, 0xad, 0xac, 0xd2, 0x4a, 0xb3, 0xb9, 0x92, 0x12,
-	0xb2, 0x60, 0x5e, 0x68, 0xd1, 0x90, 0x92, 0xea, 0xd9, 0x84, 0xa6, 0x4c, 0xb9, 0x93, 0x3b, 0xc7,
-	0x25, 0x7d, 0x41, 0xe1, 0x76, 0xd0, 0x5a, 0x0a, 0xae, 0x4f, 0x97, 0x72, 0xbc, 0x68, 0x07, 0x20,
-	0x6e, 0xa9, 0x50, 0x3b, 0xd9, 0x62, 0x89, 0xba, 0x94, 0xbc, 0xa9, 0x08, 0xf4, 0x36, 0x2c, 0x88,
-	0x3d, 0x09, 0xa2, 0x46, 0xcc, 0x69, 0xc6, 0x14, 0x39, 0x3b, 0x11, 0x09, 0x79, 0x01, 0xb7, 0x12,
-	0x5d, 0x00, 0xa2, 0x8b, 0xf3, 0xda, 0x10, 0xa5, 0x9d, 0x33, 0x13, 0xc9, 0x39, 0x0c, 0x1b, 0x7f,
-	0xf1, 0xa3, 0x06, 0xdd, 0x8d, 0x2d, 0x9e, 0xf3, 0xeb, 0xa3, 0x74, 0x8a, 0xa6, 0x23, 0xb1, 0xaf,
-	0x61, 0xb5, 0xe0, 0xef, 0x0c, 0xa9, 0xf1, 0xe6, 0xa2, 0x8f, 0x35, 0xa5, 0xf0, 0x65, 0x56, 0x4b,
-	0x24, 0x64, 0xe2, 0x32, 0x92, 0x85, 0x4c, 0xa6, 0x40, 0x66, 0x21, 0x93, 0xad, 0x36, 0xd5, 0x12,
-	0x32, 0x60, 0xb5, 0xa0, 0x7f, 0x61, 0xc8, 0x26, 0x37, 0x46, 0xca, 0xe7, 0x13, 0xd7, 0x08, 0xe7,
-	0x6f, 0x65, 0xfb, 0x09, 0x1a, 0xe3, 0x77, 0x85, 0x2b, 0x93, 0x2d, 0x4a, 0x99, 0x69, 0x8b, 0x5b,
-	0x11, 0xb5, 0x84, 0xf6, 0xa1, 0x91, 0x2e, 0x1c, 0x11, 0x0d, 0xee, 0x82, 0x3a, 0x57, 0x59, 0xcb,
-	0x9f, 0x14, 0x04, 0xa2, 0xec, 0xd7, 0x2a, 0xc3, 0x59, 0xf8, 0xe5, 0x3a, 0xd1, 0x43, 0x4f, 0xa0,
-	0x1e, 0x15, 0x8e, 0x2c, 0x2f, 0xa5, 0xeb, 0x4d, 0x96, 0x97, 0x32, 0xd5, 0x25, 0x8b, 0xeb, 0x44,
-	0x9d, 0xc7, 0xe2, 0x3a, 0xaf, 0x90, 0x64, 0x71, 0x9d, 0x5b, 0x14, 0xaa, 0x25, 0xb4, 0x0b, 0x8b,
-	0xc9, 0x8a, 0x8b, 0xdd, 0xd7, 0xdc, 0x62, 0x8e, 0xdd, 0xd7, 0xfc, 0x02, 0x8d, 0x43, 0x12, 0x4b,
-	0x26, 0x0e, 0x29, 0xa7, 0x16, 0xe3, 0x90, 0xf2, 0xea, 0x2b, 0x0a, 0xa9, 0x91, 0xae, 0x0c, 0x58,
-	0xf8, 0x66, 0x8a, 0x08, 0xe6, 0xb2, 0xa2, 0x32, 0x22, 0x2d, 0x8a, 0xa3, 0xba, 0x9a, 0xa8, 0xc9,
-	0xa8, 0xd8, 0xeb, 0x75, 0x45, 0x51, 0xc9, 0x0a, 0x43, 0x2d, 0x3d, 0x97, 0xdf, 0x7d, 0xe8, 0x48,
-	0xef, 0x3f, 0x74, 0xa4, 0xbf, 0x3f, 0x74, 0xa4, 0x5f, 0x3f, 0x76, 0x4a, 0xef, 0x3f, 0x76, 0x4a,
-	0x7f, 0x7d, 0xec, 0x94, 0x8e, 0x6a, 0xf4, 0x13, 0xff, 0xf1, 0xbf, 0x01, 0x00, 0x00, 0xff, 0xff,
-	0x28, 0x6a, 0xf8, 0xf2, 0x08, 0x18, 0x00, 0x00,
+	// 1668 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x58, 0x4f, 0x6f, 0xdb, 0xc6,
+	0x12, 0x17, 0x25, 0x5b, 0xb6, 0x47, 0x8e, 0x23, 0x6f, 0x6c, 0x59, 0x66, 0x1c, 0xc5, 0x8f, 0xef,
+	0xbd, 0xc0, 0xc8, 0xc1, 0x6e, 0x9c, 0x5b, 0x80, 0x00, 0x8d, 0x2d, 0x07, 0x31, 0xa0, 0xc4, 0x0e,
+	0x55, 0xa3, 0x08, 0x0a, 0x14, 0xa0, 0xa4, 0x95, 0x4c, 0x98, 0x22, 0x69, 0x92, 0xb2, 0x6b, 0x14,
+	0x45, 0x81, 0x7e, 0x80, 0xb6, 0x40, 0x0f, 0x39, 0xf6, 0xd0, 0x2f, 0x93, 0x63, 0x80, 0x5e, 0x7a,
+	0x2c, 0x92, 0x7e, 0x86, 0x9e, 0x8b, 0xdd, 0x59, 0x92, 0xcb, 0x3f, 0x52, 0xa3, 0x14, 0xf5, 0x6d,
+	0x67, 0x76, 0x77, 0xe6, 0x37, 0xb3, 0xb3, 0xb3, 0x33, 0x0b, 0x4b, 0xbd, 0xe1, 0xd0, 0xf0, 0x03,
+	0xea, 0x6d, 0xbb, 0x9e, 0x13, 0x38, 0xa4, 0xe8, 0x76, 0xd4, 0xa5, 0xde, 0xf0, 0xd2, 0xf1, 0xce,
+	0x42, 0x9e, 0xba, 0x31, 0x70, 0x9c, 0x81, 0x45, 0x77, 0x0c, 0xd7, 0xdc, 0x31, 0x6c, 0xdb, 0x09,
+	0x8c, 0xc0, 0x74, 0x6c, 0x1f, 0x67, 0xb5, 0x73, 0x58, 0x7f, 0x6e, 0x0e, 0x3c, 0x23, 0xa0, 0x9f,
+	0xf3, 0x4d, 0x3a, 0xb5, 0x8c, 0x2b, 0x9d, 0x9e, 0x8f, 0xa8, 0x1f, 0x90, 0x06, 0xc0, 0x9e, 0x69,
+	0x5b, 0xce, 0xe0, 0x85, 0x31, 0xa4, 0x75, 0x65, 0x53, 0xd9, 0x5a, 0xd0, 0x25, 0x0e, 0xd9, 0x80,
+	0x05, 0xa4, 0x8e, 0x1d, 0xbf, 0x5e, 0xdc, 0x54, 0xb6, 0x6e, 0xe8, 0x31, 0x83, 0xd4, 0xa0, 0xec,
+	0x3b, 0x23, 0xaf, 0x4b, 0xeb, 0x25, 0xbe, 0x53, 0x50, 0xda, 0x31, 0x34, 0x4e, 0xdc, 0x5e, 0x52,
+	0xe3, 0xbe, 0x63, 0xf7, 0xcd, 0x41, 0xa8, 0xb7, 0x06, 0xe5, 0x2e, 0x67, 0x08, 0x9d, 0x82, 0x92,
+	0x24, 0x16, 0x13, 0x12, 0x3f, 0x85, 0x6a, 0x3b, 0x30, 0xbc, 0xe0, 0x33, 0xc3, 0x3f, 0x0b, 0x65,
+	0x10, 0x98, 0x09, 0x0c, 0xff, 0x4c, 0x48, 0xe0, 0x63, 0x52, 0x87, 0x39, 0xdc, 0xc1, 0xd0, 0x96,
+	0xb6, 0x16, 0xf4, 0x90, 0xd4, 0xce, 0x61, 0x59, 0x92, 0xe0, 0xbb, 0x8e, 0xed, 0x53, 0xa6, 0xce,
+	0xa3, 0xfe, 0xc8, 0x0a, 0xb8, 0x90, 0x79, 0x5d, 0x50, 0xa4, 0x0a, 0xa5, 0xa1, 0x3f, 0x10, 0x18,
+	0xd8, 0x90, 0xec, 0xc6, 0x82, 0x4b, 0x9b, 0xa5, 0xad, 0xca, 0x6e, 0x7d, 0xdb, 0xed, 0x6c, 0xef,
+	0x3b, 0xc3, 0xa1, 0x63, 0x87, 0x56, 0xa2, 0xd0, 0x58, 0xe5, 0x43, 0x58, 0x47, 0x37, 0x3c, 0xe7,
+	0x27, 0xf8, 0x41, 0x1e, 0xd0, 0xae, 0x40, 0xcd, 0xdb, 0x34, 0x35, 0xe0, 0x07, 0x69, 0xc0, 0x6b,
+	0x0c, 0xf0, 0xcb, 0x11, 0xf5, 0xae, 0xda, 0x81, 0x11, 0x8c, 0xfc, 0x2c, 0xde, 0x2f, 0x81, 0x1c,
+	0xb9, 0x94, 0x45, 0x8a, 0xec, 0x66, 0x15, 0x8a, 0x8e, 0xcb, 0xd5, 0x2d, 0xed, 0x02, 0x93, 0xc1,
+	0x26, 0x8f, 0x5c, 0xbd, 0xe8, 0xb8, 0xec, 0x08, 0x6c, 0x16, 0x38, 0xa8, 0x97, 0x8f, 0xe5, 0x23,
+	0x28, 0x25, 0x8f, 0xe0, 0x07, 0x05, 0x6e, 0x25, 0x14, 0x08, 0xa3, 0x26, 0x69, 0x88, 0x0d, 0x2e,
+	0xe6, 0x19, 0x5c, 0xca, 0x3d, 0xa1, 0x99, 0x0f, 0x3d, 0xa1, 0x27, 0xb0, 0x8c, 0xce, 0xfe, 0xf8,
+	0xb8, 0xf2, 0x80, 0xc8, 0x22, 0xae, 0x25, 0xb0, 0x9e, 0x42, 0x4d, 0x3a, 0xc8, 0x96, 0xe9, 0x07,
+	0x12, 0x76, 0x3b, 0xbe, 0xc9, 0x99, 0x03, 0x49, 0x61, 0xbf, 0x80, 0xb5, 0x8c, 0x9c, 0xeb, 0x08,
+	0xb4, 0x03, 0x58, 0xe5, 0xf3, 0x07, 0x9e, 0xe7, 0x78, 0x1f, 0x0f, 0x3f, 0x10, 0x6e, 0x90, 0xc4,
+	0x4c, 0x8d, 0xfe, 0x93, 0x34, 0xfa, 0x5a, 0x84, 0x9e, 0x8b, 0xcd, 0x82, 0xdf, 0x87, 0x5b, 0xed,
+	0x53, 0xe7, 0xb2, 0xd9, 0x6c, 0xb5, 0x9c, 0xee, 0x99, 0xff, 0x71, 0x51, 0xf3, 0xb3, 0x02, 0x73,
+	0x42, 0x02, 0x59, 0x82, 0xe2, 0x61, 0x53, 0xec, 0x2b, 0x1e, 0x36, 0x23, 0x49, 0x45, 0x49, 0x12,
+	0x81, 0x99, 0xa1, 0xd3, 0x0b, 0xf3, 0x2c, 0x1f, 0x93, 0x15, 0x98, 0x75, 0x2e, 0x6d, 0xea, 0xd5,
+	0x67, 0x38, 0x13, 0x09, 0xb6, 0xb2, 0xd9, 0x6c, 0xf9, 0xf5, 0x59, 0xae, 0x90, 0x8f, 0x79, 0x56,
+	0xbd, 0xb2, 0xbb, 0xb4, 0x57, 0x2f, 0x73, 0xae, 0xa0, 0x88, 0x0a, 0xf3, 0x23, 0x5b, 0xcc, 0xcc,
+	0xf1, 0x99, 0x88, 0xd6, 0xba, 0xb0, 0x92, 0x34, 0x73, 0x6a, 0xd7, 0xfe, 0x07, 0x66, 0x2d, 0xb6,
+	0x55, 0x38, 0xb6, 0xc2, 0x1c, 0x2b, 0xc4, 0xe9, 0x38, 0xa3, 0x59, 0xb0, 0x72, 0x62, 0xb3, 0x61,
+	0xc8, 0x17, 0xce, 0x4c, 0xbb, 0x44, 0x83, 0x45, 0x8f, 0xba, 0x96, 0xd1, 0xa5, 0x47, 0xdc, 0x62,
+	0xd4, 0x92, 0xe0, 0x91, 0x4d, 0xa8, 0xf4, 0x1d, 0xaf, 0x4b, 0x75, 0x3a, 0x74, 0x2e, 0xd0, 0x53,
+	0xf3, 0xba, 0xcc, 0xd2, 0x9e, 0xc0, 0x6a, 0x4a, 0xdb, 0xb4, 0x36, 0x69, 0x8f, 0xa0, 0xd1, 0xbe,
+	0x34, 0x83, 0xee, 0xa9, 0xf4, 0xb2, 0x61, 0xa2, 0x0e, 0xa1, 0x4b, 0x67, 0xae, 0x24, 0xcf, 0xfc,
+	0x5b, 0xb8, 0x3b, 0x76, 0xef, 0xb5, 0xa4, 0x0d, 0x1d, 0xd6, 0x45, 0xfa, 0xcd, 0xa9, 0x04, 0x6e,
+	0x4b, 0x49, 0x98, 0x1f, 0x15, 0x9f, 0x15, 0x59, 0x78, 0x7c, 0x20, 0xbf, 0x56, 0x40, 0xcd, 0x13,
+	0x2a, 0x0c, 0x9a, 0x28, 0xf5, 0xdf, 0xcd, 0xed, 0x6f, 0x14, 0x58, 0x7e, 0x66, 0xd8, 0x3d, 0x8b,
+	0xb6, 0x5f, 0xb6, 0xfc, 0x49, 0x19, 0x66, 0x9d, 0x83, 0x2c, 0x72, 0x90, 0x0b, 0x4c, 0x70, 0xfb,
+	0x65, 0x2b, 0x7e, 0xe0, 0x0c, 0x6f, 0x10, 0xbe, 0x64, 0x7c, 0xcc, 0x6a, 0xa2, 0x4e, 0x54, 0x13,
+	0xe1, 0xdd, 0x8b, 0x19, 0x52, 0x05, 0x33, 0x2b, 0x57, 0x30, 0xac, 0xd2, 0xf2, 0xcf, 0xad, 0x63,
+	0x23, 0x08, 0xa8, 0x67, 0xd7, 0xcb, 0x58, 0x69, 0xc5, 0x1c, 0x76, 0x17, 0xfd, 0x53, 0xc3, 0xeb,
+	0x99, 0xf6, 0xa0, 0x3e, 0xc7, 0xdd, 0x11, 0xd1, 0xec, 0x8d, 0x91, 0x2d, 0xb9, 0x96, 0x60, 0x79,
+	0xad, 0xc0, 0xda, 0xf1, 0xc8, 0x1b, 0xe4, 0xc5, 0xca, 0xd8, 0x18, 0x67, 0x56, 0x98, 0xb6, 0xd1,
+	0x0d, 0xcc, 0x0b, 0x2a, 0x0e, 0x35, 0xa2, 0x79, 0x5e, 0x33, 0x87, 0x78, 0x33, 0x4b, 0x3a, 0x1f,
+	0xb3, 0xf5, 0x7d, 0xd3, 0xa2, 0xfc, 0x48, 0xd0, 0x95, 0x11, 0xcd, 0x3d, 0x39, 0xea, 0x34, 0x4d,
+	0x2f, 0xf2, 0x24, 0xa7, 0xb4, 0xaf, 0xa0, 0x9e, 0x05, 0x76, 0x2d, 0x3e, 0xb9, 0x07, 0xd5, 0xfd,
+	0x53, 0xda, 0x3d, 0xfb, 0x9b, 0x6a, 0x41, 0x7b, 0x0c, 0xcb, 0xd2, 0xba, 0xa9, 0x93, 0x4c, 0x0b,
+	0x56, 0xc4, 0x95, 0x6a, 0x73, 0xc5, 0xa1, 0xaa, 0x0d, 0xe9, 0x32, 0x2d, 0xf2, 0x38, 0xe5, 0xd3,
+	0xf1, 0x6d, 0x12, 0x05, 0x65, 0x31, 0x51, 0x50, 0x8e, 0x60, 0x35, 0x25, 0xed, 0x5a, 0x7c, 0x75,
+	0x00, 0xab, 0x3a, 0x1d, 0x98, 0x2c, 0xbd, 0x85, 0x4b, 0x26, 0xbe, 0xf1, 0x46, 0xaf, 0xe7, 0x51,
+	0xdf, 0x17, 0x6a, 0x43, 0x52, 0xdb, 0x83, 0x5a, 0x5a, 0xcc, 0xd4, 0xfe, 0x6c, 0xc2, 0xca, 0x51,
+	0xbf, 0x6f, 0x99, 0x36, 0xfd, 0x27, 0x48, 0x9e, 0xc0, 0x6a, 0x4a, 0xca, 0xd4, 0x40, 0xbe, 0x57,
+	0x00, 0x30, 0xe3, 0x1f, 0xda, 0x7d, 0x27, 0x57, 0xbf, 0x0a, 0xf3, 0x43, 0x3a, 0xec, 0x50, 0xef,
+	0xb0, 0xc9, 0x77, 0xce, 0xe8, 0x11, 0xcd, 0x1e, 0x7c, 0xc3, 0x32, 0xa3, 0xb7, 0x0d, 0x09, 0xb6,
+	0xc3, 0xa5, 0xd4, 0x3b, 0xd1, 0x5b, 0x98, 0x1c, 0x17, 0xf4, 0x88, 0x66, 0x49, 0xa7, 0x6b, 0x99,
+	0xd4, 0x0e, 0xf8, 0x2c, 0x96, 0x04, 0x12, 0x47, 0xeb, 0x00, 0xa0, 0x31, 0x63, 0xf1, 0xb0, 0x04,
+	0xd8, 0xeb, 0x85, 0x2f, 0x2e, 0x1f, 0x33, 0x1c, 0x7e, 0x60, 0x0c, 0xc2, 0x6a, 0x04, 0x09, 0x29,
+	0xf1, 0xcd, 0x24, 0x5a, 0xb7, 0x0e, 0x54, 0x59, 0x6d, 0xd6, 0xa2, 0x46, 0x8f, 0x7a, 0xcf, 0xb9,
+	0x2d, 0xa1, 0x6b, 0x94, 0x38, 0xc4, 0xf2, 0x3a, 0x89, 0x7c, 0x7b, 0x43, 0x44, 0x33, 0x31, 0x22,
+	0xed, 0x05, 0xea, 0x40, 0xdf, 0x8e, 0xd5, 0xb1, 0x05, 0x73, 0xd8, 0x4b, 0xe3, 0x2b, 0x56, 0xd9,
+	0x5d, 0x62, 0x61, 0x1c, 0x1f, 0x88, 0x1e, 0x4e, 0x87, 0xf2, 0xd0, 0x37, 0x93, 0xe4, 0x61, 0x1f,
+	0x9e, 0x90, 0x17, 0x3b, 0x54, 0x0f, 0xa7, 0xb5, 0x5f, 0x14, 0x98, 0x43, 0x31, 0x3e, 0xd9, 0x86,
+	0xb2, 0xc5, 0x7d, 0xc1, 0x45, 0x55, 0x76, 0x57, 0xd8, 0xa6, 0xb4, 0x87, 0x9e, 0x15, 0x74, 0xb1,
+	0x8a, 0xad, 0x47, 0x58, 0xdc, 0x37, 0xd2, 0x7a, 0xd9, 0x5a, 0xb6, 0x1e, 0x57, 0xb1, 0xf5, 0xa8,
+	0x96, 0xbb, 0x4d, 0x5a, 0x2f, 0x5b, 0xc3, 0xd6, 0xe3, 0xaa, 0xbd, 0x79, 0x28, 0x63, 0x84, 0x69,
+	0x5f, 0xc0, 0x32, 0x97, 0xcb, 0x29, 0xa9, 0x4f, 0x15, 0xea, 0x45, 0x74, 0x0b, 0x35, 0xb5, 0x48,
+	0x8d, 0x78, 0xbc, 0x91, 0x62, 0x7c, 0x61, 0x1e, 0x9e, 0x9a, 0xa0, 0x34, 0x0a, 0x44, 0x16, 0x3e,
+	0x75, 0x0e, 0xfa, 0x3f, 0xcc, 0x21, 0xcc, 0x44, 0x3d, 0x29, 0x9c, 0xaa, 0x87, 0x73, 0xf7, 0x75,
+	0x98, 0x0f, 0xb3, 0x22, 0xb9, 0x05, 0x37, 0x0f, 0xed, 0x0b, 0xc3, 0x32, 0x7b, 0x21, 0xab, 0x5a,
+	0x20, 0x37, 0xa1, 0xc2, 0xff, 0x01, 0x90, 0x55, 0x55, 0x48, 0x15, 0x16, 0xb1, 0x81, 0x13, 0x9c,
+	0x22, 0x59, 0x02, 0x68, 0x07, 0x8e, 0x2b, 0xe8, 0xd2, 0xee, 0x9f, 0x15, 0x28, 0xa3, 0xb3, 0xc9,
+	0x2b, 0x58, 0x88, 0x7e, 0x11, 0x08, 0xf7, 0x6c, 0xfa, 0x5b, 0x42, 0x5d, 0x4d, 0x71, 0xd1, 0x52,
+	0xed, 0xee, 0x77, 0xbf, 0xfe, 0xf1, 0x53, 0x71, 0x5d, 0x5b, 0xd9, 0x31, 0x5c, 0xd3, 0xdf, 0xb9,
+	0x78, 0x60, 0x58, 0xee, 0xa9, 0xf1, 0x60, 0x87, 0x3d, 0x18, 0xfe, 0x23, 0xe5, 0x3e, 0xe9, 0x43,
+	0x45, 0x6a, 0x8e, 0x09, 0xef, 0x43, 0xb2, 0xed, 0xb8, 0xba, 0x96, 0xe1, 0x0b, 0x05, 0xf7, 0xb8,
+	0x82, 0x4d, 0xf5, 0x76, 0x9e, 0x82, 0x9d, 0xaf, 0xd9, 0x8d, 0xfa, 0x86, 0xe9, 0x79, 0x0c, 0x10,
+	0x37, 0xac, 0x84, 0xa3, 0xcd, 0xf4, 0xc0, 0x6a, 0x2d, 0xcd, 0x16, 0x4a, 0x0a, 0xc4, 0x82, 0x8a,
+	0xd4, 0xdb, 0x11, 0x35, 0xd5, 0xec, 0x49, 0xdd, 0x9c, 0x7a, 0x3b, 0x77, 0x4e, 0x48, 0xfa, 0x1f,
+	0x87, 0xdb, 0x20, 0x1b, 0x29, 0xb8, 0x3e, 0x5f, 0x2a, 0xf0, 0x92, 0x03, 0x80, 0xb8, 0x17, 0x23,
+	0xeb, 0xc9, 0xde, 0x4c, 0xd6, 0xa5, 0xe6, 0x4d, 0x45, 0xa0, 0xf7, 0x61, 0x51, 0x6e, 0x66, 0x08,
+	0x77, 0x62, 0x4e, 0x17, 0xa7, 0xd6, 0xb3, 0x13, 0x91, 0x90, 0xa7, 0x70, 0x23, 0xd1, 0x3e, 0x10,
+	0xbe, 0x38, 0xaf, 0x7f, 0x51, 0xd7, 0x73, 0x66, 0x22, 0x39, 0x27, 0xe1, 0x8f, 0x81, 0xfc, 0xc3,
+	0x43, 0xee, 0xc4, 0x1e, 0xcf, 0xf9, 0x2e, 0x52, 0x1b, 0xe3, 0xa6, 0x23, 0xb1, 0xaf, 0x60, 0x6d,
+	0xcc, 0xa7, 0x1b, 0xd1, 0xe2, 0xcd, 0xe3, 0x7e, 0xe4, 0xd4, 0xb1, 0x4f, 0xba, 0x56, 0x60, 0x21,
+	0x13, 0xd7, 0x9f, 0x18, 0x32, 0x99, 0xca, 0x1a, 0x43, 0x26, 0x5b, 0xa6, 0x6a, 0x05, 0xd2, 0x83,
+	0xb5, 0x31, 0x8d, 0x0f, 0x22, 0x9b, 0xdc, 0x51, 0xa9, 0xff, 0x9d, 0xb8, 0x46, 0xb2, 0xbf, 0x96,
+	0x6d, 0x44, 0x78, 0x8c, 0xdf, 0x91, 0xae, 0x4c, 0xb6, 0x9a, 0x45, 0xd7, 0x8e, 0xef, 0x61, 0xb4,
+	0x02, 0x39, 0x82, 0x6a, 0xba, 0xe2, 0x24, 0x3c, 0xb8, 0xc7, 0x14, 0xc8, 0xea, 0x46, 0xfe, 0xa4,
+	0x24, 0x90, 0x64, 0xff, 0x64, 0x11, 0xe7, 0xd8, 0xbf, 0xda, 0x89, 0x27, 0xf4, 0x08, 0x16, 0xa2,
+	0x8a, 0x13, 0xf3, 0x52, 0xba, 0x50, 0xc5, 0xbc, 0x94, 0x29, 0x4b, 0x31, 0xae, 0x13, 0x05, 0x22,
+	0xc6, 0x75, 0x5e, 0x05, 0x8a, 0x71, 0x9d, 0x5b, 0x4d, 0x6a, 0x05, 0x72, 0x08, 0x4b, 0xc9, 0x52,
+	0x0d, 0xef, 0x6b, 0x6e, 0x15, 0x88, 0xf7, 0x35, 0xbf, 0xb2, 0x13, 0x90, 0xe4, 0x5a, 0x4b, 0x40,
+	0xca, 0x29, 0xe2, 0x04, 0xa4, 0xbc, 0xc2, 0x0c, 0x03, 0x37, 0x7e, 0x74, 0x30, 0x70, 0x33, 0x2f,
+	0x1c, 0x06, 0x6e, 0xf6, 0x6d, 0xd2, 0x0a, 0x7b, 0xf5, 0x37, 0xef, 0x1a, 0xca, 0xdb, 0x77, 0x0d,
+	0xe5, 0xf7, 0x77, 0x0d, 0xe5, 0xc7, 0xf7, 0x8d, 0xc2, 0xdb, 0xf7, 0x8d, 0xc2, 0x6f, 0xef, 0x1b,
+	0x85, 0x4e, 0x99, 0xff, 0xad, 0x3f, 0xfc, 0x2b, 0x00, 0x00, 0xff, 0xff, 0x89, 0x73, 0xb9, 0x84,
+	0x9f, 0x17, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -2743,12 +2859,8 @@ type MasterClient interface {
 	RegisterWorker(ctx context.Context, in *RegisterWorkerRequest, opts ...grpc.CallOption) (*RegisterWorkerResponse, error)
 	// OfflineWorker offline the dm-workers.
 	OfflineWorker(ctx context.Context, in *OfflineWorkerRequest, opts ...grpc.CallOption) (*OfflineWorkerResponse, error)
-	// ListMember list member master information
-	ListMemberMaster(ctx context.Context, in *ListMemberRequest, opts ...grpc.CallOption) (*ListMemberMasterResponse, error)
-	// ListMember list member worker information
-	ListMemberWorker(ctx context.Context, in *ListMemberRequest, opts ...grpc.CallOption) (*ListMemberWorkerResponse, error)
-	// ListMember list member leader information
-	ListMemberLeader(ctx context.Context, in *ListMemberRequest, opts ...grpc.CallOption) (*ListMemberLeaderResponse, error)
+	// ListMember list member information
+	ListMember(ctx context.Context, in *ListMemberRequest, opts ...grpc.CallOption) (*ListMemberResponse, error)
 }
 
 type masterClient struct {
@@ -2921,27 +3033,9 @@ func (c *masterClient) OfflineWorker(ctx context.Context, in *OfflineWorkerReque
 	return out, nil
 }
 
-func (c *masterClient) ListMemberMaster(ctx context.Context, in *ListMemberRequest, opts ...grpc.CallOption) (*ListMemberMasterResponse, error) {
-	out := new(ListMemberMasterResponse)
-	err := c.cc.Invoke(ctx, "/pb.Master/ListMemberMaster", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func (c *masterClient) ListMemberWorker(ctx context.Context, in *ListMemberRequest, opts ...grpc.CallOption) (*ListMemberWorkerResponse, error) {
-	out := new(ListMemberWorkerResponse)
-	err := c.cc.Invoke(ctx, "/pb.Master/ListMemberWorker", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func (c *masterClient) ListMemberLeader(ctx context.Context, in *ListMemberRequest, opts ...grpc.CallOption) (*ListMemberLeaderResponse, error) {
-	out := new(ListMemberLeaderResponse)
-	err := c.cc.Invoke(ctx, "/pb.Master/ListMemberLeader", in, out, opts...)
+func (c *masterClient) ListMember(ctx context.Context, in *ListMemberRequest, opts ...grpc.CallOption) (*ListMemberResponse, error) {
+	out := new(ListMemberResponse)
+	err := c.cc.Invoke(ctx, "/pb.Master/ListMember", in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
@@ -2978,12 +3072,8 @@ type MasterServer interface {
 	RegisterWorker(context.Context, *RegisterWorkerRequest) (*RegisterWorkerResponse, error)
 	// OfflineWorker offline the dm-workers.
 	OfflineWorker(context.Context, *OfflineWorkerRequest) (*OfflineWorkerResponse, error)
-	// ListMember list member master information
-	ListMemberMaster(context.Context, *ListMemberRequest) (*ListMemberMasterResponse, error)
-	// ListMember list member worker information
-	ListMemberWorker(context.Context, *ListMemberRequest) (*ListMemberWorkerResponse, error)
-	// ListMember list member leader information
-	ListMemberLeader(context.Context, *ListMemberRequest) (*ListMemberLeaderResponse, error)
+	// ListMember list member information
+	ListMember(context.Context, *ListMemberRequest) (*ListMemberResponse, error)
 }
 
 // UnimplementedMasterServer can be embedded to have forward compatible implementations.
@@ -3044,14 +3134,8 @@ func (*UnimplementedMasterServer) RegisterWorker(ctx context.Context, req *Regis
 func (*UnimplementedMasterServer) OfflineWorker(ctx context.Context, req *OfflineWorkerRequest) (*OfflineWorkerResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method OfflineWorker not implemented")
 }
-func (*UnimplementedMasterServer) ListMemberMaster(ctx context.Context, req *ListMemberRequest) (*ListMemberMasterResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method ListMemberMaster not implemented")
-}
-func (*UnimplementedMasterServer) ListMemberWorker(ctx context.Context, req *ListMemberRequest) (*ListMemberWorkerResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method ListMemberWorker not implemented")
-}
-func (*UnimplementedMasterServer) ListMemberLeader(ctx context.Context, req *ListMemberRequest) (*ListMemberLeaderResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method ListMemberLeader not implemented")
+func (*UnimplementedMasterServer) ListMember(ctx context.Context, req *ListMemberRequest) (*ListMemberResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method ListMember not implemented")
 }
 
 func RegisterMasterServer(s *grpc.Server, srv MasterServer) {
@@ -3382,56 +3466,20 @@ func _Master_OfflineWorker_Handler(srv interface{}, ctx context.Context, dec fun
 	return interceptor(ctx, in, info, handler)
 }
 
-func _Master_ListMemberMaster_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(ListMemberRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(MasterServer).ListMemberMaster(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/pb.Master/ListMemberMaster",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(MasterServer).ListMemberMaster(ctx, req.(*ListMemberRequest))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-func _Master_ListMemberWorker_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(ListMemberRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(MasterServer).ListMemberWorker(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/pb.Master/ListMemberWorker",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(MasterServer).ListMemberWorker(ctx, req.(*ListMemberRequest))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-func _Master_ListMemberLeader_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+func _Master_ListMember_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(ListMemberRequest)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
-		return srv.(MasterServer).ListMemberLeader(ctx, in)
+		return srv.(MasterServer).ListMember(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/pb.Master/ListMemberLeader",
+		FullMethod: "/pb.Master/ListMember",
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(MasterServer).ListMemberLeader(ctx, req.(*ListMemberRequest))
+		return srv.(MasterServer).ListMember(ctx, req.(*ListMemberRequest))
 	}
 	return interceptor(ctx, in, info, handler)
 }
@@ -3513,16 +3561,8 @@ var _Master_serviceDesc = grpc.ServiceDesc{
 			Handler:    _Master_OfflineWorker_Handler,
 		},
 		{
-			MethodName: "ListMemberMaster",
-			Handler:    _Master_ListMemberMaster_Handler,
-		},
-		{
-			MethodName: "ListMemberWorker",
-			Handler:    _Master_ListMemberWorker_Handler,
-		},
-		{
-			MethodName: "ListMemberLeader",
-			Handler:    _Master_ListMemberLeader_Handler,
+			MethodName: "ListMember",
+			Handler:    _Master_ListMember_Handler,
 		},
 	},
 	Streams:  []grpc.StreamDesc{},
@@ -5164,7 +5204,7 @@ func (m *OfflineWorkerResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
-func (m *MemberMasterResponse) Marshal() (dAtA []byte, err error) {
+func (m *MasterInfo) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -5174,12 +5214,12 @@ func (m *MemberMasterResponse) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *MemberMasterResponse) MarshalTo(dAtA []byte) (int, error) {
+func (m *MasterInfo) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *MemberMasterResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *MasterInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
@@ -5227,7 +5267,7 @@ func (m *MemberMasterResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
-func (m *MemberWorkerResponse) Marshal() (dAtA []byte, err error) {
+func (m *WorkerInfo) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -5237,12 +5277,12 @@ func (m *MemberWorkerResponse) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *MemberWorkerResponse) MarshalTo(dAtA []byte) (int, error) {
+func (m *WorkerInfo) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *MemberWorkerResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *WorkerInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
@@ -5278,7 +5318,7 @@ func (m *MemberWorkerResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
-func (m *ListMemberRequest) Marshal() (dAtA []byte, err error) {
+func (m *ListLeaderMember) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -5288,20 +5328,51 @@ func (m *ListMemberRequest) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *ListMemberRequest) MarshalTo(dAtA []byte) (int, error) {
+func (m *ListLeaderMember) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *ListMemberRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *ListLeaderMember) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
+	if len(m.Addr) > 0 {
+		i -= len(m.Addr)
+		copy(dAtA[i:], m.Addr)
+		i = encodeVarintDmmaster(dAtA, i, uint64(len(m.Addr)))
+		i--
+		dAtA[i] = 0x22
+	}
+	if m.Alive {
+		i--
+		if m.Alive {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i--
+		dAtA[i] = 0x18
+	}
+	if len(m.Name) > 0 {
+		i -= len(m.Name)
+		copy(dAtA[i:], m.Name)
+		i = encodeVarintDmmaster(dAtA, i, uint64(len(m.Name)))
+		i--
+		dAtA[i] = 0x12
+	}
+	if len(m.Msg) > 0 {
+		i -= len(m.Msg)
+		copy(dAtA[i:], m.Msg)
+		i = encodeVarintDmmaster(dAtA, i, uint64(len(m.Msg)))
+		i--
+		dAtA[i] = 0xa
+	}
 	return len(dAtA) - i, nil
 }
 
-func (m *ListMemberMasterResponse) Marshal() (dAtA []byte, err error) {
+func (m *ListMasterMember) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -5311,20 +5382,20 @@ func (m *ListMemberMasterResponse) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *ListMemberMasterResponse) MarshalTo(dAtA []byte) (int, error) {
+func (m *ListMasterMember) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *ListMemberMasterResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *ListMasterMember) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if len(m.Members) > 0 {
-		for iNdEx := len(m.Members) - 1; iNdEx >= 0; iNdEx-- {
+	if len(m.Masters) > 0 {
+		for iNdEx := len(m.Masters) - 1; iNdEx >= 0; iNdEx-- {
 			{
-				size, err := m.Members[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				size, err := m.Masters[iNdEx].MarshalToSizedBuffer(dAtA[:i])
 				if err != nil {
 					return 0, err
 				}
@@ -5332,7 +5403,7 @@ func (m *ListMemberMasterResponse) MarshalToSizedBuffer(dAtA []byte) (int, error
 				i = encodeVarintDmmaster(dAtA, i, uint64(size))
 			}
 			i--
-			dAtA[i] = 0x1a
+			dAtA[i] = 0x12
 		}
 	}
 	if len(m.Msg) > 0 {
@@ -5340,22 +5411,12 @@ func (m *ListMemberMasterResponse) MarshalToSizedBuffer(dAtA []byte) (int, error
 		copy(dAtA[i:], m.Msg)
 		i = encodeVarintDmmaster(dAtA, i, uint64(len(m.Msg)))
 		i--
-		dAtA[i] = 0x12
-	}
-	if m.Result {
-		i--
-		if m.Result {
-			dAtA[i] = 1
-		} else {
-			dAtA[i] = 0
-		}
-		i--
-		dAtA[i] = 0x8
+		dAtA[i] = 0xa
 	}
 	return len(dAtA) - i, nil
 }
 
-func (m *ListMemberLeaderResponse) Marshal() (dAtA []byte, err error) {
+func (m *ListWorkerMember) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -5365,66 +5426,178 @@ func (m *ListMemberLeaderResponse) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *ListMemberLeaderResponse) MarshalTo(dAtA []byte) (int, error) {
+func (m *ListWorkerMember) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *ListMemberLeaderResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *ListWorkerMember) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if len(m.ClientURLs) > 0 {
-		for iNdEx := len(m.ClientURLs) - 1; iNdEx >= 0; iNdEx-- {
-			i -= len(m.ClientURLs[iNdEx])
-			copy(dAtA[i:], m.ClientURLs[iNdEx])
-			i = encodeVarintDmmaster(dAtA, i, uint64(len(m.ClientURLs[iNdEx])))
+	if len(m.Workers) > 0 {
+		for iNdEx := len(m.Workers) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.Workers[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintDmmaster(dAtA, i, uint64(size))
+			}
 			i--
-			dAtA[i] = 0x3a
+			dAtA[i] = 0x12
 		}
 	}
-	if len(m.PeerURLs) > 0 {
-		for iNdEx := len(m.PeerURLs) - 1; iNdEx >= 0; iNdEx-- {
-			i -= len(m.PeerURLs[iNdEx])
-			copy(dAtA[i:], m.PeerURLs[iNdEx])
-			i = encodeVarintDmmaster(dAtA, i, uint64(len(m.PeerURLs[iNdEx])))
-			i--
-			dAtA[i] = 0x32
+	if len(m.Msg) > 0 {
+		i -= len(m.Msg)
+		copy(dAtA[i:], m.Msg)
+		i = encodeVarintDmmaster(dAtA, i, uint64(len(m.Msg)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *Members) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *Members) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Members) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.Member != nil {
+		{
+			size := m.Member.Size()
+			i -= size
+			if _, err := m.Member.MarshalTo(dAtA[i:]); err != nil {
+				return 0, err
+			}
 		}
 	}
-	if m.Alive {
-		i--
-		if m.Alive {
-			dAtA[i] = 1
-		} else {
-			dAtA[i] = 0
+	return len(dAtA) - i, nil
+}
+
+func (m *Members_Leader) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Members_Leader) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	if m.Leader != nil {
+		{
+			size, err := m.Leader.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintDmmaster(dAtA, i, uint64(size))
 		}
 		i--
-		dAtA[i] = 0x28
+		dAtA[i] = 0xa
 	}
-	if m.MemberID != 0 {
-		i = encodeVarintDmmaster(dAtA, i, uint64(m.MemberID))
+	return len(dAtA) - i, nil
+}
+func (m *Members_Master) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Members_Master) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	if m.Master != nil {
+		{
+			size, err := m.Master.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintDmmaster(dAtA, i, uint64(size))
+		}
 		i--
-		dAtA[i] = 0x20
+		dAtA[i] = 0x12
 	}
-	if len(m.Name) > 0 {
-		i -= len(m.Name)
-		copy(dAtA[i:], m.Name)
-		i = encodeVarintDmmaster(dAtA, i, uint64(len(m.Name)))
+	return len(dAtA) - i, nil
+}
+func (m *Members_Worker) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Members_Worker) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	if m.Worker != nil {
+		{
+			size, err := m.Worker.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintDmmaster(dAtA, i, uint64(size))
+		}
 		i--
 		dAtA[i] = 0x1a
 	}
-	if len(m.Msg) > 0 {
-		i -= len(m.Msg)
-		copy(dAtA[i:], m.Msg)
-		i = encodeVarintDmmaster(dAtA, i, uint64(len(m.Msg)))
+	return len(dAtA) - i, nil
+}
+func (m *ListMemberRequest) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *ListMemberRequest) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *ListMemberRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.Leader {
 		i--
-		dAtA[i] = 0x12
+		if m.Leader {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i--
+		dAtA[i] = 0x18
 	}
-	if m.Result {
+	if m.Worker {
 		i--
-		if m.Result {
+		if m.Worker {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i--
+		dAtA[i] = 0x10
+	}
+	if m.Master {
+		i--
+		if m.Master {
 			dAtA[i] = 1
 		} else {
 			dAtA[i] = 0
@@ -5435,7 +5608,7 @@ func (m *ListMemberLeaderResponse) MarshalToSizedBuffer(dAtA []byte) (int, error
 	return len(dAtA) - i, nil
 }
 
-func (m *ListMemberWorkerResponse) Marshal() (dAtA []byte, err error) {
+func (m *ListMemberResponse) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -5445,12 +5618,12 @@ func (m *ListMemberWorkerResponse) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *ListMemberWorkerResponse) MarshalTo(dAtA []byte) (int, error) {
+func (m *ListMemberResponse) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *ListMemberWorkerResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *ListMemberResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
@@ -6226,7 +6399,7 @@ func (m *OfflineWorkerResponse) Size() (n int) {
 	return n
 }
 
-func (m *MemberMasterResponse) Size() (n int) {
+func (m *MasterInfo) Size() (n int) {
 	if m == nil {
 		return 0
 	}
@@ -6257,7 +6430,7 @@ func (m *MemberMasterResponse) Size() (n int) {
 	return n
 }
 
-func (m *MemberWorkerResponse) Size() (n int) {
+func (m *WorkerInfo) Size() (n int) {
 	if m == nil {
 		return 0
 	}
@@ -6282,30 +6455,42 @@ func (m *MemberWorkerResponse) Size() (n int) {
 	return n
 }
 
-func (m *ListMemberRequest) Size() (n int) {
+func (m *ListLeaderMember) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
+	l = len(m.Msg)
+	if l > 0 {
+		n += 1 + l + sovDmmaster(uint64(l))
+	}
+	l = len(m.Name)
+	if l > 0 {
+		n += 1 + l + sovDmmaster(uint64(l))
+	}
+	if m.Alive {
+		n += 2
+	}
+	l = len(m.Addr)
+	if l > 0 {
+		n += 1 + l + sovDmmaster(uint64(l))
+	}
 	return n
 }
 
-func (m *ListMemberMasterResponse) Size() (n int) {
+func (m *ListMasterMember) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	if m.Result {
-		n += 2
-	}
 	l = len(m.Msg)
 	if l > 0 {
 		n += 1 + l + sovDmmaster(uint64(l))
 	}
-	if len(m.Members) > 0 {
-		for _, e := range m.Members {
+	if len(m.Masters) > 0 {
+		for _, e := range m.Masters {
 			l = e.Size()
 			n += 1 + l + sovDmmaster(uint64(l))
 		}
@@ -6313,45 +6498,92 @@ func (m *ListMemberMasterResponse) Size() (n int) {
 	return n
 }
 
-func (m *ListMemberLeaderResponse) Size() (n int) {
+func (m *ListWorkerMember) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	if m.Result {
-		n += 2
-	}
 	l = len(m.Msg)
 	if l > 0 {
 		n += 1 + l + sovDmmaster(uint64(l))
 	}
-	l = len(m.Name)
-	if l > 0 {
+	if len(m.Workers) > 0 {
+		for _, e := range m.Workers {
+			l = e.Size()
+			n += 1 + l + sovDmmaster(uint64(l))
+		}
+	}
+	return n
+}
+
+func (m *Members) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.Member != nil {
+		n += m.Member.Size()
+	}
+	return n
+}
+
+func (m *Members_Leader) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.Leader != nil {
+		l = m.Leader.Size()
 		n += 1 + l + sovDmmaster(uint64(l))
 	}
-	if m.MemberID != 0 {
-		n += 1 + sovDmmaster(uint64(m.MemberID))
+	return n
+}
+func (m *Members_Master) Size() (n int) {
+	if m == nil {
+		return 0
 	}
-	if m.Alive {
+	var l int
+	_ = l
+	if m.Master != nil {
+		l = m.Master.Size()
+		n += 1 + l + sovDmmaster(uint64(l))
+	}
+	return n
+}
+func (m *Members_Worker) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.Worker != nil {
+		l = m.Worker.Size()
+		n += 1 + l + sovDmmaster(uint64(l))
+	}
+	return n
+}
+func (m *ListMemberRequest) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.Master {
 		n += 2
 	}
-	if len(m.PeerURLs) > 0 {
-		for _, s := range m.PeerURLs {
-			l = len(s)
-			n += 1 + l + sovDmmaster(uint64(l))
-		}
+	if m.Worker {
+		n += 2
 	}
-	if len(m.ClientURLs) > 0 {
-		for _, s := range m.ClientURLs {
-			l = len(s)
-			n += 1 + l + sovDmmaster(uint64(l))
-		}
+	if m.Leader {
+		n += 2
 	}
 	return n
 }
 
-func (m *ListMemberWorkerResponse) Size() (n int) {
+func (m *ListMemberResponse) Size() (n int) {
 	if m == nil {
 		return 0
 	}
@@ -11030,7 +11262,7 @@ func (m *OfflineWorkerResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *MemberMasterResponse) Unmarshal(dAtA []byte) error {
+func (m *MasterInfo) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -11053,10 +11285,10 @@ func (m *MemberMasterResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: MemberMasterResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: MasterInfo: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: MemberMasterResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: MasterInfo: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
@@ -11218,7 +11450,7 @@ func (m *MemberMasterResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *MemberWorkerResponse) Unmarshal(dAtA []byte) error {
+func (m *WorkerInfo) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -11241,10 +11473,10 @@ func (m *MemberWorkerResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: MemberWorkerResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: WorkerInfo: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: MemberWorkerResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: WorkerInfo: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
@@ -11399,7 +11631,7 @@ func (m *MemberWorkerResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *ListMemberRequest) Unmarshal(dAtA []byte) error {
+func (m *ListLeaderMember) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -11422,19 +11654,135 @@ func (m *ListMemberRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: ListMemberRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: ListLeaderMember: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: ListMemberRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: ListLeaderMember: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
-		default:
-			iNdEx = preIndex
-			skippy, err := skipDmmaster(dAtA[iNdEx:])
-			if err != nil {
-				return err
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Msg", wireType)
 			}
-			if skippy < 0 {
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowDmmaster
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthDmmaster
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthDmmaster
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Msg = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowDmmaster
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthDmmaster
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthDmmaster
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Name = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Alive", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowDmmaster
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.Alive = bool(v != 0)
+		case 4:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Addr", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowDmmaster
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthDmmaster
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthDmmaster
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Addr = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipDmmaster(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
 				return ErrInvalidLengthDmmaster
 			}
 			if (iNdEx + skippy) < 0 {
@@ -11452,7 +11800,7 @@ func (m *ListMemberRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *ListMemberMasterResponse) Unmarshal(dAtA []byte) error {
+func (m *ListMasterMember) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -11475,17 +11823,17 @@ func (m *ListMemberMasterResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: ListMemberMasterResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: ListMasterMember: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: ListMemberMasterResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: ListMasterMember: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType)
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Msg", wireType)
 			}
-			var v int
+			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowDmmaster
@@ -11495,13 +11843,112 @@ func (m *ListMemberMasterResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				v |= int(b&0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			m.Result = bool(v != 0)
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthDmmaster
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthDmmaster
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Msg = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
 		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Masters", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowDmmaster
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthDmmaster
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthDmmaster
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Masters = append(m.Masters, &MasterInfo{})
+			if err := m.Masters[len(m.Masters)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipDmmaster(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthDmmaster
+			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthDmmaster
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *ListWorkerMember) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowDmmaster
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: ListWorkerMember: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: ListWorkerMember: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field Msg", wireType)
 			}
@@ -11533,9 +11980,9 @@ func (m *ListMemberMasterResponse) Unmarshal(dAtA []byte) error {
 			}
 			m.Msg = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
-		case 3:
+		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Members", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Workers", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -11562,8 +12009,8 @@ func (m *ListMemberMasterResponse) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Members = append(m.Members, &MemberMasterResponse{})
-			if err := m.Members[len(m.Members)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			m.Workers = append(m.Workers, &WorkerInfo{})
+			if err := m.Workers[len(m.Workers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
@@ -11591,7 +12038,7 @@ func (m *ListMemberMasterResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *ListMemberLeaderResponse) Unmarshal(dAtA []byte) error {
+func (m *Members) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -11614,17 +12061,17 @@ func (m *ListMemberLeaderResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: ListMemberLeaderResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: Members: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: ListMemberLeaderResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: Members: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType)
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Leader", wireType)
 			}
-			var v int
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowDmmaster
@@ -11634,17 +12081,32 @@ func (m *ListMemberLeaderResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				v |= int(b&0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			m.Result = bool(v != 0)
+			if msglen < 0 {
+				return ErrInvalidLengthDmmaster
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthDmmaster
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			v := &ListLeaderMember{}
+			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			m.Member = &Members_Leader{v}
+			iNdEx = postIndex
 		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Msg", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Master", wireType)
 			}
-			var stringLen uint64
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowDmmaster
@@ -11654,29 +12116,32 @@ func (m *ListMemberLeaderResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
+			if msglen < 0 {
 				return ErrInvalidLengthDmmaster
 			}
-			postIndex := iNdEx + intStringLen
+			postIndex := iNdEx + msglen
 			if postIndex < 0 {
 				return ErrInvalidLengthDmmaster
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Msg = string(dAtA[iNdEx:postIndex])
+			v := &ListMasterMember{}
+			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			m.Member = &Members_Master{v}
 			iNdEx = postIndex
 		case 3:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Worker", wireType)
 			}
-			var stringLen uint64
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowDmmaster
@@ -11686,46 +12151,83 @@ func (m *ListMemberLeaderResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
+			if msglen < 0 {
 				return ErrInvalidLengthDmmaster
 			}
-			postIndex := iNdEx + intStringLen
+			postIndex := iNdEx + msglen
 			if postIndex < 0 {
 				return ErrInvalidLengthDmmaster
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Name = string(dAtA[iNdEx:postIndex])
+			v := &ListWorkerMember{}
+			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			m.Member = &Members_Worker{v}
 			iNdEx = postIndex
-		case 4:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field MemberID", wireType)
+		default:
+			iNdEx = preIndex
+			skippy, err := skipDmmaster(dAtA[iNdEx:])
+			if err != nil {
+				return err
 			}
-			m.MemberID = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowDmmaster
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.MemberID |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
+			if skippy < 0 {
+				return ErrInvalidLengthDmmaster
 			}
-		case 5:
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthDmmaster
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *ListMemberRequest) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowDmmaster
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: ListMemberRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: ListMemberRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Alive", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Master", wireType)
 			}
 			var v int
 			for shift := uint(0); ; shift += 7 {
@@ -11742,12 +12244,12 @@ func (m *ListMemberLeaderResponse) Unmarshal(dAtA []byte) error {
 					break
 				}
 			}
-			m.Alive = bool(v != 0)
-		case 6:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field PeerURLs", wireType)
+			m.Master = bool(v != 0)
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Worker", wireType)
 			}
-			var stringLen uint64
+			var v int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowDmmaster
@@ -11757,29 +12259,17 @@ func (m *ListMemberLeaderResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				v |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthDmmaster
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthDmmaster
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.PeerURLs = append(m.PeerURLs, string(dAtA[iNdEx:postIndex]))
-			iNdEx = postIndex
-		case 7:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ClientURLs", wireType)
+			m.Worker = bool(v != 0)
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Leader", wireType)
 			}
-			var stringLen uint64
+			var v int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowDmmaster
@@ -11789,24 +12279,12 @@ func (m *ListMemberLeaderResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				v |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthDmmaster
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthDmmaster
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.ClientURLs = append(m.ClientURLs, string(dAtA[iNdEx:postIndex]))
-			iNdEx = postIndex
+			m.Leader = bool(v != 0)
 		default:
 			iNdEx = preIndex
 			skippy, err := skipDmmaster(dAtA[iNdEx:])
@@ -11831,7 +12309,7 @@ func (m *ListMemberLeaderResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *ListMemberWorkerResponse) Unmarshal(dAtA []byte) error {
+func (m *ListMemberResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -11854,10 +12332,10 @@ func (m *ListMemberWorkerResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: ListMemberWorkerResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: ListMemberResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: ListMemberWorkerResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: ListMemberResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
@@ -11941,7 +12419,7 @@ func (m *ListMemberWorkerResponse) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Members = append(m.Members, &MemberWorkerResponse{})
+			m.Members = append(m.Members, &Members{})
 			if err := m.Members[len(m.Members)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
diff --git a/dm/pbmock/dmmaster.go b/dm/pbmock/dmmaster.go
index b674235ea5..58941d2381 100644
--- a/dm/pbmock/dmmaster.go
+++ b/dm/pbmock/dmmaster.go
@@ -75,64 +75,24 @@ func (mr *MockMasterClientMockRecorder) HandleSQLs(arg0, arg1 interface{}, arg2
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleSQLs", reflect.TypeOf((*MockMasterClient)(nil).HandleSQLs), varargs...)
 }
 
-// ListMemberLeader mocks base method
-func (m *MockMasterClient) ListMemberLeader(arg0 context.Context, arg1 *pb.ListMemberRequest, arg2 ...grpc.CallOption) (*pb.ListMemberLeaderResponse, error) {
+// ListMember mocks base method
+func (m *MockMasterClient) ListMember(arg0 context.Context, arg1 *pb.ListMemberRequest, arg2 ...grpc.CallOption) (*pb.ListMemberResponse, error) {
 	m.ctrl.T.Helper()
 	varargs := []interface{}{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "ListMemberLeader", varargs...)
-	ret0, _ := ret[0].(*pb.ListMemberLeaderResponse)
+	ret := m.ctrl.Call(m, "ListMember", varargs...)
+	ret0, _ := ret[0].(*pb.ListMemberResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// ListMemberLeader indicates an expected call of ListMemberLeader
-func (mr *MockMasterClientMockRecorder) ListMemberLeader(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// ListMember indicates an expected call of ListMember
+func (mr *MockMasterClientMockRecorder) ListMember(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMemberLeader", reflect.TypeOf((*MockMasterClient)(nil).ListMemberLeader), varargs...)
-}
-
-// ListMemberMaster mocks base method
-func (m *MockMasterClient) ListMemberMaster(arg0 context.Context, arg1 *pb.ListMemberRequest, arg2 ...grpc.CallOption) (*pb.ListMemberMasterResponse, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ListMemberMaster", varargs...)
-	ret0, _ := ret[0].(*pb.ListMemberMasterResponse)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ListMemberMaster indicates an expected call of ListMemberMaster
-func (mr *MockMasterClientMockRecorder) ListMemberMaster(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMemberMaster", reflect.TypeOf((*MockMasterClient)(nil).ListMemberMaster), varargs...)
-}
-
-// ListMemberWorker mocks base method
-func (m *MockMasterClient) ListMemberWorker(arg0 context.Context, arg1 *pb.ListMemberRequest, arg2 ...grpc.CallOption) (*pb.ListMemberWorkerResponse, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ListMemberWorker", varargs...)
-	ret0, _ := ret[0].(*pb.ListMemberWorkerResponse)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ListMemberWorker indicates an expected call of ListMemberWorker
-func (mr *MockMasterClientMockRecorder) ListMemberWorker(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMemberWorker", reflect.TypeOf((*MockMasterClient)(nil).ListMemberWorker), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMember", reflect.TypeOf((*MockMasterClient)(nil).ListMember), varargs...)
 }
 
 // MigrateWorkerRelay mocks base method
@@ -508,49 +468,19 @@ func (mr *MockMasterServerMockRecorder) HandleSQLs(arg0, arg1 interface{}) *gomo
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleSQLs", reflect.TypeOf((*MockMasterServer)(nil).HandleSQLs), arg0, arg1)
 }
 
-// ListMemberLeader mocks base method
-func (m *MockMasterServer) ListMemberLeader(arg0 context.Context, arg1 *pb.ListMemberRequest) (*pb.ListMemberLeaderResponse, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ListMemberLeader", arg0, arg1)
-	ret0, _ := ret[0].(*pb.ListMemberLeaderResponse)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ListMemberLeader indicates an expected call of ListMemberLeader
-func (mr *MockMasterServerMockRecorder) ListMemberLeader(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMemberLeader", reflect.TypeOf((*MockMasterServer)(nil).ListMemberLeader), arg0, arg1)
-}
-
-// ListMemberMaster mocks base method
-func (m *MockMasterServer) ListMemberMaster(arg0 context.Context, arg1 *pb.ListMemberRequest) (*pb.ListMemberMasterResponse, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ListMemberMaster", arg0, arg1)
-	ret0, _ := ret[0].(*pb.ListMemberMasterResponse)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ListMemberMaster indicates an expected call of ListMemberMaster
-func (mr *MockMasterServerMockRecorder) ListMemberMaster(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMemberMaster", reflect.TypeOf((*MockMasterServer)(nil).ListMemberMaster), arg0, arg1)
-}
-
-// ListMemberWorker mocks base method
-func (m *MockMasterServer) ListMemberWorker(arg0 context.Context, arg1 *pb.ListMemberRequest) (*pb.ListMemberWorkerResponse, error) {
+// ListMember mocks base method
+func (m *MockMasterServer) ListMember(arg0 context.Context, arg1 *pb.ListMemberRequest) (*pb.ListMemberResponse, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ListMemberWorker", arg0, arg1)
-	ret0, _ := ret[0].(*pb.ListMemberWorkerResponse)
+	ret := m.ctrl.Call(m, "ListMember", arg0, arg1)
+	ret0, _ := ret[0].(*pb.ListMemberResponse)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
-// ListMemberWorker indicates an expected call of ListMemberWorker
-func (mr *MockMasterServerMockRecorder) ListMemberWorker(arg0, arg1 interface{}) *gomock.Call {
+// ListMember indicates an expected call of ListMember
+func (mr *MockMasterServerMockRecorder) ListMember(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMemberWorker", reflect.TypeOf((*MockMasterServer)(nil).ListMemberWorker), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMember", reflect.TypeOf((*MockMasterServer)(nil).ListMember), arg0, arg1)
 }
 
 // MigrateWorkerRelay mocks base method
diff --git a/dm/proto/dmmaster.proto b/dm/proto/dmmaster.proto
index a84e91615a..bd0a40d8e3 100644
--- a/dm/proto/dmmaster.proto
+++ b/dm/proto/dmmaster.proto
@@ -63,21 +63,8 @@ service Master {
     // OfflineWorker offline the dm-workers.
     rpc OfflineWorker(OfflineWorkerRequest) returns(OfflineWorkerResponse) {}
 
-    // ListMember list member master information
-    rpc ListMemberMaster(ListMemberRequest) returns(ListMemberMasterResponse) {}
-
-    // ListMember list member worker information
-    rpc ListMemberWorker(ListMemberRequest) returns(ListMemberWorkerResponse) {}
-
-    // ListMember list member leader information
-    rpc ListMemberLeader(ListMemberRequest) returns(ListMemberLeaderResponse) {}
-}
-
-enum MemberType {
-    InvalidType = 0;  // placeholder
-    MasterType = 1;
-    WorkerType = 2;
-    LeaderType = 3;
+    // ListMember list member information
+    rpc ListMember(ListMemberRequest) returns(ListMemberResponse) {}
 }
 
 message MigrateWorkerRelayRequest {
@@ -323,7 +310,7 @@ message OfflineWorkerResponse {
     string msg = 2;
 }
 
-message MemberMasterResponse {
+message MasterInfo {
     string name = 1;
     uint64 memberID = 2;
     bool alive = 3;
@@ -331,34 +318,46 @@ message MemberMasterResponse {
     repeated string clientURLs = 5;
 }
 
-message MemberWorkerResponse {
+message WorkerInfo {
     string name = 1;
     string addr = 2;
     string stage = 3;
     string source = 4;
 }
 
-message ListMemberRequest {
+message ListLeaderMember {
+    string msg = 1;
+    string name = 2;
+    bool alive = 3;
+    string addr = 4;
 }
 
-message ListMemberMasterResponse {
-    bool result = 1;
-    string msg = 2;
-    repeated MemberMasterResponse members = 3;
+message ListMasterMember {
+    string msg = 1;
+    repeated MasterInfo masters = 2;
 }
 
-message ListMemberLeaderResponse {
-    bool result = 1;
-    string msg = 2;
-    string name = 3;
-    uint64 memberID = 4;
-    bool alive = 5;
-    repeated string peerURLs = 6;
-    repeated string clientURLs = 7;
+message ListWorkerMember {
+    string msg = 1;
+    repeated WorkerInfo workers = 2;
+}
+
+message Members {
+    oneof member {
+        ListLeaderMember leader = 1;
+        ListMasterMember master = 2;
+        ListWorkerMember worker = 3;
+    }
+}
+
+message ListMemberRequest {
+    bool master = 1;
+    bool worker = 2;
+    bool leader = 3;
 }
 
-message ListMemberWorkerResponse {
+message ListMemberResponse {
     bool result = 1;
     string msg = 2;
-    repeated MemberWorkerResponse members = 3;
+    repeated Members members = 3;
 }
\ No newline at end of file
diff --git a/tests/_utils/get_leader b/tests/_utils/get_leader
index f0289355f5..c3a070496c 100755
--- a/tests/_utils/get_leader
+++ b/tests/_utils/get_leader
@@ -12,4 +12,4 @@ ts=$(date +"%s")
 dmctl_log=$workdir/dmctl.$ts.log
 pid=$$
 
-echo $($binary -test.coverprofile="$TEST_DIR/cov.$TEST_NAME.dmctl.$ts.$pid.out" DEVEL -master-addr=$master_addr list-member leader | grep name | gawk 'match($2,/"(.*)",/,a) {print a[1]}')
\ No newline at end of file
+echo $($binary -test.coverprofile="$TEST_DIR/cov.$TEST_NAME.dmctl.$ts.$pid.out" DEVEL -master-addr=$master_addr list-member --leader | grep name | gawk 'match($2,/"(.*)",/,a) {print a[1]}')
\ No newline at end of file
diff --git a/tests/ha_master/run.sh b/tests/ha_master/run.sh
index a4c0042047..99c03a6c04 100755
--- a/tests/ha_master/run.sh
+++ b/tests/ha_master/run.sh
@@ -38,7 +38,7 @@ function test_list_member() {
 
     # check list-member master
     run_dm_ctl $WORK_DIR "127.0.0.1:$MASTER_PORT" \
-        "list-member master" \
+        "list-member --master" \
         "\"alive\": true" 5
 
     # kill leader
@@ -63,7 +63,7 @@ function test_list_member() {
         fi
     done
     run_dm_ctl $WORK_DIR "127.0.0.1:$MASTER_PORT" \
-        "list-member master" \
+        "list-member --master" \
         "\"alive\": true" 4
     echo "kill leader" $leader
     ps aux | grep $leader |awk '{print $2}'|xargs kill || true
@@ -86,7 +86,7 @@ function test_list_member() {
         fi
     done
     run_dm_ctl $WORK_DIR "127.0.0.1:$MASTER_PORT" \
-        "list-member master" \
+        "list-member --master" \
         "\"alive\": true" 3
     echo "kill leader" $leader
     ps aux | grep $leader |awk '{print $2}'|xargs kill || true
@@ -118,19 +118,19 @@ function test_list_member() {
         fi
     done
     run_dm_ctl $WORK_DIR "127.0.0.1:$MASTER_PORT" \
-        "list-member master" \
+        "list-member --master" \
         "\"alive\": true" 5
     
     # check list-member worker
     run_dm_ctl $WORK_DIR "127.0.0.1:$MASTER_PORT" \
-        "list-member worker" \
+        "list-member --worker" \
         "\"stage\": \"bound\"" 2
     
     dmctl_operate_source stop $WORK_DIR/source1.toml $SOURCE_ID1
     sleep 5
 
     run_dm_ctl $WORK_DIR "127.0.0.1:$MASTER_PORT" \
-        "list-member worker" \
+        "list-member --worker" \
         "\"stage\": \"bound\"" 1 \
         "\"stage\": \"free\"" 1
  
@@ -138,7 +138,7 @@ function test_list_member() {
     sleep 5
 
     run_dm_ctl $WORK_DIR "127.0.0.1:$MASTER_PORT" \
-        "list-member worker" \
+        "list-member --worker" \
         "\"stage\": \"free\"" 2
  
     dmctl_operate_source create $WORK_DIR/source1.toml $SOURCE_ID1
@@ -146,7 +146,7 @@ function test_list_member() {
     sleep 5
 
     run_dm_ctl $WORK_DIR "127.0.0.1:$MASTER_PORT" \
-        "list-member worker" \
+        "list-member" \
         "\"stage\": \"bound\"" 2
 
     # kill worker
@@ -156,7 +156,7 @@ function test_list_member() {
     sleep 5
 
     run_dm_ctl $WORK_DIR "127.0.0.1:$MASTER_PORT" \
-        "list-member worker" \
+        "list-member" \
         "\"stage\": \"bound\"" 1 \
         "\"stage\": \"offline\"" 1
 
@@ -167,7 +167,7 @@ function test_list_member() {
     sleep 5
 
     run_dm_ctl $WORK_DIR "127.0.0.1:$MASTER_PORT" \
-        "list-member worker" \
+        "list-member" \
         "\"stage\": \"offline\"" 2
 
     run_dm_worker $WORK_DIR/worker1 $WORKER1_PORT $cur/conf/dm-worker1.toml
@@ -177,7 +177,7 @@ function test_list_member() {
     sleep 5
 
     run_dm_ctl $WORK_DIR "127.0.0.1:$MASTER_PORT" \
-        "list-member worker" \
+        "list-member --worker" \
         "\"stage\": \"bound\"" 2
 
     echo "[$(date)] <<<<<< finish test_list_member_command >>>>>>"

From 608c3049eb3aa2d62e16dd173260b55aa310e8d2 Mon Sep 17 00:00:00 2001
From: gmhdbjd <gmhdbjd@gmail.com>
Date: Wed, 13 May 2020 18:16:47 +0800
Subject: [PATCH 09/17] add sleep

---
 tests/ha_master/run.sh | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/tests/ha_master/run.sh b/tests/ha_master/run.sh
index 99c03a6c04..47be923726 100755
--- a/tests/ha_master/run.sh
+++ b/tests/ha_master/run.sh
@@ -121,6 +121,8 @@ function test_list_member() {
         "list-member --master" \
         "\"alive\": true" 5
     
+    sleep 5
+    
     # check list-member worker
     run_dm_ctl $WORK_DIR "127.0.0.1:$MASTER_PORT" \
         "list-member --worker" \

From b0feea5d8ecb3875d2dc2b1d1245bfed3a8afae0 Mon Sep 17 00:00:00 2001
From: gmhdbjd <gmhdbjd@gmail.com>
Date: Thu, 14 May 2020 14:44:18 +0800
Subject: [PATCH 10/17] remove alive in listMemberLeader

---
 dm/master/server.go     |  11 --
 dm/pb/dmmaster.pb.go    | 251 +++++++++++++++++-----------------------
 dm/proto/dmmaster.proto |   3 +-
 3 files changed, 106 insertions(+), 159 deletions(-)

diff --git a/dm/master/server.go b/dm/master/server.go
index c9343ec722..f047b6d848 100644
--- a/dm/master/server.go
+++ b/dm/master/server.go
@@ -1629,19 +1629,8 @@ func (s *Server) listMemberLeader(ctx context.Context) (*pb.Members_Leader, erro
 		return resp, nil
 	}
 
-	client := http.Client{
-		Timeout: 1 * time.Second,
-	}
-
-	alive := true
-	_, err = client.Get("http://" + addr + "/health")
-	if err != nil {
-		alive = false
-	}
-
 	resp.Leader.Name = name
 	resp.Leader.Addr = addr
-	resp.Leader.Alive = alive
 	return resp, nil
 }
 
diff --git a/dm/pb/dmmaster.pb.go b/dm/pb/dmmaster.pb.go
index 17d7bdb32d..54899df4fd 100644
--- a/dm/pb/dmmaster.pb.go
+++ b/dm/pb/dmmaster.pb.go
@@ -2272,10 +2272,9 @@ func (m *WorkerInfo) GetSource() string {
 }
 
 type ListLeaderMember struct {
-	Msg   string `protobuf:"bytes,1,opt,name=msg,proto3" json:"msg,omitempty"`
-	Name  string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
-	Alive bool   `protobuf:"varint,3,opt,name=alive,proto3" json:"alive,omitempty"`
-	Addr  string `protobuf:"bytes,4,opt,name=addr,proto3" json:"addr,omitempty"`
+	Msg  string `protobuf:"bytes,1,opt,name=msg,proto3" json:"msg,omitempty"`
+	Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
+	Addr string `protobuf:"bytes,3,opt,name=addr,proto3" json:"addr,omitempty"`
 }
 
 func (m *ListLeaderMember) Reset()         { *m = ListLeaderMember{} }
@@ -2325,13 +2324,6 @@ func (m *ListLeaderMember) GetName() string {
 	return ""
 }
 
-func (m *ListLeaderMember) GetAlive() bool {
-	if m != nil {
-		return m.Alive
-	}
-	return false
-}
-
 func (m *ListLeaderMember) GetAddr() string {
 	if m != nil {
 		return m.Addr
@@ -2711,112 +2703,112 @@ func init() {
 func init() { proto.RegisterFile("dmmaster.proto", fileDescriptor_f9bef11f2a341f03) }
 
 var fileDescriptor_f9bef11f2a341f03 = []byte{
-	// 1668 bytes of a gzipped FileDescriptorProto
+	// 1665 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x58, 0x4f, 0x6f, 0xdb, 0xc6,
 	0x12, 0x17, 0x25, 0x5b, 0xb6, 0x47, 0x8e, 0x23, 0x6f, 0x6c, 0x59, 0x66, 0x1c, 0xc5, 0x8f, 0xef,
 	0xbd, 0xc0, 0xc8, 0xc1, 0x6e, 0x9c, 0x5b, 0x80, 0x00, 0x8d, 0x2d, 0x07, 0x31, 0xa0, 0xc4, 0x0e,
-	0x55, 0xa3, 0x08, 0x0a, 0x14, 0xa0, 0xa4, 0x95, 0x4c, 0x98, 0x22, 0x69, 0x92, 0xb2, 0x6b, 0x14,
+	0x55, 0xa3, 0x08, 0x0a, 0x14, 0xa0, 0xc5, 0xb5, 0x4c, 0x98, 0x22, 0x69, 0x92, 0xb2, 0x6b, 0x14,
 	0x45, 0x81, 0x7e, 0x80, 0xb6, 0x40, 0x0f, 0x39, 0xf6, 0xd0, 0x2f, 0x93, 0x63, 0x80, 0x5e, 0x7a,
 	0x2c, 0x92, 0x7e, 0x86, 0x9e, 0x8b, 0xdd, 0x59, 0x92, 0xcb, 0x3f, 0x52, 0xa3, 0x14, 0xf5, 0x6d,
-	0x67, 0x76, 0x77, 0xe6, 0x37, 0xb3, 0xb3, 0xb3, 0x33, 0x0b, 0x4b, 0xbd, 0xe1, 0xd0, 0xf0, 0x03,
-	0xea, 0x6d, 0xbb, 0x9e, 0x13, 0x38, 0xa4, 0xe8, 0x76, 0xd4, 0xa5, 0xde, 0xf0, 0xd2, 0xf1, 0xce,
-	0x42, 0x9e, 0xba, 0x31, 0x70, 0x9c, 0x81, 0x45, 0x77, 0x0c, 0xd7, 0xdc, 0x31, 0x6c, 0xdb, 0x09,
-	0x8c, 0xc0, 0x74, 0x6c, 0x1f, 0x67, 0xb5, 0x73, 0x58, 0x7f, 0x6e, 0x0e, 0x3c, 0x23, 0xa0, 0x9f,
-	0xf3, 0x4d, 0x3a, 0xb5, 0x8c, 0x2b, 0x9d, 0x9e, 0x8f, 0xa8, 0x1f, 0x90, 0x06, 0xc0, 0x9e, 0x69,
-	0x5b, 0xce, 0xe0, 0x85, 0x31, 0xa4, 0x75, 0x65, 0x53, 0xd9, 0x5a, 0xd0, 0x25, 0x0e, 0xd9, 0x80,
-	0x05, 0xa4, 0x8e, 0x1d, 0xbf, 0x5e, 0xdc, 0x54, 0xb6, 0x6e, 0xe8, 0x31, 0x83, 0xd4, 0xa0, 0xec,
-	0x3b, 0x23, 0xaf, 0x4b, 0xeb, 0x25, 0xbe, 0x53, 0x50, 0xda, 0x31, 0x34, 0x4e, 0xdc, 0x5e, 0x52,
-	0xe3, 0xbe, 0x63, 0xf7, 0xcd, 0x41, 0xa8, 0xb7, 0x06, 0xe5, 0x2e, 0x67, 0x08, 0x9d, 0x82, 0x92,
-	0x24, 0x16, 0x13, 0x12, 0x3f, 0x85, 0x6a, 0x3b, 0x30, 0xbc, 0xe0, 0x33, 0xc3, 0x3f, 0x0b, 0x65,
-	0x10, 0x98, 0x09, 0x0c, 0xff, 0x4c, 0x48, 0xe0, 0x63, 0x52, 0x87, 0x39, 0xdc, 0xc1, 0xd0, 0x96,
-	0xb6, 0x16, 0xf4, 0x90, 0xd4, 0xce, 0x61, 0x59, 0x92, 0xe0, 0xbb, 0x8e, 0xed, 0x53, 0xa6, 0xce,
-	0xa3, 0xfe, 0xc8, 0x0a, 0xb8, 0x90, 0x79, 0x5d, 0x50, 0xa4, 0x0a, 0xa5, 0xa1, 0x3f, 0x10, 0x18,
-	0xd8, 0x90, 0xec, 0xc6, 0x82, 0x4b, 0x9b, 0xa5, 0xad, 0xca, 0x6e, 0x7d, 0xdb, 0xed, 0x6c, 0xef,
-	0x3b, 0xc3, 0xa1, 0x63, 0x87, 0x56, 0xa2, 0xd0, 0x58, 0xe5, 0x43, 0x58, 0x47, 0x37, 0x3c, 0xe7,
-	0x27, 0xf8, 0x41, 0x1e, 0xd0, 0xae, 0x40, 0xcd, 0xdb, 0x34, 0x35, 0xe0, 0x07, 0x69, 0xc0, 0x6b,
-	0x0c, 0xf0, 0xcb, 0x11, 0xf5, 0xae, 0xda, 0x81, 0x11, 0x8c, 0xfc, 0x2c, 0xde, 0x2f, 0x81, 0x1c,
-	0xb9, 0x94, 0x45, 0x8a, 0xec, 0x66, 0x15, 0x8a, 0x8e, 0xcb, 0xd5, 0x2d, 0xed, 0x02, 0x93, 0xc1,
-	0x26, 0x8f, 0x5c, 0xbd, 0xe8, 0xb8, 0xec, 0x08, 0x6c, 0x16, 0x38, 0xa8, 0x97, 0x8f, 0xe5, 0x23,
-	0x28, 0x25, 0x8f, 0xe0, 0x07, 0x05, 0x6e, 0x25, 0x14, 0x08, 0xa3, 0x26, 0x69, 0x88, 0x0d, 0x2e,
-	0xe6, 0x19, 0x5c, 0xca, 0x3d, 0xa1, 0x99, 0x0f, 0x3d, 0xa1, 0x27, 0xb0, 0x8c, 0xce, 0xfe, 0xf8,
-	0xb8, 0xf2, 0x80, 0xc8, 0x22, 0xae, 0x25, 0xb0, 0x9e, 0x42, 0x4d, 0x3a, 0xc8, 0x96, 0xe9, 0x07,
-	0x12, 0x76, 0x3b, 0xbe, 0xc9, 0x99, 0x03, 0x49, 0x61, 0xbf, 0x80, 0xb5, 0x8c, 0x9c, 0xeb, 0x08,
-	0xb4, 0x03, 0x58, 0xe5, 0xf3, 0x07, 0x9e, 0xe7, 0x78, 0x1f, 0x0f, 0x3f, 0x10, 0x6e, 0x90, 0xc4,
-	0x4c, 0x8d, 0xfe, 0x93, 0x34, 0xfa, 0x5a, 0x84, 0x9e, 0x8b, 0xcd, 0x82, 0xdf, 0x87, 0x5b, 0xed,
-	0x53, 0xe7, 0xb2, 0xd9, 0x6c, 0xb5, 0x9c, 0xee, 0x99, 0xff, 0x71, 0x51, 0xf3, 0xb3, 0x02, 0x73,
-	0x42, 0x02, 0x59, 0x82, 0xe2, 0x61, 0x53, 0xec, 0x2b, 0x1e, 0x36, 0x23, 0x49, 0x45, 0x49, 0x12,
-	0x81, 0x99, 0xa1, 0xd3, 0x0b, 0xf3, 0x2c, 0x1f, 0x93, 0x15, 0x98, 0x75, 0x2e, 0x6d, 0xea, 0xd5,
-	0x67, 0x38, 0x13, 0x09, 0xb6, 0xb2, 0xd9, 0x6c, 0xf9, 0xf5, 0x59, 0xae, 0x90, 0x8f, 0x79, 0x56,
-	0xbd, 0xb2, 0xbb, 0xb4, 0x57, 0x2f, 0x73, 0xae, 0xa0, 0x88, 0x0a, 0xf3, 0x23, 0x5b, 0xcc, 0xcc,
-	0xf1, 0x99, 0x88, 0xd6, 0xba, 0xb0, 0x92, 0x34, 0x73, 0x6a, 0xd7, 0xfe, 0x07, 0x66, 0x2d, 0xb6,
-	0x55, 0x38, 0xb6, 0xc2, 0x1c, 0x2b, 0xc4, 0xe9, 0x38, 0xa3, 0x59, 0xb0, 0x72, 0x62, 0xb3, 0x61,
-	0xc8, 0x17, 0xce, 0x4c, 0xbb, 0x44, 0x83, 0x45, 0x8f, 0xba, 0x96, 0xd1, 0xa5, 0x47, 0xdc, 0x62,
-	0xd4, 0x92, 0xe0, 0x91, 0x4d, 0xa8, 0xf4, 0x1d, 0xaf, 0x4b, 0x75, 0x3a, 0x74, 0x2e, 0xd0, 0x53,
-	0xf3, 0xba, 0xcc, 0xd2, 0x9e, 0xc0, 0x6a, 0x4a, 0xdb, 0xb4, 0x36, 0x69, 0x8f, 0xa0, 0xd1, 0xbe,
-	0x34, 0x83, 0xee, 0xa9, 0xf4, 0xb2, 0x61, 0xa2, 0x0e, 0xa1, 0x4b, 0x67, 0xae, 0x24, 0xcf, 0xfc,
-	0x5b, 0xb8, 0x3b, 0x76, 0xef, 0xb5, 0xa4, 0x0d, 0x1d, 0xd6, 0x45, 0xfa, 0xcd, 0xa9, 0x04, 0x6e,
-	0x4b, 0x49, 0x98, 0x1f, 0x15, 0x9f, 0x15, 0x59, 0x78, 0x7c, 0x20, 0xbf, 0x56, 0x40, 0xcd, 0x13,
-	0x2a, 0x0c, 0x9a, 0x28, 0xf5, 0xdf, 0xcd, 0xed, 0x6f, 0x14, 0x58, 0x7e, 0x66, 0xd8, 0x3d, 0x8b,
-	0xb6, 0x5f, 0xb6, 0xfc, 0x49, 0x19, 0x66, 0x9d, 0x83, 0x2c, 0x72, 0x90, 0x0b, 0x4c, 0x70, 0xfb,
-	0x65, 0x2b, 0x7e, 0xe0, 0x0c, 0x6f, 0x10, 0xbe, 0x64, 0x7c, 0xcc, 0x6a, 0xa2, 0x4e, 0x54, 0x13,
-	0xe1, 0xdd, 0x8b, 0x19, 0x52, 0x05, 0x33, 0x2b, 0x57, 0x30, 0xac, 0xd2, 0xf2, 0xcf, 0xad, 0x63,
-	0x23, 0x08, 0xa8, 0x67, 0xd7, 0xcb, 0x58, 0x69, 0xc5, 0x1c, 0x76, 0x17, 0xfd, 0x53, 0xc3, 0xeb,
-	0x99, 0xf6, 0xa0, 0x3e, 0xc7, 0xdd, 0x11, 0xd1, 0xec, 0x8d, 0x91, 0x2d, 0xb9, 0x96, 0x60, 0x79,
-	0xad, 0xc0, 0xda, 0xf1, 0xc8, 0x1b, 0xe4, 0xc5, 0xca, 0xd8, 0x18, 0x67, 0x56, 0x98, 0xb6, 0xd1,
-	0x0d, 0xcc, 0x0b, 0x2a, 0x0e, 0x35, 0xa2, 0x79, 0x5e, 0x33, 0x87, 0x78, 0x33, 0x4b, 0x3a, 0x1f,
-	0xb3, 0xf5, 0x7d, 0xd3, 0xa2, 0xfc, 0x48, 0xd0, 0x95, 0x11, 0xcd, 0x3d, 0x39, 0xea, 0x34, 0x4d,
-	0x2f, 0xf2, 0x24, 0xa7, 0xb4, 0xaf, 0xa0, 0x9e, 0x05, 0x76, 0x2d, 0x3e, 0xb9, 0x07, 0xd5, 0xfd,
-	0x53, 0xda, 0x3d, 0xfb, 0x9b, 0x6a, 0x41, 0x7b, 0x0c, 0xcb, 0xd2, 0xba, 0xa9, 0x93, 0x4c, 0x0b,
-	0x56, 0xc4, 0x95, 0x6a, 0x73, 0xc5, 0xa1, 0xaa, 0x0d, 0xe9, 0x32, 0x2d, 0xf2, 0x38, 0xe5, 0xd3,
-	0xf1, 0x6d, 0x12, 0x05, 0x65, 0x31, 0x51, 0x50, 0x8e, 0x60, 0x35, 0x25, 0xed, 0x5a, 0x7c, 0x75,
-	0x00, 0xab, 0x3a, 0x1d, 0x98, 0x2c, 0xbd, 0x85, 0x4b, 0x26, 0xbe, 0xf1, 0x46, 0xaf, 0xe7, 0x51,
-	0xdf, 0x17, 0x6a, 0x43, 0x52, 0xdb, 0x83, 0x5a, 0x5a, 0xcc, 0xd4, 0xfe, 0x6c, 0xc2, 0xca, 0x51,
-	0xbf, 0x6f, 0x99, 0x36, 0xfd, 0x27, 0x48, 0x9e, 0xc0, 0x6a, 0x4a, 0xca, 0xd4, 0x40, 0xbe, 0x57,
-	0x00, 0x30, 0xe3, 0x1f, 0xda, 0x7d, 0x27, 0x57, 0xbf, 0x0a, 0xf3, 0x43, 0x3a, 0xec, 0x50, 0xef,
-	0xb0, 0xc9, 0x77, 0xce, 0xe8, 0x11, 0xcd, 0x1e, 0x7c, 0xc3, 0x32, 0xa3, 0xb7, 0x0d, 0x09, 0xb6,
-	0xc3, 0xa5, 0xd4, 0x3b, 0xd1, 0x5b, 0x98, 0x1c, 0x17, 0xf4, 0x88, 0x66, 0x49, 0xa7, 0x6b, 0x99,
-	0xd4, 0x0e, 0xf8, 0x2c, 0x96, 0x04, 0x12, 0x47, 0xeb, 0x00, 0xa0, 0x31, 0x63, 0xf1, 0xb0, 0x04,
-	0xd8, 0xeb, 0x85, 0x2f, 0x2e, 0x1f, 0x33, 0x1c, 0x7e, 0x60, 0x0c, 0xc2, 0x6a, 0x04, 0x09, 0x29,
-	0xf1, 0xcd, 0x24, 0x5a, 0xb7, 0x0e, 0x54, 0x59, 0x6d, 0xd6, 0xa2, 0x46, 0x8f, 0x7a, 0xcf, 0xb9,
-	0x2d, 0xa1, 0x6b, 0x94, 0x38, 0xc4, 0xf2, 0x3a, 0x89, 0x7c, 0x7b, 0x43, 0x44, 0x33, 0x31, 0x22,
-	0xed, 0x05, 0xea, 0x40, 0xdf, 0x8e, 0xd5, 0xb1, 0x05, 0x73, 0xd8, 0x4b, 0xe3, 0x2b, 0x56, 0xd9,
-	0x5d, 0x62, 0x61, 0x1c, 0x1f, 0x88, 0x1e, 0x4e, 0x87, 0xf2, 0xd0, 0x37, 0x93, 0xe4, 0x61, 0x1f,
-	0x9e, 0x90, 0x17, 0x3b, 0x54, 0x0f, 0xa7, 0xb5, 0x5f, 0x14, 0x98, 0x43, 0x31, 0x3e, 0xd9, 0x86,
-	0xb2, 0xc5, 0x7d, 0xc1, 0x45, 0x55, 0x76, 0x57, 0xd8, 0xa6, 0xb4, 0x87, 0x9e, 0x15, 0x74, 0xb1,
-	0x8a, 0xad, 0x47, 0x58, 0xdc, 0x37, 0xd2, 0x7a, 0xd9, 0x5a, 0xb6, 0x1e, 0x57, 0xb1, 0xf5, 0xa8,
-	0x96, 0xbb, 0x4d, 0x5a, 0x2f, 0x5b, 0xc3, 0xd6, 0xe3, 0xaa, 0xbd, 0x79, 0x28, 0x63, 0x84, 0x69,
-	0x5f, 0xc0, 0x32, 0x97, 0xcb, 0x29, 0xa9, 0x4f, 0x15, 0xea, 0x45, 0x74, 0x0b, 0x35, 0xb5, 0x48,
-	0x8d, 0x78, 0xbc, 0x91, 0x62, 0x7c, 0x61, 0x1e, 0x9e, 0x9a, 0xa0, 0x34, 0x0a, 0x44, 0x16, 0x3e,
-	0x75, 0x0e, 0xfa, 0x3f, 0xcc, 0x21, 0xcc, 0x44, 0x3d, 0x29, 0x9c, 0xaa, 0x87, 0x73, 0xf7, 0x75,
-	0x98, 0x0f, 0xb3, 0x22, 0xb9, 0x05, 0x37, 0x0f, 0xed, 0x0b, 0xc3, 0x32, 0x7b, 0x21, 0xab, 0x5a,
-	0x20, 0x37, 0xa1, 0xc2, 0xff, 0x01, 0x90, 0x55, 0x55, 0x48, 0x15, 0x16, 0xb1, 0x81, 0x13, 0x9c,
-	0x22, 0x59, 0x02, 0x68, 0x07, 0x8e, 0x2b, 0xe8, 0xd2, 0xee, 0x9f, 0x15, 0x28, 0xa3, 0xb3, 0xc9,
-	0x2b, 0x58, 0x88, 0x7e, 0x11, 0x08, 0xf7, 0x6c, 0xfa, 0x5b, 0x42, 0x5d, 0x4d, 0x71, 0xd1, 0x52,
-	0xed, 0xee, 0x77, 0xbf, 0xfe, 0xf1, 0x53, 0x71, 0x5d, 0x5b, 0xd9, 0x31, 0x5c, 0xd3, 0xdf, 0xb9,
-	0x78, 0x60, 0x58, 0xee, 0xa9, 0xf1, 0x60, 0x87, 0x3d, 0x18, 0xfe, 0x23, 0xe5, 0x3e, 0xe9, 0x43,
-	0x45, 0x6a, 0x8e, 0x09, 0xef, 0x43, 0xb2, 0xed, 0xb8, 0xba, 0x96, 0xe1, 0x0b, 0x05, 0xf7, 0xb8,
-	0x82, 0x4d, 0xf5, 0x76, 0x9e, 0x82, 0x9d, 0xaf, 0xd9, 0x8d, 0xfa, 0x86, 0xe9, 0x79, 0x0c, 0x10,
-	0x37, 0xac, 0x84, 0xa3, 0xcd, 0xf4, 0xc0, 0x6a, 0x2d, 0xcd, 0x16, 0x4a, 0x0a, 0xc4, 0x82, 0x8a,
-	0xd4, 0xdb, 0x11, 0x35, 0xd5, 0xec, 0x49, 0xdd, 0x9c, 0x7a, 0x3b, 0x77, 0x4e, 0x48, 0xfa, 0x1f,
-	0x87, 0xdb, 0x20, 0x1b, 0x29, 0xb8, 0x3e, 0x5f, 0x2a, 0xf0, 0x92, 0x03, 0x80, 0xb8, 0x17, 0x23,
-	0xeb, 0xc9, 0xde, 0x4c, 0xd6, 0xa5, 0xe6, 0x4d, 0x45, 0xa0, 0xf7, 0x61, 0x51, 0x6e, 0x66, 0x08,
-	0x77, 0x62, 0x4e, 0x17, 0xa7, 0xd6, 0xb3, 0x13, 0x91, 0x90, 0xa7, 0x70, 0x23, 0xd1, 0x3e, 0x10,
-	0xbe, 0x38, 0xaf, 0x7f, 0x51, 0xd7, 0x73, 0x66, 0x22, 0x39, 0x27, 0xe1, 0x8f, 0x81, 0xfc, 0xc3,
-	0x43, 0xee, 0xc4, 0x1e, 0xcf, 0xf9, 0x2e, 0x52, 0x1b, 0xe3, 0xa6, 0x23, 0xb1, 0xaf, 0x60, 0x6d,
-	0xcc, 0xa7, 0x1b, 0xd1, 0xe2, 0xcd, 0xe3, 0x7e, 0xe4, 0xd4, 0xb1, 0x4f, 0xba, 0x56, 0x60, 0x21,
-	0x13, 0xd7, 0x9f, 0x18, 0x32, 0x99, 0xca, 0x1a, 0x43, 0x26, 0x5b, 0xa6, 0x6a, 0x05, 0xd2, 0x83,
-	0xb5, 0x31, 0x8d, 0x0f, 0x22, 0x9b, 0xdc, 0x51, 0xa9, 0xff, 0x9d, 0xb8, 0x46, 0xb2, 0xbf, 0x96,
-	0x6d, 0x44, 0x78, 0x8c, 0xdf, 0x91, 0xae, 0x4c, 0xb6, 0x9a, 0x45, 0xd7, 0x8e, 0xef, 0x61, 0xb4,
-	0x02, 0x39, 0x82, 0x6a, 0xba, 0xe2, 0x24, 0x3c, 0xb8, 0xc7, 0x14, 0xc8, 0xea, 0x46, 0xfe, 0xa4,
-	0x24, 0x90, 0x64, 0xff, 0x64, 0x11, 0xe7, 0xd8, 0xbf, 0xda, 0x89, 0x27, 0xf4, 0x08, 0x16, 0xa2,
-	0x8a, 0x13, 0xf3, 0x52, 0xba, 0x50, 0xc5, 0xbc, 0x94, 0x29, 0x4b, 0x31, 0xae, 0x13, 0x05, 0x22,
-	0xc6, 0x75, 0x5e, 0x05, 0x8a, 0x71, 0x9d, 0x5b, 0x4d, 0x6a, 0x05, 0x72, 0x08, 0x4b, 0xc9, 0x52,
-	0x0d, 0xef, 0x6b, 0x6e, 0x15, 0x88, 0xf7, 0x35, 0xbf, 0xb2, 0x13, 0x90, 0xe4, 0x5a, 0x4b, 0x40,
-	0xca, 0x29, 0xe2, 0x04, 0xa4, 0xbc, 0xc2, 0x0c, 0x03, 0x37, 0x7e, 0x74, 0x30, 0x70, 0x33, 0x2f,
-	0x1c, 0x06, 0x6e, 0xf6, 0x6d, 0xd2, 0x0a, 0x7b, 0xf5, 0x37, 0xef, 0x1a, 0xca, 0xdb, 0x77, 0x0d,
-	0xe5, 0xf7, 0x77, 0x0d, 0xe5, 0xc7, 0xf7, 0x8d, 0xc2, 0xdb, 0xf7, 0x8d, 0xc2, 0x6f, 0xef, 0x1b,
-	0x85, 0x4e, 0x99, 0xff, 0xad, 0x3f, 0xfc, 0x2b, 0x00, 0x00, 0xff, 0xff, 0x89, 0x73, 0xb9, 0x84,
-	0x9f, 0x17, 0x00, 0x00,
+	0x67, 0x76, 0xf7, 0x37, 0x7f, 0x76, 0x76, 0x76, 0x66, 0x61, 0xc1, 0x1c, 0x0c, 0x8c, 0x20, 0xa4,
+	0xfe, 0xa6, 0xe7, 0xbb, 0xa1, 0x4b, 0xca, 0xde, 0xb1, 0xba, 0x60, 0x0e, 0x2e, 0x5d, 0xff, 0x2c,
+	0xe2, 0xa9, 0x6b, 0x7d, 0xd7, 0xed, 0xdb, 0x74, 0xcb, 0xf0, 0xac, 0x2d, 0xc3, 0x71, 0xdc, 0xd0,
+	0x08, 0x2d, 0xd7, 0x09, 0x70, 0x56, 0x3b, 0x87, 0xd5, 0xe7, 0x56, 0xdf, 0x37, 0x42, 0xfa, 0x39,
+	0xdf, 0xa4, 0x53, 0xdb, 0xb8, 0xd2, 0xe9, 0xf9, 0x90, 0x06, 0x21, 0x69, 0x01, 0xec, 0x58, 0x8e,
+	0xed, 0xf6, 0x5f, 0x18, 0x03, 0xda, 0x54, 0xd6, 0x95, 0x8d, 0x39, 0x5d, 0xe2, 0x90, 0x35, 0x98,
+	0x43, 0xea, 0xd0, 0x0d, 0x9a, 0xe5, 0x75, 0x65, 0xe3, 0x86, 0x9e, 0x30, 0x48, 0x03, 0xaa, 0x81,
+	0x3b, 0xf4, 0x7b, 0xb4, 0x59, 0xe1, 0x3b, 0x05, 0xa5, 0x1d, 0x42, 0xeb, 0xc8, 0x33, 0xd3, 0x12,
+	0x77, 0x5d, 0xe7, 0xc4, 0xea, 0x47, 0x72, 0x1b, 0x50, 0xed, 0x71, 0x86, 0x90, 0x29, 0x28, 0x09,
+	0xb1, 0x9c, 0x42, 0xfc, 0x14, 0xea, 0xdd, 0xd0, 0xf0, 0xc3, 0xcf, 0x8c, 0xe0, 0x2c, 0xc2, 0x20,
+	0x30, 0x15, 0x1a, 0xc1, 0x99, 0x40, 0xe0, 0x63, 0xd2, 0x84, 0x19, 0xdc, 0xc1, 0xb4, 0xad, 0x6c,
+	0xcc, 0xe9, 0x11, 0xa9, 0x9d, 0xc3, 0xa2, 0x84, 0x10, 0x78, 0xae, 0x13, 0x50, 0x26, 0xce, 0xa7,
+	0xc1, 0xd0, 0x0e, 0x39, 0xc8, 0xac, 0x2e, 0x28, 0x52, 0x87, 0xca, 0x20, 0xe8, 0x0b, 0x1d, 0xd8,
+	0x90, 0x6c, 0x27, 0xc0, 0x95, 0xf5, 0xca, 0x46, 0x6d, 0xbb, 0xb9, 0xe9, 0x1d, 0x6f, 0xee, 0xba,
+	0x83, 0x81, 0xeb, 0x44, 0x56, 0x22, 0x68, 0x22, 0xf2, 0x21, 0xac, 0xa2, 0x1b, 0x9e, 0xf3, 0x13,
+	0xfc, 0x20, 0x0f, 0x68, 0x57, 0xa0, 0x16, 0x6d, 0x9a, 0x58, 0xe1, 0x07, 0x59, 0x85, 0x57, 0x98,
+	0xc2, 0x2f, 0x87, 0xd4, 0xbf, 0xea, 0x86, 0x46, 0x38, 0x0c, 0xf2, 0xfa, 0x7e, 0x09, 0xe4, 0xc0,
+	0xa3, 0x2c, 0x52, 0x64, 0x37, 0xab, 0x50, 0x76, 0x3d, 0x2e, 0x6e, 0x61, 0x1b, 0x18, 0x06, 0x9b,
+	0x3c, 0xf0, 0xf4, 0xb2, 0xeb, 0xb1, 0x23, 0x70, 0x58, 0xe0, 0xa0, 0x5c, 0x3e, 0x96, 0x8f, 0xa0,
+	0x92, 0x3e, 0x82, 0x1f, 0x14, 0xb8, 0x95, 0x12, 0x20, 0x8c, 0x1a, 0x27, 0x21, 0x31, 0xb8, 0x5c,
+	0x64, 0x70, 0xa5, 0xf0, 0x84, 0xa6, 0x3e, 0xf4, 0x84, 0x9e, 0xc0, 0x22, 0x3a, 0xfb, 0xe3, 0xe3,
+	0xca, 0x07, 0x22, 0x43, 0x5c, 0x4b, 0x60, 0x3d, 0x85, 0x86, 0x74, 0x90, 0x1d, 0x2b, 0x08, 0x25,
+	0xdd, 0x9d, 0xe4, 0x26, 0xe7, 0x0e, 0x24, 0xa3, 0xfb, 0x05, 0xac, 0xe4, 0x70, 0xae, 0x23, 0xd0,
+	0xf6, 0x60, 0x99, 0xcf, 0xef, 0xf9, 0xbe, 0xeb, 0x7f, 0xbc, 0xfa, 0xa1, 0x70, 0x83, 0x04, 0x33,
+	0xb1, 0xf6, 0x9f, 0x64, 0xb5, 0x6f, 0xc4, 0xda, 0x73, 0xd8, 0xbc, 0xf2, 0xbb, 0x70, 0xab, 0x7b,
+	0xea, 0x5e, 0xb6, 0xdb, 0x9d, 0x8e, 0xdb, 0x3b, 0x0b, 0x3e, 0x2e, 0x6a, 0x7e, 0x56, 0x60, 0x46,
+	0x20, 0x90, 0x05, 0x28, 0xef, 0xb7, 0xc5, 0xbe, 0xf2, 0x7e, 0x3b, 0x46, 0x2a, 0x4b, 0x48, 0x04,
+	0xa6, 0x06, 0xae, 0x19, 0xe5, 0x59, 0x3e, 0x26, 0x4b, 0x30, 0xed, 0x5e, 0x3a, 0xd4, 0x6f, 0x4e,
+	0x71, 0x26, 0x12, 0x6c, 0x65, 0xbb, 0xdd, 0x09, 0x9a, 0xd3, 0x5c, 0x20, 0x1f, 0xf3, 0xac, 0x7a,
+	0xe5, 0xf4, 0xa8, 0xd9, 0xac, 0x72, 0xae, 0xa0, 0x88, 0x0a, 0xb3, 0x43, 0x47, 0xcc, 0xcc, 0xf0,
+	0x99, 0x98, 0xd6, 0x7a, 0xb0, 0x94, 0x36, 0x73, 0x62, 0xd7, 0xfe, 0x07, 0xa6, 0x6d, 0xb6, 0x55,
+	0x38, 0xb6, 0xc6, 0x1c, 0x2b, 0xe0, 0x74, 0x9c, 0xd1, 0x6c, 0x58, 0x3a, 0x72, 0xd8, 0x30, 0xe2,
+	0x0b, 0x67, 0x66, 0x5d, 0xa2, 0xc1, 0xbc, 0x4f, 0x3d, 0xdb, 0xe8, 0xd1, 0x03, 0x6e, 0x31, 0x4a,
+	0x49, 0xf1, 0xc8, 0x3a, 0xd4, 0x4e, 0x5c, 0xbf, 0x47, 0x75, 0x3a, 0x70, 0x2f, 0xd0, 0x53, 0xb3,
+	0xba, 0xcc, 0xd2, 0x9e, 0xc0, 0x72, 0x46, 0xda, 0xa4, 0x36, 0x69, 0x8f, 0xa0, 0xd5, 0xbd, 0xb4,
+	0xc2, 0xde, 0xa9, 0xf4, 0xb2, 0x61, 0xa2, 0x8e, 0x54, 0x97, 0xce, 0x5c, 0x49, 0x9f, 0xf9, 0xb7,
+	0x70, 0x77, 0xe4, 0xde, 0x6b, 0x49, 0x1b, 0x3a, 0xac, 0x8a, 0xf4, 0x5b, 0x50, 0x09, 0xdc, 0x96,
+	0x92, 0x30, 0x3f, 0x2a, 0x3e, 0x2b, 0xb2, 0xf0, 0xe8, 0x40, 0x7e, 0xad, 0x80, 0x5a, 0x04, 0x2a,
+	0x0c, 0x1a, 0x8b, 0xfa, 0xef, 0xe6, 0xf6, 0x37, 0x0a, 0x2c, 0x3e, 0x33, 0x1c, 0xd3, 0xa6, 0xdd,
+	0x97, 0x9d, 0x60, 0x5c, 0x86, 0x59, 0xe5, 0x4a, 0x96, 0xb9, 0x92, 0x73, 0x0c, 0xb8, 0xfb, 0xb2,
+	0x93, 0x3c, 0x70, 0x86, 0xdf, 0x8f, 0x5e, 0x32, 0x3e, 0x66, 0x35, 0xd1, 0x71, 0x5c, 0x13, 0xe1,
+	0xdd, 0x4b, 0x18, 0x52, 0x05, 0x33, 0x2d, 0x57, 0x30, 0xac, 0xd2, 0x0a, 0xce, 0xed, 0x43, 0x23,
+	0x0c, 0xa9, 0xef, 0x34, 0xab, 0x58, 0x69, 0x25, 0x1c, 0x76, 0x17, 0x83, 0x53, 0xc3, 0x37, 0x2d,
+	0xa7, 0xdf, 0x9c, 0xe1, 0xee, 0x88, 0x69, 0xf6, 0xc6, 0xc8, 0x96, 0x5c, 0x4b, 0xb0, 0xbc, 0x56,
+	0x60, 0xe5, 0x70, 0xe8, 0xf7, 0x8b, 0x62, 0x65, 0x64, 0x8c, 0x33, 0x2b, 0x2c, 0xc7, 0xe8, 0x85,
+	0xd6, 0x05, 0x15, 0x87, 0x1a, 0xd3, 0x3c, 0xaf, 0x59, 0x03, 0xbc, 0x99, 0x15, 0x9d, 0x8f, 0xd9,
+	0xfa, 0x13, 0xcb, 0xa6, 0xfc, 0x48, 0xd0, 0x95, 0x31, 0xcd, 0x3d, 0x39, 0x3c, 0x6e, 0x5b, 0x7e,
+	0xec, 0x49, 0x4e, 0x69, 0x5f, 0x41, 0x33, 0xaf, 0xd8, 0xb5, 0xf8, 0xe4, 0x1e, 0xd4, 0x77, 0x4f,
+	0x69, 0xef, 0xec, 0x6f, 0xaa, 0x05, 0xed, 0x31, 0x2c, 0x4a, 0xeb, 0x26, 0x4e, 0x32, 0x1d, 0x58,
+	0x12, 0x57, 0xaa, 0xcb, 0x05, 0x47, 0xa2, 0xd6, 0xa4, 0xcb, 0x34, 0xcf, 0xe3, 0x94, 0x4f, 0x27,
+	0xb7, 0x49, 0x14, 0x94, 0xe5, 0x54, 0x41, 0x39, 0x84, 0xe5, 0x0c, 0xda, 0xb5, 0xf8, 0x6a, 0x0f,
+	0x96, 0x75, 0xda, 0xb7, 0x58, 0x7a, 0x8b, 0x96, 0x8c, 0x7d, 0xe3, 0x0d, 0xd3, 0xf4, 0x69, 0x10,
+	0x08, 0xb1, 0x11, 0xa9, 0xed, 0x40, 0x23, 0x0b, 0x33, 0xb1, 0x3f, 0xdb, 0xb0, 0x74, 0x70, 0x72,
+	0x62, 0x5b, 0x0e, 0xfd, 0x27, 0x9a, 0x3c, 0x81, 0xe5, 0x0c, 0xca, 0xc4, 0x8a, 0x7c, 0xaf, 0x00,
+	0x60, 0xc6, 0xdf, 0x77, 0x4e, 0xdc, 0x42, 0xf9, 0x2a, 0xcc, 0x0e, 0xe8, 0xe0, 0x98, 0xfa, 0xfb,
+	0x6d, 0xbe, 0x73, 0x4a, 0x8f, 0x69, 0xf6, 0xe0, 0x1b, 0xb6, 0x15, 0xbf, 0x6d, 0x48, 0xb0, 0x1d,
+	0x1e, 0xa5, 0xfe, 0x91, 0xde, 0xc1, 0xe4, 0x38, 0xa7, 0xc7, 0x34, 0x4b, 0x3a, 0x3d, 0xdb, 0xa2,
+	0x4e, 0xc8, 0x67, 0xb1, 0x24, 0x90, 0x38, 0xda, 0x31, 0x00, 0x1a, 0x33, 0x52, 0x1f, 0x96, 0x00,
+	0x4d, 0x33, 0x7a, 0x71, 0xf9, 0x98, 0xe9, 0x11, 0x84, 0x46, 0x3f, 0xaa, 0x46, 0x90, 0x90, 0x12,
+	0xdf, 0x54, 0xaa, 0x75, 0xeb, 0x40, 0x9d, 0xd5, 0x66, 0x1d, 0x6a, 0x98, 0xd4, 0x7f, 0xce, 0x6d,
+	0x89, 0x5c, 0xa3, 0x24, 0x21, 0x56, 0xd4, 0x49, 0x44, 0xb2, 0x2b, 0x89, 0x6c, 0xed, 0x05, 0xa2,
+	0xa1, 0x17, 0x47, 0xa2, 0x6d, 0xc0, 0x0c, 0x76, 0xcd, 0xf8, 0x5e, 0xd5, 0xb6, 0x17, 0x58, 0xc0,
+	0x26, 0xae, 0xd7, 0xa3, 0xe9, 0x08, 0x0f, 0xbd, 0x30, 0x0e, 0x0f, 0x3b, 0xee, 0x14, 0x5e, 0xe2,
+	0x3a, 0x3d, 0x9a, 0xd6, 0x7e, 0x51, 0x60, 0x06, 0x61, 0x02, 0xb2, 0x09, 0x55, 0x9b, 0x5b, 0xcd,
+	0xa1, 0x6a, 0xdb, 0x4b, 0x6c, 0x53, 0xd6, 0x17, 0xcf, 0x4a, 0xba, 0x58, 0xc5, 0xd6, 0xa3, 0x5a,
+	0xdc, 0x0b, 0xd2, 0x7a, 0xd9, 0x5a, 0xb6, 0x1e, 0x57, 0xb1, 0xf5, 0x28, 0x96, 0x7b, 0x48, 0x5a,
+	0x2f, 0x5b, 0xc3, 0xd6, 0xe3, 0xaa, 0x9d, 0x59, 0xa8, 0x62, 0x2c, 0x69, 0x5f, 0xc0, 0x22, 0xc7,
+	0xe5, 0x94, 0xd4, 0x91, 0x0a, 0xf1, 0x22, 0x8e, 0x85, 0x98, 0x46, 0x2c, 0x46, 0x3c, 0xd3, 0x48,
+	0x31, 0xbe, 0x30, 0x0f, 0xe3, 0x51, 0x50, 0x1a, 0x05, 0x22, 0x83, 0x4f, 0x9c, 0x6d, 0xfe, 0x0f,
+	0x33, 0xa8, 0x66, 0xaa, 0x72, 0x14, 0x4e, 0xd5, 0xa3, 0xb9, 0xfb, 0x3a, 0xcc, 0x46, 0xf9, 0x8f,
+	0xdc, 0x82, 0x9b, 0xfb, 0xce, 0x85, 0x61, 0x5b, 0x66, 0xc4, 0xaa, 0x97, 0xc8, 0x4d, 0xa8, 0xf1,
+	0x8e, 0x1f, 0x59, 0x75, 0x85, 0xd4, 0x61, 0x1e, 0x5b, 0x35, 0xc1, 0x29, 0x93, 0x05, 0x80, 0x6e,
+	0xe8, 0x7a, 0x82, 0xae, 0x6c, 0xff, 0x59, 0x83, 0x2a, 0x3a, 0x9b, 0xbc, 0x82, 0xb9, 0xf8, 0xbf,
+	0x80, 0x70, 0xcf, 0x66, 0x3f, 0x20, 0xd4, 0xe5, 0x0c, 0x17, 0x2d, 0xd5, 0xee, 0x7e, 0xf7, 0xeb,
+	0x1f, 0x3f, 0x95, 0x57, 0xb5, 0xa5, 0x2d, 0xc3, 0xb3, 0x82, 0xad, 0x8b, 0x07, 0x86, 0xed, 0x9d,
+	0x1a, 0x0f, 0xb6, 0xd8, 0xd3, 0x10, 0x3c, 0x52, 0xee, 0x93, 0x13, 0xa8, 0x49, 0x6d, 0x30, 0xe1,
+	0x1d, 0x47, 0xbe, 0xf1, 0x56, 0x57, 0x72, 0x7c, 0x21, 0xe0, 0x1e, 0x17, 0xb0, 0xae, 0xde, 0x2e,
+	0x12, 0xb0, 0xf5, 0x35, 0xbb, 0x3b, 0xdf, 0x30, 0x39, 0x8f, 0x01, 0x92, 0xd6, 0x94, 0x70, 0x6d,
+	0x73, 0xdd, 0xae, 0xda, 0xc8, 0xb2, 0x85, 0x90, 0x12, 0xb1, 0xa1, 0x26, 0x75, 0x71, 0x44, 0xcd,
+	0xb4, 0x75, 0x52, 0xdf, 0xa6, 0xde, 0x2e, 0x9c, 0x13, 0x48, 0xff, 0xe3, 0xea, 0xb6, 0xc8, 0x5a,
+	0x46, 0xdd, 0x80, 0x2f, 0x15, 0xfa, 0x92, 0x3d, 0x80, 0xa4, 0xeb, 0x22, 0xab, 0xe9, 0x2e, 0x4c,
+	0x96, 0xa5, 0x16, 0x4d, 0xc5, 0x4a, 0xef, 0xc2, 0xbc, 0xdc, 0xb6, 0x10, 0xee, 0xc4, 0x82, 0x7e,
+	0x4d, 0x6d, 0xe6, 0x27, 0x62, 0x90, 0xa7, 0x70, 0x23, 0xd5, 0x28, 0x10, 0xbe, 0xb8, 0xa8, 0x53,
+	0x51, 0x57, 0x0b, 0x66, 0x62, 0x9c, 0xa3, 0xe8, 0x6f, 0x40, 0xfe, 0xcb, 0x21, 0x77, 0x12, 0x8f,
+	0x17, 0x7c, 0x0c, 0xa9, 0xad, 0x51, 0xd3, 0x31, 0xec, 0x2b, 0x58, 0x19, 0xf1, 0xbd, 0x46, 0xb4,
+	0x64, 0xf3, 0xa8, 0xbf, 0x37, 0x75, 0xe4, 0xe3, 0xad, 0x95, 0x58, 0xc8, 0x24, 0x95, 0x26, 0x86,
+	0x4c, 0xae, 0x86, 0xc6, 0x90, 0xc9, 0x17, 0xa4, 0x5a, 0x89, 0x98, 0xb0, 0x32, 0xa2, 0xc5, 0x41,
+	0xcd, 0xc6, 0xf7, 0x4e, 0xea, 0x7f, 0xc7, 0xae, 0x91, 0xec, 0x6f, 0xe4, 0x5b, 0x0e, 0x1e, 0xe3,
+	0x77, 0xa4, 0x2b, 0x93, 0xaf, 0x5b, 0xd1, 0xb5, 0xa3, 0xbb, 0x15, 0xad, 0x44, 0x0e, 0xa0, 0x9e,
+	0xad, 0x2d, 0x09, 0x0f, 0xee, 0x11, 0xa5, 0xb0, 0xba, 0x56, 0x3c, 0x29, 0x01, 0x92, 0xfc, 0xef,
+	0x2b, 0xea, 0x39, 0xf2, 0x57, 0x76, 0xec, 0x09, 0x3d, 0x82, 0xb9, 0xb8, 0xb6, 0xc4, 0xbc, 0x94,
+	0x2d, 0x49, 0x31, 0x2f, 0xe5, 0x0a, 0x50, 0x8c, 0xeb, 0x54, 0x29, 0x88, 0x71, 0x5d, 0x54, 0x6b,
+	0x62, 0x5c, 0x17, 0xd6, 0x8d, 0x5a, 0x89, 0xec, 0xc3, 0x42, 0xba, 0x28, 0xc3, 0xfb, 0x5a, 0x58,
+	0xef, 0xe1, 0x7d, 0x2d, 0xae, 0xe1, 0x84, 0x4a, 0x72, 0x55, 0x25, 0x54, 0x2a, 0x28, 0xd7, 0x84,
+	0x4a, 0x45, 0x25, 0x18, 0x06, 0x6e, 0xf2, 0xe8, 0x60, 0xe0, 0xe6, 0x5e, 0x38, 0x0c, 0xdc, 0xfc,
+	0xdb, 0xa4, 0x95, 0x76, 0x9a, 0x6f, 0xde, 0xb5, 0x94, 0xb7, 0xef, 0x5a, 0xca, 0xef, 0xef, 0x5a,
+	0xca, 0x8f, 0xef, 0x5b, 0xa5, 0xb7, 0xef, 0x5b, 0xa5, 0xdf, 0xde, 0xb7, 0x4a, 0xc7, 0x55, 0xfe,
+	0x8b, 0xfe, 0xf0, 0xaf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x42, 0x20, 0x3c, 0x0b, 0x89, 0x17, 0x00,
+	0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -5343,17 +5335,7 @@ func (m *ListLeaderMember) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		copy(dAtA[i:], m.Addr)
 		i = encodeVarintDmmaster(dAtA, i, uint64(len(m.Addr)))
 		i--
-		dAtA[i] = 0x22
-	}
-	if m.Alive {
-		i--
-		if m.Alive {
-			dAtA[i] = 1
-		} else {
-			dAtA[i] = 0
-		}
-		i--
-		dAtA[i] = 0x18
+		dAtA[i] = 0x1a
 	}
 	if len(m.Name) > 0 {
 		i -= len(m.Name)
@@ -6469,9 +6451,6 @@ func (m *ListLeaderMember) Size() (n int) {
 	if l > 0 {
 		n += 1 + l + sovDmmaster(uint64(l))
 	}
-	if m.Alive {
-		n += 2
-	}
 	l = len(m.Addr)
 	if l > 0 {
 		n += 1 + l + sovDmmaster(uint64(l))
@@ -11725,26 +11704,6 @@ func (m *ListLeaderMember) Unmarshal(dAtA []byte) error {
 			m.Name = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
 		case 3:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Alive", wireType)
-			}
-			var v int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowDmmaster
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				v |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			m.Alive = bool(v != 0)
-		case 4:
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field Addr", wireType)
 			}
diff --git a/dm/proto/dmmaster.proto b/dm/proto/dmmaster.proto
index bd0a40d8e3..e377f1593c 100644
--- a/dm/proto/dmmaster.proto
+++ b/dm/proto/dmmaster.proto
@@ -328,8 +328,7 @@ message WorkerInfo {
 message ListLeaderMember {
     string msg = 1;
     string name = 2;
-    bool alive = 3;
-    string addr = 4;
+    string addr = 3;
 }
 
 message ListMasterMember {

From e59f7c4a64039a5c7b53b5cb1898d05e323f4fb6 Mon Sep 17 00:00:00 2001
From: gmhdbjd <gmhdbjd@gmail.com>
Date: Thu, 14 May 2020 15:47:18 +0800
Subject: [PATCH 11/17] add err for scheduler not started

---
 dm/master/scheduler/scheduler.go | 9 +++++++--
 dm/master/server.go              | 7 ++++++-
 2 files changed, 13 insertions(+), 3 deletions(-)

diff --git a/dm/master/scheduler/scheduler.go b/dm/master/scheduler/scheduler.go
index 346ea1efe3..448ba12c48 100644
--- a/dm/master/scheduler/scheduler.go
+++ b/dm/master/scheduler/scheduler.go
@@ -574,14 +574,19 @@ func (s *Scheduler) RemoveWorker(name string) error {
 }
 
 // GetWorker gets all worker agent.
-func (s *Scheduler) GetWorker() []*Worker {
+func (s *Scheduler) GetWorker() ([]*Worker, error) {
 	s.mu.RLock()
 	defer s.mu.RUnlock()
+
+	if !s.started {
+		return nil, terror.ErrSchedulerNotStarted.Generate()
+	}
+
 	workers := make([]*Worker, 0, len(s.workers))
 	for _, value := range s.workers {
 		workers = append(workers, value)
 	}
-	return workers
+	return workers, nil
 }
 
 // GetWorkerByName gets worker agent by worker name.
diff --git a/dm/master/server.go b/dm/master/server.go
index f047b6d848..b64949cedb 100644
--- a/dm/master/server.go
+++ b/dm/master/server.go
@@ -1602,7 +1602,12 @@ func (s *Server) listMemberWorker(ctx context.Context) (*pb.Members_Worker, erro
 		Worker: &pb.ListWorkerMember{},
 	}
 
-	workerAgents := s.scheduler.GetWorker()
+	workerAgents, err := s.scheduler.GetWorker()
+	if err != nil {
+		resp.Worker.Msg = errors.ErrorStack(err)
+		return resp, nil
+	}
+
 	workers := make([]*pb.WorkerInfo, 0, len(workerAgents))
 
 	for _, workerAgent := range workerAgents {

From da734a898cdfb8a99189d8b1134f9172b42e0724 Mon Sep 17 00:00:00 2001
From: gmhdbjd <gmhdbjd@gmail.com>
Date: Fri, 15 May 2020 12:21:16 +0800
Subject: [PATCH 12/17] add type and name flags

---
 dm/ctl/master/list_member.go |  65 ++++---
 dm/master/server.go          |  49 ++++-
 dm/pb/dmmaster.pb.go         | 366 ++++++++++++++++++-----------------
 dm/proto/dmmaster.proto      |  13 +-
 tests/_utils/get_leader      |   2 +-
 tests/ha_master/run.sh       |  20 +-
 6 files changed, 281 insertions(+), 234 deletions(-)

diff --git a/dm/ctl/master/list_member.go b/dm/ctl/master/list_member.go
index 4dcb8d98e6..e21e96f408 100644
--- a/dm/ctl/master/list_member.go
+++ b/dm/ctl/master/list_member.go
@@ -24,41 +24,45 @@ import (
 	"github.com/pingcap/dm/dm/pb"
 )
 
+var (
+	listMemberFlags = ListMemberFlags{}
+)
+
+// ListMemberFlags are flags that used in ListMember command
+type ListMemberFlags struct {
+	names []string // specify names to list information
+}
+
+// Reset clears cache of ListMemberFlags
+func (c ListMemberFlags) Reset() {
+	c.names = c.names[:0]
+}
+
 // NewListMemberCmd creates an ListMember command
 func NewListMemberCmd() *cobra.Command {
 	cmd := &cobra.Command{
-		Use:   "list-member [--master] [--worker] [--leader]",
+		Use:   "list-member [--type] [--name]",
 		Short: "list member information",
 		Run:   listMemberFunc,
 	}
-	cmd.Flags().BoolP("master", "", false, "only to list master")
-	cmd.Flags().BoolP("worker", "", false, "only to list worker")
-	cmd.Flags().BoolP("leader", "", false, "only to list leader")
+	cmd.Flags().StringP("type", "t", "", "specify a member type from master, worker, and leader")
+	cmd.Flags().StringSliceVarP(&listMemberFlags.names, "name", "n", []string{}, "specify member names in choosing type")
 	return cmd
 }
 
-func extractListMemberFlag(cmd *cobra.Command) (bool, bool, bool, error) {
-	master, err := cmd.Flags().GetBool("master")
-	if err != nil {
-		return false, false, false, errors.Trace(err)
-	}
-
-	worker, err := cmd.Flags().GetBool("worker")
-	if err != nil {
-		return false, false, false, errors.Trace(err)
-	}
-
-	leader, err := cmd.Flags().GetBool("leader")
-	if err != nil {
-		return false, false, false, errors.Trace(err)
-	}
-
-	if !master && !worker && !leader {
-		master = true
-		worker = true
-		leader = true
+func convertListMemberType(t string) pb.MemberType {
+	switch t {
+	case "master":
+		return pb.MemberType_MasterType
+	case "worker":
+		return pb.MemberType_WorkerType
+	case "leader":
+		return pb.MemberType_LeaderType
+	case "":
+		return pb.MemberType_AllType
+	default:
+		return pb.MemberType_InvalidType
 	}
-	return master, worker, leader, nil
 }
 
 // listMemberFunc does list member request
@@ -69,20 +73,21 @@ func listMemberFunc(cmd *cobra.Command, _ []string) {
 		return
 	}
 
-	master, worker, leader, err := extractListMemberFlag(cmd)
+	member, err := cmd.Flags().GetString("type")
 	if err != nil {
-		common.PrintLines("%s", err.Error())
+		common.PrintLines("%s", errors.ErrorStack(err))
 		return
 	}
 
+	memType := convertListMemberType(member)
+
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
 	cli := common.MasterClient()
 	resp, err := cli.ListMember(ctx, &pb.ListMemberRequest{
-		Master: master,
-		Worker: worker,
-		Leader: leader,
+		MemType: memType,
+		Names:   listMemberFlags.names,
 	})
 
 	if err != nil {
diff --git a/dm/master/server.go b/dm/master/server.go
index b64949cedb..6ab2c70d38 100644
--- a/dm/master/server.go
+++ b/dm/master/server.go
@@ -1560,7 +1560,7 @@ func (s *Server) getSourceRespsAfterOperation(ctx context.Context, taskName stri
 	return sortCommonWorkerResults(sourceRespCh)
 }
 
-func (s *Server) listMemberMaster(ctx context.Context) (*pb.Members_Master, error) {
+func (s *Server) listMemberMaster(ctx context.Context, names []string) (*pb.Members_Master, error) {
 
 	resp := &pb.Members_Master{
 		Master: &pb.ListMasterMember{},
@@ -1571,6 +1571,13 @@ func (s *Server) listMemberMaster(ctx context.Context) (*pb.Members_Master, erro
 		resp.Master.Msg = errors.ErrorStack(err)
 		return resp, nil
 	}
+
+	all := len(names) == 0
+	set := make(map[string]bool)
+	for _, name := range names {
+		set[name] = true
+	}
+
 	etcdMembers := memberList.Members
 	masters := make([]*pb.MasterInfo, 0, len(etcdMembers))
 	client := http.Client{
@@ -1578,6 +1585,10 @@ func (s *Server) listMemberMaster(ctx context.Context) (*pb.Members_Master, erro
 	}
 
 	for _, etcdMember := range etcdMembers {
+		if !all && !set[etcdMember.Name] {
+			continue
+		}
+
 		alive := true
 		_, err := client.Get(etcdMember.ClientURLs[0] + "/health")
 		if err != nil {
@@ -1597,7 +1608,7 @@ func (s *Server) listMemberMaster(ctx context.Context) (*pb.Members_Master, erro
 	return resp, nil
 }
 
-func (s *Server) listMemberWorker(ctx context.Context) (*pb.Members_Worker, error) {
+func (s *Server) listMemberWorker(ctx context.Context, names []string) (*pb.Members_Worker, error) {
 	resp := &pb.Members_Worker{
 		Worker: &pb.ListWorkerMember{},
 	}
@@ -1608,9 +1619,19 @@ func (s *Server) listMemberWorker(ctx context.Context) (*pb.Members_Worker, erro
 		return resp, nil
 	}
 
+	all := len(names) == 0
+	set := make(map[string]bool)
+	for _, name := range names {
+		set[name] = true
+	}
+
 	workers := make([]*pb.WorkerInfo, 0, len(workerAgents))
 
 	for _, workerAgent := range workerAgents {
+		if !all && !set[workerAgent.BaseInfo().Name] {
+			continue
+		}
+
 		workers = append(workers, &pb.WorkerInfo{
 			Name:   workerAgent.BaseInfo().Name,
 			Addr:   workerAgent.BaseInfo().Addr,
@@ -1623,17 +1644,27 @@ func (s *Server) listMemberWorker(ctx context.Context) (*pb.Members_Worker, erro
 	return resp, nil
 }
 
-func (s *Server) listMemberLeader(ctx context.Context) (*pb.Members_Leader, error) {
+func (s *Server) listMemberLeader(ctx context.Context, names []string) (*pb.Members_Leader, error) {
 	resp := &pb.Members_Leader{
 		Leader: &pb.ListLeaderMember{},
 	}
 
+	all := len(names) == 0
+	set := make(map[string]bool)
+	for _, name := range names {
+		set[name] = true
+	}
+
 	_, name, addr, err := s.election.LeaderInfo(ctx)
 	if err != nil {
 		resp.Leader.Msg = errors.ErrorStack(err)
 		return resp, nil
 	}
 
+	if !all && !set[name] {
+		return resp, nil
+	}
+
 	resp.Leader.Name = name
 	resp.Leader.Addr = addr
 	return resp, nil
@@ -1654,8 +1685,8 @@ func (s *Server) ListMember(ctx context.Context, req *pb.ListMemberRequest) (*pb
 	resp := &pb.ListMemberResponse{}
 	members := make([]*pb.Members, 0)
 
-	if req.Master {
-		res, err := s.listMemberMaster(ctx)
+	if req.MemType == pb.MemberType_AllType || req.MemType == pb.MemberType_MasterType {
+		res, err := s.listMemberMaster(ctx, req.Names)
 		if err != nil {
 			resp.Msg = errors.ErrorStack(err)
 			return resp, nil
@@ -1665,8 +1696,8 @@ func (s *Server) ListMember(ctx context.Context, req *pb.ListMemberRequest) (*pb
 		})
 	}
 
-	if req.Worker {
-		res, err := s.listMemberWorker(ctx)
+	if req.MemType == pb.MemberType_AllType || req.MemType == pb.MemberType_WorkerType {
+		res, err := s.listMemberWorker(ctx, req.Names)
 		if err != nil {
 			resp.Msg = errors.ErrorStack(err)
 			return resp, nil
@@ -1676,8 +1707,8 @@ func (s *Server) ListMember(ctx context.Context, req *pb.ListMemberRequest) (*pb
 		})
 	}
 
-	if req.Leader {
-		res, err := s.listMemberLeader(ctx)
+	if req.MemType == pb.MemberType_AllType || req.MemType == pb.MemberType_LeaderType {
+		res, err := s.listMemberLeader(ctx, req.Names)
 		if err != nil {
 			resp.Msg = errors.ErrorStack(err)
 			return resp, nil
diff --git a/dm/pb/dmmaster.pb.go b/dm/pb/dmmaster.pb.go
index 54899df4fd..20de92c8cf 100644
--- a/dm/pb/dmmaster.pb.go
+++ b/dm/pb/dmmaster.pb.go
@@ -59,6 +59,40 @@ func (SourceOp) EnumDescriptor() ([]byte, []int) {
 	return fileDescriptor_f9bef11f2a341f03, []int{0}
 }
 
+type MemberType int32
+
+const (
+	MemberType_InvalidType MemberType = 0
+	MemberType_MasterType  MemberType = 1
+	MemberType_WorkerType  MemberType = 2
+	MemberType_LeaderType  MemberType = 3
+	MemberType_AllType     MemberType = 4
+)
+
+var MemberType_name = map[int32]string{
+	0: "InvalidType",
+	1: "MasterType",
+	2: "WorkerType",
+	3: "LeaderType",
+	4: "AllType",
+}
+
+var MemberType_value = map[string]int32{
+	"InvalidType": 0,
+	"MasterType":  1,
+	"WorkerType":  2,
+	"LeaderType":  3,
+	"AllType":     4,
+}
+
+func (x MemberType) String() string {
+	return proto.EnumName(MemberType_name, int32(x))
+}
+
+func (MemberType) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor_f9bef11f2a341f03, []int{1}
+}
+
 type MigrateWorkerRelayRequest struct {
 	BinlogName string `protobuf:"bytes,1,opt,name=BinlogName,proto3" json:"BinlogName,omitempty"`
 	BinlogPos  uint32 `protobuf:"varint,2,opt,name=BinlogPos,proto3" json:"BinlogPos,omitempty"`
@@ -2534,9 +2568,8 @@ func (*Members) XXX_OneofWrappers() []interface{} {
 }
 
 type ListMemberRequest struct {
-	Master bool `protobuf:"varint,1,opt,name=master,proto3" json:"master,omitempty"`
-	Worker bool `protobuf:"varint,2,opt,name=worker,proto3" json:"worker,omitempty"`
-	Leader bool `protobuf:"varint,3,opt,name=leader,proto3" json:"leader,omitempty"`
+	MemType MemberType `protobuf:"varint,1,opt,name=memType,proto3,enum=pb.MemberType" json:"memType,omitempty"`
+	Names   []string   `protobuf:"bytes,2,rep,name=names,proto3" json:"names,omitempty"`
 }
 
 func (m *ListMemberRequest) Reset()         { *m = ListMemberRequest{} }
@@ -2572,25 +2605,18 @@ func (m *ListMemberRequest) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_ListMemberRequest proto.InternalMessageInfo
 
-func (m *ListMemberRequest) GetMaster() bool {
+func (m *ListMemberRequest) GetMemType() MemberType {
 	if m != nil {
-		return m.Master
+		return m.MemType
 	}
-	return false
+	return MemberType_InvalidType
 }
 
-func (m *ListMemberRequest) GetWorker() bool {
+func (m *ListMemberRequest) GetNames() []string {
 	if m != nil {
-		return m.Worker
+		return m.Names
 	}
-	return false
-}
-
-func (m *ListMemberRequest) GetLeader() bool {
-	if m != nil {
-		return m.Leader
-	}
-	return false
+	return nil
 }
 
 type ListMemberResponse struct {
@@ -2655,6 +2681,7 @@ func (m *ListMemberResponse) GetMembers() []*Members {
 
 func init() {
 	proto.RegisterEnum("pb.SourceOp", SourceOp_name, SourceOp_value)
+	proto.RegisterEnum("pb.MemberType", MemberType_name, MemberType_value)
 	proto.RegisterType((*MigrateWorkerRelayRequest)(nil), "pb.MigrateWorkerRelayRequest")
 	proto.RegisterType((*UpdateWorkerRelayConfigRequest)(nil), "pb.UpdateWorkerRelayConfigRequest")
 	proto.RegisterType((*StartTaskRequest)(nil), "pb.StartTaskRequest")
@@ -2703,112 +2730,114 @@ func init() {
 func init() { proto.RegisterFile("dmmaster.proto", fileDescriptor_f9bef11f2a341f03) }
 
 var fileDescriptor_f9bef11f2a341f03 = []byte{
-	// 1665 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x58, 0x4f, 0x6f, 0xdb, 0xc6,
-	0x12, 0x17, 0x25, 0x5b, 0xb6, 0x47, 0x8e, 0x23, 0x6f, 0x6c, 0x59, 0x66, 0x1c, 0xc5, 0x8f, 0xef,
-	0xbd, 0xc0, 0xc8, 0xc1, 0x6e, 0x9c, 0x5b, 0x80, 0x00, 0x8d, 0x2d, 0x07, 0x31, 0xa0, 0xc4, 0x0e,
-	0x55, 0xa3, 0x08, 0x0a, 0x14, 0xa0, 0xc5, 0xb5, 0x4c, 0x98, 0x22, 0x69, 0x92, 0xb2, 0x6b, 0x14,
-	0x45, 0x81, 0x7e, 0x80, 0xb6, 0x40, 0x0f, 0x39, 0xf6, 0xd0, 0x2f, 0x93, 0x63, 0x80, 0x5e, 0x7a,
-	0x2c, 0x92, 0x7e, 0x86, 0x9e, 0x8b, 0xdd, 0x59, 0x92, 0xcb, 0x3f, 0x52, 0xa3, 0x14, 0xf5, 0x6d,
-	0x67, 0x76, 0xf7, 0x37, 0x7f, 0x76, 0x76, 0x76, 0x66, 0x61, 0xc1, 0x1c, 0x0c, 0x8c, 0x20, 0xa4,
-	0xfe, 0xa6, 0xe7, 0xbb, 0xa1, 0x4b, 0xca, 0xde, 0xb1, 0xba, 0x60, 0x0e, 0x2e, 0x5d, 0xff, 0x2c,
-	0xe2, 0xa9, 0x6b, 0x7d, 0xd7, 0xed, 0xdb, 0x74, 0xcb, 0xf0, 0xac, 0x2d, 0xc3, 0x71, 0xdc, 0xd0,
-	0x08, 0x2d, 0xd7, 0x09, 0x70, 0x56, 0x3b, 0x87, 0xd5, 0xe7, 0x56, 0xdf, 0x37, 0x42, 0xfa, 0x39,
-	0xdf, 0xa4, 0x53, 0xdb, 0xb8, 0xd2, 0xe9, 0xf9, 0x90, 0x06, 0x21, 0x69, 0x01, 0xec, 0x58, 0x8e,
-	0xed, 0xf6, 0x5f, 0x18, 0x03, 0xda, 0x54, 0xd6, 0x95, 0x8d, 0x39, 0x5d, 0xe2, 0x90, 0x35, 0x98,
-	0x43, 0xea, 0xd0, 0x0d, 0x9a, 0xe5, 0x75, 0x65, 0xe3, 0x86, 0x9e, 0x30, 0x48, 0x03, 0xaa, 0x81,
-	0x3b, 0xf4, 0x7b, 0xb4, 0x59, 0xe1, 0x3b, 0x05, 0xa5, 0x1d, 0x42, 0xeb, 0xc8, 0x33, 0xd3, 0x12,
-	0x77, 0x5d, 0xe7, 0xc4, 0xea, 0x47, 0x72, 0x1b, 0x50, 0xed, 0x71, 0x86, 0x90, 0x29, 0x28, 0x09,
-	0xb1, 0x9c, 0x42, 0xfc, 0x14, 0xea, 0xdd, 0xd0, 0xf0, 0xc3, 0xcf, 0x8c, 0xe0, 0x2c, 0xc2, 0x20,
-	0x30, 0x15, 0x1a, 0xc1, 0x99, 0x40, 0xe0, 0x63, 0xd2, 0x84, 0x19, 0xdc, 0xc1, 0xb4, 0xad, 0x6c,
-	0xcc, 0xe9, 0x11, 0xa9, 0x9d, 0xc3, 0xa2, 0x84, 0x10, 0x78, 0xae, 0x13, 0x50, 0x26, 0xce, 0xa7,
-	0xc1, 0xd0, 0x0e, 0x39, 0xc8, 0xac, 0x2e, 0x28, 0x52, 0x87, 0xca, 0x20, 0xe8, 0x0b, 0x1d, 0xd8,
-	0x90, 0x6c, 0x27, 0xc0, 0x95, 0xf5, 0xca, 0x46, 0x6d, 0xbb, 0xb9, 0xe9, 0x1d, 0x6f, 0xee, 0xba,
-	0x83, 0x81, 0xeb, 0x44, 0x56, 0x22, 0x68, 0x22, 0xf2, 0x21, 0xac, 0xa2, 0x1b, 0x9e, 0xf3, 0x13,
-	0xfc, 0x20, 0x0f, 0x68, 0x57, 0xa0, 0x16, 0x6d, 0x9a, 0x58, 0xe1, 0x07, 0x59, 0x85, 0x57, 0x98,
-	0xc2, 0x2f, 0x87, 0xd4, 0xbf, 0xea, 0x86, 0x46, 0x38, 0x0c, 0xf2, 0xfa, 0x7e, 0x09, 0xe4, 0xc0,
-	0xa3, 0x2c, 0x52, 0x64, 0x37, 0xab, 0x50, 0x76, 0x3d, 0x2e, 0x6e, 0x61, 0x1b, 0x18, 0x06, 0x9b,
-	0x3c, 0xf0, 0xf4, 0xb2, 0xeb, 0xb1, 0x23, 0x70, 0x58, 0xe0, 0xa0, 0x5c, 0x3e, 0x96, 0x8f, 0xa0,
-	0x92, 0x3e, 0x82, 0x1f, 0x14, 0xb8, 0x95, 0x12, 0x20, 0x8c, 0x1a, 0x27, 0x21, 0x31, 0xb8, 0x5c,
-	0x64, 0x70, 0xa5, 0xf0, 0x84, 0xa6, 0x3e, 0xf4, 0x84, 0x9e, 0xc0, 0x22, 0x3a, 0xfb, 0xe3, 0xe3,
-	0xca, 0x07, 0x22, 0x43, 0x5c, 0x4b, 0x60, 0x3d, 0x85, 0x86, 0x74, 0x90, 0x1d, 0x2b, 0x08, 0x25,
-	0xdd, 0x9d, 0xe4, 0x26, 0xe7, 0x0e, 0x24, 0xa3, 0xfb, 0x05, 0xac, 0xe4, 0x70, 0xae, 0x23, 0xd0,
-	0xf6, 0x60, 0x99, 0xcf, 0xef, 0xf9, 0xbe, 0xeb, 0x7f, 0xbc, 0xfa, 0xa1, 0x70, 0x83, 0x04, 0x33,
-	0xb1, 0xf6, 0x9f, 0x64, 0xb5, 0x6f, 0xc4, 0xda, 0x73, 0xd8, 0xbc, 0xf2, 0xbb, 0x70, 0xab, 0x7b,
-	0xea, 0x5e, 0xb6, 0xdb, 0x9d, 0x8e, 0xdb, 0x3b, 0x0b, 0x3e, 0x2e, 0x6a, 0x7e, 0x56, 0x60, 0x46,
-	0x20, 0x90, 0x05, 0x28, 0xef, 0xb7, 0xc5, 0xbe, 0xf2, 0x7e, 0x3b, 0x46, 0x2a, 0x4b, 0x48, 0x04,
-	0xa6, 0x06, 0xae, 0x19, 0xe5, 0x59, 0x3e, 0x26, 0x4b, 0x30, 0xed, 0x5e, 0x3a, 0xd4, 0x6f, 0x4e,
-	0x71, 0x26, 0x12, 0x6c, 0x65, 0xbb, 0xdd, 0x09, 0x9a, 0xd3, 0x5c, 0x20, 0x1f, 0xf3, 0xac, 0x7a,
-	0xe5, 0xf4, 0xa8, 0xd9, 0xac, 0x72, 0xae, 0xa0, 0x88, 0x0a, 0xb3, 0x43, 0x47, 0xcc, 0xcc, 0xf0,
-	0x99, 0x98, 0xd6, 0x7a, 0xb0, 0x94, 0x36, 0x73, 0x62, 0xd7, 0xfe, 0x07, 0xa6, 0x6d, 0xb6, 0x55,
-	0x38, 0xb6, 0xc6, 0x1c, 0x2b, 0xe0, 0x74, 0x9c, 0xd1, 0x6c, 0x58, 0x3a, 0x72, 0xd8, 0x30, 0xe2,
-	0x0b, 0x67, 0x66, 0x5d, 0xa2, 0xc1, 0xbc, 0x4f, 0x3d, 0xdb, 0xe8, 0xd1, 0x03, 0x6e, 0x31, 0x4a,
-	0x49, 0xf1, 0xc8, 0x3a, 0xd4, 0x4e, 0x5c, 0xbf, 0x47, 0x75, 0x3a, 0x70, 0x2f, 0xd0, 0x53, 0xb3,
-	0xba, 0xcc, 0xd2, 0x9e, 0xc0, 0x72, 0x46, 0xda, 0xa4, 0x36, 0x69, 0x8f, 0xa0, 0xd5, 0xbd, 0xb4,
-	0xc2, 0xde, 0xa9, 0xf4, 0xb2, 0x61, 0xa2, 0x8e, 0x54, 0x97, 0xce, 0x5c, 0x49, 0x9f, 0xf9, 0xb7,
-	0x70, 0x77, 0xe4, 0xde, 0x6b, 0x49, 0x1b, 0x3a, 0xac, 0x8a, 0xf4, 0x5b, 0x50, 0x09, 0xdc, 0x96,
-	0x92, 0x30, 0x3f, 0x2a, 0x3e, 0x2b, 0xb2, 0xf0, 0xe8, 0x40, 0x7e, 0xad, 0x80, 0x5a, 0x04, 0x2a,
-	0x0c, 0x1a, 0x8b, 0xfa, 0xef, 0xe6, 0xf6, 0x37, 0x0a, 0x2c, 0x3e, 0x33, 0x1c, 0xd3, 0xa6, 0xdd,
-	0x97, 0x9d, 0x60, 0x5c, 0x86, 0x59, 0xe5, 0x4a, 0x96, 0xb9, 0x92, 0x73, 0x0c, 0xb8, 0xfb, 0xb2,
-	0x93, 0x3c, 0x70, 0x86, 0xdf, 0x8f, 0x5e, 0x32, 0x3e, 0x66, 0x35, 0xd1, 0x71, 0x5c, 0x13, 0xe1,
-	0xdd, 0x4b, 0x18, 0x52, 0x05, 0x33, 0x2d, 0x57, 0x30, 0xac, 0xd2, 0x0a, 0xce, 0xed, 0x43, 0x23,
-	0x0c, 0xa9, 0xef, 0x34, 0xab, 0x58, 0x69, 0x25, 0x1c, 0x76, 0x17, 0x83, 0x53, 0xc3, 0x37, 0x2d,
-	0xa7, 0xdf, 0x9c, 0xe1, 0xee, 0x88, 0x69, 0xf6, 0xc6, 0xc8, 0x96, 0x5c, 0x4b, 0xb0, 0xbc, 0x56,
-	0x60, 0xe5, 0x70, 0xe8, 0xf7, 0x8b, 0x62, 0x65, 0x64, 0x8c, 0x33, 0x2b, 0x2c, 0xc7, 0xe8, 0x85,
-	0xd6, 0x05, 0x15, 0x87, 0x1a, 0xd3, 0x3c, 0xaf, 0x59, 0x03, 0xbc, 0x99, 0x15, 0x9d, 0x8f, 0xd9,
-	0xfa, 0x13, 0xcb, 0xa6, 0xfc, 0x48, 0xd0, 0x95, 0x31, 0xcd, 0x3d, 0x39, 0x3c, 0x6e, 0x5b, 0x7e,
-	0xec, 0x49, 0x4e, 0x69, 0x5f, 0x41, 0x33, 0xaf, 0xd8, 0xb5, 0xf8, 0xe4, 0x1e, 0xd4, 0x77, 0x4f,
-	0x69, 0xef, 0xec, 0x6f, 0xaa, 0x05, 0xed, 0x31, 0x2c, 0x4a, 0xeb, 0x26, 0x4e, 0x32, 0x1d, 0x58,
-	0x12, 0x57, 0xaa, 0xcb, 0x05, 0x47, 0xa2, 0xd6, 0xa4, 0xcb, 0x34, 0xcf, 0xe3, 0x94, 0x4f, 0x27,
-	0xb7, 0x49, 0x14, 0x94, 0xe5, 0x54, 0x41, 0x39, 0x84, 0xe5, 0x0c, 0xda, 0xb5, 0xf8, 0x6a, 0x0f,
-	0x96, 0x75, 0xda, 0xb7, 0x58, 0x7a, 0x8b, 0x96, 0x8c, 0x7d, 0xe3, 0x0d, 0xd3, 0xf4, 0x69, 0x10,
-	0x08, 0xb1, 0x11, 0xa9, 0xed, 0x40, 0x23, 0x0b, 0x33, 0xb1, 0x3f, 0xdb, 0xb0, 0x74, 0x70, 0x72,
-	0x62, 0x5b, 0x0e, 0xfd, 0x27, 0x9a, 0x3c, 0x81, 0xe5, 0x0c, 0xca, 0xc4, 0x8a, 0x7c, 0xaf, 0x00,
-	0x60, 0xc6, 0xdf, 0x77, 0x4e, 0xdc, 0x42, 0xf9, 0x2a, 0xcc, 0x0e, 0xe8, 0xe0, 0x98, 0xfa, 0xfb,
-	0x6d, 0xbe, 0x73, 0x4a, 0x8f, 0x69, 0xf6, 0xe0, 0x1b, 0xb6, 0x15, 0xbf, 0x6d, 0x48, 0xb0, 0x1d,
-	0x1e, 0xa5, 0xfe, 0x91, 0xde, 0xc1, 0xe4, 0x38, 0xa7, 0xc7, 0x34, 0x4b, 0x3a, 0x3d, 0xdb, 0xa2,
-	0x4e, 0xc8, 0x67, 0xb1, 0x24, 0x90, 0x38, 0xda, 0x31, 0x00, 0x1a, 0x33, 0x52, 0x1f, 0x96, 0x00,
-	0x4d, 0x33, 0x7a, 0x71, 0xf9, 0x98, 0xe9, 0x11, 0x84, 0x46, 0x3f, 0xaa, 0x46, 0x90, 0x90, 0x12,
-	0xdf, 0x54, 0xaa, 0x75, 0xeb, 0x40, 0x9d, 0xd5, 0x66, 0x1d, 0x6a, 0x98, 0xd4, 0x7f, 0xce, 0x6d,
-	0x89, 0x5c, 0xa3, 0x24, 0x21, 0x56, 0xd4, 0x49, 0x44, 0xb2, 0x2b, 0x89, 0x6c, 0xed, 0x05, 0xa2,
-	0xa1, 0x17, 0x47, 0xa2, 0x6d, 0xc0, 0x0c, 0x76, 0xcd, 0xf8, 0x5e, 0xd5, 0xb6, 0x17, 0x58, 0xc0,
-	0x26, 0xae, 0xd7, 0xa3, 0xe9, 0x08, 0x0f, 0xbd, 0x30, 0x0e, 0x0f, 0x3b, 0xee, 0x14, 0x5e, 0xe2,
-	0x3a, 0x3d, 0x9a, 0xd6, 0x7e, 0x51, 0x60, 0x06, 0x61, 0x02, 0xb2, 0x09, 0x55, 0x9b, 0x5b, 0xcd,
-	0xa1, 0x6a, 0xdb, 0x4b, 0x6c, 0x53, 0xd6, 0x17, 0xcf, 0x4a, 0xba, 0x58, 0xc5, 0xd6, 0xa3, 0x5a,
-	0xdc, 0x0b, 0xd2, 0x7a, 0xd9, 0x5a, 0xb6, 0x1e, 0x57, 0xb1, 0xf5, 0x28, 0x96, 0x7b, 0x48, 0x5a,
-	0x2f, 0x5b, 0xc3, 0xd6, 0xe3, 0xaa, 0x9d, 0x59, 0xa8, 0x62, 0x2c, 0x69, 0x5f, 0xc0, 0x22, 0xc7,
-	0xe5, 0x94, 0xd4, 0x91, 0x0a, 0xf1, 0x22, 0x8e, 0x85, 0x98, 0x46, 0x2c, 0x46, 0x3c, 0xd3, 0x48,
-	0x31, 0xbe, 0x30, 0x0f, 0xe3, 0x51, 0x50, 0x1a, 0x05, 0x22, 0x83, 0x4f, 0x9c, 0x6d, 0xfe, 0x0f,
-	0x33, 0xa8, 0x66, 0xaa, 0x72, 0x14, 0x4e, 0xd5, 0xa3, 0xb9, 0xfb, 0x3a, 0xcc, 0x46, 0xf9, 0x8f,
-	0xdc, 0x82, 0x9b, 0xfb, 0xce, 0x85, 0x61, 0x5b, 0x66, 0xc4, 0xaa, 0x97, 0xc8, 0x4d, 0xa8, 0xf1,
-	0x8e, 0x1f, 0x59, 0x75, 0x85, 0xd4, 0x61, 0x1e, 0x5b, 0x35, 0xc1, 0x29, 0x93, 0x05, 0x80, 0x6e,
-	0xe8, 0x7a, 0x82, 0xae, 0x6c, 0xff, 0x59, 0x83, 0x2a, 0x3a, 0x9b, 0xbc, 0x82, 0xb9, 0xf8, 0xbf,
-	0x80, 0x70, 0xcf, 0x66, 0x3f, 0x20, 0xd4, 0xe5, 0x0c, 0x17, 0x2d, 0xd5, 0xee, 0x7e, 0xf7, 0xeb,
-	0x1f, 0x3f, 0x95, 0x57, 0xb5, 0xa5, 0x2d, 0xc3, 0xb3, 0x82, 0xad, 0x8b, 0x07, 0x86, 0xed, 0x9d,
-	0x1a, 0x0f, 0xb6, 0xd8, 0xd3, 0x10, 0x3c, 0x52, 0xee, 0x93, 0x13, 0xa8, 0x49, 0x6d, 0x30, 0xe1,
-	0x1d, 0x47, 0xbe, 0xf1, 0x56, 0x57, 0x72, 0x7c, 0x21, 0xe0, 0x1e, 0x17, 0xb0, 0xae, 0xde, 0x2e,
-	0x12, 0xb0, 0xf5, 0x35, 0xbb, 0x3b, 0xdf, 0x30, 0x39, 0x8f, 0x01, 0x92, 0xd6, 0x94, 0x70, 0x6d,
-	0x73, 0xdd, 0xae, 0xda, 0xc8, 0xb2, 0x85, 0x90, 0x12, 0xb1, 0xa1, 0x26, 0x75, 0x71, 0x44, 0xcd,
-	0xb4, 0x75, 0x52, 0xdf, 0xa6, 0xde, 0x2e, 0x9c, 0x13, 0x48, 0xff, 0xe3, 0xea, 0xb6, 0xc8, 0x5a,
-	0x46, 0xdd, 0x80, 0x2f, 0x15, 0xfa, 0x92, 0x3d, 0x80, 0xa4, 0xeb, 0x22, 0xab, 0xe9, 0x2e, 0x4c,
-	0x96, 0xa5, 0x16, 0x4d, 0xc5, 0x4a, 0xef, 0xc2, 0xbc, 0xdc, 0xb6, 0x10, 0xee, 0xc4, 0x82, 0x7e,
-	0x4d, 0x6d, 0xe6, 0x27, 0x62, 0x90, 0xa7, 0x70, 0x23, 0xd5, 0x28, 0x10, 0xbe, 0xb8, 0xa8, 0x53,
-	0x51, 0x57, 0x0b, 0x66, 0x62, 0x9c, 0xa3, 0xe8, 0x6f, 0x40, 0xfe, 0xcb, 0x21, 0x77, 0x12, 0x8f,
-	0x17, 0x7c, 0x0c, 0xa9, 0xad, 0x51, 0xd3, 0x31, 0xec, 0x2b, 0x58, 0x19, 0xf1, 0xbd, 0x46, 0xb4,
-	0x64, 0xf3, 0xa8, 0xbf, 0x37, 0x75, 0xe4, 0xe3, 0xad, 0x95, 0x58, 0xc8, 0x24, 0x95, 0x26, 0x86,
-	0x4c, 0xae, 0x86, 0xc6, 0x90, 0xc9, 0x17, 0xa4, 0x5a, 0x89, 0x98, 0xb0, 0x32, 0xa2, 0xc5, 0x41,
-	0xcd, 0xc6, 0xf7, 0x4e, 0xea, 0x7f, 0xc7, 0xae, 0x91, 0xec, 0x6f, 0xe4, 0x5b, 0x0e, 0x1e, 0xe3,
-	0x77, 0xa4, 0x2b, 0x93, 0xaf, 0x5b, 0xd1, 0xb5, 0xa3, 0xbb, 0x15, 0xad, 0x44, 0x0e, 0xa0, 0x9e,
-	0xad, 0x2d, 0x09, 0x0f, 0xee, 0x11, 0xa5, 0xb0, 0xba, 0x56, 0x3c, 0x29, 0x01, 0x92, 0xfc, 0xef,
-	0x2b, 0xea, 0x39, 0xf2, 0x57, 0x76, 0xec, 0x09, 0x3d, 0x82, 0xb9, 0xb8, 0xb6, 0xc4, 0xbc, 0x94,
-	0x2d, 0x49, 0x31, 0x2f, 0xe5, 0x0a, 0x50, 0x8c, 0xeb, 0x54, 0x29, 0x88, 0x71, 0x5d, 0x54, 0x6b,
-	0x62, 0x5c, 0x17, 0xd6, 0x8d, 0x5a, 0x89, 0xec, 0xc3, 0x42, 0xba, 0x28, 0xc3, 0xfb, 0x5a, 0x58,
-	0xef, 0xe1, 0x7d, 0x2d, 0xae, 0xe1, 0x84, 0x4a, 0x72, 0x55, 0x25, 0x54, 0x2a, 0x28, 0xd7, 0x84,
-	0x4a, 0x45, 0x25, 0x18, 0x06, 0x6e, 0xf2, 0xe8, 0x60, 0xe0, 0xe6, 0x5e, 0x38, 0x0c, 0xdc, 0xfc,
-	0xdb, 0xa4, 0x95, 0x76, 0x9a, 0x6f, 0xde, 0xb5, 0x94, 0xb7, 0xef, 0x5a, 0xca, 0xef, 0xef, 0x5a,
-	0xca, 0x8f, 0xef, 0x5b, 0xa5, 0xb7, 0xef, 0x5b, 0xa5, 0xdf, 0xde, 0xb7, 0x4a, 0xc7, 0x55, 0xfe,
-	0x8b, 0xfe, 0xf0, 0xaf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x42, 0x20, 0x3c, 0x0b, 0x89, 0x17, 0x00,
-	0x00,
+	// 1705 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x58, 0xcd, 0x6e, 0xdb, 0xc6,
+	0x13, 0x17, 0x25, 0x5b, 0xb6, 0x47, 0x8e, 0x23, 0x6f, 0xfc, 0x21, 0x33, 0x8e, 0xe2, 0x3f, 0xff,
+	0x6d, 0x60, 0xe4, 0x60, 0x37, 0xce, 0x2d, 0x40, 0x80, 0xda, 0x96, 0x83, 0x18, 0x50, 0x62, 0x87,
+	0x8a, 0x51, 0xa4, 0x87, 0x02, 0xb4, 0xb8, 0x96, 0x09, 0x53, 0x24, 0x4d, 0x52, 0x76, 0x8d, 0xa2,
+	0x28, 0xd0, 0x07, 0x68, 0x0b, 0xf4, 0x90, 0x63, 0x0f, 0x7d, 0x99, 0x1c, 0x03, 0xf4, 0xd2, 0x63,
+	0x91, 0xf4, 0x19, 0x7a, 0x2e, 0x76, 0x76, 0x49, 0x2e, 0x3f, 0xa4, 0x46, 0x29, 0xea, 0x1b, 0x67,
+	0x66, 0xf7, 0x37, 0xb3, 0x33, 0xb3, 0xb3, 0x33, 0x84, 0x39, 0xb3, 0xdf, 0x37, 0x82, 0x90, 0xfa,
+	0x1b, 0x9e, 0xef, 0x86, 0x2e, 0x29, 0x7b, 0xc7, 0xea, 0x9c, 0xd9, 0xbf, 0x74, 0xfd, 0xb3, 0x88,
+	0xa7, 0xae, 0xf6, 0x5c, 0xb7, 0x67, 0xd3, 0x4d, 0xc3, 0xb3, 0x36, 0x0d, 0xc7, 0x71, 0x43, 0x23,
+	0xb4, 0x5c, 0x27, 0xe0, 0x52, 0xed, 0x1c, 0x56, 0x9e, 0x59, 0x3d, 0xdf, 0x08, 0xe9, 0x17, 0xb8,
+	0x49, 0xa7, 0xb6, 0x71, 0xa5, 0xd3, 0xf3, 0x01, 0x0d, 0x42, 0xd2, 0x04, 0xd8, 0xb1, 0x1c, 0xdb,
+	0xed, 0x3d, 0x37, 0xfa, 0xb4, 0xa1, 0xac, 0x29, 0xeb, 0x33, 0xba, 0xc4, 0x21, 0xab, 0x30, 0xc3,
+	0xa9, 0x43, 0x37, 0x68, 0x94, 0xd7, 0x94, 0xf5, 0x1b, 0x7a, 0xc2, 0x20, 0x4b, 0x50, 0x0d, 0xdc,
+	0x81, 0xdf, 0xa5, 0x8d, 0x0a, 0xee, 0x14, 0x94, 0x76, 0x08, 0xcd, 0x23, 0xcf, 0x4c, 0x6b, 0xdc,
+	0x75, 0x9d, 0x13, 0xab, 0x17, 0xe9, 0x5d, 0x82, 0x6a, 0x17, 0x19, 0x42, 0xa7, 0xa0, 0x24, 0xc4,
+	0x72, 0x0a, 0xf1, 0x73, 0xa8, 0x77, 0x42, 0xc3, 0x0f, 0x5f, 0x1a, 0xc1, 0x59, 0x84, 0x41, 0x60,
+	0x22, 0x34, 0x82, 0x33, 0x81, 0x80, 0xdf, 0xa4, 0x01, 0x53, 0x7c, 0x07, 0xb3, 0xb6, 0xb2, 0x3e,
+	0xa3, 0x47, 0xa4, 0x76, 0x0e, 0xf3, 0x12, 0x42, 0xe0, 0xb9, 0x4e, 0x40, 0x99, 0x3a, 0x9f, 0x06,
+	0x03, 0x3b, 0x44, 0x90, 0x69, 0x5d, 0x50, 0xa4, 0x0e, 0x95, 0x7e, 0xd0, 0x13, 0x36, 0xb0, 0x4f,
+	0xb2, 0x95, 0x00, 0x57, 0xd6, 0x2a, 0xeb, 0xb5, 0xad, 0xc6, 0x86, 0x77, 0xbc, 0xb1, 0xeb, 0xf6,
+	0xfb, 0xae, 0x13, 0x9d, 0x92, 0x83, 0x26, 0x2a, 0x1f, 0xc2, 0x0a, 0x77, 0xc3, 0x33, 0x8c, 0xe0,
+	0x07, 0x79, 0x40, 0xbb, 0x02, 0xb5, 0x68, 0xd3, 0xd8, 0x06, 0x3f, 0xc8, 0x1a, 0xbc, 0xcc, 0x0c,
+	0x7e, 0x31, 0xa0, 0xfe, 0x55, 0x27, 0x34, 0xc2, 0x41, 0x90, 0xb7, 0xf7, 0x2b, 0x20, 0x07, 0x1e,
+	0x65, 0x99, 0x22, 0xbb, 0x59, 0x85, 0xb2, 0xeb, 0xa1, 0xba, 0xb9, 0x2d, 0x60, 0x18, 0x4c, 0x78,
+	0xe0, 0xe9, 0x65, 0xd7, 0x63, 0x21, 0x70, 0x58, 0xe2, 0x70, 0xbd, 0xf8, 0x2d, 0x87, 0xa0, 0x92,
+	0x0e, 0xc1, 0x8f, 0x0a, 0xdc, 0x4a, 0x29, 0x10, 0x87, 0x1a, 0xa5, 0x21, 0x39, 0x70, 0xb9, 0xe8,
+	0xc0, 0x95, 0xc2, 0x08, 0x4d, 0x7c, 0x68, 0x84, 0xb6, 0x61, 0x9e, 0x3b, 0xfb, 0xe3, 0xf3, 0xca,
+	0x07, 0x22, 0x43, 0x5c, 0x4b, 0x62, 0x3d, 0x81, 0x25, 0x29, 0x90, 0x6d, 0x2b, 0x08, 0x25, 0xdb,
+	0x9d, 0xe4, 0x26, 0xe7, 0x02, 0x92, 0xb1, 0xfd, 0x02, 0x96, 0x73, 0x38, 0xd7, 0x91, 0x68, 0x7b,
+	0xb0, 0x88, 0xf2, 0x3d, 0xdf, 0x77, 0xfd, 0x8f, 0x37, 0x3f, 0x14, 0x6e, 0x90, 0x60, 0xc6, 0xb6,
+	0xfe, 0xb3, 0xac, 0xf5, 0x4b, 0xb1, 0xf5, 0x08, 0x9b, 0x37, 0x7e, 0x17, 0x6e, 0x75, 0x4e, 0xdd,
+	0xcb, 0x56, 0xab, 0xdd, 0x76, 0xbb, 0x67, 0xc1, 0xc7, 0x65, 0xcd, 0x2f, 0x0a, 0x4c, 0x09, 0x04,
+	0x32, 0x07, 0xe5, 0xfd, 0x96, 0xd8, 0x57, 0xde, 0x6f, 0xc5, 0x48, 0x65, 0x09, 0x89, 0xc0, 0x44,
+	0xdf, 0x35, 0xa3, 0x3a, 0x8b, 0xdf, 0x64, 0x01, 0x26, 0xdd, 0x4b, 0x87, 0xfa, 0x8d, 0x09, 0x64,
+	0x72, 0x82, 0xad, 0x6c, 0xb5, 0xda, 0x41, 0x63, 0x12, 0x15, 0xe2, 0x37, 0x56, 0xd5, 0x2b, 0xa7,
+	0x4b, 0xcd, 0x46, 0x15, 0xb9, 0x82, 0x22, 0x2a, 0x4c, 0x0f, 0x1c, 0x21, 0x99, 0x42, 0x49, 0x4c,
+	0x6b, 0x5d, 0x58, 0x48, 0x1f, 0x73, 0x6c, 0xd7, 0xfe, 0x0f, 0x26, 0x6d, 0xb6, 0x55, 0x38, 0xb6,
+	0xc6, 0x1c, 0x2b, 0xe0, 0x74, 0x2e, 0xd1, 0x6c, 0x58, 0x38, 0x72, 0xd8, 0x67, 0xc4, 0x17, 0xce,
+	0xcc, 0xba, 0x44, 0x83, 0x59, 0x9f, 0x7a, 0xb6, 0xd1, 0xa5, 0x07, 0x78, 0x62, 0xae, 0x25, 0xc5,
+	0x23, 0x6b, 0x50, 0x3b, 0x71, 0xfd, 0x2e, 0xd5, 0x69, 0xdf, 0xbd, 0xe0, 0x9e, 0x9a, 0xd6, 0x65,
+	0x96, 0xb6, 0x0d, 0x8b, 0x19, 0x6d, 0xe3, 0x9e, 0x49, 0x7b, 0x04, 0xcd, 0xce, 0xa5, 0x15, 0x76,
+	0x4f, 0xa5, 0x97, 0x8d, 0x17, 0xea, 0xc8, 0x74, 0x29, 0xe6, 0x4a, 0x3a, 0xe6, 0xdf, 0xc1, 0xdd,
+	0xa1, 0x7b, 0xaf, 0xa5, 0x6c, 0xe8, 0xb0, 0x22, 0xca, 0x6f, 0x41, 0x27, 0x70, 0x5b, 0x2a, 0xc2,
+	0x18, 0x2a, 0x94, 0x8a, 0x2a, 0x3c, 0x3c, 0x91, 0x5f, 0x2b, 0xa0, 0x16, 0x81, 0x8a, 0x03, 0x8d,
+	0x44, 0xfd, 0x6f, 0x6b, 0xfb, 0x1b, 0x05, 0xe6, 0x9f, 0x1a, 0x8e, 0x69, 0xd3, 0xce, 0x8b, 0x76,
+	0x30, 0xaa, 0xc2, 0xac, 0xa0, 0x91, 0x65, 0x34, 0x72, 0x86, 0x01, 0x77, 0x5e, 0xb4, 0x93, 0x07,
+	0xce, 0xf0, 0x7b, 0xd1, 0x4b, 0x86, 0xdf, 0xac, 0x27, 0x3a, 0x8e, 0x7b, 0x22, 0x7e, 0xf7, 0x12,
+	0x86, 0xd4, 0xc1, 0x4c, 0xca, 0x1d, 0x0c, 0xeb, 0xb4, 0x82, 0x73, 0xfb, 0xd0, 0x08, 0x43, 0xea,
+	0x3b, 0x8d, 0x2a, 0xef, 0xb4, 0x12, 0x0e, 0xbb, 0x8b, 0xc1, 0xa9, 0xe1, 0x9b, 0x96, 0xd3, 0x6b,
+	0x4c, 0xa1, 0x3b, 0x62, 0x9a, 0xbd, 0x31, 0xf2, 0x49, 0xae, 0x25, 0x59, 0x5e, 0x2b, 0xb0, 0x7c,
+	0x38, 0xf0, 0x7b, 0x45, 0xb9, 0x32, 0x34, 0xc7, 0xd9, 0x29, 0x2c, 0xc7, 0xe8, 0x86, 0xd6, 0x05,
+	0x15, 0x41, 0x8d, 0x69, 0xac, 0x6b, 0x56, 0x9f, 0xdf, 0xcc, 0x8a, 0x8e, 0xdf, 0x6c, 0xfd, 0x89,
+	0x65, 0x53, 0x0c, 0x09, 0x77, 0x65, 0x4c, 0xa3, 0x27, 0x07, 0xc7, 0x2d, 0xcb, 0x8f, 0x3d, 0x89,
+	0x94, 0xf6, 0x35, 0x34, 0xf2, 0x86, 0x5d, 0x8b, 0x4f, 0xee, 0x41, 0x7d, 0xf7, 0x94, 0x76, 0xcf,
+	0xfe, 0xa1, 0x5b, 0xd0, 0x1e, 0xc3, 0xbc, 0xb4, 0x6e, 0xec, 0x22, 0xd3, 0x86, 0x05, 0x71, 0xa5,
+	0x3a, 0xa8, 0x38, 0x52, 0xb5, 0x2a, 0x5d, 0xa6, 0x59, 0xcc, 0x53, 0x14, 0x27, 0xb7, 0x49, 0x34,
+	0x94, 0xe5, 0x54, 0x43, 0x39, 0x80, 0xc5, 0x0c, 0xda, 0xb5, 0xf8, 0x6a, 0x0f, 0x16, 0x75, 0xda,
+	0xb3, 0x58, 0x79, 0x8b, 0x96, 0x8c, 0x7c, 0xe3, 0x0d, 0xd3, 0xf4, 0x69, 0x10, 0x08, 0xb5, 0x11,
+	0xa9, 0xed, 0xc0, 0x52, 0x16, 0x66, 0x6c, 0x7f, 0xb6, 0x60, 0xe1, 0xe0, 0xe4, 0xc4, 0xb6, 0x1c,
+	0xfa, 0x6f, 0x2c, 0xd9, 0x86, 0xc5, 0x0c, 0xca, 0xd8, 0x86, 0xfc, 0xa0, 0x00, 0xf0, 0x8a, 0xbf,
+	0xef, 0x9c, 0xb8, 0x85, 0xfa, 0x55, 0x98, 0xee, 0xd3, 0xfe, 0x31, 0xf5, 0xf7, 0x5b, 0xb8, 0x73,
+	0x42, 0x8f, 0x69, 0xf6, 0xe0, 0x1b, 0xb6, 0x15, 0xbf, 0x6d, 0x9c, 0x60, 0x3b, 0x3c, 0x4a, 0xfd,
+	0x23, 0xbd, 0xcd, 0x8b, 0xe3, 0x8c, 0x1e, 0xd3, 0xac, 0xe8, 0x74, 0x6d, 0x8b, 0x3a, 0x21, 0x4a,
+	0x79, 0x4b, 0x20, 0x71, 0xb4, 0x63, 0x00, 0x7e, 0x98, 0xa1, 0xf6, 0xb0, 0x02, 0x68, 0x9a, 0xd1,
+	0x8b, 0x8b, 0xdf, 0xcc, 0x8e, 0x20, 0x34, 0x7a, 0x51, 0x37, 0xc2, 0x09, 0xa9, 0xf0, 0x4d, 0xa4,
+	0x46, 0xb7, 0x36, 0xd4, 0x59, 0x6f, 0xd6, 0xa6, 0x86, 0x49, 0xfd, 0x67, 0x78, 0x96, 0xc8, 0x35,
+	0x4a, 0x92, 0x62, 0x45, 0x93, 0x44, 0xa4, 0xbb, 0x92, 0xe8, 0xd6, 0x9e, 0x73, 0x34, 0xee, 0xc5,
+	0xa1, 0x68, 0xeb, 0x30, 0xc5, 0xa7, 0x66, 0xfe, 0x5e, 0xd5, 0xb6, 0xe6, 0x58, 0xc2, 0x26, 0xae,
+	0xd7, 0x23, 0x71, 0x84, 0xc7, 0xbd, 0x30, 0x0a, 0x8f, 0x4f, 0xdc, 0x29, 0xbc, 0xc4, 0x75, 0x7a,
+	0x24, 0xd6, 0x7e, 0x55, 0x60, 0x8a, 0xc3, 0x04, 0x64, 0x03, 0xaa, 0x36, 0x9e, 0x1a, 0xa1, 0x6a,
+	0x5b, 0x0b, 0x6c, 0x53, 0xd6, 0x17, 0x4f, 0x4b, 0xba, 0x58, 0xc5, 0xd6, 0x73, 0xb3, 0xd0, 0x0b,
+	0xd2, 0x7a, 0xf9, 0xb4, 0x6c, 0x3d, 0x5f, 0xc5, 0xd6, 0x73, 0xb5, 0xe8, 0x21, 0x69, 0xbd, 0x7c,
+	0x1a, 0xb6, 0x9e, 0xaf, 0xda, 0x99, 0x86, 0x2a, 0xcf, 0x25, 0xad, 0x03, 0xf3, 0x88, 0x8b, 0x54,
+	0x74, 0x1d, 0x98, 0xd3, 0x68, 0xff, 0xe5, 0x95, 0x47, 0x45, 0x8d, 0xe1, 0x4e, 0xc3, 0x35, 0x8c,
+	0xab, 0x47, 0x62, 0x96, 0x00, 0x2c, 0x40, 0x51, 0x33, 0xc0, 0x09, 0x8d, 0x02, 0x91, 0x41, 0xc7,
+	0xae, 0x32, 0x9f, 0xa2, 0x7e, 0xe6, 0x39, 0xb9, 0x63, 0x14, 0xce, 0xd4, 0x23, 0xd9, 0x7d, 0x1d,
+	0xa6, 0xa3, 0xba, 0x47, 0x6e, 0xc1, 0xcd, 0x7d, 0xe7, 0xc2, 0xb0, 0x2d, 0x33, 0x62, 0xd5, 0x4b,
+	0xe4, 0x26, 0xd4, 0x70, 0xd2, 0xe7, 0xac, 0xba, 0x42, 0xea, 0x30, 0xcb, 0x47, 0x34, 0xc1, 0x29,
+	0x93, 0x39, 0x80, 0x4e, 0xe8, 0x7a, 0x82, 0xae, 0xdc, 0xff, 0x12, 0x20, 0x39, 0x27, 0x03, 0x10,
+	0xa8, 0x8c, 0xac, 0x97, 0xd8, 0x72, 0x1e, 0x02, 0xa4, 0x15, 0x46, 0x73, 0x17, 0x23, 0x8d, 0x70,
+	0x3c, 0xa4, 0x48, 0x57, 0x48, 0x0d, 0xa6, 0xb6, 0x6d, 0x1b, 0x89, 0x89, 0xad, 0xbf, 0x6a, 0x50,
+	0xe5, 0xbb, 0xc9, 0x2b, 0x98, 0x89, 0xff, 0x41, 0x10, 0x8c, 0x56, 0xf6, 0xa7, 0x86, 0xba, 0x98,
+	0xe1, 0x72, 0x2f, 0x6a, 0x77, 0xbf, 0xff, 0xed, 0xcf, 0x9f, 0xcb, 0x2b, 0xda, 0xc2, 0xa6, 0xe1,
+	0x59, 0xc1, 0xe6, 0xc5, 0x03, 0xc3, 0xf6, 0x4e, 0x8d, 0x07, 0x9b, 0xec, 0xb9, 0x09, 0x1e, 0x29,
+	0xf7, 0xc9, 0x09, 0xd4, 0xa4, 0xd1, 0x9a, 0xe0, 0x14, 0x93, 0x1f, 0xe6, 0xd5, 0xe5, 0x1c, 0x5f,
+	0x28, 0xb8, 0x87, 0x0a, 0xd6, 0xd4, 0xdb, 0x45, 0x0a, 0x36, 0xbf, 0x61, 0x11, 0xfe, 0x96, 0xe9,
+	0x79, 0x0c, 0x90, 0x8c, 0xbb, 0x04, 0xad, 0xcd, 0x4d, 0xd0, 0xea, 0x52, 0x96, 0x2d, 0x94, 0x94,
+	0x88, 0x0d, 0x35, 0x69, 0x32, 0x24, 0x6a, 0x66, 0x54, 0x94, 0x66, 0x41, 0xf5, 0x76, 0xa1, 0x4c,
+	0x20, 0x7d, 0x82, 0xe6, 0x36, 0xc9, 0x6a, 0xc6, 0xdc, 0x00, 0x97, 0x0a, 0x7b, 0xc9, 0x1e, 0x40,
+	0x32, 0xc9, 0x91, 0x95, 0xf4, 0x64, 0x27, 0xeb, 0x52, 0x8b, 0x44, 0xb1, 0xd1, 0xbb, 0x30, 0x2b,
+	0x8f, 0x42, 0x04, 0x9d, 0x58, 0x30, 0x03, 0xaa, 0x8d, 0xbc, 0x20, 0x06, 0x79, 0x02, 0x37, 0x52,
+	0xc3, 0x07, 0xc1, 0xc5, 0x45, 0xd3, 0x8f, 0xba, 0x52, 0x20, 0x89, 0x71, 0x8e, 0xa2, 0xff, 0x0d,
+	0xf2, 0xff, 0x21, 0x72, 0x27, 0xf1, 0x78, 0xc1, 0xcf, 0x26, 0xb5, 0x39, 0x4c, 0x1c, 0xc3, 0xbe,
+	0x82, 0xe5, 0x21, 0xbf, 0xec, 0x88, 0x96, 0x6c, 0x1e, 0xf6, 0x3f, 0x4f, 0x1d, 0xda, 0x10, 0x68,
+	0x25, 0x96, 0x32, 0x49, 0xf7, 0xca, 0x53, 0x26, 0xd7, 0x97, 0xf3, 0x94, 0xc9, 0x37, 0xb9, 0x5a,
+	0x89, 0x98, 0xb0, 0x3c, 0x64, 0x6c, 0xe2, 0x96, 0x8d, 0x9e, 0xc7, 0xd4, 0xff, 0x8f, 0x5c, 0x23,
+	0x9d, 0x7f, 0x29, 0x3f, 0xc6, 0x60, 0x8e, 0xdf, 0x91, 0xae, 0x4c, 0xbe, 0x17, 0xe6, 0xae, 0x1d,
+	0x3e, 0x01, 0x69, 0x25, 0x72, 0x00, 0xf5, 0x6c, 0xbf, 0x4a, 0x30, 0xb9, 0x87, 0xb4, 0xd7, 0xea,
+	0x6a, 0xb1, 0x50, 0x02, 0x24, 0xf9, 0x3f, 0xba, 0xdc, 0xce, 0xa1, 0x7f, 0x7a, 0x47, 0x46, 0xe8,
+	0x11, 0xcc, 0xc4, 0xfd, 0x2a, 0xaf, 0x4b, 0xd9, 0x36, 0x97, 0xd7, 0xa5, 0x5c, 0x53, 0xcb, 0xf3,
+	0x3a, 0xd5, 0x5e, 0xf2, 0xbc, 0x2e, 0xea, 0x5f, 0x79, 0x5e, 0x17, 0xf6, 0xa2, 0x5a, 0x89, 0xec,
+	0xc3, 0x5c, 0xba, 0xd1, 0xe3, 0xf7, 0xb5, 0xb0, 0x87, 0xe4, 0xf7, 0xb5, 0xb8, 0x2f, 0x14, 0x26,
+	0xc9, 0x9d, 0x9a, 0x30, 0xa9, 0xa0, 0x05, 0x14, 0x26, 0x15, 0xb5, 0x75, 0x3c, 0x71, 0x93, 0x07,
+	0x8d, 0x27, 0x6e, 0xee, 0xd5, 0xe4, 0x89, 0x9b, 0x7f, 0xf7, 0xb4, 0xd2, 0x4e, 0xe3, 0xcd, 0xbb,
+	0xa6, 0xf2, 0xf6, 0x5d, 0x53, 0xf9, 0xe3, 0x5d, 0x53, 0xf9, 0xe9, 0x7d, 0xb3, 0xf4, 0xf6, 0x7d,
+	0xb3, 0xf4, 0xfb, 0xfb, 0x66, 0xe9, 0xb8, 0x8a, 0x7f, 0xe6, 0x1f, 0xfe, 0x1d, 0x00, 0x00, 0xff,
+	0xff, 0x48, 0xc1, 0x1c, 0xb1, 0xdd, 0x17, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -5557,33 +5586,17 @@ func (m *ListMemberRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	_ = i
 	var l int
 	_ = l
-	if m.Leader {
-		i--
-		if m.Leader {
-			dAtA[i] = 1
-		} else {
-			dAtA[i] = 0
-		}
-		i--
-		dAtA[i] = 0x18
-	}
-	if m.Worker {
-		i--
-		if m.Worker {
-			dAtA[i] = 1
-		} else {
-			dAtA[i] = 0
+	if len(m.Names) > 0 {
+		for iNdEx := len(m.Names) - 1; iNdEx >= 0; iNdEx-- {
+			i -= len(m.Names[iNdEx])
+			copy(dAtA[i:], m.Names[iNdEx])
+			i = encodeVarintDmmaster(dAtA, i, uint64(len(m.Names[iNdEx])))
+			i--
+			dAtA[i] = 0x12
 		}
-		i--
-		dAtA[i] = 0x10
 	}
-	if m.Master {
-		i--
-		if m.Master {
-			dAtA[i] = 1
-		} else {
-			dAtA[i] = 0
-		}
+	if m.MemType != 0 {
+		i = encodeVarintDmmaster(dAtA, i, uint64(m.MemType))
 		i--
 		dAtA[i] = 0x8
 	}
@@ -6550,14 +6563,14 @@ func (m *ListMemberRequest) Size() (n int) {
 	}
 	var l int
 	_ = l
-	if m.Master {
-		n += 2
+	if m.MemType != 0 {
+		n += 1 + sovDmmaster(uint64(m.MemType))
 	}
-	if m.Worker {
-		n += 2
-	}
-	if m.Leader {
-		n += 2
+	if len(m.Names) > 0 {
+		for _, s := range m.Names {
+			l = len(s)
+			n += 1 + l + sovDmmaster(uint64(l))
+		}
 	}
 	return n
 }
@@ -12186,9 +12199,9 @@ func (m *ListMemberRequest) Unmarshal(dAtA []byte) error {
 		switch fieldNum {
 		case 1:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Master", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field MemType", wireType)
 			}
-			var v int
+			m.MemType = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowDmmaster
@@ -12198,17 +12211,16 @@ func (m *ListMemberRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				v |= int(b&0x7F) << shift
+				m.MemType |= MemberType(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			m.Master = bool(v != 0)
 		case 2:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Worker", wireType)
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Names", wireType)
 			}
-			var v int
+			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowDmmaster
@@ -12218,32 +12230,24 @@ func (m *ListMemberRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				v |= int(b&0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			m.Worker = bool(v != 0)
-		case 3:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Leader", wireType)
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthDmmaster
 			}
-			var v int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowDmmaster
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				v |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthDmmaster
 			}
-			m.Leader = bool(v != 0)
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Names = append(m.Names, string(dAtA[iNdEx:postIndex]))
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipDmmaster(dAtA[iNdEx:])
diff --git a/dm/proto/dmmaster.proto b/dm/proto/dmmaster.proto
index e377f1593c..7a44f3457c 100644
--- a/dm/proto/dmmaster.proto
+++ b/dm/proto/dmmaster.proto
@@ -310,6 +310,14 @@ message OfflineWorkerResponse {
     string msg = 2;
 }
 
+enum MemberType {
+    InvalidType = 0;  // placeholder
+    MasterType = 1;
+    WorkerType = 2;
+    LeaderType = 3;
+    AllType = 4;
+}
+
 message MasterInfo {
     string name = 1;
     uint64 memberID = 2;
@@ -350,9 +358,8 @@ message Members {
 }
 
 message ListMemberRequest {
-    bool master = 1;
-    bool worker = 2;
-    bool leader = 3;
+    MemberType memType = 1;
+    repeated string names = 2;
 }
 
 message ListMemberResponse {
diff --git a/tests/_utils/get_leader b/tests/_utils/get_leader
index c3a070496c..be60852539 100755
--- a/tests/_utils/get_leader
+++ b/tests/_utils/get_leader
@@ -12,4 +12,4 @@ ts=$(date +"%s")
 dmctl_log=$workdir/dmctl.$ts.log
 pid=$$
 
-echo $($binary -test.coverprofile="$TEST_DIR/cov.$TEST_NAME.dmctl.$ts.$pid.out" DEVEL -master-addr=$master_addr list-member --leader | grep name | gawk 'match($2,/"(.*)",/,a) {print a[1]}')
\ No newline at end of file
+echo $($binary -test.coverprofile="$TEST_DIR/cov.$TEST_NAME.dmctl.$ts.$pid.out" DEVEL -master-addr=$master_addr list-member --type=leader | grep name | gawk 'match($2,/"(.*)",/,a) {print a[1]}')
\ No newline at end of file
diff --git a/tests/ha_master/run.sh b/tests/ha_master/run.sh
index 47be923726..c27be9b7f0 100755
--- a/tests/ha_master/run.sh
+++ b/tests/ha_master/run.sh
@@ -38,7 +38,7 @@ function test_list_member() {
 
     # check list-member master
     run_dm_ctl $WORK_DIR "127.0.0.1:$MASTER_PORT" \
-        "list-member --master" \
+        "list-member --type=master" \
         "\"alive\": true" 5
 
     # kill leader
@@ -63,7 +63,7 @@ function test_list_member() {
         fi
     done
     run_dm_ctl $WORK_DIR "127.0.0.1:$MASTER_PORT" \
-        "list-member --master" \
+        "list-member --type=master" \
         "\"alive\": true" 4
     echo "kill leader" $leader
     ps aux | grep $leader |awk '{print $2}'|xargs kill || true
@@ -86,7 +86,7 @@ function test_list_member() {
         fi
     done
     run_dm_ctl $WORK_DIR "127.0.0.1:$MASTER_PORT" \
-        "list-member --master" \
+        "list-member --type=master" \
         "\"alive\": true" 3
     echo "kill leader" $leader
     ps aux | grep $leader |awk '{print $2}'|xargs kill || true
@@ -118,21 +118,21 @@ function test_list_member() {
         fi
     done
     run_dm_ctl $WORK_DIR "127.0.0.1:$MASTER_PORT" \
-        "list-member --master" \
+        "list-member --type=master" \
         "\"alive\": true" 5
     
     sleep 5
     
     # check list-member worker
     run_dm_ctl $WORK_DIR "127.0.0.1:$MASTER_PORT" \
-        "list-member --worker" \
+        "list-member --type=worker --name=worker1,worker2" \
         "\"stage\": \"bound\"" 2
     
     dmctl_operate_source stop $WORK_DIR/source1.toml $SOURCE_ID1
     sleep 5
 
     run_dm_ctl $WORK_DIR "127.0.0.1:$MASTER_PORT" \
-        "list-member --worker" \
+        "list-member --type=worker" \
         "\"stage\": \"bound\"" 1 \
         "\"stage\": \"free\"" 1
  
@@ -140,7 +140,7 @@ function test_list_member() {
     sleep 5
 
     run_dm_ctl $WORK_DIR "127.0.0.1:$MASTER_PORT" \
-        "list-member --worker" \
+        "list-member" \
         "\"stage\": \"free\"" 2
  
     dmctl_operate_source create $WORK_DIR/source1.toml $SOURCE_ID1
@@ -148,7 +148,7 @@ function test_list_member() {
     sleep 5
 
     run_dm_ctl $WORK_DIR "127.0.0.1:$MASTER_PORT" \
-        "list-member" \
+        "list-member --name=worker1,worker2" \
         "\"stage\": \"bound\"" 2
 
     # kill worker
@@ -158,7 +158,7 @@ function test_list_member() {
     sleep 5
 
     run_dm_ctl $WORK_DIR "127.0.0.1:$MASTER_PORT" \
-        "list-member" \
+        "list-member --name=worker1,worker2" \
         "\"stage\": \"bound\"" 1 \
         "\"stage\": \"offline\"" 1
 
@@ -179,7 +179,7 @@ function test_list_member() {
     sleep 5
 
     run_dm_ctl $WORK_DIR "127.0.0.1:$MASTER_PORT" \
-        "list-member --worker" \
+        "list-member --type=worker" \
         "\"stage\": \"bound\"" 2
 
     echo "[$(date)] <<<<<< finish test_list_member_command >>>>>>"

From 63e96f62bc0aa5543a4ccd1a2b0ca0d2821497ed Mon Sep 17 00:00:00 2001
From: gmhdbjd <gmhdbjd@gmail.com>
Date: Fri, 15 May 2020 13:41:33 +0800
Subject: [PATCH 13/17] add retry in test

---
 tests/_utils/get_leader | 15 ++++++++++++++-
 tests/ha_master/run.sh  | 30 +++++++++++-------------------
 2 files changed, 25 insertions(+), 20 deletions(-)

diff --git a/tests/_utils/get_leader b/tests/_utils/get_leader
index be60852539..76d01e670b 100755
--- a/tests/_utils/get_leader
+++ b/tests/_utils/get_leader
@@ -12,4 +12,17 @@ ts=$(date +"%s")
 dmctl_log=$workdir/dmctl.$ts.log
 pid=$$
 
-echo $($binary -test.coverprofile="$TEST_DIR/cov.$TEST_NAME.dmctl.$ts.$pid.out" DEVEL -master-addr=$master_addr list-member --type=leader | grep name | gawk 'match($2,/"(.*)",/,a) {print a[1]}')
\ No newline at end of file
+leader_name=""
+
+for ((k=0; k<10; k++)); do
+    leader_name=$($binary -test.coverprofile="$TEST_DIR/cov.$TEST_NAME.dmctl.$ts.$pid.out" DEVEL -master-addr=$master_addr list-member --type=leader | grep name | gawk 'match($2,/"(.*)",/,a) {print a[1]}')
+    if [[ ! -z "$leader_name" ]]; then
+        echo $leader_name
+        break
+    fi
+    sleep 2
+done
+
+if [[ -z "$leader_name" ]]; then
+    exit 1
+fi
\ No newline at end of file
diff --git a/tests/ha_master/run.sh b/tests/ha_master/run.sh
index c27be9b7f0..44dcc350c0 100755
--- a/tests/ha_master/run.sh
+++ b/tests/ha_master/run.sh
@@ -37,7 +37,7 @@ function test_list_member() {
     done
 
     # check list-member master
-    run_dm_ctl $WORK_DIR "127.0.0.1:$MASTER_PORT" \
+    run_dm_ctl_with_retry $WORK_DIR "127.0.0.1:$MASTER_PORT" \
         "list-member --type=master" \
         "\"alive\": true" 5
 
@@ -62,7 +62,7 @@ function test_list_member() {
             exit 1
         fi
     done
-    run_dm_ctl $WORK_DIR "127.0.0.1:$MASTER_PORT" \
+    run_dm_ctl_with_retry $WORK_DIR "127.0.0.1:$MASTER_PORT" \
         "list-member --type=master" \
         "\"alive\": true" 4
     echo "kill leader" $leader
@@ -85,7 +85,7 @@ function test_list_member() {
             exit 1
         fi
     done
-    run_dm_ctl $WORK_DIR "127.0.0.1:$MASTER_PORT" \
+    run_dm_ctl_with_retry $WORK_DIR "127.0.0.1:$MASTER_PORT" \
         "list-member --type=master" \
         "\"alive\": true" 3
     echo "kill leader" $leader
@@ -117,37 +117,32 @@ function test_list_member() {
             exit 1
         fi
     done
-    run_dm_ctl $WORK_DIR "127.0.0.1:$MASTER_PORT" \
+    run_dm_ctl_with_retry $WORK_DIR "127.0.0.1:$MASTER_PORT" \
         "list-member --type=master" \
         "\"alive\": true" 5
     
-    sleep 5
-    
     # check list-member worker
-    run_dm_ctl $WORK_DIR "127.0.0.1:$MASTER_PORT" \
+    run_dm_ctl_with_retry $WORK_DIR "127.0.0.1:$MASTER_PORT" \
         "list-member --type=worker --name=worker1,worker2" \
         "\"stage\": \"bound\"" 2
     
     dmctl_operate_source stop $WORK_DIR/source1.toml $SOURCE_ID1
-    sleep 5
 
-    run_dm_ctl $WORK_DIR "127.0.0.1:$MASTER_PORT" \
+    run_dm_ctl_with_retry $WORK_DIR "127.0.0.1:$MASTER_PORT" \
         "list-member --type=worker" \
         "\"stage\": \"bound\"" 1 \
         "\"stage\": \"free\"" 1
  
     dmctl_operate_source stop $WORK_DIR/source2.toml $SOURCE_ID2
-    sleep 5
 
-    run_dm_ctl $WORK_DIR "127.0.0.1:$MASTER_PORT" \
+    run_dm_ctl_with_retry $WORK_DIR "127.0.0.1:$MASTER_PORT" \
         "list-member" \
         "\"stage\": \"free\"" 2
  
     dmctl_operate_source create $WORK_DIR/source1.toml $SOURCE_ID1
     dmctl_operate_source create $WORK_DIR/source2.toml $SOURCE_ID2
-    sleep 5
 
-    run_dm_ctl $WORK_DIR "127.0.0.1:$MASTER_PORT" \
+    run_dm_ctl_with_retry $WORK_DIR "127.0.0.1:$MASTER_PORT" \
         "list-member --name=worker1,worker2" \
         "\"stage\": \"bound\"" 2
 
@@ -155,9 +150,8 @@ function test_list_member() {
     echo "kill worker1"
     ps aux | grep dm-worker1 |awk '{print $2}'|xargs kill || true
     check_port_offline $WORKER1_PORT 20
-    sleep 5
 
-    run_dm_ctl $WORK_DIR "127.0.0.1:$MASTER_PORT" \
+    run_dm_ctl_with_retry $WORK_DIR "127.0.0.1:$MASTER_PORT" \
         "list-member --name=worker1,worker2" \
         "\"stage\": \"bound\"" 1 \
         "\"stage\": \"offline\"" 1
@@ -166,9 +160,8 @@ function test_list_member() {
     echo "kill worker2"
     ps aux | grep dm-worker2 |awk '{print $2}'|xargs kill || true
     check_port_offline $WORKER2_PORT 20
-    sleep 5
 
-    run_dm_ctl $WORK_DIR "127.0.0.1:$MASTER_PORT" \
+    run_dm_ctl_with_retry $WORK_DIR "127.0.0.1:$MASTER_PORT" \
         "list-member" \
         "\"stage\": \"offline\"" 2
 
@@ -176,9 +169,8 @@ function test_list_member() {
     check_rpc_alive $cur/../bin/check_worker_online 127.0.0.1:$WORKER1_PORT
     run_dm_worker $WORK_DIR/worker2 $WORKER2_PORT $cur/conf/dm-worker2.toml
     check_rpc_alive $cur/../bin/check_worker_online 127.0.0.1:$WORKER2_PORT
-    sleep 5
 
-    run_dm_ctl $WORK_DIR "127.0.0.1:$MASTER_PORT" \
+    run_dm_ctl_with_retry $WORK_DIR "127.0.0.1:$MASTER_PORT" \
         "list-member --type=worker" \
         "\"stage\": \"bound\"" 2
 

From a8cf11d6bdd68691e270721539a11bf6400c1a7c Mon Sep 17 00:00:00 2001
From: GMHDBJD <35025882+GMHDBJD@users.noreply.github.com>
Date: Fri, 15 May 2020 14:43:13 +0800
Subject: [PATCH 14/17] Update dm/ctl/master/list_member.go

Co-authored-by: Chunzhu Li <lichunzhu@pingcap.com>
---
 dm/ctl/master/list_member.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dm/ctl/master/list_member.go b/dm/ctl/master/list_member.go
index e21e96f408..b736071fc8 100644
--- a/dm/ctl/master/list_member.go
+++ b/dm/ctl/master/list_member.go
@@ -41,7 +41,7 @@ func (c ListMemberFlags) Reset() {
 // NewListMemberCmd creates an ListMember command
 func NewListMemberCmd() *cobra.Command {
 	cmd := &cobra.Command{
-		Use:   "list-member [--type] [--name]",
+		Use:   "list-member [--type leader/master/worker] [--name master-name/worker-name ...]",
 		Short: "list member information",
 		Run:   listMemberFunc,
 	}

From 5cc96349c30a26fa1231a4e70eba4b80fca37401 Mon Sep 17 00:00:00 2001
From: gmhdbjd <gmhdbjd@gmail.com>
Date: Fri, 15 May 2020 16:57:35 +0800
Subject: [PATCH 15/17] address comment

---
 dm/ctl/master/list_member.go     |   4 ++
 dm/master/scheduler/scheduler.go |   4 +-
 dm/master/server.go              |   2 +-
 tests/ha_master/run.sh           | 104 ++++++++++---------------------
 4 files changed, 39 insertions(+), 75 deletions(-)

diff --git a/dm/ctl/master/list_member.go b/dm/ctl/master/list_member.go
index b736071fc8..8e7473bd45 100644
--- a/dm/ctl/master/list_member.go
+++ b/dm/ctl/master/list_member.go
@@ -80,6 +80,10 @@ func listMemberFunc(cmd *cobra.Command, _ []string) {
 	}
 
 	memType := convertListMemberType(member)
+	if memType == pb.MemberType_InvalidType {
+		common.PrintLines("invalid type '%s', choose from master, worker, and leader", member)
+		return
+	}
 
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
diff --git a/dm/master/scheduler/scheduler.go b/dm/master/scheduler/scheduler.go
index 448ba12c48..1ae480bdb8 100644
--- a/dm/master/scheduler/scheduler.go
+++ b/dm/master/scheduler/scheduler.go
@@ -573,8 +573,8 @@ func (s *Scheduler) RemoveWorker(name string) error {
 	return nil
 }
 
-// GetWorker gets all worker agent.
-func (s *Scheduler) GetWorker() ([]*Worker, error) {
+// GetAllWorkers gets all worker agent.
+func (s *Scheduler) GetAllWorkers() ([]*Worker, error) {
 	s.mu.RLock()
 	defer s.mu.RUnlock()
 
diff --git a/dm/master/server.go b/dm/master/server.go
index 6ab2c70d38..e8f91be3d3 100644
--- a/dm/master/server.go
+++ b/dm/master/server.go
@@ -1613,7 +1613,7 @@ func (s *Server) listMemberWorker(ctx context.Context, names []string) (*pb.Memb
 		Worker: &pb.ListWorkerMember{},
 	}
 
-	workerAgents, err := s.scheduler.GetWorker()
+	workerAgents, err := s.scheduler.GetAllWorkers()
 	if err != nil {
 		resp.Worker.Msg = errors.ErrorStack(err)
 		return resp, nil
diff --git a/tests/ha_master/run.sh b/tests/ha_master/run.sh
index 44dcc350c0..8d8ec8023a 100755
--- a/tests/ha_master/run.sh
+++ b/tests/ha_master/run.sh
@@ -19,80 +19,40 @@ function test_list_member() {
 
     alive=(1 2 3 4 5)
     leaders=()
-
-    # get leader in all masters
-    for idx in ${alive[@]}; do
-        leaders+=($(get_leader $WORK_DIR 127.0.0.1:${master_ports[$idx]}))
-    done
-
-    # check leader is same for every master
-    leader=${leaders[0]}
-    leader_idx=${leader:6}
-    echo "current leader is" $leader
-    for ld in ${leaders[@]}; do
-        if [ "$leader" != "$ld" ]; then
-            echo "leader not consisent"
-            exit 1
-        fi
+    leader_idx=0
+
+    for i in $(seq 0 2); do
+        alive=( "${alive[@]/$leader_idx}" )
+        leaders=()
+
+        # get leader in all masters
+        for idx in ${alive[@]}; do
+            leaders+=($(get_leader $WORK_DIR 127.0.0.1:${master_ports[$idx]}))
+        done
+        leader=${leaders[0]}
+        leader_idx=${leader:6}
+        echo "current leader is" $leader
+
+        # check leader is same for every master
+        for ld in ${leaders[@]}; do
+            if [ "$leader" != "$ld" ]; then
+                echo "leader not consisent"
+                exit 1
+            fi
+        done
+
+        # check list-member master
+        run_dm_ctl_with_retry $WORK_DIR "127.0.0.1:$MASTER_PORT" \
+            "list-member --type=master" \
+            "\"alive\": true" $((5 - i))
+
+        # kill leader
+        echo "kill leader" $leader
+        ps aux | grep $leader |awk '{print $2}'|xargs kill || true
+        check_port_offline ${master_ports[$leader_idx]} 20
+        sleep 5
     done
 
-    # check list-member master
-    run_dm_ctl_with_retry $WORK_DIR "127.0.0.1:$MASTER_PORT" \
-        "list-member --type=master" \
-        "\"alive\": true" 5
-
-    # kill leader
-    echo "kill leader" $leader
-    ps aux | grep $leader |awk '{print $2}'|xargs kill || true
-    check_port_offline ${master_ports[$leader_idx]} 20
-    sleep 5
-
-    # test again
-    alive=( "${alive[@]/$leader_idx}" )
-    leaders=()
-    for idx in ${alive[@]}; do
-        leaders+=($(get_leader $WORK_DIR 127.0.0.1:${master_ports[$idx]}))
-    done
-    leader=${leaders[0]}
-    leader_idx=${leader:6}
-    echo "current leader is" $leader
-    for ld in ${leaders[@]}; do
-        if [ "$leader" != "$ld" ]; then
-            echo "leader not consisent"
-            exit 1
-        fi
-    done
-    run_dm_ctl_with_retry $WORK_DIR "127.0.0.1:$MASTER_PORT" \
-        "list-member --type=master" \
-        "\"alive\": true" 4
-    echo "kill leader" $leader
-    ps aux | grep $leader |awk '{print $2}'|xargs kill || true
-    check_port_offline ${master_ports[$leader_idx]} 20
-    sleep 5
-
-    # test again
-    alive=( "${alive[@]/$leader_idx}" )
-    leaders=()
-    for idx in ${alive[@]}; do
-        leaders+=($(get_leader $WORK_DIR 127.0.0.1:${master_ports[$idx]}))
-    done
-    leader=${leaders[0]}
-    leader_idx=${leader:6}
-    echo "current leader is" $leader
-    for ld in ${leaders[@]}; do
-        if [ "$leader" != "$ld" ]; then
-            echo "leader not consisent"
-            exit 1
-        fi
-    done
-    run_dm_ctl_with_retry $WORK_DIR "127.0.0.1:$MASTER_PORT" \
-        "list-member --type=master" \
-        "\"alive\": true" 3
-    echo "kill leader" $leader
-    ps aux | grep $leader |awk '{print $2}'|xargs kill || true
-    check_port_offline ${master_ports[$leader_idx]} 20
-    sleep 5
-    
     # join master which has been killed
     alive=( "${alive[@]/$leader_idx}" )
     for idx in $(seq 1 5); do

From 2dacb9a2ece05fcf9c102da7626761fc43c0e095 Mon Sep 17 00:00:00 2001
From: gmhdbjd <gmhdbjd@gmail.com>
Date: Mon, 18 May 2020 14:57:49 +0800
Subject: [PATCH 16/17] remove type

---
 dm/ctl/master/list_member.go |  49 ++---
 dm/master/server.go          |  18 +-
 dm/pb/dmmaster.pb.go         | 363 ++++++++++++++++++++---------------
 dm/proto/dmmaster.proto      |  14 +-
 tests/_utils/get_leader      |   2 +-
 tests/ha_master/run.sh       |  10 +-
 6 files changed, 255 insertions(+), 201 deletions(-)

diff --git a/dm/ctl/master/list_member.go b/dm/ctl/master/list_member.go
index 8e7473bd45..155b805f13 100644
--- a/dm/ctl/master/list_member.go
+++ b/dm/ctl/master/list_member.go
@@ -41,28 +41,36 @@ func (c ListMemberFlags) Reset() {
 // NewListMemberCmd creates an ListMember command
 func NewListMemberCmd() *cobra.Command {
 	cmd := &cobra.Command{
-		Use:   "list-member [--type leader/master/worker] [--name master-name/worker-name ...]",
+		Use:   "list-member [--leader] [--master] [--worker] [--name master-name/worker-name ...]",
 		Short: "list member information",
 		Run:   listMemberFunc,
 	}
-	cmd.Flags().StringP("type", "t", "", "specify a member type from master, worker, and leader")
+	cmd.Flags().BoolP("leader", "l", false, "only to list leader information")
+	cmd.Flags().BoolP("master", "m", false, "only to list master information")
+	cmd.Flags().BoolP("worker", "w", false, "only to list worker information")
 	cmd.Flags().StringSliceVarP(&listMemberFlags.names, "name", "n", []string{}, "specify member names in choosing type")
 	return cmd
 }
 
-func convertListMemberType(t string) pb.MemberType {
-	switch t {
-	case "master":
-		return pb.MemberType_MasterType
-	case "worker":
-		return pb.MemberType_WorkerType
-	case "leader":
-		return pb.MemberType_LeaderType
-	case "":
-		return pb.MemberType_AllType
-	default:
-		return pb.MemberType_InvalidType
+func convertListMemberType(cmd *cobra.Command) (bool, bool, bool, error) {
+	leader, err := cmd.Flags().GetBool("leader")
+	if err != nil {
+		return false, false, false, err
+	}
+	master, err := cmd.Flags().GetBool("master")
+	if err != nil {
+		return false, false, false, err
+	}
+	worker, err := cmd.Flags().GetBool("worker")
+	if err != nil {
+		return false, false, false, err
 	}
+	if !leader && !master && !worker {
+		leader = true
+		master = true
+		worker = true
+	}
+	return leader, master, worker, nil
 }
 
 // listMemberFunc does list member request
@@ -73,16 +81,9 @@ func listMemberFunc(cmd *cobra.Command, _ []string) {
 		return
 	}
 
-	member, err := cmd.Flags().GetString("type")
+	leader, master, worker, err := convertListMemberType(cmd)
 	if err != nil {
 		common.PrintLines("%s", errors.ErrorStack(err))
-		return
-	}
-
-	memType := convertListMemberType(member)
-	if memType == pb.MemberType_InvalidType {
-		common.PrintLines("invalid type '%s', choose from master, worker, and leader", member)
-		return
 	}
 
 	ctx, cancel := context.WithCancel(context.Background())
@@ -90,7 +91,9 @@ func listMemberFunc(cmd *cobra.Command, _ []string) {
 
 	cli := common.MasterClient()
 	resp, err := cli.ListMember(ctx, &pb.ListMemberRequest{
-		MemType: memType,
+		Leader: leader,
+		Master: master,
+		Worker: worker,
 		Names:   listMemberFlags.names,
 	})
 
diff --git a/dm/master/server.go b/dm/master/server.go
index e8f91be3d3..2ef529b508 100644
--- a/dm/master/server.go
+++ b/dm/master/server.go
@@ -1604,6 +1604,9 @@ func (s *Server) listMemberMaster(ctx context.Context, names []string) (*pb.Memb
 		})
 	}
 
+	sort.Slice(masters, func(lhs, rhs int) bool {
+		return masters[lhs].Name < masters[rhs].Name
+	})
 	resp.Master.Masters = masters
 	return resp, nil
 }
@@ -1640,6 +1643,9 @@ func (s *Server) listMemberWorker(ctx context.Context, names []string) (*pb.Memb
 		})
 	}
 
+	sort.Slice(workers, func(lhs, rhs int) bool {
+		return workers[lhs].Name < workers[rhs].Name
+	})
 	resp.Worker.Workers = workers
 	return resp, nil
 }
@@ -1685,8 +1691,8 @@ func (s *Server) ListMember(ctx context.Context, req *pb.ListMemberRequest) (*pb
 	resp := &pb.ListMemberResponse{}
 	members := make([]*pb.Members, 0)
 
-	if req.MemType == pb.MemberType_AllType || req.MemType == pb.MemberType_MasterType {
-		res, err := s.listMemberMaster(ctx, req.Names)
+	if req.Leader {
+		res, err := s.listMemberLeader(ctx, req.Names)
 		if err != nil {
 			resp.Msg = errors.ErrorStack(err)
 			return resp, nil
@@ -1696,8 +1702,8 @@ func (s *Server) ListMember(ctx context.Context, req *pb.ListMemberRequest) (*pb
 		})
 	}
 
-	if req.MemType == pb.MemberType_AllType || req.MemType == pb.MemberType_WorkerType {
-		res, err := s.listMemberWorker(ctx, req.Names)
+	if req.Master {
+		res, err := s.listMemberMaster(ctx, req.Names)
 		if err != nil {
 			resp.Msg = errors.ErrorStack(err)
 			return resp, nil
@@ -1707,8 +1713,8 @@ func (s *Server) ListMember(ctx context.Context, req *pb.ListMemberRequest) (*pb
 		})
 	}
 
-	if req.MemType == pb.MemberType_AllType || req.MemType == pb.MemberType_LeaderType {
-		res, err := s.listMemberLeader(ctx, req.Names)
+	if req.Worker {
+		res, err := s.listMemberWorker(ctx, req.Names)
 		if err != nil {
 			resp.Msg = errors.ErrorStack(err)
 			return resp, nil
diff --git a/dm/pb/dmmaster.pb.go b/dm/pb/dmmaster.pb.go
index 22fec4379f..3ea58a4ecf 100644
--- a/dm/pb/dmmaster.pb.go
+++ b/dm/pb/dmmaster.pb.go
@@ -59,40 +59,6 @@ func (SourceOp) EnumDescriptor() ([]byte, []int) {
 	return fileDescriptor_f9bef11f2a341f03, []int{0}
 }
 
-type MemberType int32
-
-const (
-	MemberType_InvalidType MemberType = 0
-	MemberType_MasterType  MemberType = 1
-	MemberType_WorkerType  MemberType = 2
-	MemberType_LeaderType  MemberType = 3
-	MemberType_AllType     MemberType = 4
-)
-
-var MemberType_name = map[int32]string{
-	0: "InvalidType",
-	1: "MasterType",
-	2: "WorkerType",
-	3: "LeaderType",
-	4: "AllType",
-}
-
-var MemberType_value = map[string]int32{
-	"InvalidType": 0,
-	"MasterType":  1,
-	"WorkerType":  2,
-	"LeaderType":  3,
-	"AllType":     4,
-}
-
-func (x MemberType) String() string {
-	return proto.EnumName(MemberType_name, int32(x))
-}
-
-func (MemberType) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_f9bef11f2a341f03, []int{1}
-}
-
 type MigrateWorkerRelayRequest struct {
 	BinlogName string `protobuf:"bytes,1,opt,name=BinlogName,proto3" json:"BinlogName,omitempty"`
 	BinlogPos  uint32 `protobuf:"varint,2,opt,name=BinlogPos,proto3" json:"BinlogPos,omitempty"`
@@ -2568,8 +2534,10 @@ func (*Members) XXX_OneofWrappers() []interface{} {
 }
 
 type ListMemberRequest struct {
-	MemType MemberType `protobuf:"varint,1,opt,name=memType,proto3,enum=pb.MemberType" json:"memType,omitempty"`
-	Names   []string   `protobuf:"bytes,2,rep,name=names,proto3" json:"names,omitempty"`
+	Leader bool     `protobuf:"varint,1,opt,name=leader,proto3" json:"leader,omitempty"`
+	Master bool     `protobuf:"varint,2,opt,name=master,proto3" json:"master,omitempty"`
+	Worker bool     `protobuf:"varint,3,opt,name=worker,proto3" json:"worker,omitempty"`
+	Names  []string `protobuf:"bytes,4,rep,name=names,proto3" json:"names,omitempty"`
 }
 
 func (m *ListMemberRequest) Reset()         { *m = ListMemberRequest{} }
@@ -2605,11 +2573,25 @@ func (m *ListMemberRequest) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_ListMemberRequest proto.InternalMessageInfo
 
-func (m *ListMemberRequest) GetMemType() MemberType {
+func (m *ListMemberRequest) GetLeader() bool {
+	if m != nil {
+		return m.Leader
+	}
+	return false
+}
+
+func (m *ListMemberRequest) GetMaster() bool {
 	if m != nil {
-		return m.MemType
+		return m.Master
 	}
-	return MemberType_InvalidType
+	return false
+}
+
+func (m *ListMemberRequest) GetWorker() bool {
+	if m != nil {
+		return m.Worker
+	}
+	return false
 }
 
 func (m *ListMemberRequest) GetNames() []string {
@@ -2681,7 +2663,6 @@ func (m *ListMemberResponse) GetMembers() []*Members {
 
 func init() {
 	proto.RegisterEnum("pb.SourceOp", SourceOp_name, SourceOp_value)
-	proto.RegisterEnum("pb.MemberType", MemberType_name, MemberType_value)
 	proto.RegisterType((*MigrateWorkerRelayRequest)(nil), "pb.MigrateWorkerRelayRequest")
 	proto.RegisterType((*UpdateWorkerRelayConfigRequest)(nil), "pb.UpdateWorkerRelayConfigRequest")
 	proto.RegisterType((*StartTaskRequest)(nil), "pb.StartTaskRequest")
@@ -2730,115 +2711,113 @@ func init() {
 func init() { proto.RegisterFile("dmmaster.proto", fileDescriptor_f9bef11f2a341f03) }
 
 var fileDescriptor_f9bef11f2a341f03 = []byte{
-	// 1720 bytes of a gzipped FileDescriptorProto
+	// 1683 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x58, 0x4f, 0x6f, 0xdb, 0xc6,
-	0x12, 0x17, 0x25, 0x5b, 0xb6, 0x47, 0x8e, 0x23, 0x6f, 0x6c, 0x59, 0xa6, 0x1d, 0xc5, 0xe1, 0x7b,
-	0x2f, 0x30, 0x72, 0xb0, 0x5f, 0x9c, 0x5b, 0x80, 0x00, 0xcf, 0xb6, 0x1c, 0xc4, 0x80, 0x12, 0x3b,
-	0x54, 0x8c, 0x87, 0xf4, 0x50, 0x80, 0x96, 0x56, 0x32, 0x61, 0x8a, 0xa4, 0x49, 0xca, 0xae, 0x51,
-	0x14, 0x05, 0xfa, 0x01, 0xda, 0x02, 0x3d, 0xe4, 0xd8, 0x43, 0xbf, 0x4c, 0x8e, 0x01, 0x7a, 0xe9,
-	0xb1, 0x48, 0xfa, 0x41, 0x8a, 0x9d, 0x5d, 0x92, 0xcb, 0x3f, 0x52, 0xa3, 0x14, 0xf5, 0x8d, 0x33,
-	0xb3, 0xfb, 0x9b, 0xd9, 0x99, 0xd9, 0xd9, 0x19, 0xc2, 0x42, 0x77, 0x30, 0x30, 0xfc, 0x80, 0x7a,
-	0x5b, 0xae, 0xe7, 0x04, 0x0e, 0x29, 0xba, 0xa7, 0xea, 0x42, 0x77, 0x70, 0xe5, 0x78, 0xe7, 0x21,
-	0x4f, 0x5d, 0xef, 0x3b, 0x4e, 0xdf, 0xa2, 0xdb, 0x86, 0x6b, 0x6e, 0x1b, 0xb6, 0xed, 0x04, 0x46,
-	0x60, 0x3a, 0xb6, 0xcf, 0xa5, 0xda, 0x05, 0xac, 0xbe, 0x30, 0xfb, 0x9e, 0x11, 0xd0, 0xff, 0xe3,
-	0x26, 0x9d, 0x5a, 0xc6, 0xb5, 0x4e, 0x2f, 0x86, 0xd4, 0x0f, 0x48, 0x03, 0x60, 0xcf, 0xb4, 0x2d,
-	0xa7, 0xff, 0xd2, 0x18, 0xd0, 0xba, 0xb2, 0xa1, 0x6c, 0xce, 0xe9, 0x12, 0x87, 0xac, 0xc3, 0x1c,
-	0xa7, 0x8e, 0x1d, 0xbf, 0x5e, 0xdc, 0x50, 0x36, 0x6f, 0xe9, 0x31, 0x83, 0xd4, 0xa0, 0xec, 0x3b,
-	0x43, 0xaf, 0x43, 0xeb, 0x25, 0xdc, 0x29, 0x28, 0xed, 0x18, 0x1a, 0x27, 0x6e, 0x37, 0xa9, 0x71,
-	0xdf, 0xb1, 0x7b, 0x66, 0x3f, 0xd4, 0x5b, 0x83, 0x72, 0x07, 0x19, 0x42, 0xa7, 0xa0, 0x24, 0xc4,
-	0x62, 0x02, 0xf1, 0x7f, 0x50, 0x6d, 0x07, 0x86, 0x17, 0xbc, 0x36, 0xfc, 0xf3, 0x10, 0x83, 0xc0,
-	0x54, 0x60, 0xf8, 0xe7, 0x02, 0x01, 0xbf, 0x49, 0x1d, 0x66, 0xf8, 0x0e, 0x66, 0x6d, 0x69, 0x73,
-	0x4e, 0x0f, 0x49, 0xed, 0x02, 0x16, 0x25, 0x04, 0xdf, 0x75, 0x6c, 0x9f, 0x32, 0x75, 0x1e, 0xf5,
-	0x87, 0x56, 0x80, 0x20, 0xb3, 0xba, 0xa0, 0x48, 0x15, 0x4a, 0x03, 0xbf, 0x2f, 0x6c, 0x60, 0x9f,
-	0x64, 0x27, 0x06, 0x2e, 0x6d, 0x94, 0x36, 0x2b, 0x3b, 0xf5, 0x2d, 0xf7, 0x74, 0x6b, 0xdf, 0x19,
-	0x0c, 0x1c, 0x3b, 0x3c, 0x25, 0x07, 0x8d, 0x55, 0x3e, 0x86, 0x55, 0xee, 0x86, 0x17, 0x18, 0xc1,
-	0x4f, 0xf2, 0x80, 0x76, 0x0d, 0x6a, 0xde, 0xa6, 0x89, 0x0d, 0x7e, 0x94, 0x36, 0x78, 0x85, 0x19,
-	0xfc, 0x6a, 0x48, 0xbd, 0xeb, 0x76, 0x60, 0x04, 0x43, 0x3f, 0x6b, 0xef, 0x97, 0x40, 0x8e, 0x5c,
-	0xca, 0x32, 0x45, 0x76, 0xb3, 0x0a, 0x45, 0xc7, 0x45, 0x75, 0x0b, 0x3b, 0xc0, 0x30, 0x98, 0xf0,
-	0xc8, 0xd5, 0x8b, 0x8e, 0xcb, 0x42, 0x60, 0xb3, 0xc4, 0xe1, 0x7a, 0xf1, 0x5b, 0x0e, 0x41, 0x29,
-	0x19, 0x82, 0x1f, 0x14, 0xb8, 0x93, 0x50, 0x20, 0x0e, 0x35, 0x4e, 0x43, 0x7c, 0xe0, 0x62, 0xde,
-	0x81, 0x4b, 0xb9, 0x11, 0x9a, 0xfa, 0xd4, 0x08, 0xed, 0xc2, 0x22, 0x77, 0xf6, 0xe7, 0xe7, 0x95,
-	0x07, 0x44, 0x86, 0xb8, 0x91, 0xc4, 0x7a, 0x06, 0x35, 0x29, 0x90, 0x2d, 0xd3, 0x0f, 0x24, 0xdb,
-	0xed, 0xf8, 0x26, 0x67, 0x02, 0x92, 0xb2, 0xfd, 0x12, 0x56, 0x32, 0x38, 0x37, 0x91, 0x68, 0x07,
-	0xb0, 0x8c, 0xf2, 0x03, 0xcf, 0x73, 0xbc, 0xcf, 0x37, 0x3f, 0x10, 0x6e, 0x90, 0x60, 0x26, 0xb6,
-	0xfe, 0xbf, 0x69, 0xeb, 0x6b, 0x91, 0xf5, 0x08, 0x9b, 0x35, 0x7e, 0x1f, 0xee, 0xb4, 0xcf, 0x9c,
-	0xab, 0x66, 0xb3, 0xd5, 0x72, 0x3a, 0xe7, 0xfe, 0xe7, 0x65, 0xcd, 0xcf, 0x0a, 0xcc, 0x08, 0x04,
-	0xb2, 0x00, 0xc5, 0xc3, 0xa6, 0xd8, 0x57, 0x3c, 0x6c, 0x46, 0x48, 0x45, 0x09, 0x89, 0xc0, 0xd4,
-	0xc0, 0xe9, 0x86, 0x75, 0x16, 0xbf, 0xc9, 0x12, 0x4c, 0x3b, 0x57, 0x36, 0xf5, 0xea, 0x53, 0xc8,
-	0xe4, 0x04, 0x5b, 0xd9, 0x6c, 0xb6, 0xfc, 0xfa, 0x34, 0x2a, 0xc4, 0x6f, 0xac, 0xaa, 0xd7, 0x76,
-	0x87, 0x76, 0xeb, 0x65, 0xe4, 0x0a, 0x8a, 0xa8, 0x30, 0x3b, 0xb4, 0x85, 0x64, 0x06, 0x25, 0x11,
-	0xad, 0x75, 0x60, 0x29, 0x79, 0xcc, 0x89, 0x5d, 0x7b, 0x1f, 0xa6, 0x2d, 0xb6, 0x55, 0x38, 0xb6,
-	0xc2, 0x1c, 0x2b, 0xe0, 0x74, 0x2e, 0xd1, 0x2c, 0x58, 0x3a, 0xb1, 0xd9, 0x67, 0xc8, 0x17, 0xce,
-	0x4c, 0xbb, 0x44, 0x83, 0x79, 0x8f, 0xba, 0x96, 0xd1, 0xa1, 0x47, 0x78, 0x62, 0xae, 0x25, 0xc1,
-	0x23, 0x1b, 0x50, 0xe9, 0x39, 0x5e, 0x87, 0xea, 0x74, 0xe0, 0x5c, 0x72, 0x4f, 0xcd, 0xea, 0x32,
-	0x4b, 0xdb, 0x85, 0xe5, 0x94, 0xb6, 0x49, 0xcf, 0xa4, 0x3d, 0x81, 0x46, 0xfb, 0xca, 0x0c, 0x3a,
-	0x67, 0xd2, 0xcb, 0xc6, 0x0b, 0x75, 0x68, 0xba, 0x14, 0x73, 0x25, 0x19, 0xf3, 0x6f, 0xe1, 0xde,
-	0xc8, 0xbd, 0x37, 0x52, 0x36, 0x74, 0x58, 0x15, 0xe5, 0x37, 0xa7, 0x13, 0x58, 0x93, 0x8a, 0x30,
-	0x86, 0x0a, 0xa5, 0xa2, 0x0a, 0x8f, 0x4e, 0xe4, 0xb7, 0x0a, 0xa8, 0x79, 0xa0, 0xe2, 0x40, 0x63,
-	0x51, 0xff, 0xd9, 0xda, 0xfe, 0x4e, 0x81, 0xc5, 0xe7, 0x86, 0xdd, 0xb5, 0x68, 0xfb, 0x55, 0xcb,
-	0x1f, 0x57, 0x61, 0x56, 0xd1, 0xc8, 0x22, 0x1a, 0x39, 0xc7, 0x80, 0xdb, 0xaf, 0x5a, 0xf1, 0x03,
-	0x67, 0x78, 0xfd, 0xf0, 0x25, 0xc3, 0x6f, 0xd6, 0x13, 0x9d, 0x46, 0x3d, 0x11, 0xbf, 0x7b, 0x31,
-	0x43, 0xea, 0x60, 0xa6, 0xe5, 0x0e, 0x86, 0x75, 0x5a, 0xfe, 0x85, 0x75, 0x6c, 0x04, 0x01, 0xf5,
-	0xec, 0x7a, 0x99, 0x77, 0x5a, 0x31, 0x87, 0xdd, 0x45, 0xff, 0xcc, 0xf0, 0xba, 0xa6, 0xdd, 0xaf,
-	0xcf, 0xa0, 0x3b, 0x22, 0x9a, 0xbd, 0x31, 0xf2, 0x49, 0x6e, 0x24, 0x59, 0xde, 0x2a, 0xb0, 0x72,
-	0x3c, 0xf4, 0xfa, 0x79, 0xb9, 0x32, 0x32, 0xc7, 0xd9, 0x29, 0x4c, 0xdb, 0xe8, 0x04, 0xe6, 0x25,
-	0x15, 0x41, 0x8d, 0x68, 0xac, 0x6b, 0xe6, 0x80, 0xdf, 0xcc, 0x92, 0x8e, 0xdf, 0x6c, 0x7d, 0xcf,
-	0xb4, 0x28, 0x86, 0x84, 0xbb, 0x32, 0xa2, 0xd1, 0x93, 0xc3, 0xd3, 0xa6, 0xe9, 0x45, 0x9e, 0x44,
-	0x4a, 0xfb, 0x0a, 0xea, 0x59, 0xc3, 0x6e, 0xc4, 0x27, 0x0f, 0xa0, 0xba, 0x7f, 0x46, 0x3b, 0xe7,
-	0x7f, 0xd1, 0x2d, 0x68, 0x4f, 0x61, 0x51, 0x5a, 0x37, 0x71, 0x91, 0x69, 0xc1, 0x92, 0xb8, 0x52,
-	0x6d, 0x54, 0x1c, 0xaa, 0x5a, 0x97, 0x2e, 0xd3, 0x3c, 0xe6, 0x29, 0x8a, 0xe3, 0xdb, 0x24, 0x1a,
-	0xca, 0x62, 0xa2, 0xa1, 0x1c, 0xc2, 0x72, 0x0a, 0xed, 0x46, 0x7c, 0x75, 0x00, 0xcb, 0x3a, 0xed,
-	0x9b, 0xac, 0xbc, 0x85, 0x4b, 0xc6, 0xbe, 0xf1, 0x46, 0xb7, 0xeb, 0x51, 0xdf, 0x17, 0x6a, 0x43,
-	0x52, 0xdb, 0x83, 0x5a, 0x1a, 0x66, 0x62, 0x7f, 0x36, 0x61, 0xe9, 0xa8, 0xd7, 0xb3, 0x4c, 0x9b,
-	0xfe, 0x1d, 0x4b, 0x76, 0x61, 0x39, 0x85, 0x32, 0xb1, 0x21, 0xdf, 0x2b, 0x00, 0xbc, 0xe2, 0x1f,
-	0xda, 0x3d, 0x27, 0x57, 0xbf, 0x0a, 0xb3, 0x03, 0x3a, 0x38, 0xa5, 0xde, 0x61, 0x13, 0x77, 0x4e,
-	0xe9, 0x11, 0xcd, 0x1e, 0x7c, 0xc3, 0x32, 0xa3, 0xb7, 0x8d, 0x13, 0x6c, 0x87, 0x4b, 0xa9, 0x77,
-	0xa2, 0xb7, 0x78, 0x71, 0x9c, 0xd3, 0x23, 0x9a, 0x15, 0x9d, 0x8e, 0x65, 0x52, 0x3b, 0x40, 0x29,
-	0x6f, 0x09, 0x24, 0x8e, 0x76, 0x0a, 0xc0, 0x0f, 0x33, 0xd2, 0x1e, 0x56, 0x00, 0xbb, 0xdd, 0xf0,
-	0xc5, 0xc5, 0x6f, 0x66, 0x87, 0x1f, 0x18, 0xfd, 0xb0, 0x1b, 0xe1, 0x84, 0x54, 0xf8, 0xa6, 0x12,
-	0xa3, 0x5b, 0x0b, 0xaa, 0xac, 0x37, 0x6b, 0x51, 0xa3, 0x4b, 0xbd, 0x17, 0x78, 0x96, 0xd0, 0x35,
-	0x4a, 0x9c, 0x62, 0x79, 0x93, 0x44, 0xa8, 0xbb, 0x14, 0xeb, 0xd6, 0x5e, 0x72, 0x34, 0xee, 0xc5,
-	0x91, 0x68, 0x9b, 0x30, 0xc3, 0xa7, 0x66, 0xfe, 0x5e, 0x55, 0x76, 0x16, 0x58, 0xc2, 0xc6, 0xae,
-	0xd7, 0x43, 0x71, 0x88, 0xc7, 0xbd, 0x30, 0x0e, 0x8f, 0x4f, 0xdc, 0x09, 0xbc, 0xd8, 0x75, 0x7a,
-	0x28, 0xd6, 0x7e, 0x51, 0x60, 0x86, 0xc3, 0xf8, 0x64, 0x0b, 0xca, 0x16, 0x9e, 0x1a, 0xa1, 0x2a,
-	0x3b, 0x4b, 0x6c, 0x53, 0xda, 0x17, 0xcf, 0x0b, 0xba, 0x58, 0xc5, 0xd6, 0x73, 0xb3, 0xd0, 0x0b,
-	0xd2, 0x7a, 0xf9, 0xb4, 0x6c, 0x3d, 0x5f, 0xc5, 0xd6, 0x73, 0xb5, 0xe8, 0x21, 0x69, 0xbd, 0x7c,
-	0x1a, 0xb6, 0x9e, 0xaf, 0xda, 0x9b, 0x85, 0x32, 0xcf, 0x25, 0xad, 0x0d, 0x8b, 0x88, 0x8b, 0x54,
-	0x78, 0x1d, 0x98, 0xd3, 0xe8, 0xe0, 0xf5, 0xb5, 0x4b, 0x45, 0x8d, 0xe1, 0x4e, 0xc3, 0x35, 0x8c,
-	0xab, 0x87, 0x62, 0x96, 0x00, 0x2c, 0x40, 0x61, 0x33, 0xc0, 0x09, 0x8d, 0x02, 0x91, 0x41, 0x27,
-	0xae, 0x32, 0xff, 0x41, 0xfd, 0xcc, 0x73, 0x72, 0xc7, 0x28, 0x9c, 0xa9, 0x87, 0xb2, 0x87, 0x3a,
-	0xcc, 0x86, 0x75, 0x8f, 0xdc, 0x81, 0xdb, 0x87, 0xf6, 0xa5, 0x61, 0x99, 0xdd, 0x90, 0x55, 0x2d,
-	0x90, 0xdb, 0x50, 0xc1, 0x49, 0x9f, 0xb3, 0xaa, 0x0a, 0xa9, 0xc2, 0x3c, 0x1f, 0xd1, 0x04, 0xa7,
-	0x48, 0x16, 0x00, 0xda, 0x81, 0xe3, 0x0a, 0xba, 0xf4, 0xf0, 0x0b, 0x80, 0xf8, 0x9c, 0x0c, 0x40,
-	0xa0, 0x32, 0xb2, 0x5a, 0x60, 0xcb, 0x79, 0x08, 0x90, 0x56, 0x18, 0xcd, 0x5d, 0x8c, 0x34, 0xc2,
-	0xf1, 0x90, 0x22, 0x5d, 0x22, 0x15, 0x98, 0xd9, 0xb5, 0x2c, 0x24, 0xa6, 0x76, 0xde, 0xce, 0x43,
-	0x99, 0xef, 0x26, 0x6f, 0x60, 0x2e, 0xfa, 0x07, 0x41, 0x30, 0x5a, 0xe9, 0x9f, 0x1a, 0xea, 0x72,
-	0x8a, 0xcb, 0xbd, 0xa8, 0xdd, 0xfb, 0xee, 0xd7, 0x3f, 0x7e, 0x2a, 0xae, 0x6a, 0x4b, 0xdb, 0x86,
-	0x6b, 0xfa, 0xdb, 0x97, 0x8f, 0x0c, 0xcb, 0x3d, 0x33, 0x1e, 0x6d, 0xb3, 0xe7, 0xc6, 0x7f, 0xa2,
-	0x3c, 0x24, 0x3d, 0xa8, 0x48, 0xa3, 0x35, 0xc1, 0x29, 0x26, 0x3b, 0xcc, 0xab, 0x2b, 0x19, 0xbe,
-	0x50, 0xf0, 0x00, 0x15, 0x6c, 0xa8, 0x6b, 0x79, 0x0a, 0xb6, 0xbf, 0x66, 0x11, 0xfe, 0x86, 0xe9,
-	0x79, 0x0a, 0x10, 0x8f, 0xbb, 0x04, 0xad, 0xcd, 0x4c, 0xd0, 0x6a, 0x2d, 0xcd, 0x16, 0x4a, 0x0a,
-	0xc4, 0x82, 0x8a, 0x34, 0x19, 0x12, 0x35, 0x35, 0x2a, 0x4a, 0xb3, 0xa0, 0xba, 0x96, 0x2b, 0x13,
-	0x48, 0xff, 0x46, 0x73, 0x1b, 0x64, 0x3d, 0x65, 0xae, 0x8f, 0x4b, 0x85, 0xbd, 0xe4, 0x00, 0x20,
-	0x9e, 0xe4, 0xc8, 0x6a, 0x72, 0xb2, 0x93, 0x75, 0xa9, 0x79, 0xa2, 0xc8, 0xe8, 0x7d, 0x98, 0x97,
-	0x47, 0x21, 0x82, 0x4e, 0xcc, 0x99, 0x01, 0xd5, 0x7a, 0x56, 0x10, 0x81, 0x3c, 0x83, 0x5b, 0x89,
-	0xe1, 0x83, 0xe0, 0xe2, 0xbc, 0xe9, 0x47, 0x5d, 0xcd, 0x91, 0x44, 0x38, 0x27, 0xe1, 0xff, 0x06,
-	0xf9, 0xff, 0x10, 0xb9, 0x1b, 0x7b, 0x3c, 0xe7, 0x67, 0x93, 0xda, 0x18, 0x25, 0x8e, 0x60, 0xdf,
-	0xc0, 0xca, 0x88, 0x5f, 0x76, 0x44, 0x8b, 0x37, 0x8f, 0xfa, 0x9f, 0xa7, 0x8e, 0x6c, 0x08, 0xb4,
-	0x02, 0x4b, 0x99, 0xb8, 0x7b, 0xe5, 0x29, 0x93, 0xe9, 0xcb, 0x79, 0xca, 0x64, 0x9b, 0x5c, 0xad,
-	0x40, 0xba, 0xb0, 0x32, 0x62, 0x6c, 0xe2, 0x96, 0x8d, 0x9f, 0xc7, 0xd4, 0x7f, 0x8d, 0x5d, 0x23,
-	0x9d, 0xbf, 0x96, 0x1d, 0x63, 0x30, 0xc7, 0xef, 0x4a, 0x57, 0x26, 0xdb, 0x0b, 0x73, 0xd7, 0x8e,
-	0x9e, 0x80, 0xb4, 0x02, 0x39, 0x82, 0x6a, 0xba, 0x5f, 0x25, 0x98, 0xdc, 0x23, 0xda, 0x6b, 0x75,
-	0x3d, 0x5f, 0x28, 0x01, 0x92, 0xec, 0x1f, 0x5d, 0x6e, 0xe7, 0xc8, 0x3f, 0xbd, 0x63, 0x23, 0xf4,
-	0x04, 0xe6, 0xa2, 0x7e, 0x95, 0xd7, 0xa5, 0x74, 0x9b, 0xcb, 0xeb, 0x52, 0xa6, 0xa9, 0xd5, 0x0a,
-	0xa4, 0x0f, 0xb7, 0x12, 0xed, 0x25, 0xcf, 0xeb, 0xbc, 0xfe, 0x95, 0xe7, 0x75, 0x6e, 0x2f, 0xaa,
-	0xdd, 0xc7, 0xfb, 0xbc, 0xa6, 0xd6, 0xd2, 0xf7, 0x99, 0x77, 0x93, 0xac, 0xf2, 0x1c, 0xc2, 0x42,
-	0xb2, 0x13, 0xe4, 0x17, 0x3a, 0xb7, 0xc9, 0xe4, 0x17, 0x3a, 0xbf, 0x71, 0xe4, 0x77, 0x31, 0xd1,
-	0xca, 0x09, 0x9b, 0x73, 0x7a, 0x44, 0x61, 0x73, 0x5e, 0xdf, 0xc7, 0x33, 0x3b, 0x7e, 0xf1, 0x78,
-	0x66, 0x67, 0x9e, 0x55, 0x9e, 0xd9, 0xd9, 0x87, 0x51, 0x2b, 0xec, 0xd5, 0xdf, 0x7d, 0x68, 0x28,
-	0xef, 0x3f, 0x34, 0x94, 0xdf, 0x3f, 0x34, 0x94, 0x1f, 0x3f, 0x36, 0x0a, 0xef, 0x3f, 0x36, 0x0a,
-	0xbf, 0x7d, 0x6c, 0x14, 0x4e, 0xcb, 0xf8, 0xeb, 0xfe, 0xf1, 0x9f, 0x01, 0x00, 0x00, 0xff, 0xff,
-	0x94, 0x85, 0x8c, 0x45, 0xfe, 0x17, 0x00, 0x00,
+	0x12, 0x17, 0x25, 0x5b, 0x96, 0x47, 0x8e, 0x23, 0x6f, 0x6c, 0x59, 0xa6, 0x1d, 0xc5, 0xe1, 0x7b,
+	0x2f, 0x30, 0x72, 0xb0, 0x5f, 0x9c, 0x5b, 0x80, 0x00, 0x2f, 0xb6, 0x1c, 0xc4, 0x80, 0x12, 0x3b,
+	0xd4, 0x33, 0x8a, 0x5c, 0x0a, 0xd0, 0xd2, 0x4a, 0x26, 0x4c, 0x91, 0x34, 0x49, 0xd9, 0x35, 0x8a,
+	0xa2, 0x40, 0x3f, 0x40, 0x5b, 0xa0, 0x87, 0x1c, 0x7b, 0xe8, 0x97, 0xc9, 0x31, 0x40, 0x2f, 0x3d,
+	0x16, 0x49, 0x3f, 0x48, 0xb1, 0x3b, 0x4b, 0x72, 0xf9, 0x47, 0x6a, 0x94, 0xa2, 0xbe, 0xed, 0xcc,
+	0xec, 0xfe, 0x66, 0x76, 0x76, 0x76, 0x76, 0x66, 0x61, 0xb1, 0x37, 0x1c, 0x1a, 0x7e, 0x40, 0xbd,
+	0x6d, 0xd7, 0x73, 0x02, 0x87, 0x14, 0xdd, 0x53, 0x75, 0xb1, 0x37, 0xbc, 0x72, 0xbc, 0xf3, 0x90,
+	0xa7, 0x6e, 0x0c, 0x1c, 0x67, 0x60, 0xd1, 0x1d, 0xc3, 0x35, 0x77, 0x0c, 0xdb, 0x76, 0x02, 0x23,
+	0x30, 0x1d, 0xdb, 0x47, 0xa9, 0x76, 0x01, 0x6b, 0x2f, 0xcd, 0x81, 0x67, 0x04, 0xf4, 0x0b, 0xbe,
+	0x48, 0xa7, 0x96, 0x71, 0xad, 0xd3, 0x8b, 0x11, 0xf5, 0x03, 0xd2, 0x04, 0xd8, 0x33, 0x6d, 0xcb,
+	0x19, 0xbc, 0x32, 0x86, 0xb4, 0xa1, 0x6c, 0x2a, 0x5b, 0xf3, 0xba, 0xc4, 0x21, 0x1b, 0x30, 0x8f,
+	0xd4, 0xb1, 0xe3, 0x37, 0x8a, 0x9b, 0xca, 0xd6, 0x2d, 0x3d, 0x66, 0x90, 0x3a, 0x94, 0x7d, 0x67,
+	0xe4, 0x75, 0x69, 0xa3, 0xc4, 0x57, 0x0a, 0x4a, 0x3b, 0x86, 0xe6, 0x89, 0xdb, 0x4b, 0x6a, 0xdc,
+	0x77, 0xec, 0xbe, 0x39, 0x08, 0xf5, 0xd6, 0xa1, 0xdc, 0xe5, 0x0c, 0xa1, 0x53, 0x50, 0x12, 0x62,
+	0x31, 0x81, 0xf8, 0x3f, 0xa8, 0x75, 0x02, 0xc3, 0x0b, 0xfe, 0x6f, 0xf8, 0xe7, 0x21, 0x06, 0x81,
+	0x99, 0xc0, 0xf0, 0xcf, 0x05, 0x02, 0x1f, 0x93, 0x06, 0xcc, 0xe1, 0x0a, 0x66, 0x6d, 0x69, 0x6b,
+	0x5e, 0x0f, 0x49, 0xed, 0x02, 0x96, 0x24, 0x04, 0xdf, 0x75, 0x6c, 0x9f, 0x32, 0x75, 0x1e, 0xf5,
+	0x47, 0x56, 0xc0, 0x41, 0x2a, 0xba, 0xa0, 0x48, 0x0d, 0x4a, 0x43, 0x7f, 0x20, 0x6c, 0x60, 0x43,
+	0xb2, 0x1b, 0x03, 0x97, 0x36, 0x4b, 0x5b, 0xd5, 0xdd, 0xc6, 0xb6, 0x7b, 0xba, 0xbd, 0xef, 0x0c,
+	0x87, 0x8e, 0x1d, 0xee, 0x12, 0x41, 0x63, 0x95, 0x8f, 0x61, 0x0d, 0xdd, 0xf0, 0x92, 0x9f, 0xe0,
+	0x27, 0x79, 0x40, 0xbb, 0x06, 0x35, 0x6f, 0xd1, 0xd4, 0x06, 0x3f, 0x4a, 0x1b, 0xbc, 0xca, 0x0c,
+	0x7e, 0x3d, 0xa2, 0xde, 0x75, 0x27, 0x30, 0x82, 0x91, 0x9f, 0xb5, 0xf7, 0x4b, 0x20, 0x47, 0x2e,
+	0x65, 0x91, 0x22, 0xbb, 0x59, 0x85, 0xa2, 0xe3, 0x72, 0x75, 0x8b, 0xbb, 0xc0, 0x30, 0x98, 0xf0,
+	0xc8, 0xd5, 0x8b, 0x8e, 0xcb, 0x8e, 0xc0, 0x66, 0x81, 0x83, 0x7a, 0xf9, 0x58, 0x3e, 0x82, 0x52,
+	0xf2, 0x08, 0x7e, 0x50, 0xe0, 0x4e, 0x42, 0x81, 0xd8, 0xd4, 0x24, 0x0d, 0xf1, 0x86, 0x8b, 0x79,
+	0x1b, 0x2e, 0xe5, 0x9e, 0xd0, 0xcc, 0xa7, 0x9e, 0xd0, 0x33, 0x58, 0x42, 0x67, 0x7f, 0x7e, 0x5c,
+	0x79, 0x40, 0x64, 0x88, 0x1b, 0x09, 0xac, 0xe7, 0x50, 0x97, 0x0e, 0xb2, 0x6d, 0xfa, 0x81, 0x64,
+	0xbb, 0x1d, 0xdf, 0xe4, 0xcc, 0x81, 0xa4, 0x6c, 0xbf, 0x84, 0xd5, 0x0c, 0xce, 0x4d, 0x04, 0xda,
+	0x01, 0xac, 0x70, 0xf9, 0x81, 0xe7, 0x39, 0xde, 0xe7, 0x9b, 0x1f, 0x08, 0x37, 0x48, 0x30, 0x53,
+	0x5b, 0xff, 0xdf, 0xb4, 0xf5, 0xf5, 0xc8, 0x7a, 0x0e, 0x9b, 0x35, 0x7e, 0x1f, 0xee, 0x74, 0xce,
+	0x9c, 0xab, 0x56, 0xab, 0xdd, 0x76, 0xba, 0xe7, 0xfe, 0xe7, 0x45, 0xcd, 0xcf, 0x0a, 0xcc, 0x09,
+	0x04, 0xb2, 0x08, 0xc5, 0xc3, 0x96, 0x58, 0x57, 0x3c, 0x6c, 0x45, 0x48, 0x45, 0x09, 0x89, 0xc0,
+	0xcc, 0xd0, 0xe9, 0x85, 0x79, 0x96, 0x8f, 0xc9, 0x32, 0xcc, 0x3a, 0x57, 0x36, 0xf5, 0x1a, 0x33,
+	0x9c, 0x89, 0x04, 0x9b, 0xd9, 0x6a, 0xb5, 0xfd, 0xc6, 0x2c, 0x57, 0xc8, 0xc7, 0x3c, 0xab, 0x5e,
+	0xdb, 0x5d, 0xda, 0x6b, 0x94, 0x39, 0x57, 0x50, 0x44, 0x85, 0xca, 0xc8, 0x16, 0x92, 0x39, 0x2e,
+	0x89, 0x68, 0xad, 0x0b, 0xcb, 0xc9, 0x6d, 0x4e, 0xed, 0xda, 0xfb, 0x30, 0x6b, 0xb1, 0xa5, 0xc2,
+	0xb1, 0x55, 0xe6, 0x58, 0x01, 0xa7, 0xa3, 0x44, 0xb3, 0x60, 0xf9, 0xc4, 0x66, 0xc3, 0x90, 0x2f,
+	0x9c, 0x99, 0x76, 0x89, 0x06, 0x0b, 0x1e, 0x75, 0x2d, 0xa3, 0x4b, 0x8f, 0xf8, 0x8e, 0x51, 0x4b,
+	0x82, 0x47, 0x36, 0xa1, 0xda, 0x77, 0xbc, 0x2e, 0xd5, 0xe9, 0xd0, 0xb9, 0x44, 0x4f, 0x55, 0x74,
+	0x99, 0xa5, 0x3d, 0x83, 0x95, 0x94, 0xb6, 0x69, 0xf7, 0xa4, 0x3d, 0x81, 0x66, 0xe7, 0xca, 0x0c,
+	0xba, 0x67, 0xd2, 0xcb, 0x86, 0x89, 0x3a, 0x34, 0x5d, 0x3a, 0x73, 0x25, 0x79, 0xe6, 0xdf, 0xc2,
+	0xbd, 0xb1, 0x6b, 0x6f, 0x24, 0x6d, 0xe8, 0xb0, 0x26, 0xd2, 0x6f, 0x4e, 0x25, 0xb0, 0x2e, 0x25,
+	0x61, 0x7e, 0x54, 0x5c, 0x2a, 0xb2, 0xf0, 0xf8, 0x40, 0x7e, 0xab, 0x80, 0x9a, 0x07, 0x2a, 0x36,
+	0x34, 0x11, 0xf5, 0x9f, 0xcd, 0xed, 0xef, 0x14, 0x58, 0x7a, 0x61, 0xd8, 0x3d, 0x8b, 0x76, 0x5e,
+	0xb7, 0xfd, 0x49, 0x19, 0x66, 0x8d, 0x1b, 0x59, 0xe4, 0x46, 0xce, 0x33, 0xe0, 0xce, 0xeb, 0x76,
+	0xfc, 0xc0, 0x19, 0xde, 0x20, 0x7c, 0xc9, 0xf8, 0x98, 0xd5, 0x44, 0xa7, 0x51, 0x4d, 0x84, 0x77,
+	0x2f, 0x66, 0x48, 0x15, 0xcc, 0xac, 0x5c, 0xc1, 0xb0, 0x4a, 0xcb, 0xbf, 0xb0, 0x8e, 0x8d, 0x20,
+	0xa0, 0x9e, 0xdd, 0x28, 0x63, 0xa5, 0x15, 0x73, 0xd8, 0x5d, 0xf4, 0xcf, 0x0c, 0xaf, 0x67, 0xda,
+	0x83, 0xc6, 0x1c, 0x77, 0x47, 0x44, 0xb3, 0x37, 0x46, 0xde, 0xc9, 0x8d, 0x04, 0xcb, 0x5b, 0x05,
+	0x56, 0x8f, 0x47, 0xde, 0x20, 0x2f, 0x56, 0xc6, 0xc6, 0x38, 0xdb, 0x85, 0x69, 0x1b, 0xdd, 0xc0,
+	0xbc, 0xa4, 0xe2, 0x50, 0x23, 0x9a, 0xe7, 0x35, 0x73, 0x88, 0x37, 0xb3, 0xa4, 0xf3, 0x31, 0x9b,
+	0xdf, 0x37, 0x2d, 0xca, 0x8f, 0x04, 0x5d, 0x19, 0xd1, 0xdc, 0x93, 0xa3, 0xd3, 0x96, 0xe9, 0x45,
+	0x9e, 0xe4, 0x94, 0xf6, 0x15, 0x34, 0xb2, 0x86, 0xdd, 0x88, 0x4f, 0x1e, 0x40, 0x6d, 0xff, 0x8c,
+	0x76, 0xcf, 0xff, 0xa2, 0x5a, 0xd0, 0x9e, 0xc2, 0x92, 0x34, 0x6f, 0xea, 0x24, 0xd3, 0x86, 0x65,
+	0x71, 0xa5, 0x3a, 0x5c, 0x71, 0xa8, 0x6a, 0x43, 0xba, 0x4c, 0x0b, 0x3c, 0x4e, 0xb9, 0x38, 0xbe,
+	0x4d, 0xa2, 0xa0, 0x2c, 0x26, 0x0a, 0xca, 0x11, 0xac, 0xa4, 0xd0, 0x6e, 0xc4, 0x57, 0x07, 0xb0,
+	0xa2, 0xd3, 0x81, 0xc9, 0xd2, 0x5b, 0x38, 0x65, 0xe2, 0x1b, 0x6f, 0xf4, 0x7a, 0x1e, 0xf5, 0x7d,
+	0xa1, 0x36, 0x24, 0xb5, 0x3d, 0xa8, 0xa7, 0x61, 0xa6, 0xf6, 0x67, 0x0b, 0x96, 0x8f, 0xfa, 0x7d,
+	0xcb, 0xb4, 0xe9, 0xdf, 0xb1, 0xe4, 0x19, 0xac, 0xa4, 0x50, 0xa6, 0x36, 0xe4, 0x7b, 0x05, 0x00,
+	0x33, 0xfe, 0xa1, 0xdd, 0x77, 0x72, 0xf5, 0xab, 0x50, 0x19, 0xd2, 0xe1, 0x29, 0xf5, 0x0e, 0x5b,
+	0x7c, 0xe5, 0x8c, 0x1e, 0xd1, 0xec, 0xc1, 0x37, 0x2c, 0x33, 0x7a, 0xdb, 0x90, 0x60, 0x2b, 0x5c,
+	0x4a, 0xbd, 0x13, 0xbd, 0x8d, 0xc9, 0x71, 0x5e, 0x8f, 0x68, 0x96, 0x74, 0xba, 0x96, 0x49, 0xed,
+	0x80, 0x4b, 0xb1, 0x24, 0x90, 0x38, 0xda, 0x29, 0x00, 0x6e, 0x66, 0xac, 0x3d, 0x2c, 0x01, 0xf6,
+	0x7a, 0xe1, 0x8b, 0xcb, 0xc7, 0xcc, 0x0e, 0x3f, 0x30, 0x06, 0x61, 0x35, 0x82, 0x84, 0x94, 0xf8,
+	0x66, 0x12, 0xad, 0x5b, 0x1b, 0x6a, 0xac, 0x36, 0x6b, 0x53, 0xa3, 0x47, 0xbd, 0x97, 0x7c, 0x2f,
+	0xa1, 0x6b, 0x94, 0x38, 0xc4, 0xf2, 0x3a, 0x89, 0x50, 0x77, 0x29, 0xd6, 0xad, 0xbd, 0x42, 0x34,
+	0xf4, 0xe2, 0x58, 0xb4, 0x2d, 0x98, 0xc3, 0xae, 0x19, 0xdf, 0xab, 0xea, 0xee, 0x22, 0x0b, 0xd8,
+	0xd8, 0xf5, 0x7a, 0x28, 0x0e, 0xf1, 0xd0, 0x0b, 0x93, 0xf0, 0xb0, 0xe3, 0x4e, 0xe0, 0xc5, 0xae,
+	0xd3, 0x43, 0xb1, 0xf6, 0x8b, 0x02, 0x73, 0x08, 0xe3, 0x93, 0x6d, 0x28, 0x5b, 0x7c, 0xd7, 0x1c,
+	0xaa, 0xba, 0xbb, 0xcc, 0x16, 0xa5, 0x7d, 0xf1, 0xa2, 0xa0, 0x8b, 0x59, 0x6c, 0x3e, 0x9a, 0xc5,
+	0xbd, 0x20, 0xcd, 0x97, 0x77, 0xcb, 0xe6, 0xe3, 0x2c, 0x36, 0x1f, 0xd5, 0x72, 0x0f, 0x49, 0xf3,
+	0xe5, 0xdd, 0xb0, 0xf9, 0x38, 0x6b, 0xaf, 0x02, 0x65, 0x8c, 0x25, 0xd6, 0x0c, 0x73, 0x5c, 0x4e,
+	0x49, 0x1d, 0xa9, 0x64, 0x6e, 0x25, 0x32, 0xab, 0x9e, 0x30, 0xab, 0x12, 0xa9, 0xaf, 0x27, 0xd4,
+	0x57, 0x42, 0x35, 0x2c, 0x3c, 0xd8, 0xf1, 0x85, 0xd1, 0x88, 0x84, 0x46, 0x81, 0xc8, 0x2a, 0xa7,
+	0xce, 0x41, 0xff, 0x81, 0x39, 0x34, 0x3e, 0x51, 0x4f, 0x0a, 0x57, 0xeb, 0xa1, 0xec, 0xa1, 0x0e,
+	0x95, 0x30, 0x2b, 0x92, 0x3b, 0x70, 0xfb, 0xd0, 0xbe, 0x34, 0x2c, 0xb3, 0x17, 0xb2, 0x6a, 0x05,
+	0x72, 0x1b, 0xaa, 0xfc, 0x1f, 0x00, 0x59, 0x35, 0x85, 0xd4, 0x60, 0x01, 0x1b, 0x38, 0xc1, 0x29,
+	0x92, 0x45, 0x80, 0x4e, 0xe0, 0xb8, 0x82, 0x2e, 0xed, 0xbe, 0x5d, 0x80, 0x32, 0x1e, 0x01, 0x79,
+	0x03, 0xf3, 0xd1, 0x2f, 0x02, 0xe1, 0xfe, 0x4e, 0x7f, 0x4b, 0xa8, 0x2b, 0x29, 0x2e, 0xee, 0x54,
+	0xbb, 0xf7, 0xdd, 0xaf, 0x7f, 0xfc, 0x54, 0x5c, 0xd3, 0x96, 0x77, 0x0c, 0xd7, 0xf4, 0x77, 0x2e,
+	0x1f, 0x19, 0x96, 0x7b, 0x66, 0x3c, 0xda, 0x61, 0x0f, 0x86, 0xff, 0x44, 0x79, 0x48, 0xfa, 0x50,
+	0x95, 0x9a, 0x63, 0xc2, 0xfb, 0x90, 0x6c, 0x3b, 0xae, 0xae, 0x66, 0xf8, 0x42, 0xc1, 0x03, 0xae,
+	0x60, 0x53, 0x5d, 0xcf, 0x53, 0xb0, 0xf3, 0x35, 0x3b, 0x85, 0x6f, 0x98, 0x9e, 0xa7, 0x00, 0x71,
+	0xc3, 0x4a, 0xb8, 0xb5, 0x99, 0x1e, 0x58, 0xad, 0xa7, 0xd9, 0x42, 0x49, 0x81, 0x58, 0x50, 0x95,
+	0x7a, 0x3b, 0xa2, 0xa6, 0x9a, 0x3d, 0xa9, 0x9b, 0x53, 0xd7, 0x73, 0x65, 0x02, 0xe9, 0xdf, 0xdc,
+	0xdc, 0x26, 0xd9, 0x48, 0x99, 0xeb, 0xf3, 0xa9, 0xc2, 0x5e, 0x72, 0x00, 0x10, 0xf7, 0x62, 0x64,
+	0x2d, 0xd9, 0x9b, 0xc9, 0xba, 0xd4, 0x3c, 0x51, 0x64, 0xf4, 0x3e, 0x2c, 0xc8, 0xcd, 0x0c, 0xe1,
+	0x4e, 0xcc, 0xe9, 0xe2, 0xd4, 0x46, 0x56, 0x10, 0x81, 0x3c, 0x87, 0x5b, 0x89, 0xf6, 0x81, 0xf0,
+	0xc9, 0x79, 0xfd, 0x8b, 0xba, 0x96, 0x23, 0x89, 0x70, 0x4e, 0xc2, 0x1f, 0x03, 0xf9, 0x87, 0x87,
+	0xdc, 0x8d, 0x3d, 0x9e, 0xf3, 0x5d, 0xa4, 0x36, 0xc7, 0x89, 0x23, 0xd8, 0x37, 0xb0, 0x3a, 0xe6,
+	0xd3, 0x8d, 0x68, 0xf1, 0xe2, 0x71, 0x3f, 0x72, 0xea, 0xd8, 0x27, 0x5d, 0x2b, 0xb0, 0x90, 0x89,
+	0xeb, 0x4f, 0x0c, 0x99, 0x4c, 0x65, 0x8d, 0x21, 0x93, 0x2d, 0x53, 0xb5, 0x02, 0xe9, 0xc1, 0xea,
+	0x98, 0xc6, 0x07, 0x2d, 0x9b, 0xdc, 0x51, 0xa9, 0xff, 0x9a, 0x38, 0x47, 0xda, 0x7f, 0x3d, 0xdb,
+	0x88, 0xf0, 0x18, 0xbf, 0x2b, 0x5d, 0x99, 0x6c, 0x35, 0x8b, 0xae, 0x1d, 0xdf, 0xc3, 0x68, 0x05,
+	0x72, 0x04, 0xb5, 0x74, 0xc5, 0x49, 0x78, 0x70, 0x8f, 0x29, 0x90, 0xd5, 0x8d, 0x7c, 0xa1, 0x04,
+	0x48, 0xb2, 0x7f, 0xb2, 0x68, 0xe7, 0xd8, 0xbf, 0xda, 0x89, 0x27, 0xf4, 0x04, 0xe6, 0xa3, 0x8a,
+	0x13, 0xf3, 0x52, 0xba, 0x50, 0xc5, 0xbc, 0x94, 0x29, 0x4b, 0xb5, 0x02, 0x19, 0xc0, 0xad, 0x44,
+	0x81, 0x88, 0x71, 0x9d, 0x57, 0x81, 0x62, 0x5c, 0xe7, 0x56, 0x93, 0xda, 0x7d, 0x7e, 0x9f, 0xd7,
+	0xd5, 0x7a, 0xfa, 0x3e, 0x63, 0x3d, 0xc8, 0x32, 0xcf, 0x21, 0x2c, 0x26, 0x6b, 0x39, 0xbc, 0xd0,
+	0xb9, 0x65, 0x22, 0x5e, 0xe8, 0xfc, 0xd2, 0x0f, 0xef, 0x62, 0xa2, 0x18, 0x13, 0x36, 0xe7, 0x54,
+	0x79, 0xc2, 0xe6, 0xbc, 0xca, 0x0d, 0x23, 0x3b, 0x7e, 0x95, 0x30, 0xb2, 0x33, 0x0f, 0x23, 0x46,
+	0x76, 0xf6, 0xf1, 0xd2, 0x0a, 0x7b, 0x8d, 0x77, 0x1f, 0x9a, 0xca, 0xfb, 0x0f, 0x4d, 0xe5, 0xf7,
+	0x0f, 0x4d, 0xe5, 0xc7, 0x8f, 0xcd, 0xc2, 0xfb, 0x8f, 0xcd, 0xc2, 0x6f, 0x1f, 0x9b, 0x85, 0xd3,
+	0x32, 0xff, 0x7c, 0x7f, 0xfc, 0x67, 0x00, 0x00, 0x00, 0xff, 0xff, 0xbb, 0x7c, 0x5e, 0x3f, 0xc0,
+	0x17, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -5593,11 +5572,36 @@ func (m *ListMemberRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 			copy(dAtA[i:], m.Names[iNdEx])
 			i = encodeVarintDmmaster(dAtA, i, uint64(len(m.Names[iNdEx])))
 			i--
-			dAtA[i] = 0x12
+			dAtA[i] = 0x22
+		}
+	}
+	if m.Worker {
+		i--
+		if m.Worker {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
 		}
+		i--
+		dAtA[i] = 0x18
 	}
-	if m.MemType != 0 {
-		i = encodeVarintDmmaster(dAtA, i, uint64(m.MemType))
+	if m.Master {
+		i--
+		if m.Master {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i--
+		dAtA[i] = 0x10
+	}
+	if m.Leader {
+		i--
+		if m.Leader {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
 		i--
 		dAtA[i] = 0x8
 	}
@@ -6564,8 +6568,14 @@ func (m *ListMemberRequest) Size() (n int) {
 	}
 	var l int
 	_ = l
-	if m.MemType != 0 {
-		n += 1 + sovDmmaster(uint64(m.MemType))
+	if m.Leader {
+		n += 2
+	}
+	if m.Master {
+		n += 2
+	}
+	if m.Worker {
+		n += 2
 	}
 	if len(m.Names) > 0 {
 		for _, s := range m.Names {
@@ -12200,9 +12210,9 @@ func (m *ListMemberRequest) Unmarshal(dAtA []byte) error {
 		switch fieldNum {
 		case 1:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field MemType", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Leader", wireType)
 			}
-			m.MemType = 0
+			var v int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowDmmaster
@@ -12212,12 +12222,53 @@ func (m *ListMemberRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.MemType |= MemberType(b&0x7F) << shift
+				v |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
+			m.Leader = bool(v != 0)
 		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Master", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowDmmaster
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.Master = bool(v != 0)
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Worker", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowDmmaster
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.Worker = bool(v != 0)
+		case 4:
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field Names", wireType)
 			}
diff --git a/dm/proto/dmmaster.proto b/dm/proto/dmmaster.proto
index b6238a9e29..1860d3c8ec 100644
--- a/dm/proto/dmmaster.proto
+++ b/dm/proto/dmmaster.proto
@@ -315,14 +315,6 @@ message OfflineWorkerResponse {
     string msg = 2;
 }
 
-enum MemberType {
-    InvalidType = 0;  // placeholder
-    MasterType = 1;
-    WorkerType = 2;
-    LeaderType = 3;
-    AllType = 4;
-}
-
 message MasterInfo {
     string name = 1;
     uint64 memberID = 2;
@@ -363,8 +355,10 @@ message Members {
 }
 
 message ListMemberRequest {
-    MemberType memType = 1;
-    repeated string names = 2;
+    bool leader = 1;
+    bool master = 2;
+    bool worker = 3;
+    repeated string names = 4;
 }
 
 message ListMemberResponse {
diff --git a/tests/_utils/get_leader b/tests/_utils/get_leader
index 76d01e670b..678c29f61d 100755
--- a/tests/_utils/get_leader
+++ b/tests/_utils/get_leader
@@ -15,7 +15,7 @@ pid=$$
 leader_name=""
 
 for ((k=0; k<10; k++)); do
-    leader_name=$($binary -test.coverprofile="$TEST_DIR/cov.$TEST_NAME.dmctl.$ts.$pid.out" DEVEL -master-addr=$master_addr list-member --type=leader | grep name | gawk 'match($2,/"(.*)",/,a) {print a[1]}')
+    leader_name=$($binary -test.coverprofile="$TEST_DIR/cov.$TEST_NAME.dmctl.$ts.$pid.out" DEVEL -master-addr=$master_addr list-member --leader | grep name | gawk 'match($2,/"(.*)",/,a) {print a[1]}')
     if [[ ! -z "$leader_name" ]]; then
         echo $leader_name
         break
diff --git a/tests/ha_master/run.sh b/tests/ha_master/run.sh
index 8d8ec8023a..746d2909fc 100755
--- a/tests/ha_master/run.sh
+++ b/tests/ha_master/run.sh
@@ -43,7 +43,7 @@ function test_list_member() {
 
         # check list-member master
         run_dm_ctl_with_retry $WORK_DIR "127.0.0.1:$MASTER_PORT" \
-            "list-member --type=master" \
+            "list-member --master" \
             "\"alive\": true" $((5 - i))
 
         # kill leader
@@ -78,18 +78,18 @@ function test_list_member() {
         fi
     done
     run_dm_ctl_with_retry $WORK_DIR "127.0.0.1:$MASTER_PORT" \
-        "list-member --type=master" \
+        "list-member --master" \
         "\"alive\": true" 5
     
     # check list-member worker
     run_dm_ctl_with_retry $WORK_DIR "127.0.0.1:$MASTER_PORT" \
-        "list-member --type=worker --name=worker1,worker2" \
+        "list-member --worker --name=worker1,worker2" \
         "\"stage\": \"bound\"" 2
     
     dmctl_operate_source stop $WORK_DIR/source1.toml $SOURCE_ID1
 
     run_dm_ctl_with_retry $WORK_DIR "127.0.0.1:$MASTER_PORT" \
-        "list-member --type=worker" \
+        "list-member --worker" \
         "\"stage\": \"bound\"" 1 \
         "\"stage\": \"free\"" 1
  
@@ -131,7 +131,7 @@ function test_list_member() {
     check_rpc_alive $cur/../bin/check_worker_online 127.0.0.1:$WORKER2_PORT
 
     run_dm_ctl_with_retry $WORK_DIR "127.0.0.1:$MASTER_PORT" \
-        "list-member --type=worker" \
+        "list-member --worker" \
         "\"stage\": \"bound\"" 2
 
     echo "[$(date)] <<<<<< finish test_list_member_command >>>>>>"

From 866d8c9dc4d25cfa5a782ff08e5e1b35570eda7d Mon Sep 17 00:00:00 2001
From: gmhdbjd <gmhdbjd@gmail.com>
Date: Tue, 19 May 2020 13:14:17 +0800
Subject: [PATCH 17/17] remove reset function

---
 dm/ctl/master/list_member.go | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/dm/ctl/master/list_member.go b/dm/ctl/master/list_member.go
index 89172090b5..231d266465 100644
--- a/dm/ctl/master/list_member.go
+++ b/dm/ctl/master/list_member.go
@@ -33,11 +33,6 @@ type ListMemberFlags struct {
 	names []string // specify names to list information
 }
 
-// Reset clears cache of ListMemberFlags
-func (c ListMemberFlags) Reset() {
-	c.names = c.names[:0]
-}
-
 // NewListMemberCmd creates an ListMember command
 func NewListMemberCmd() *cobra.Command {
 	cmd := &cobra.Command{