Support check health for the service level (#19779)

Signed-off-by: yun.zhang <yun.zhang@zilliz.com>

Signed-off-by: yun.zhang <yun.zhang@zilliz.com>

go.mod

@@ -29,7 +29,7 @@ require (
 	github.com/klauspost/compress v1.14.2
 	github.com/lingdor/stackerror v0.0.0-20191119040541-976d8885ed76
 	github.com/mgutz/ansi v0.0.0-20200706080929-d51e80ef957d
-	github.com/milvus-io/milvus-proto/go-api v0.0.0-20221014075920-6c03ca8c3749
+	github.com/milvus-io/milvus-proto/go-api v0.0.0-20221017091121-7a703d4485b5
 	github.com/minio/minio-go/v7 v7.0.17
 	github.com/opentracing/opentracing-go v1.2.0
 	github.com/panjf2000/ants/v2 v2.4.8

go.sum

@@ -495,6 +495,8 @@ github.com/milvus-io/gorocksdb v0.0.0-20220624081344-8c5f4212846b h1:TfeY0NxYxZz
 github.com/milvus-io/gorocksdb v0.0.0-20220624081344-8c5f4212846b/go.mod h1:iwW+9cWfIzzDseEBCCeDSN5SD16Tidvy8cwQ7ZY8Qj4=
 github.com/milvus-io/milvus-proto/go-api v0.0.0-20221014075920-6c03ca8c3749 h1:IB+Jyx3dVtrMSGYYVlobkSC9Kat+lxd/GM1i0cKIJXA=
 github.com/milvus-io/milvus-proto/go-api v0.0.0-20221014075920-6c03ca8c3749/go.mod h1:148qnlmZ0Fdm1Fq+Mj/OW2uDoEP25g3mjh0vMGtkgmk=
+github.com/milvus-io/milvus-proto/go-api v0.0.0-20221017091121-7a703d4485b5 h1:CDEQi9T8A7YEtQwHXEBXTl/PDXLzzJSRral8TM+1Krk=
+github.com/milvus-io/milvus-proto/go-api v0.0.0-20221017091121-7a703d4485b5/go.mod h1:148qnlmZ0Fdm1Fq+Mj/OW2uDoEP25g3mjh0vMGtkgmk=
 github.com/milvus-io/pulsar-client-go v0.6.8 h1:fZdZH73aPRszu2fazyeeahQEz34tyn1Pt9EkqJmV100=
 github.com/milvus-io/pulsar-client-go v0.6.8/go.mod h1:oFIlYIk23tamkSLttw849qphmMIpHY8ztEBWDWJW+sc=
 github.com/minio/asm2plan9s v0.0.0-20200509001527-cdd76441f9d8 h1:AMFGa4R4MiIpspGNG7Z948v4n35fFGB3RR3G/ry4FWs=

internal/datacoord/mock_test.go

@@ -277,6 +277,10 @@ type mockRootCoordService struct {
 	cnt   int64
 }
 
+func (m *mockRootCoordService) CheckHealth(ctx context.Context, req *milvuspb.CheckHealthRequest) (*milvuspb.CheckHealthResponse, error) {
+	panic("implement me")
+}
+
 func (m *mockRootCoordService) CreateAlias(ctx context.Context, req *milvuspb.CreateAliasRequest) (*commonpb.Status, error) {
 	panic("implement me")
 }

internal/datacoord/server_test.go

@@ -25,6 +25,7 @@ import (
 	"os/signal"
 	"path"
 	"strconv"
+	"sync"
 	"syscall"
 	"testing"
 	"time"
@@ -3341,6 +3342,67 @@ func newTestServer2(t *testing.T, receiveCh chan any, opts ...Option) *Server {
 	return svr
 }
 
+func Test_CheckHealth(t *testing.T) {
+	t.Run("not healthy", func(t *testing.T) {
+		ctx := context.Background()
+		s := &Server{session: &sessionutil.Session{ServerID: 1}}
+		s.stateCode.Store(commonpb.StateCode_Abnormal)
+		resp, err := s.CheckHealth(ctx, &milvuspb.CheckHealthRequest{})
+		assert.NoError(t, err)
+		assert.Equal(t, false, resp.IsHealthy)
+		assert.NotEmpty(t, resp.Reasons)
+	})
+
+	t.Run("data node health check is ok", func(t *testing.T) {
+		svr := &Server{session: &sessionutil.Session{ServerID: 1}}
+		svr.stateCode.Store(commonpb.StateCode_Healthy)
+		healthClient := &mockDataNodeClient{
+			id:    1,
+			state: commonpb.StateCode_Healthy}
+		sm := NewSessionManager()
+		sm.sessions = struct {
+			sync.RWMutex
+			data map[int64]*Session
+		}{data: map[int64]*Session{1: {
+			client: healthClient,
+			clientCreator: func(ctx context.Context, addr string) (types.DataNode, error) {
+				return healthClient, nil
+			},
+		}}}
+
+		svr.sessionManager = sm
+		ctx := context.Background()
+		resp, err := svr.CheckHealth(ctx, &milvuspb.CheckHealthRequest{})
+		assert.NoError(t, err)
+		assert.Equal(t, true, resp.IsHealthy)
+		assert.Empty(t, resp.Reasons)
+	})
+
+	t.Run("data node health check is fail", func(t *testing.T) {
+		svr := &Server{session: &sessionutil.Session{ServerID: 1}}
+		svr.stateCode.Store(commonpb.StateCode_Healthy)
+		unhealthClient := &mockDataNodeClient{
+			id:    1,
+			state: commonpb.StateCode_Abnormal}
+		sm := NewSessionManager()
+		sm.sessions = struct {
+			sync.RWMutex
+			data map[int64]*Session
+		}{data: map[int64]*Session{1: {
+			client: unhealthClient,
+			clientCreator: func(ctx context.Context, addr string) (types.DataNode, error) {
+				return unhealthClient, nil
+			},
+		}}}
+		svr.sessionManager = sm
+		ctx := context.Background()
+		resp, err := svr.CheckHealth(ctx, &milvuspb.CheckHealthRequest{})
+		assert.NoError(t, err)
+		assert.Equal(t, false, resp.IsHealthy)
+		assert.NotEmpty(t, resp.Reasons)
+	})
+}
+
 func Test_initServiceDiscovery(t *testing.T) {
 	server := newTestServer2(t, nil)
 	assert.NotNil(t, server)

internal/datacoord/services.go

@@ -21,6 +21,11 @@ import (
 	"fmt"
 	"math/rand"
 	"strconv"
+	"sync"
+
+	"github.com/milvus-io/milvus/internal/util/errorutil"
+
+	"golang.org/x/sync/errgroup"
 
 	"github.com/milvus-io/milvus-proto/go-api/commonpb"
 	"github.com/milvus-io/milvus-proto/go-api/milvuspb"
@@ -1392,3 +1397,44 @@ func (s *Server) BroadcastAlteredCollection(ctx context.Context,
 		ErrorCode: commonpb.ErrorCode_Success,
 	}, nil
 }
+
+func (s *Server) CheckHealth(ctx context.Context, req *milvuspb.CheckHealthRequest) (*milvuspb.CheckHealthResponse, error) {
+	if s.isClosed() {
+		reason := errorutil.UnHealthReason("datacoord", s.session.ServerID, "datacoord is closed")
+		return &milvuspb.CheckHealthResponse{IsHealthy: false, Reasons: []string{reason}}, nil
+	}
+
+	mu := &sync.Mutex{}
+	group, ctx := errgroup.WithContext(ctx)
+	nodes := s.sessionManager.getLiveNodeIDs()
+	errReasons := make([]string, 0, len(nodes))
+
+	for _, nodeID := range nodes {
+		nodeID := nodeID
+		group.Go(func() error {
+			cli, err := s.sessionManager.getClient(ctx, nodeID)
+			if err != nil {
+				mu.Lock()
+				defer mu.Unlock()
+				errReasons = append(errReasons, errorutil.UnHealthReason("datanode", nodeID, err.Error()))
+				return err
+			}
+
+			sta, err := cli.GetComponentStates(ctx)
+			isHealthy, reason := errorutil.UnHealthReasonWithComponentStatesOrErr("datanode", nodeID, sta, err)
+			if !isHealthy {
+				mu.Lock()
+				defer mu.Unlock()
+				errReasons = append(errReasons, reason)
+			}
+			return err
+		})
+	}
+
+	err := group.Wait()
+	if err != nil || len(errReasons) != 0 {
+		return &milvuspb.CheckHealthResponse{IsHealthy: false, Reasons: errReasons}, nil
+	}
+
+	return &milvuspb.CheckHealthResponse{IsHealthy: true, Reasons: errReasons}, nil
+}

internal/datanode/mock_test.go

@@ -277,6 +277,12 @@ func (ds *DataCoordFactory) BroadcastAlteredCollection(ctx context.Context, req
 	}, nil
 }
 
+func (ds *DataCoordFactory) CheckHealth(ctx context.Context, req *milvuspb.CheckHealthRequest) (*milvuspb.CheckHealthResponse, error) {
+	return &milvuspb.CheckHealthResponse{
+		IsHealthy: true,
+	}, nil
+}
+
 func (ds *DataCoordFactory) GetSegmentInfo(ctx context.Context, req *datapb.GetSegmentInfoRequest) (*datapb.GetSegmentInfoResponse, error) {
 	if ds.GetSegmentInfosError {
 		return nil, errors.New("mock get segment info error")

internal/distributed/datacoord/client/client.go

@@ -643,3 +643,16 @@ func (c *Client) BroadcastAlteredCollection(ctx context.Context, req *milvuspb.A
 	}
 	return ret.(*commonpb.Status), err
 }
+
+func (c *Client) CheckHealth(ctx context.Context, req *milvuspb.CheckHealthRequest) (*milvuspb.CheckHealthResponse, error) {
+	ret, err := c.grpcClient.ReCall(ctx, func(client datapb.DataCoordClient) (any, error) {
+		if !funcutil.CheckCtxValid(ctx) {
+			return nil, ctx.Err()
+		}
+		return client.CheckHealth(ctx, req)
+	})
+	if err != nil || ret == nil {
+		return nil, err
+	}
+	return ret.(*milvuspb.CheckHealthResponse), err
+}

internal/distributed/datacoord/client/client_test.go

@@ -150,6 +150,11 @@ func Test_NewClient(t *testing.T) {
 			ret, err := client.BroadcastAlteredCollection(ctx, nil)
 			retCheck(retNotNil, ret, err)
 		}
+
+		{
+			ret, err := client.CheckHealth(ctx, nil)
+			retCheck(retNotNil, ret, err)
+		}
 	}
 
 	client.grpcClient = &mock.GRPCClientBase[datapb.DataCoordClient]{

internal/distributed/datacoord/service.go

@@ -401,3 +401,7 @@ func (s *Server) MarkSegmentsDropped(ctx context.Context, req *datapb.MarkSegmen
 func (s *Server) BroadcastAlteredCollection(ctx context.Context, request *milvuspb.AlterCollectionRequest) (*commonpb.Status, error) {
 	return s.dataCoord.BroadcastAlteredCollection(ctx, request)
 }
+
+func (s *Server) CheckHealth(ctx context.Context, req *milvuspb.CheckHealthRequest) (*milvuspb.CheckHealthResponse, error) {
+	return s.dataCoord.CheckHealth(ctx, req)
+}

internal/distributed/datacoord/service_test.go

@@ -224,6 +224,12 @@ func (m *MockDataCoord) BroadcastAlteredCollection(ctx context.Context, req *mil
 	return m.broadCastResp, m.err
 }
 
+func (m *MockDataCoord) CheckHealth(ctx context.Context, req *milvuspb.CheckHealthRequest) (*milvuspb.CheckHealthResponse, error) {
+	return &milvuspb.CheckHealthResponse{
+		IsHealthy: true,
+	}, nil
+}
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 func Test_NewServer(t *testing.T) {
 	ctx := context.Background()
@@ -533,6 +539,13 @@ func Test_NewServer(t *testing.T) {
 		assert.NotNil(t, resp)
 	})
 
+	t.Run("CheckHealth", func(t *testing.T) {
+		server.dataCoord = &MockDataCoord{}
+		ret, err := server.CheckHealth(ctx, nil)
+		assert.Nil(t, err)
+		assert.Equal(t, true, ret.IsHealthy)
+	})
+
 	err := server.Stop()
 	assert.Nil(t, err)
 }

internal/distributed/indexcoord/client/client.go

@@ -270,3 +270,16 @@ func (c *Client) GetMetrics(ctx context.Context, req *milvuspb.GetMetricsRequest
 	}
 	return ret.(*milvuspb.GetMetricsResponse), err
 }
+
+func (c *Client) CheckHealth(ctx context.Context, req *milvuspb.CheckHealthRequest) (*milvuspb.CheckHealthResponse, error) {
+	ret, err := c.grpcClient.ReCall(ctx, func(client indexpb.IndexCoordClient) (any, error) {
+		if !funcutil.CheckCtxValid(ctx) {
+			return nil, ctx.Err()
+		}
+		return client.CheckHealth(ctx, req)
+	})
+	if err != nil || ret == nil {
+		return nil, err
+	}
+	return ret.(*milvuspb.CheckHealthResponse), err
+}

internal/distributed/indexcoord/client/client_test.go

@@ -188,6 +188,12 @@ func TestIndexCoordClient(t *testing.T) {
 		assert.Equal(t, typeutil.IndexCoordRole, resp.ComponentName)
 	})
 
+	t.Run("CheckHealth", func(t *testing.T) {
+		req := &milvuspb.CheckHealthRequest{}
+		resp, err := icc.CheckHealth(ctx, req)
+		assert.NoError(t, err)
+		assert.Equal(t, true, resp.IsHealthy)
+	})
 	err = server.Stop()
 	assert.NoError(t, err)
 

internal/distributed/indexcoord/service.go

@@ -290,6 +290,10 @@ func (s *Server) GetMetrics(ctx context.Context, request *milvuspb.GetMetricsReq
 	return s.indexcoord.GetMetrics(ctx, request)
 }
 
+func (s *Server) CheckHealth(ctx context.Context, request *milvuspb.CheckHealthRequest) (*milvuspb.CheckHealthResponse, error) {
+	return s.indexcoord.CheckHealth(ctx, request)
+}
+
 // startGrpcLoop starts the grep loop of IndexCoord component.
 func (s *Server) startGrpcLoop(grpcPort int) {
 

internal/distributed/indexcoord/service_test.go

@@ -157,6 +157,12 @@ func TestIndexCoordinateServer(t *testing.T) {
 		assert.Equal(t, typeutil.IndexCoordRole, resp.ComponentName)
 	})
 
+	t.Run("CheckHealth", func(t *testing.T) {
+		ret, err := server.CheckHealth(ctx, nil)
+		assert.Nil(t, err)
+		assert.Equal(t, true, ret.IsHealthy)
+	})
+
 	err = server.Stop()
 	assert.NoError(t, err)
 }

internal/distributed/proxy/service.go

@@ -882,3 +882,7 @@ func (s *Server) GetVersion(ctx context.Context, request *milvuspb.GetVersionReq
 		Version: buildTags,
 	}, nil
 }
+
+func (s *Server) CheckHealth(ctx context.Context, request *milvuspb.CheckHealthRequest) (*milvuspb.CheckHealthResponse, error) {
+	return s.proxy.CheckHealth(ctx, request)
+}

internal/distributed/proxy/service_test.go

@@ -268,6 +268,12 @@ func (m *MockRootCoord) ListPolicy(ctx context.Context, in *internalpb.ListPolic
 	return nil, nil
 }
 
+func (m *MockRootCoord) CheckHealth(ctx context.Context, req *milvuspb.CheckHealthRequest) (*milvuspb.CheckHealthResponse, error) {
+	return &milvuspb.CheckHealthResponse{
+		IsHealthy: true,
+	}, nil
+}
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 type MockIndexCoord struct {
 	MockBase
@@ -329,6 +335,10 @@ func (m *MockIndexCoord) GetMetrics(ctx context.Context, req *milvuspb.GetMetric
 	return nil, nil
 }
 
+func (m *MockIndexCoord) CheckHealth(ctx context.Context, req *milvuspb.CheckHealthRequest) (*milvuspb.CheckHealthResponse, error) {
+	return nil, nil
+}
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 type MockQueryCoord struct {
 	MockBase
@@ -438,6 +448,12 @@ func (m *MockQueryCoord) ShowConfigurations(ctx context.Context, req *internalpb
 	return nil, nil
 }
 
+func (m *MockQueryCoord) CheckHealth(ctx context.Context, req *milvuspb.CheckHealthRequest) (*milvuspb.CheckHealthResponse, error) {
+	return &milvuspb.CheckHealthResponse{
+		IsHealthy: true,
+	}, nil
+}
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 type MockDataCoord struct {
 	MockBase
@@ -588,6 +604,10 @@ func (m *MockDataCoord) BroadcastAlteredCollection(ctx context.Context, req *mil
 	return nil, nil
 }
 
+func (m *MockDataCoord) CheckHealth(ctx context.Context, req *milvuspb.CheckHealthRequest) (*milvuspb.CheckHealthResponse, error) {
+	return nil, nil
+}
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 type MockProxy struct {
 	MockBase
@@ -894,6 +914,10 @@ func (m *MockProxy) RefreshPolicyInfoCache(ctx context.Context, req *proxypb.Ref
 	return nil, nil
 }
 
+func (m *MockProxy) CheckHealth(ctx context.Context, request *milvuspb.CheckHealthRequest) (*milvuspb.CheckHealthResponse, error) {
+	return nil, nil
+}
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 type WaitOption struct {
@@ -1314,6 +1338,11 @@ func Test_NewServer(t *testing.T) {
 		assert.Nil(t, err)
 	})
 
+	t.Run("CheckHealth", func(t *testing.T) {
+		_, err := server.CheckHealth(ctx, nil)
+		assert.Nil(t, err)
+	})
+
 	err = server.Stop()
 	assert.Nil(t, err)
 

internal/distributed/querycoord/client/client.go

@@ -337,3 +337,16 @@ func (c *Client) GetShardLeaders(ctx context.Context, req *querypb.GetShardLeade
 	}
 	return ret.(*querypb.GetShardLeadersResponse), err
 }
+
+func (c *Client) CheckHealth(ctx context.Context, req *milvuspb.CheckHealthRequest) (*milvuspb.CheckHealthResponse, error) {
+	ret, err := c.grpcClient.ReCall(ctx, func(client querypb.QueryCoordClient) (any, error) {
+		if !funcutil.CheckCtxValid(ctx) {
+			return nil, ctx.Err()
+		}
+		return client.CheckHealth(ctx, req)
+	})
+	if err != nil || ret == nil {
+		return nil, err
+	}
+	return ret.(*milvuspb.CheckHealthResponse), err
+}

internal/distributed/querycoord/client/client_test.go

@@ -114,6 +114,9 @@ func Test_NewClient(t *testing.T) {
 
 		r19, err := client.ShowConfigurations(ctx, nil)
 		retCheck(retNotNil, r19, err)
+
+		r20, err := client.CheckHealth(ctx, nil)
+		retCheck(retNotNil, r20, err)
 	}
 
 	client.grpcClient = &mock.GRPCClientBase[querypb.QueryCoordClient]{

internal/distributed/querycoord/service.go

@@ -406,3 +406,7 @@ func (s *Server) GetReplicas(ctx context.Context, req *milvuspb.GetReplicasReque
 func (s *Server) GetShardLeaders(ctx context.Context, req *querypb.GetShardLeadersRequest) (*querypb.GetShardLeadersResponse, error) {
 	return s.queryCoord.GetShardLeaders(ctx, req)
 }
+
+func (s *Server) CheckHealth(ctx context.Context, req *milvuspb.CheckHealthRequest) (*milvuspb.CheckHealthResponse, error) {
+	return s.queryCoord.CheckHealth(ctx, req)
+}

internal/distributed/querycoord/service_test.go

@@ -152,6 +152,12 @@ func (m *MockQueryCoord) GetShardLeaders(ctx context.Context, req *querypb.GetSh
 	return m.shardLeadersResp, m.err
 }
 
+func (m *MockQueryCoord) CheckHealth(ctx context.Context, req *milvuspb.CheckHealthRequest) (*milvuspb.CheckHealthResponse, error) {
+	return &milvuspb.CheckHealthResponse{
+		IsHealthy: true,
+	}, m.err
+}
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 type MockRootCoord struct {
 	types.RootCoord
@@ -387,6 +393,12 @@ func Test_NewServer(t *testing.T) {
 		assert.Equal(t, commonpb.ErrorCode_Success, resp.Status.ErrorCode)
 	})
 
+	t.Run("CheckHealth", func(t *testing.T) {
+		ret, err := server.CheckHealth(ctx, nil)
+		assert.Nil(t, err)
+		assert.Equal(t, true, ret.IsHealthy)
+	})
+
 	err = server.Stop()
 	assert.Nil(t, err)
 }

internal/distributed/rootcoord/client/client.go

@@ -665,3 +665,16 @@ func (c *Client) ListPolicy(ctx context.Context, req *internalpb.ListPolicyReque
 	}
 	return ret.(*internalpb.ListPolicyResponse), err
 }
+
+func (c *Client) CheckHealth(ctx context.Context, req *milvuspb.CheckHealthRequest) (*milvuspb.CheckHealthResponse, error) {
+	ret, err := c.grpcClient.ReCall(ctx, func(client rootcoordpb.RootCoordClient) (any, error) {
+		if !funcutil.CheckCtxValid(ctx) {
+			return nil, ctx.Err()
+		}
+		return client.CheckHealth(ctx, req)
+	})
+	if err != nil {
+		return nil, err
+	}
+	return ret.(*milvuspb.CheckHealthResponse), err
+}

internal/distributed/rootcoord/client/client_test.go

@@ -213,6 +213,10 @@ func Test_NewClient(t *testing.T) {
 			r, err := client.ShowConfigurations(ctx, nil)
 			retCheck(retNotNil, r, err)
 		}
+		{
+			r, err := client.CheckHealth(ctx, nil)
+			retCheck(retNotNil, r, err)
+		}
 	}
 
 	client.grpcClient = &mock.GRPCClientBase[rootcoordpb.RootCoordClient]{
@@ -411,6 +415,10 @@ func Test_NewClient(t *testing.T) {
 		rTimeout, err := client.ListPolicy(shortCtx, nil)
 		retCheck(rTimeout, err)
 	}
+	{
+		rTimeout, err := client.CheckHealth(shortCtx, nil)
+		retCheck(rTimeout, err)
+	}
 	// clean up
 	err = client.Stop()
 	assert.Nil(t, err)

internal/distributed/rootcoord/service.go

@@ -77,6 +77,10 @@ type Server struct {
 	closer io.Closer
 }
 
+func (s *Server) CheckHealth(ctx context.Context, request *milvuspb.CheckHealthRequest) (*milvuspb.CheckHealthResponse, error) {
+	return s.rootCoord.CheckHealth(ctx, request)
+}
+
 // CreateAlias creates an alias for specified collection.
 func (s *Server) CreateAlias(ctx context.Context, request *milvuspb.CreateAliasRequest) (*commonpb.Status, error) {
 	return s.rootCoord.CreateAlias(ctx, request)

internal/distributed/rootcoord/service_test.go

@@ -52,6 +52,11 @@ type mockCore struct {
 	types.RootCoordComponent
 }
 
+func (m *mockCore) CheckHealth(ctx context.Context, req *milvuspb.CheckHealthRequest) (*milvuspb.CheckHealthResponse, error) {
+	return &milvuspb.CheckHealthResponse{
+		IsHealthy: true,
+	}, nil
+}
 func (m *mockCore) UpdateStateCode(commonpb.StateCode) {
 }
 
@@ -181,6 +186,12 @@ func TestRun(t *testing.T) {
 	err = svr.Run()
 	assert.Nil(t, err)
 
+	t.Run("CheckHealth", func(t *testing.T) {
+		ret, err := svr.CheckHealth(ctx, nil)
+		assert.Nil(t, err)
+		assert.Equal(t, true, ret.IsHealthy)
+	})
+
 	err = svr.Stop()
 	assert.Nil(t, err)
 

internal/indexcoord/index_coord.go

@@ -28,6 +28,10 @@ import (
 	"syscall"
 	"time"
 
+	"github.com/milvus-io/milvus/internal/util/errorutil"
+
+	"golang.org/x/sync/errgroup"
+
 	"go.etcd.io/etcd/api/v3/mvccpb"
 	v3rpc "go.etcd.io/etcd/api/v3/v3rpc/rpctypes"
 	clientv3 "go.etcd.io/etcd/client/v3"
@@ -973,6 +977,39 @@ func (i *IndexCoord) GetMetrics(ctx context.Context, req *milvuspb.GetMetricsReq
 	}, nil
 }
 
+func (i *IndexCoord) CheckHealth(ctx context.Context, req *milvuspb.CheckHealthRequest) (*milvuspb.CheckHealthResponse, error) {
+	if !i.isHealthy() {
+		reason := errorutil.UnHealthReason("indexcoord", i.session.ServerID, "indexcoord is unhealthy")
+		return &milvuspb.CheckHealthResponse{IsHealthy: false, Reasons: []string{reason}}, nil
+	}
+
+	mu := &sync.Mutex{}
+	group, ctx := errgroup.WithContext(ctx)
+	errReasons := make([]string, 0, len(i.nodeManager.GetAllClients()))
+
+	for nodeID, indexClient := range i.nodeManager.GetAllClients() {
+		nodeID := nodeID
+		indexClient := indexClient
+		group.Go(func() error {
+			sta, err := indexClient.GetComponentStates(ctx)
+			isHealthy, reason := errorutil.UnHealthReasonWithComponentStatesOrErr("indexnode", nodeID, sta, err)
+			if !isHealthy {
+				mu.Lock()
+				defer mu.Unlock()
+				errReasons = append(errReasons, reason)
+			}
+			return err
+		})
+	}
+
+	err := group.Wait()
+	if err != nil || len(errReasons) != 0 {
+		return &milvuspb.CheckHealthResponse{IsHealthy: false, Reasons: errReasons}, nil
+	}
+
+	return &milvuspb.CheckHealthResponse{IsHealthy: true, Reasons: errReasons}, nil
+}
+
 // watchNodeLoop is used to monitor IndexNode going online and offline.
 // fix datarace in unittest
 // startWatchService will only be invoked at start procedure

internal/indexcoord/index_coord_mock.go

@@ -145,6 +145,12 @@ func (m *Mock) GetMetrics(ctx context.Context, req *milvuspb.GetMetricsRequest)
 	return m.CallGetMetrics(ctx, req)
 }
 
+func (m *Mock) CheckHealth(ctx context.Context, req *milvuspb.CheckHealthRequest) (*milvuspb.CheckHealthResponse, error) {
+	return &milvuspb.CheckHealthResponse{
+		IsHealthy: true,
+	}, nil
+}
+
 func NewIndexCoordMock() *Mock {
 	return &Mock{
 		CallInit: func() error {

internal/indexcoord/index_coord_test.go

@@ -26,15 +26,13 @@ import (
 	"testing"
 	"time"
 
-	"github.com/milvus-io/milvus/internal/metastore/model"
-
-	"github.com/stretchr/testify/assert"
-
 	"github.com/milvus-io/milvus-proto/go-api/commonpb"
+	"github.com/milvus-io/milvus-proto/go-api/milvuspb"
 	"github.com/milvus-io/milvus/internal/common"
 	"github.com/milvus-io/milvus/internal/indexnode"
 	etcdkv "github.com/milvus-io/milvus/internal/kv/etcd"
 	"github.com/milvus-io/milvus/internal/metastore/kv/indexcoord"
+	"github.com/milvus-io/milvus/internal/metastore/model"
 	"github.com/milvus-io/milvus/internal/proto/datapb"
 	"github.com/milvus-io/milvus/internal/proto/indexpb"
 	"github.com/milvus-io/milvus/internal/proto/internalpb"
@@ -43,6 +41,7 @@ import (
 	"github.com/milvus-io/milvus/internal/util/etcd"
 	"github.com/milvus-io/milvus/internal/util/metricsinfo"
 	"github.com/milvus-io/milvus/internal/util/sessionutil"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestMockEtcd(t *testing.T) {
@@ -1016,3 +1015,60 @@ func TestIndexCoord_pullSegmentInfo(t *testing.T) {
 		assert.Nil(t, info)
 	})
 }
+
+func TestIndexCoord_CheckHealth(t *testing.T) {
+	t.Run("not healthy", func(t *testing.T) {
+		ctx := context.Background()
+		ic := &IndexCoord{session: &sessionutil.Session{ServerID: 1}}
+		ic.stateCode.Store(commonpb.StateCode_Abnormal)
+		resp, err := ic.CheckHealth(ctx, &milvuspb.CheckHealthRequest{})
+		assert.NoError(t, err)
+		assert.Equal(t, false, resp.IsHealthy)
+		assert.NotEmpty(t, resp.Reasons)
+	})
+
+	t.Run("index node health check is ok", func(t *testing.T) {
+		ctx := context.Background()
+		indexNode := indexnode.NewIndexNodeMock()
+		nm := NewNodeManager(ctx)
+		nm.nodeClients[1] = indexNode
+		ic := &IndexCoord{
+			session:     &sessionutil.Session{ServerID: 1},
+			nodeManager: nm,
+		}
+		ic.stateCode.Store(commonpb.StateCode_Healthy)
+		resp, err := ic.CheckHealth(ctx, &milvuspb.CheckHealthRequest{})
+		assert.NoError(t, err)
+		assert.Equal(t, true, resp.IsHealthy)
+		assert.Empty(t, resp.Reasons)
+	})
+
+	t.Run("index node health check is fail", func(t *testing.T) {
+		ctx := context.Background()
+		indexNode := indexnode.NewIndexNodeMock()
+		indexNode.CallGetComponentStates = func(ctx context.Context) (*milvuspb.ComponentStates, error) {
+			return &milvuspb.ComponentStates{
+				State: &milvuspb.ComponentInfo{
+					NodeID:    1,
+					StateCode: commonpb.StateCode_Abnormal,
+				},
+				SubcomponentStates: nil,
+				Status: &commonpb.Status{
+					ErrorCode: commonpb.ErrorCode_Success,
+				},
+			}, nil
+		}
+		nm := NewNodeManager(ctx)
+		nm.nodeClients[1] = indexNode
+		ic := &IndexCoord{
+			nodeManager: nm,
+			session:     &sessionutil.Session{ServerID: 1},
+		}
+		ic.stateCode.Store(commonpb.StateCode_Healthy)
+
+		resp, err := ic.CheckHealth(ctx, &milvuspb.CheckHealthRequest{})
+		assert.NoError(t, err)
+		assert.Equal(t, false, resp.IsHealthy)
+		assert.NotEmpty(t, resp.Reasons)
+	})
+}

internal/mocks/mock_datacoord.go

@@ -123,6 +123,7 @@ func (_c *DataCoord_AssignSegmentID_Call) Return(_a0 *datapb.AssignSegmentIDResp
 	return _c
 }
 
+// BroadcastAlteredCollection provides a mock function with given fields: ctx, req
 func (_m *DataCoord) BroadcastAlteredCollection(ctx context.Context, req *milvuspb.AlterCollectionRequest) (*commonpb.Status, error) {
 	ret := _m.Called(ctx, req)
 
@@ -145,14 +146,14 @@ func (_m *DataCoord) BroadcastAlteredCollection(ctx context.Context, req *milvus
 	return r0, r1
 }
 
-// DataCoord_BroadcastAlteredCollection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DataCoord_BroadcastAlteredCollection_Call'
+// DataCoord_BroadcastAlteredCollection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BroadcastAlteredCollection'
 type DataCoord_BroadcastAlteredCollection_Call struct {
 	*mock.Call
 }
 
-// AddSegment is a helper method to define mock.On call
+// BroadcastAlteredCollection is a helper method to define mock.On call
 //  - ctx context.Context
-//  - req *datapb.AddSegmentRequest
+//  - req *milvuspb.AlterCollectionRequest
 func (_e *DataCoord_Expecter) BroadcastAlteredCollection(ctx interface{}, req interface{}) *DataCoord_BroadcastAlteredCollection_Call {
 	return &DataCoord_BroadcastAlteredCollection_Call{Call: _e.mock.On("BroadcastAlteredCollection", ctx, req)}
 }
@@ -169,6 +170,53 @@ func (_c *DataCoord_BroadcastAlteredCollection_Call) Return(_a0 *commonpb.Status
 	return _c
 }
 
+// CheckHealth provides a mock function with given fields: ctx, req
+func (_m *DataCoord) CheckHealth(ctx context.Context, req *milvuspb.CheckHealthRequest) (*milvuspb.CheckHealthResponse, error) {
+	ret := _m.Called(ctx, req)
+
+	var r0 *milvuspb.CheckHealthResponse
+	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.CheckHealthRequest) *milvuspb.CheckHealthResponse); ok {
+		r0 = rf(ctx, req)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*milvuspb.CheckHealthResponse)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.CheckHealthRequest) error); ok {
+		r1 = rf(ctx, req)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// DataCoord_CheckHealth_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CheckHealth'
+type DataCoord_CheckHealth_Call struct {
+	*mock.Call
+}
+
+// CheckHealth is a helper method to define mock.On call
+//  - ctx context.Context
+//  - req *milvuspb.CheckHealthRequest
+func (_e *DataCoord_Expecter) CheckHealth(ctx interface{}, req interface{}) *DataCoord_CheckHealth_Call {
+	return &DataCoord_CheckHealth_Call{Call: _e.mock.On("CheckHealth", ctx, req)}
+}
+
+func (_c *DataCoord_CheckHealth_Call) Run(run func(ctx context.Context, req *milvuspb.CheckHealthRequest)) *DataCoord_CheckHealth_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(*milvuspb.CheckHealthRequest))
+	})
+	return _c
+}
+
+func (_c *DataCoord_CheckHealth_Call) Return(_a0 *milvuspb.CheckHealthResponse, _a1 error) *DataCoord_CheckHealth_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
 // DropVirtualChannel provides a mock function with given fields: ctx, req
 func (_m *DataCoord) DropVirtualChannel(ctx context.Context, req *datapb.DropVirtualChannelRequest) (*datapb.DropVirtualChannelResponse, error) {
 	ret := _m.Called(ctx, req)
@@ -520,28 +568,6 @@ func (_m *DataCoord) GetFlushedSegments(ctx context.Context, req *datapb.GetFlus
 	return r0, r1
 }
 
-func (_m *DataCoord) GetSegmentsByStates(ctx context.Context, req *datapb.GetSegmentsByStatesRequest) (*datapb.GetSegmentsByStatesResponse, error) {
-	ret := _m.Called(ctx, req)
-
-	var r0 *datapb.GetSegmentsByStatesResponse
-	if rf, ok := ret.Get(0).(func(context.Context, *datapb.GetSegmentsByStatesRequest) *datapb.GetSegmentsByStatesResponse); ok {
-		r0 = rf(ctx, req)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*datapb.GetSegmentsByStatesResponse)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *datapb.GetSegmentsByStatesRequest) error); ok {
-		r1 = rf(ctx, req)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
 // DataCoord_GetFlushedSegments_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFlushedSegments'
 type DataCoord_GetFlushedSegments_Call struct {
 	*mock.Call
@@ -894,6 +920,53 @@ func (_c *DataCoord_GetSegmentStates_Call) Return(_a0 *datapb.GetSegmentStatesRe
 	return _c
 }
 
+// GetSegmentsByStates provides a mock function with given fields: ctx, req
+func (_m *DataCoord) GetSegmentsByStates(ctx context.Context, req *datapb.GetSegmentsByStatesRequest) (*datapb.GetSegmentsByStatesResponse, error) {
+	ret := _m.Called(ctx, req)
+
+	var r0 *datapb.GetSegmentsByStatesResponse
+	if rf, ok := ret.Get(0).(func(context.Context, *datapb.GetSegmentsByStatesRequest) *datapb.GetSegmentsByStatesResponse); ok {
+		r0 = rf(ctx, req)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*datapb.GetSegmentsByStatesResponse)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(context.Context, *datapb.GetSegmentsByStatesRequest) error); ok {
+		r1 = rf(ctx, req)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// DataCoord_GetSegmentsByStates_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSegmentsByStates'
+type DataCoord_GetSegmentsByStates_Call struct {
+	*mock.Call
+}
+
+// GetSegmentsByStates is a helper method to define mock.On call
+//  - ctx context.Context
+//  - req *datapb.GetSegmentsByStatesRequest
+func (_e *DataCoord_Expecter) GetSegmentsByStates(ctx interface{}, req interface{}) *DataCoord_GetSegmentsByStates_Call {
+	return &DataCoord_GetSegmentsByStates_Call{Call: _e.mock.On("GetSegmentsByStates", ctx, req)}
+}
+
+func (_c *DataCoord_GetSegmentsByStates_Call) Run(run func(ctx context.Context, req *datapb.GetSegmentsByStatesRequest)) *DataCoord_GetSegmentsByStates_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(*datapb.GetSegmentsByStatesRequest))
+	})
+	return _c
+}
+
+func (_c *DataCoord_GetSegmentsByStates_Call) Return(_a0 *datapb.GetSegmentsByStatesResponse, _a1 error) *DataCoord_GetSegmentsByStates_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
 // GetStatisticsChannel provides a mock function with given fields: ctx
 func (_m *DataCoord) GetStatisticsChannel(ctx context.Context) (*milvuspb.StringResponse, error) {
 	ret := _m.Called(ctx)

internal/mocks/mock_indexcoord.go

@@ -29,6 +29,53 @@ func (_m *MockIndexCoord) EXPECT() *MockIndexCoord_Expecter {
 	return &MockIndexCoord_Expecter{mock: &_m.Mock}
 }
 
+// CheckHealth provides a mock function with given fields: ctx, req
+func (_m *MockIndexCoord) CheckHealth(ctx context.Context, req *milvuspb.CheckHealthRequest) (*milvuspb.CheckHealthResponse, error) {
+	ret := _m.Called(ctx, req)
+
+	var r0 *milvuspb.CheckHealthResponse
+	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.CheckHealthRequest) *milvuspb.CheckHealthResponse); ok {
+		r0 = rf(ctx, req)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*milvuspb.CheckHealthResponse)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.CheckHealthRequest) error); ok {
+		r1 = rf(ctx, req)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockIndexCoord_CheckHealth_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CheckHealth'
+type MockIndexCoord_CheckHealth_Call struct {
+	*mock.Call
+}
+
+// CheckHealth is a helper method to define mock.On call
+//  - ctx context.Context
+//  - req *milvuspb.CheckHealthRequest
+func (_e *MockIndexCoord_Expecter) CheckHealth(ctx interface{}, req interface{}) *MockIndexCoord_CheckHealth_Call {
+	return &MockIndexCoord_CheckHealth_Call{Call: _e.mock.On("CheckHealth", ctx, req)}
+}
+
+func (_c *MockIndexCoord_CheckHealth_Call) Run(run func(ctx context.Context, req *milvuspb.CheckHealthRequest)) *MockIndexCoord_CheckHealth_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(*milvuspb.CheckHealthRequest))
+	})
+	return _c
+}
+
+func (_c *MockIndexCoord_CheckHealth_Call) Return(_a0 *milvuspb.CheckHealthResponse, _a1 error) *MockIndexCoord_CheckHealth_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
 // CreateIndex provides a mock function with given fields: ctx, req
 func (_m *MockIndexCoord) CreateIndex(ctx context.Context, req *indexpb.CreateIndexRequest) (*commonpb.Status, error) {
 	ret := _m.Called(ctx, req)

internal/mocks/mock_rootcoord.go

@@ -172,6 +172,100 @@ func (_c *RootCoord_AlterAlias_Call) Return(_a0 *commonpb.Status, _a1 error) *Ro
 	return _c
 }
 
+// AlterCollection provides a mock function with given fields: ctx, request
+func (_m *RootCoord) AlterCollection(ctx context.Context, request *milvuspb.AlterCollectionRequest) (*commonpb.Status, error) {
+	ret := _m.Called(ctx, request)
+
+	var r0 *commonpb.Status
+	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.AlterCollectionRequest) *commonpb.Status); ok {
+		r0 = rf(ctx, request)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*commonpb.Status)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.AlterCollectionRequest) error); ok {
+		r1 = rf(ctx, request)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// RootCoord_AlterCollection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AlterCollection'
+type RootCoord_AlterCollection_Call struct {
+	*mock.Call
+}
+
+// AlterCollection is a helper method to define mock.On call
+//  - ctx context.Context
+//  - request *milvuspb.AlterCollectionRequest
+func (_e *RootCoord_Expecter) AlterCollection(ctx interface{}, request interface{}) *RootCoord_AlterCollection_Call {
+	return &RootCoord_AlterCollection_Call{Call: _e.mock.On("AlterCollection", ctx, request)}
+}
+
+func (_c *RootCoord_AlterCollection_Call) Run(run func(ctx context.Context, request *milvuspb.AlterCollectionRequest)) *RootCoord_AlterCollection_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(*milvuspb.AlterCollectionRequest))
+	})
+	return _c
+}
+
+func (_c *RootCoord_AlterCollection_Call) Return(_a0 *commonpb.Status, _a1 error) *RootCoord_AlterCollection_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+// CheckHealth provides a mock function with given fields: ctx, req
+func (_m *RootCoord) CheckHealth(ctx context.Context, req *milvuspb.CheckHealthRequest) (*milvuspb.CheckHealthResponse, error) {
+	ret := _m.Called(ctx, req)
+
+	var r0 *milvuspb.CheckHealthResponse
+	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.CheckHealthRequest) *milvuspb.CheckHealthResponse); ok {
+		r0 = rf(ctx, req)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*milvuspb.CheckHealthResponse)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.CheckHealthRequest) error); ok {
+		r1 = rf(ctx, req)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// RootCoord_CheckHealth_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CheckHealth'
+type RootCoord_CheckHealth_Call struct {
+	*mock.Call
+}
+
+// CheckHealth is a helper method to define mock.On call
+//  - ctx context.Context
+//  - req *milvuspb.CheckHealthRequest
+func (_e *RootCoord_Expecter) CheckHealth(ctx interface{}, req interface{}) *RootCoord_CheckHealth_Call {
+	return &RootCoord_CheckHealth_Call{Call: _e.mock.On("CheckHealth", ctx, req)}
+}
+
+func (_c *RootCoord_CheckHealth_Call) Run(run func(ctx context.Context, req *milvuspb.CheckHealthRequest)) *RootCoord_CheckHealth_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(*milvuspb.CheckHealthRequest))
+	})
+	return _c
+}
+
+func (_c *RootCoord_CheckHealth_Call) Return(_a0 *milvuspb.CheckHealthResponse, _a1 error) *RootCoord_CheckHealth_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
 // CreateAlias provides a mock function with given fields: ctx, req
 func (_m *RootCoord) CreateAlias(ctx context.Context, req *milvuspb.CreateAliasRequest) (*commonpb.Status, error) {
 	ret := _m.Called(ctx, req)
@@ -1698,53 +1792,6 @@ func (_c *RootCoord_ShowCollections_Call) Return(_a0 *milvuspb.ShowCollectionsRe
 	return _c
 }
 
-// ShowCollections provides a mock function with given fields: ctx, req
-func (_m *RootCoord) AlterCollection(ctx context.Context, req *milvuspb.AlterCollectionRequest) (*commonpb.Status, error) {
-	ret := _m.Called(ctx, req)
-
-	var r0 *commonpb.Status
-	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.AlterCollectionRequest) *commonpb.Status); ok {
-		r0 = rf(ctx, req)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*commonpb.Status)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.AlterCollectionRequest) error); ok {
-		r1 = rf(ctx, req)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// RootCoord_AlterCollection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ShowCollections'
-type RootCoord_AlterCollection_Call struct {
-	*mock.Call
-}
-
-// AlterCollection is a helper method to define mock.On call
-//  - ctx context.Context
-//  - req *milvuspb.AlterCollectionRequest
-func (_e *RootCoord_Expecter) AlterCollection(ctx interface{}, req interface{}) *RootCoord_AlterCollection_Call {
-	return &RootCoord_AlterCollection_Call{Call: _e.mock.On("AlterCollection", ctx, req)}
-}
-
-func (_c *RootCoord_AlterCollection_Call) Run(run func(ctx context.Context, req *milvuspb.AlterCollectionRequest)) *RootCoord_AlterCollection_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context), args[1].(*milvuspb.AlterCollectionRequest))
-	})
-	return _c
-}
-
-func (_c *RootCoord_AlterCollection_Call) Return(_a0 *commonpb.Status, _a1 error) *RootCoord_AlterCollection_Call {
-	_c.Call.Return(_a0, _a1)
-	return _c
-}
-
 // ShowConfigurations provides a mock function with given fields: ctx, req
 func (_m *RootCoord) ShowConfigurations(ctx context.Context, req *internalpb.ShowConfigurationsRequest) (*internalpb.ShowConfigurationsResponse, error) {
 	ret := _m.Called(ctx, req)

internal/proto/data_coord.proto

@@ -65,6 +65,8 @@ service DataCoord {
   rpc MarkSegmentsDropped(MarkSegmentsDroppedRequest) returns(common.Status) {}
 
   rpc BroadcastAlteredCollection(milvus.AlterCollectionRequest) returns (common.Status) {}
+
+  rpc CheckHealth(milvus.CheckHealthRequest) returns (milvus.CheckHealthResponse) {}
 }
 
 service DataNode {

internal/proto/datapb/data_coord.pb.go

@@ -4796,13 +4796,13 @@ func init() {
 func init() { proto.RegisterFile("data_coord.proto", fileDescriptor_82cd95f524594f49) }
 
 var fileDescriptor_82cd95f524594f49 = []byte{
-	// 4252 bytes of a gzipped FileDescriptorProto
+	// 4272 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x3c, 0x4b, 0x6f, 0x24, 0x49,
 	0x5a, 0x9d, 0xf5, 0x72, 0xd5, 0x57, 0x0f, 0x97, 0xa3, 0x7b, 0xec, 0xea, 0xea, 0xe7, 0x64, 0x4f,
 	0xcf, 0xf4, 0xf4, 0xf4, 0x74, 0xcf, 0x78, 0x18, 0xed, 0x40, 0xef, 0xcc, 0xaa, 0xdd, 0x9e, 0x76,
 	0x17, 0xd8, 0x5e, 0x6f, 0xda, 0x3d, 0x2d, 0xed, 0x22, 0x95, 0xd2, 0x95, 0xe1, 0x72, 0xae, 0xf3,
 	0x51, 0x9d, 0x99, 0x65, 0xb7, 0x97, 0xc3, 0x8e, 0x58, 0x09, 0x69, 0x11, 0x62, 0x79, 0x08, 0x09,
-	0x0e, 0x48, 0x88, 0xd3, 0x02, 0x42, 0x42, 0x5a, 0x21, 0x01, 0x17, 0x0e, 0x5c, 0x46, 0x70, 0x58,
+	0x24, 0x90, 0x10, 0xa7, 0x05, 0x84, 0x84, 0xb4, 0xe2, 0x00, 0x17, 0x0e, 0x5c, 0x46, 0x70, 0x58,
 	0x71, 0xe1, 0x07, 0x70, 0x00, 0xee, 0x5c, 0x39, 0xa0, 0x78, 0x64, 0xe4, 0xbb, 0x2a, 0x5d, 0xe5,
 	0x9e, 0x46, 0xec, 0xcd, 0x11, 0xf5, 0x45, 0x7c, 0x11, 0xdf, 0xfb, 0xfb, 0xe2, 0x4b, 0x43, 0x5b,
 	0x53, 0x3d, 0xb5, 0x3f, 0xb0, 0x6d, 0x47, 0xbb, 0x3f, 0x72, 0x6c, 0xcf, 0x46, 0x4b, 0xa6, 0x6e,
@@ -4824,17 +4824,17 @@ var fileDescriptor_82cd95f524594f49 = []byte{
 	0x35, 0xa5, 0xce, 0xe7, 0xb6, 0x55, 0x13, 0xe7, 0xba, 0xdb, 0x4d, 0xa8, 0x8f, 0x54, 0xc7, 0xd3,
 	0x23, 0xd4, 0x0f, 0x4f, 0xa1, 0x2e, 0x54, 0x75, 0xb7, 0x67, 0x8e, 0x6c, 0xc7, 0xeb, 0x94, 0x6f,
 	0x4a, 0x77, 0xaa, 0x8a, 0x18, 0x13, 0x0c, 0x3a, 0xfd, 0x6b, 0x4f, 0x75, 0x8f, 0x7a, 0xeb, 0xfc,
-	0x46, 0x91, 0x39, 0xf9, 0xcf, 0x24, 0x58, 0x7e, 0xe4, 0xba, 0xfa, 0xd0, 0x4a, 0xdc, 0x6c, 0x19,
+	0x46, 0x91, 0x39, 0xf9, 0xcf, 0x25, 0x58, 0x7e, 0xe4, 0xba, 0xfa, 0xd0, 0x4a, 0xdc, 0x6c, 0x19,
 	0x2a, 0x96, 0xad, 0xe1, 0xde, 0x3a, 0xbd, 0x5a, 0x51, 0xe1, 0x23, 0x74, 0x05, 0x6a, 0x23, 0x8c,
 	0x9d, 0xbe, 0x63, 0x1b, 0xfe, 0xc5, 0xaa, 0x64, 0x42, 0xb1, 0x0d, 0x8c, 0xbe, 0x03, 0x4b, 0x6e,
 	0x6c, 0x23, 0x26, 0x57, 0xf5, 0xd5, 0x5b, 0xf7, 0x13, 0x9a, 0x71, 0x3f, 0x8e, 0x54, 0x49, 0xae,
 	0x96, 0xbf, 0x2c, 0xc0, 0x45, 0x01, 0xc7, 0xce, 0x4a, 0xfe, 0x26, 0x94, 0x77, 0xf1, 0x50, 0x1c,
 	0x8f, 0x0d, 0xf2, 0x50, 0x5e, 0xb0, 0xac, 0x18, 0x66, 0x59, 0x0e, 0x51, 0x8f, 0xf3, 0xa3, 0x9c,
 	0xe4, 0xc7, 0x0d, 0xa8, 0xe3, 0x97, 0x23, 0xdd, 0xc1, 0x7d, 0x22, 0x38, 0x94, 0xe4, 0x25, 0x05,
-	0xd8, 0xd4, 0x9e, 0x6e, 0x86, 0x75, 0x63, 0x21, 0xb7, 0x6e, 0xc8, 0x7f, 0x2e, 0xc1, 0x4a, 0x82,
+	0xd8, 0xd4, 0x9e, 0x6e, 0x86, 0x75, 0x63, 0x21, 0xb7, 0x6e, 0xc8, 0x7f, 0x21, 0xc1, 0x4a, 0x82,
 	0x4b, 0x5c, 0xd9, 0x14, 0x68, 0xd3, 0x9b, 0x07, 0x94, 0x21, 0x6a, 0x47, 0x08, 0xfe, 0xf6, 0x24,
 	0x82, 0x07, 0xe0, 0x4a, 0x62, 0x7d, 0xe8, 0x90, 0x85, 0xfc, 0x87, 0x3c, 0x82, 0x95, 0x0d, 0xec,
-	0x71, 0x04, 0xe4, 0x37, 0xec, 0xce, 0x6e, 0xac, 0xa2, 0x5a, 0x5d, 0x88, 0x6b, 0xb5, 0xfc, 0x37,
+	0x71, 0x04, 0xe4, 0x37, 0xec, 0xce, 0x6e, 0xac, 0xa2, 0x5a, 0x5d, 0x88, 0x6b, 0xb5, 0xfc, 0xb7,
 	0x05, 0xa1, 0x8b, 0x14, 0x55, 0xcf, 0x3a, 0xb0, 0xd1, 0x55, 0xa8, 0x09, 0x10, 0x2e, 0x15, 0xc1,
 	0x04, 0xfa, 0x06, 0x94, 0xc9, 0x49, 0x99, 0x48, 0xb4, 0x56, 0xdf, 0x4c, 0xbf, 0x53, 0x68, 0x4f,
 	0x85, 0xc1, 0xa3, 0x1e, 0xb4, 0x5c, 0x4f, 0x75, 0xbc, 0xfe, 0xc8, 0x76, 0x29, 0x9f, 0xa9, 0xe0,
@@ -4853,10 +4853,10 @@ var fileDescriptor_82cd95f524594f49 = []byte{
 	0xf8, 0xb7, 0x25, 0xb8, 0xbe, 0x81, 0xbd, 0xc7, 0xc2, 0x2e, 0x93, 0xdf, 0x75, 0xd7, 0xd3, 0x07,
 	0xee, 0xf9, 0xc6, 0x46, 0x39, 0x1c, 0xb4, 0xfc, 0x13, 0x09, 0x6e, 0x64, 0x1e, 0x86, 0x93, 0x8e,
 	0xdb, 0x1d, 0xdf, 0x2a, 0xa7, 0xdb, 0x9d, 0x5f, 0xc3, 0xa7, 0x5f, 0xa8, 0xc6, 0x18, 0xef, 0xa8,
-	0xba, 0xc3, 0xec, 0xce, 0x8c, 0x56, 0xf8, 0xaf, 0x25, 0xb8, 0xb6, 0x81, 0xbd, 0x1d, 0xdf, 0x27,
+	0xba, 0xc3, 0xec, 0xce, 0x8c, 0x56, 0xf8, 0x6f, 0x24, 0xb8, 0xb6, 0x81, 0xbd, 0x1d, 0xdf, 0x27,
 	0xbd, 0x46, 0xea, 0x10, 0x98, 0x90, 0x6f, 0xf4, 0x83, 0xb3, 0xc8, 0x9c, 0xfc, 0xbb, 0x8c, 0x9d,
 	0xa9, 0xe7, 0x7d, 0x2d, 0x04, 0xbc, 0x4e, 0x35, 0x21, 0xa4, 0x92, 0x8f, 0x59, 0xe8, 0xc0, 0xc9,
-	0x27, 0xff, 0xa9, 0x04, 0x97, 0x1f, 0x0d, 0x5e, 0x8c, 0x75, 0x07, 0x73, 0xa0, 0x4d, 0x7b, 0x70,
+	0x27, 0xff, 0x99, 0x04, 0x97, 0x1f, 0x0d, 0x5e, 0x8c, 0x75, 0x07, 0x73, 0xa0, 0x4d, 0x7b, 0x70,
 	0x34, 0x3b, 0x71, 0x83, 0x30, 0xab, 0x10, 0x09, 0xb3, 0xa6, 0x85, 0xe6, 0xcb, 0x50, 0xf1, 0x58,
 	0x5c, 0xc7, 0x22, 0x15, 0x3e, 0xa2, 0xe7, 0x53, 0xb0, 0x81, 0x55, 0xf7, 0xff, 0xe6, 0xf9, 0x7e,
 	0x52, 0x82, 0xc6, 0x17, 0x3c, 0x1c, 0xa3, 0x5e, 0x3b, 0x2e, 0x49, 0x52, 0x7a, 0xe0, 0x15, 0x8a,
@@ -4911,7 +4911,7 @@ var fileDescriptor_82cd95f524594f49 = []byte{
 	0x96, 0xf9, 0xde, 0x4a, 0x35, 0x02, 0x74, 0x13, 0x1a, 0x73, 0x46, 0x5c, 0x7a, 0x9e, 0x94, 0xff,
 	0x4b, 0x22, 0x68, 0x9c, 0x35, 0x54, 0xd0, 0x3a, 0xb0, 0xa0, 0x6a, 0x9a, 0x83, 0x5d, 0x97, 0x9f,
 	0xc3, 0x1f, 0x92, 0x5f, 0x8e, 0xb1, 0xe3, 0xfa, 0x22, 0x5f, 0x54, 0xfc, 0x21, 0xfa, 0x26, 0x54,
-	0x45, 0x90, 0xca, 0xaa, 0xe3, 0x37, 0xb3, 0xcf, 0xc9, 0x13, 0x54, 0xb1, 0x42, 0xfe, 0xdb, 0x02,
+	0x45, 0x90, 0xca, 0xaa, 0xe3, 0x37, 0xb3, 0xcf, 0xc9, 0x13, 0x54, 0xb1, 0x42, 0xfe, 0xbb, 0x02,
 	0xb4, 0x38, 0xc1, 0xd6, 0xb8, 0xdb, 0x9d, 0xac, 0x7c, 0x6b, 0xd0, 0x38, 0x08, 0x74, 0x7f, 0x52,
 	0x29, 0x2a, 0x6c, 0x22, 0x22, 0x6b, 0xa6, 0x29, 0x60, 0xd4, 0xf1, 0x97, 0xe6, 0x72, 0xfc, 0xe5,
 	0xb3, 0x5a, 0xb0, 0x64, 0x28, 0x58, 0x49, 0x09, 0x05, 0xe5, 0x5f, 0x87, 0x7a, 0x68, 0x03, 0x6a,
@@ -4957,7 +4957,7 @@ var fileDescriptor_82cd95f524594f49 = []byte{
 	0x88, 0x92, 0xe7, 0x81, 0x4d, 0x16, 0xc5, 0x82, 0x6d, 0xd5, 0xe4, 0x0d, 0x1d, 0x35, 0x25, 0x32,
 	0x87, 0x7a, 0xc9, 0x1a, 0x59, 0x6a, 0xee, 0x1a, 0xbc, 0xc8, 0x92, 0x3c, 0x99, 0x3e, 0xc8, 0xc6,
 	0x8b, 0x63, 0x81, 0xef, 0x2d, 0xcd, 0xe2, 0x7b, 0x37, 0xe1, 0x8d, 0xd8, 0x4d, 0xe7, 0xe0, 0xa8,
-	0xfc, 0x17, 0x12, 0x61, 0x47, 0xa4, 0x31, 0x66, 0xf6, 0x98, 0xf2, 0x9a, 0x78, 0xbd, 0xe9, 0xeb,
+	0xfc, 0x97, 0x12, 0x61, 0x47, 0xa4, 0x31, 0x66, 0xf6, 0x98, 0xf2, 0x9a, 0x78, 0xbd, 0xe9, 0xeb,
 	0x5a, 0xdc, 0x54, 0x68, 0xe8, 0x33, 0xa8, 0x59, 0xf8, 0xa4, 0x1f, 0x0e, 0x69, 0x72, 0x04, 0xdc,
 	0x55, 0x0b, 0x9f, 0xd0, 0xbf, 0xe4, 0x6d, 0x58, 0x49, 0x1c, 0x75, 0x9e, 0xbb, 0xff, 0x83, 0x04,
 	0x97, 0xd7, 0x1d, 0x7b, 0xf4, 0x85, 0xee, 0x78, 0x63, 0xd5, 0x88, 0xbe, 0x75, 0xbf, 0x9a, 0xa2,
@@ -4986,13 +4986,13 @@ var fileDescriptor_82cd95f524594f49 = []byte{
 	0x65, 0xa7, 0x56, 0x27, 0x26, 0x25, 0x7e, 0x30, 0xf7, 0x0e, 0x2c, 0x86, 0xc8, 0x41, 0x7d, 0x44,
 	0x83, 0x1e, 0x35, 0x14, 0xb4, 0x53, 0x37, 0x71, 0x1b, 0x5a, 0x01, 0x49, 0x28, 0x5c, 0x93, 0xe5,
 	0x4a, 0x62, 0x96, 0x80, 0xc9, 0xdf, 0x07, 0x14, 0x60, 0x9a, 0x2f, 0xb2, 0x8b, 0xb1, 0xb2, 0x10,
-	0x67, 0xa5, 0xfc, 0x97, 0x12, 0x2c, 0x85, 0x91, 0xcd, 0xea, 0x24, 0x3f, 0x83, 0x3a, 0x7b, 0x45,
+	0x67, 0xa5, 0xfc, 0x57, 0x12, 0x2c, 0x85, 0x91, 0xcd, 0xea, 0x24, 0x3f, 0x83, 0x3a, 0x7b, 0x45,
 	0xeb, 0x13, 0x25, 0xe5, 0x75, 0x97, 0x6b, 0x13, 0x69, 0xa8, 0x40, 0xd0, 0xb6, 0x4f, 0x44, 0xe1,
 	0xc4, 0x76, 0x8e, 0x74, 0x6b, 0xd8, 0x27, 0x27, 0xf3, 0x55, 0xa3, 0xc1, 0x27, 0xb7, 0xc9, 0x9c,
 	0xfc, 0x63, 0x09, 0xae, 0x3f, 0x1b, 0x69, 0xaa, 0x87, 0x43, 0xd1, 0xc2, 0xbc, 0x9d, 0x80, 0x1f,
 	0xfb, 0xad, 0x78, 0x85, 0x7c, 0x2f, 0x41, 0x0c, 0x5a, 0xde, 0x82, 0xcb, 0x0a, 0x76, 0xb1, 0xa5,
 	0x45, 0x7e, 0x9c, 0xb9, 0x5c, 0x32, 0x82, 0x6e, 0xda, 0x76, 0xf3, 0xf0, 0x9e, 0x85, 0x6d, 0x7d,
-	0x87, 0x6c, 0xeb, 0x71, 0x2b, 0x44, 0xa2, 0x05, 0x8a, 0xc7, 0x93, 0xff, 0xaa, 0x00, 0x2b, 0x8f,
+	0x87, 0x6c, 0xeb, 0x71, 0x2b, 0x44, 0xa2, 0x05, 0x8a, 0xc7, 0x93, 0xff, 0xba, 0x00, 0x2b, 0x8f,
 	0x34, 0x8d, 0x1b, 0x30, 0x1e, 0x88, 0xbc, 0xaa, 0x18, 0x31, 0x1e, 0x43, 0x15, 0x93, 0x31, 0xd4,
 	0x79, 0x19, 0x15, 0x6e, 0x5e, 0xad, 0xb1, 0xe9, 0xbb, 0x0d, 0x87, 0x35, 0xaf, 0x3c, 0xe4, 0xaf,
 	0x39, 0x24, 0x63, 0xa5, 0xae, 0x63, 0x7a, 0x68, 0x51, 0xf5, 0xcb, 0x3e, 0xf2, 0x08, 0x3a, 0x49,
@@ -5013,7 +5013,7 @@ var fileDescriptor_82cd95f524594f49 = []byte{
 	0xb8, 0x5d, 0x46, 0x08, 0x5a, 0x7e, 0x6b, 0x31, 0x5f, 0x54, 0x09, 0xcd, 0xf9, 0xcb, 0x16, 0xee,
 	0x3e, 0x0f, 0xd7, 0x2f, 0xe9, 0x7d, 0x56, 0xe0, 0xe2, 0x33, 0x4b, 0xc3, 0x07, 0xba, 0x85, 0xb5,
 	0xe0, 0xa7, 0xf6, 0x05, 0x74, 0x11, 0x16, 0xb7, 0xb0, 0x33, 0xc4, 0xa1, 0xc9, 0x02, 0x5a, 0x82,
-	0xe6, 0x96, 0xfe, 0x32, 0x34, 0x55, 0x94, 0x4b, 0x55, 0xa9, 0x2d, 0xad, 0xfe, 0xdd, 0x15, 0xa8,
+	0xe6, 0x96, 0xfe, 0x32, 0x34, 0x55, 0x94, 0x4b, 0x55, 0xa9, 0x2d, 0xad, 0xfe, 0xe9, 0x55, 0xa8,
 	0xad, 0xab, 0x9e, 0xfa, 0xd8, 0xb6, 0x1d, 0x0d, 0x19, 0x80, 0x68, 0xf3, 0xbd, 0x39, 0xb2, 0x2d,
 	0xf1, 0x49, 0x0b, 0xba, 0x1f, 0x65, 0x3b, 0x1f, 0x24, 0x01, 0xb9, 0xd0, 0x74, 0xdf, 0x4a, 0x85,
 	0x8f, 0x01, 0xcb, 0x17, 0x90, 0x49, 0xb1, 0xed, 0xe9, 0x26, 0xde, 0xd3, 0x07, 0x47, 0x7e, 0x7b,
@@ -5051,18 +5051,19 @@ var fileDescriptor_82cd95f524594f49 = []byte{
 	0x86, 0x60, 0x08, 0x6f, 0xa4, 0x26, 0xbd, 0xa9, 0x11, 0xc1, 0xa4, 0xf4, 0x78, 0x1a, 0xa2, 0x01,
 	0x5c, 0x4c, 0x49, 0x75, 0x53, 0x7d, 0x59, 0x76, 0x4a, 0x3c, 0x0d, 0xc9, 0x21, 0x74, 0xd7, 0x1c,
 	0x5b, 0xd5, 0x06, 0xaa, 0xeb, 0x3d, 0x32, 0x3c, 0xec, 0x90, 0xf4, 0xcc, 0x0f, 0xc9, 0xe2, 0x74,
-	0xe3, 0x03, 0x0a, 0x17, 0x40, 0xe5, 0xc3, 0xb4, 0xfa, 0x55, 0x0d, 0xaa, 0x7e, 0xdf, 0xf4, 0xd7,
+	0xe3, 0x03, 0x0a, 0x17, 0x40, 0xe5, 0xc4, 0xb4, 0x0f, 0x75, 0xfa, 0xb1, 0x00, 0xfb, 0xce, 0x1e,
-	0x9c, 0xb9, 0xbd, 0x86, 0x54, 0xea, 0x7b, 0xb0, 0x18, 0xfb, 0xa4, 0x31, 0xd5, 0xfc, 0xa4, 0x7f,
+	0xa5, 0xbb, 0x9f, 0x10, 0x44, 0x86, 0x4d, 0x4b, 0x03, 0xf4, 0xf5, 0x65, 0xf5, 0xab, 0x1a, 0x54,
-	0xf6, 0x38, 0x8d, 0x69, 0xcf, 0xf9, 0x3f, 0xdc, 0x11, 0x51, 0xd5, 0x3b, 0x59, 0xe9, 0x58, 0x3c,
+	0xfd, 0xde, 0xec, 0xaf, 0x39, 0x3b, 0x7c, 0x0d, 0xe9, 0xda, 0xf7, 0x60, 0x31, 0xf6, 0xd9, 0x64,
-	0xa0, 0x9a, 0xb2, 0xf1, 0xff, 0xef, 0x30, 0x66, 0x1b, 0x20, 0x14, 0xc0, 0x4c, 0xee, 0x44, 0x22,
+	0xaa, 0x89, 0x4b, 0xff, 0xb4, 0x72, 0x1a, 0xbb, 0x9e, 0xf3, 0x7f, 0xea, 0x23, 0x22, 0xb7, 0x77,
-	0x3e, 0x79, 0x1a, 0xb5, 0xcc, 0xd4, 0x18, 0xe5, 0xdd, 0x3c, 0xed, 0x20, 0xd9, 0x5e, 0x26, 0x3b,
+	0xb2, 0x52, 0xbe, 0x78, 0xd0, 0x36, 0x65, 0xe3, 0xff, 0xdf, 0xa1, 0xd2, 0x36, 0x40, 0x28, 0x48,
-	0x32, 0x79, 0x06, 0x8d, 0x70, 0x8f, 0x20, 0x4a, 0xfd, 0xf7, 0x2e, 0xc9, 0x26, 0xc2, 0x69, 0xb7,
+	0x9a, 0xdc, 0xed, 0x44, 0xfc, 0xfe, 0x34, 0x6a, 0x99, 0xa9, 0x71, 0xd0, 0xbb, 0x79, 0x5a, 0x4e,
-	0xd8, 0x3a, 0xa3, 0xf3, 0x9a, 0xb2, 0x9d, 0x4b, 0x4c, 0x7c, 0xbc, 0x36, 0x9f, 0x61, 0xe2, 0x33,
+	0xb2, 0x3d, 0x59, 0x76, 0xf4, 0xf3, 0x0c, 0x1a, 0xe1, 0x3e, 0x44, 0x94, 0xfa, 0x2f, 0x64, 0x92,
-	0x5e, 0x04, 0x52, 0x9d, 0x7d, 0x76, 0xc1, 0x9f, 0x65, 0xe5, 0xf1, 0x82, 0x73, 0x6a, 0x56, 0x9e,
+	0x8d, 0x8a, 0xd3, 0x6e, 0xb1, 0x75, 0x46, 0x07, 0x39, 0x65, 0x3b, 0x97, 0xb8, 0x91, 0x78, 0xfd,
-	0x51, 0xc2, 0x4f, 0xcd, 0xca, 0xb3, 0x2a, 0xd8, 0xf2, 0x85, 0xb5, 0x8f, 0xbe, 0xfb, 0xe1, 0x50,
+	0x3f, 0xc3, 0x8d, 0x64, 0xbc, 0x3a, 0xa4, 0x06, 0x14, 0xd9, 0x8f, 0x0a, 0x2c, 0xf3, 0x8f, 0x17,
-	0xf7, 0x0e, 0xc7, 0xfb, 0xe4, 0xf6, 0x0f, 0xd8, 0xd2, 0xf7, 0x75, 0x9b, 0xff, 0xf5, 0xc0, 0x17,
+	0xb5, 0x53, 0x33, 0xff, 0x8c, 0x67, 0x82, 0xd4, 0xcc, 0x3f, 0xab, 0x4a, 0x2e, 0x5f, 0x58, 0xfb,
-	0xf7, 0x07, 0x74, 0xb7, 0x07, 0x64, 0xb7, 0xd1, 0xfe, 0x7e, 0x85, 0x8e, 0x3e, 0xfa, 0xdf, 0x00,
+	0xe8, 0xbb, 0x1f, 0x0e, 0x75, 0xef, 0x70, 0xbc, 0x4f, 0x6e, 0xff, 0x80, 0x2d, 0x7d, 0x5f, 0xb7,
-	0x00, 0x00, 0xff, 0xff, 0xdf, 0xf6, 0xc5, 0xb3, 0x32, 0x4c, 0x00, 0x00,
+	0xf9, 0x5f, 0x0f, 0x7c, 0x71, 0x7f, 0x40, 0x77, 0x7b, 0x40, 0x76, 0x1b, 0xed, 0xef, 0x57, 0xe8,
+	0xe8, 0xa3, 0xff, 0x0d, 0x00, 0x00, 0xff, 0xff, 0x71, 0x05, 0x6a, 0x7e, 0x96, 0x4c, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -5111,6 +5112,7 @@ type DataCoordClient interface {
 	UnsetIsImportingState(ctx context.Context, in *UnsetIsImportingStateRequest, opts ...grpc.CallOption) (*commonpb.Status, error)
 	MarkSegmentsDropped(ctx context.Context, in *MarkSegmentsDroppedRequest, opts ...grpc.CallOption) (*commonpb.Status, error)
 	BroadcastAlteredCollection(ctx context.Context, in *milvuspb.AlterCollectionRequest, opts ...grpc.CallOption) (*commonpb.Status, error)
+	CheckHealth(ctx context.Context, in *milvuspb.CheckHealthRequest, opts ...grpc.CallOption) (*milvuspb.CheckHealthResponse, error)
 }
 
 type dataCoordClient struct {
@@ -5409,6 +5411,15 @@ func (c *dataCoordClient) BroadcastAlteredCollection(ctx context.Context, in *mi
 	return out, nil
 }
 
+func (c *dataCoordClient) CheckHealth(ctx context.Context, in *milvuspb.CheckHealthRequest, opts ...grpc.CallOption) (*milvuspb.CheckHealthResponse, error) {
+	out := new(milvuspb.CheckHealthResponse)
+	err := c.cc.Invoke(ctx, "/milvus.proto.data.DataCoord/CheckHealth", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 // DataCoordServer is the server API for DataCoord service.
 type DataCoordServer interface {
 	GetComponentStates(context.Context, *milvuspb.GetComponentStatesRequest) (*milvuspb.ComponentStates, error)
@@ -5445,6 +5456,7 @@ type DataCoordServer interface {
 	UnsetIsImportingState(context.Context, *UnsetIsImportingStateRequest) (*commonpb.Status, error)
 	MarkSegmentsDropped(context.Context, *MarkSegmentsDroppedRequest) (*commonpb.Status, error)
 	BroadcastAlteredCollection(context.Context, *milvuspb.AlterCollectionRequest) (*commonpb.Status, error)
+	CheckHealth(context.Context, *milvuspb.CheckHealthRequest) (*milvuspb.CheckHealthResponse, error)
 }
 
 // UnimplementedDataCoordServer can be embedded to have forward compatible implementations.
@@ -5547,6 +5559,9 @@ func (*UnimplementedDataCoordServer) MarkSegmentsDropped(ctx context.Context, re
 func (*UnimplementedDataCoordServer) BroadcastAlteredCollection(ctx context.Context, req *milvuspb.AlterCollectionRequest) (*commonpb.Status, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method BroadcastAlteredCollection not implemented")
 }
+func (*UnimplementedDataCoordServer) CheckHealth(ctx context.Context, req *milvuspb.CheckHealthRequest) (*milvuspb.CheckHealthResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method CheckHealth not implemented")
+}
 
 func RegisterDataCoordServer(s *grpc.Server, srv DataCoordServer) {
 	s.RegisterService(&_DataCoord_serviceDesc, srv)
@@ -6128,6 +6143,24 @@ func _DataCoord_BroadcastAlteredCollection_Handler(srv interface{}, ctx context.
 	return interceptor(ctx, in, info, handler)
 }
 
+func _DataCoord_CheckHealth_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(milvuspb.CheckHealthRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(DataCoordServer).CheckHealth(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/milvus.proto.data.DataCoord/CheckHealth",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(DataCoordServer).CheckHealth(ctx, req.(*milvuspb.CheckHealthRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 var _DataCoord_serviceDesc = grpc.ServiceDesc{
 	ServiceName: "milvus.proto.data.DataCoord",
 	HandlerType: (*DataCoordServer)(nil),
@@ -6260,6 +6293,10 @@ var _DataCoord_serviceDesc = grpc.ServiceDesc{
 			MethodName: "BroadcastAlteredCollection",
 			Handler:    _DataCoord_BroadcastAlteredCollection_Handler,
 		},
+		{
+			MethodName: "CheckHealth",
+			Handler:    _DataCoord_CheckHealth_Handler,
+		},
 	},
 	Streams:  []grpc.StreamDesc{},
 	Metadata: "data_coord.proto",

internal/proto/index_coord.proto

@@ -24,6 +24,8 @@ service IndexCoord {
   rpc ShowConfigurations(internal.ShowConfigurationsRequest) returns (internal.ShowConfigurationsResponse){}
   // https://wiki.lfaidata.foundation/display/MIL/MEP+8+--+Add+metrics+for+proxy
   rpc GetMetrics(milvus.GetMetricsRequest) returns (milvus.GetMetricsResponse) {}
+
+  rpc CheckHealth(milvus.CheckHealthRequest) returns (milvus.CheckHealthResponse) {}
 }
 
 service IndexNode {

internal/proto/indexpb/index_coord.pb.go

@@ -2020,141 +2020,143 @@ func init() {
 func init() { proto.RegisterFile("index_coord.proto", fileDescriptor_f9e019eb3fda53c2) }
 
 var fileDescriptor_f9e019eb3fda53c2 = []byte{
-	// 2142 bytes of a gzipped FileDescriptorProto
+	// 2165 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x59, 0x4f, 0x6f, 0x1b, 0xc7,
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x59, 0xcd, 0x6e, 0x1b, 0xc9,
-	0x15, 0xf7, 0x92, 0x94, 0xc4, 0x7d, 0x4b, 0x4a, 0xf2, 0x58, 0x69, 0x19, 0xda, 0xae, 0xe5, 0x75,
+	0xf1, 0xf7, 0x90, 0x94, 0xc4, 0xa9, 0x21, 0x25, 0xb9, 0xad, 0xfd, 0xff, 0xb9, 0xb4, 0x1d, 0xcb,
-	0x1c, 0xb3, 0x05, 0x22, 0xb9, 0x4a, 0x53, 0xa4, 0x45, 0x5b, 0x40, 0x7f, 0x62, 0x87, 0x72, 0x24,
+	0xe3, 0xf5, 0x9a, 0x09, 0xb0, 0x92, 0xa3, 0xcd, 0x06, 0x9b, 0x20, 0x09, 0xa0, 0x8f, 0xb5, 0x4d,
-	0xa8, 0x4b, 0x23, 0x40, 0x82, 0x02, 0xdb, 0x25, 0x77, 0x28, 0x4d, 0x44, 0xee, 0xd0, 0x3b, 0xb3,
+	0x79, 0x25, 0x28, 0x43, 0x63, 0x81, 0x5d, 0x04, 0x98, 0x0c, 0x39, 0x4d, 0xa9, 0x57, 0xe4, 0x34,
-	0xb6, 0xe5, 0x02, 0x45, 0x2f, 0x3d, 0xa4, 0x08, 0x50, 0xa0, 0x87, 0xf6, 0x0b, 0x14, 0x3d, 0xa4,
+	0x3d, 0xdd, 0x63, 0x5b, 0x0e, 0x10, 0xe4, 0x92, 0xc3, 0x2e, 0x16, 0x08, 0x90, 0x43, 0xf2, 0x02,
-	0x87, 0xde, 0x7b, 0xe9, 0x07, 0x68, 0x3f, 0x45, 0xbf, 0x44, 0xaf, 0xc5, 0xfc, 0xd9, 0xe5, 0xee,
+	0x39, 0x6d, 0x0e, 0xb9, 0xe7, 0x92, 0x07, 0x48, 0x9e, 0x22, 0x2f, 0x91, 0x6b, 0xd0, 0x1f, 0x33,
-	0x72, 0x29, 0x52, 0x7f, 0x7a, 0x69, 0x6e, 0x9c, 0xb7, 0x6f, 0xfe, 0xbd, 0xf7, 0x7b, 0xef, 0xf7,
+	0x9c, 0x19, 0x0e, 0x45, 0xea, 0x23, 0x97, 0xe4, 0xc6, 0xae, 0xa9, 0xfe, 0xaa, 0xfa, 0x55, 0xfd,
-	0xde, 0x10, 0x6e, 0x92, 0xc0, 0xc7, 0xaf, 0xdd, 0x1e, 0xa5, 0xa1, 0xbf, 0x31, 0x0a, 0x29, 0xa7,
+	0xaa, 0x9a, 0x70, 0x93, 0x04, 0x3e, 0x7e, 0xe3, 0xf6, 0x28, 0x0d, 0xfd, 0x8d, 0x51, 0x48, 0x39,
-	0x08, 0x0d, 0xc9, 0xe0, 0x65, 0xc4, 0xd4, 0x68, 0x43, 0x7e, 0x6f, 0xd6, 0x7a, 0x74, 0x38, 0xa4,
+	0x45, 0x68, 0x48, 0x06, 0xaf, 0x22, 0xa6, 0x46, 0x1b, 0xf2, 0x7b, 0xb3, 0xd6, 0xa3, 0xc3, 0x21,
-	0x81, 0x92, 0x35, 0x97, 0x49, 0xc0, 0x71, 0x18, 0x78, 0x03, 0x3d, 0xae, 0xa5, 0x67, 0xd8, 0x7f,
+	0x0d, 0x94, 0xac, 0xb9, 0x4c, 0x02, 0x8e, 0xc3, 0xc0, 0x1b, 0xe8, 0x71, 0x2d, 0x3d, 0xc3, 0xfe,
-	0xab, 0x80, 0xd9, 0x16, 0xb3, 0xda, 0x41, 0x9f, 0x22, 0x1b, 0x6a, 0x3d, 0x3a, 0x18, 0xe0, 0x1e,
+	0x4b, 0x05, 0xcc, 0xb6, 0x98, 0xd5, 0x0e, 0xfa, 0x14, 0xd9, 0x50, 0xeb, 0xd1, 0xc1, 0x00, 0xf7,
-	0x27, 0x34, 0x68, 0xef, 0x35, 0x8c, 0x75, 0xa3, 0x55, 0x76, 0x32, 0x32, 0xd4, 0x80, 0xa5, 0x3e,
+	0x38, 0xa1, 0x41, 0x7b, 0xaf, 0x61, 0xac, 0x1b, 0xad, 0xb2, 0x93, 0x91, 0xa1, 0x06, 0x2c, 0xf5,
-	0xc1, 0x03, 0xbf, 0xbd, 0xd7, 0x28, 0xc9, 0xcf, 0xf1, 0x10, 0xdd, 0x05, 0x50, 0x07, 0x0c, 0xbc,
+	0x09, 0x1e, 0xf8, 0xed, 0xbd, 0x46, 0x49, 0x7e, 0x8e, 0x87, 0xe8, 0x2e, 0x80, 0x3a, 0x60, 0xe0,
-	0x21, 0x6e, 0x94, 0xd7, 0x8d, 0x96, 0xe9, 0x98, 0x52, 0x72, 0xe8, 0x0d, 0xb1, 0x98, 0x28, 0x07,
+	0x0d, 0x71, 0xa3, 0xbc, 0x6e, 0xb4, 0x4c, 0xc7, 0x94, 0x92, 0x43, 0x6f, 0x88, 0xc5, 0x44, 0x39,
-	0xed, 0xbd, 0x46, 0x45, 0x4d, 0xd4, 0x43, 0xb4, 0x03, 0x16, 0x3f, 0x1b, 0x61, 0x77, 0xe4, 0x85,
+	0x68, 0xef, 0x35, 0x2a, 0x6a, 0xa2, 0x1e, 0xa2, 0x1d, 0xb0, 0xf8, 0xd9, 0x08, 0xbb, 0x23, 0x2f,
-	0xde, 0x90, 0x35, 0x16, 0xd6, 0xcb, 0x2d, 0x6b, 0xeb, 0xfe, 0x46, 0xe6, 0x6a, 0xfa, 0x4e, 0xcf,
+	0xf4, 0x86, 0xac, 0xb1, 0xb0, 0x5e, 0x6e, 0x59, 0x5b, 0xf7, 0x37, 0x32, 0x57, 0xd3, 0x77, 0x7a,
-	0xf0, 0xd9, 0xa7, 0xde, 0x20, 0xc2, 0x47, 0x1e, 0x09, 0x1d, 0x10, 0xb3, 0x8e, 0xe4, 0x24, 0xb4,
+	0x8e, 0xcf, 0x3e, 0xf3, 0x06, 0x11, 0x3e, 0xf2, 0x48, 0xe8, 0x80, 0x98, 0x75, 0x24, 0x27, 0xa1,
-	0x07, 0x35, 0xb5, 0xb9, 0x5e, 0x64, 0x71, 0xde, 0x45, 0x2c, 0x39, 0x4d, 0xaf, 0x72, 0x5f, 0xaf,
+	0x3d, 0xa8, 0xa9, 0xcd, 0xf5, 0x22, 0x8b, 0xf3, 0x2e, 0x62, 0xc9, 0x69, 0x7a, 0x95, 0xfb, 0x7a,
-	0x82, 0x7d, 0x37, 0xa4, 0xaf, 0x58, 0x63, 0x49, 0x1e, 0xd4, 0xd2, 0x32, 0x87, 0xbe, 0x62, 0xe2,
+	0x15, 0xec, 0xbb, 0x21, 0x7d, 0xcd, 0x1a, 0x4b, 0xf2, 0xa0, 0x96, 0x96, 0x39, 0xf4, 0x35, 0x13,
-	0x96, 0x9c, 0x72, 0x6f, 0xa0, 0x14, 0xaa, 0x52, 0xc1, 0x94, 0x12, 0xf9, 0xf9, 0x03, 0x58, 0x60,
+	0xb7, 0xe4, 0x94, 0x7b, 0x03, 0xa5, 0x50, 0x95, 0x0a, 0xa6, 0x94, 0xc8, 0xcf, 0x1f, 0xc1, 0x02,
-	0xdc, 0xe3, 0xb8, 0x61, 0xae, 0x1b, 0xad, 0xe5, 0xad, 0x7b, 0x85, 0x07, 0x90, 0x16, 0xef, 0x08,
+	0xe3, 0x1e, 0xc7, 0x0d, 0x73, 0xdd, 0x68, 0x2d, 0x6f, 0xdd, 0x2b, 0x3c, 0x80, 0xb4, 0x78, 0x47,
-	0x35, 0x47, 0x69, 0xa3, 0x0f, 0xe0, 0xdb, 0xea, 0xf8, 0x72, 0xe8, 0xf6, 0x3d, 0x32, 0x70, 0x43,
+	0xa8, 0x39, 0x4a, 0x1b, 0x7d, 0x04, 0xff, 0xaf, 0x8e, 0x2f, 0x87, 0x6e, 0xdf, 0x23, 0x03, 0x37,
-	0xec, 0x31, 0x1a, 0x34, 0x40, 0x1a, 0x72, 0x8d, 0x24, 0x73, 0x9e, 0x78, 0x64, 0xe0, 0xc8, 0x6f,
+	0xc4, 0x1e, 0xa3, 0x41, 0x03, 0xa4, 0x21, 0xd7, 0x48, 0x32, 0xe7, 0x89, 0x47, 0x06, 0x8e, 0xfc,
-	0xc8, 0x86, 0x3a, 0x61, 0xae, 0x17, 0x71, 0xea, 0xca, 0xef, 0x0d, 0x6b, 0xdd, 0x68, 0x55, 0x1d,
+	0x86, 0x6c, 0xa8, 0x13, 0xe6, 0x7a, 0x11, 0xa7, 0xae, 0xfc, 0xde, 0xb0, 0xd6, 0x8d, 0x56, 0xd5,
-	0x8b, 0xb0, 0xed, 0x88, 0x53, 0xb9, 0x0d, 0x3a, 0x80, 0x9b, 0x11, 0xc3, 0xa1, 0x9b, 0x31, 0x4f,
+	0xb1, 0x08, 0xdb, 0x8e, 0x38, 0x95, 0xdb, 0xa0, 0x03, 0xb8, 0x19, 0x31, 0x1c, 0xba, 0x19, 0xf3,
-	0x6d, 0x5e, 0xf3, 0xac, 0x88, 0xb9, 0xed, 0xb1, 0x89, 0xec, 0xdf, 0x1a, 0x00, 0x4f, 0xa4, 0xc7,
+	0xd4, 0xe6, 0x35, 0xcf, 0x8a, 0x98, 0xdb, 0x1e, 0x9b, 0xc8, 0xfe, 0xad, 0x01, 0xf0, 0x44, 0x7a,
-	0xe5, 0xea, 0x3f, 0x89, 0x9d, 0x4e, 0x82, 0x3e, 0x95, 0x80, 0xb1, 0xb6, 0xee, 0x6e, 0x4c, 0xa2,
+	0x5c, 0xae, 0xfe, 0x93, 0xd8, 0xe9, 0x24, 0xe8, 0x53, 0x09, 0x18, 0x6b, 0xeb, 0xee, 0xc6, 0x24,
-	0x72, 0x23, 0x41, 0x99, 0xc6, 0x84, 0x04, 0x5c, 0x03, 0x96, 0x7c, 0x3c, 0xc0, 0x1c, 0xfb, 0x12,
+	0x2a, 0x37, 0x12, 0x94, 0x69, 0x4c, 0x48, 0xc0, 0x35, 0x60, 0xc9, 0xc7, 0x03, 0xcc, 0xb1, 0x2f,
-	0x4c, 0x55, 0x27, 0x1e, 0xa2, 0x7b, 0x60, 0xf5, 0x42, 0x2c, 0x6c, 0xc1, 0x89, 0x46, 0x53, 0xc5,
+	0xc1, 0x54, 0x75, 0xe2, 0x21, 0xba, 0x07, 0x56, 0x2f, 0xc4, 0xc2, 0x16, 0x9c, 0x68, 0x34, 0x55,
-	0x01, 0x25, 0x7a, 0x4e, 0x86, 0xd8, 0xfe, 0xb2, 0x02, 0xb5, 0x0e, 0x3e, 0x1e, 0xe2, 0x80, 0xab,
+	0x1c, 0x50, 0xa2, 0x17, 0x64, 0x88, 0xed, 0xaf, 0x2a, 0x50, 0xeb, 0xe0, 0xe3, 0x21, 0x0e, 0xb8,
-	0x93, 0xcc, 0x03, 0xde, 0x75, 0xb0, 0x46, 0x5e, 0xc8, 0x89, 0x56, 0x51, 0x00, 0x4e, 0x8b, 0xd0,
+	0x3a, 0xc9, 0x3c, 0xe0, 0x5d, 0x07, 0x6b, 0xe4, 0x85, 0x9c, 0x68, 0x15, 0x05, 0xe0, 0xb4, 0x08,
-	0x1d, 0x30, 0x99, 0x5e, 0x75, 0x4f, 0xee, 0x5a, 0x76, 0xc6, 0x02, 0xf4, 0x36, 0x54, 0x83, 0x68,
+	0xdd, 0x01, 0x93, 0xe9, 0x55, 0xf7, 0xe4, 0xae, 0x65, 0x67, 0x2c, 0x40, 0xef, 0x42, 0x35, 0x88,
-	0xa8, 0x5c, 0xaf, 0x41, 0x1c, 0x44, 0x43, 0xe9, 0xf8, 0x14, 0xbc, 0x17, 0xb2, 0xf0, 0x6e, 0xc0,
+	0x86, 0xca, 0xf5, 0x1a, 0xc4, 0x41, 0x34, 0x94, 0x8e, 0x4f, 0xc1, 0x7b, 0x21, 0x0b, 0xef, 0x06,
-	0x52, 0x37, 0x22, 0x32, 0x62, 0x16, 0xd5, 0x17, 0x3d, 0x44, 0xdf, 0x82, 0xc5, 0x80, 0xfa, 0xb8,
+	0x2c, 0x75, 0x23, 0x22, 0x23, 0x66, 0x51, 0x7d, 0xd1, 0x43, 0xf4, 0x7f, 0xb0, 0x18, 0x50, 0x1f,
-	0xbd, 0xa7, 0x81, 0xa6, 0x47, 0xe8, 0x01, 0xd4, 0x95, 0x51, 0x5f, 0xe2, 0x90, 0x11, 0x1a, 0x68,
+	0xb7, 0xf7, 0x34, 0xd0, 0xf4, 0x08, 0x3d, 0x80, 0xba, 0x32, 0xea, 0x2b, 0x1c, 0x32, 0x42, 0x03,
-	0x98, 0x29, 0x6c, 0x7e, 0xaa, 0x64, 0x97, 0x45, 0xda, 0x3d, 0xb0, 0x26, 0xd1, 0x05, 0xfd, 0x31,
+	0x0d, 0x33, 0x85, 0xcd, 0xcf, 0x94, 0xec, 0xb2, 0x48, 0xbb, 0x07, 0xd6, 0x24, 0xba, 0xa0, 0x3f,
-	0xa6, 0xbe, 0x17, 0xe7, 0x99, 0x3e, 0x19, 0x60, 0xe6, 0x8e, 0x3c, 0x7e, 0xc2, 0x1a, 0xd6, 0x7a,
+	0xc6, 0xd4, 0xf7, 0xe2, 0x3c, 0xd3, 0x27, 0x03, 0xcc, 0xdc, 0x91, 0xc7, 0x4f, 0x58, 0xc3, 0x5a,
-	0xb9, 0x65, 0x3a, 0x2b, 0xf2, 0xc3, 0x13, 0x21, 0x3f, 0x12, 0xe2, 0xb4, 0xff, 0x6a, 0xe7, 0xfa,
+	0x2f, 0xb7, 0x4c, 0x67, 0x45, 0x7e, 0x78, 0x22, 0xe4, 0x47, 0x42, 0x9c, 0xf6, 0x5f, 0xed, 0x5c,
-	0xaf, 0x9e, 0xf7, 0x1f, 0x7a, 0x08, 0xcb, 0x0c, 0x87, 0xc4, 0x1b, 0x90, 0x37, 0xd8, 0x65, 0xe4,
+	0xff, 0xd5, 0xf3, 0xfe, 0x43, 0x0f, 0x61, 0x99, 0xe1, 0x90, 0x78, 0x03, 0xf2, 0x16, 0xbb, 0x8c,
-	0x0d, 0x6e, 0x2c, 0x4b, 0x9d, 0x7a, 0x22, 0xed, 0x90, 0x37, 0x58, 0x98, 0xe2, 0x55, 0x48, 0x38,
+	0xbc, 0xc5, 0x8d, 0x65, 0xa9, 0x53, 0x4f, 0xa4, 0x1d, 0xf2, 0x16, 0x0b, 0x53, 0xbc, 0x0e, 0x09,
-	0x76, 0x4f, 0xbc, 0xc0, 0xa7, 0xfd, 0x7e, 0x63, 0x45, 0xee, 0x53, 0x93, 0xc2, 0x8f, 0x95, 0xcc,
+	0xc7, 0xee, 0x89, 0x17, 0xf8, 0xb4, 0xdf, 0x6f, 0xac, 0xc8, 0x7d, 0x6a, 0x52, 0xf8, 0x4c, 0xc9,
-	0xfe, 0x93, 0x01, 0xb7, 0x1c, 0x7c, 0x4c, 0x18, 0xc7, 0xe1, 0x21, 0xf5, 0xb1, 0x83, 0x5f, 0x44,
+	0xec, 0x3f, 0x1a, 0x70, 0xcb, 0xc1, 0xc7, 0x84, 0x71, 0x1c, 0x1e, 0x52, 0x1f, 0x3b, 0xf8, 0x65,
-	0x98, 0x71, 0xf4, 0x18, 0x2a, 0x5d, 0x8f, 0x61, 0x0d, 0xcb, 0x3b, 0x85, 0x16, 0x3a, 0x60, 0xc7,
+	0x84, 0x19, 0x47, 0x8f, 0xa1, 0xd2, 0xf5, 0x18, 0xd6, 0xb0, 0xbc, 0x53, 0x68, 0xa1, 0x03, 0x76,
-	0x3b, 0x1e, 0xc3, 0x8e, 0xd4, 0x44, 0x3f, 0x84, 0x25, 0xcf, 0xf7, 0x43, 0xcc, 0x98, 0x04, 0xc7,
+	0xbc, 0xe3, 0x31, 0xec, 0x48, 0x4d, 0xf4, 0x43, 0x58, 0xf2, 0x7c, 0x3f, 0xc4, 0x8c, 0x49, 0x70,
-	0xb4, 0x49, 0xdb, 0x4a, 0xc7, 0x89, 0x95, 0x53, 0x9e, 0x2c, 0xa7, 0x3d, 0x69, 0xff, 0xde, 0x80,
+	0x4c, 0x9b, 0xb4, 0xad, 0x74, 0x9c, 0x58, 0x39, 0xe5, 0xc9, 0x72, 0xda, 0x93, 0xf6, 0xef, 0x0c,
-	0xb5, 0xec, 0xc9, 0xd8, 0x88, 0x06, 0x0c, 0xa3, 0xf7, 0x61, 0x51, 0xf8, 0x23, 0x62, 0xfa, 0x70,
+	0x58, 0xcb, 0x9e, 0x8c, 0x8d, 0x68, 0xc0, 0x30, 0xfa, 0x10, 0x16, 0x85, 0x3f, 0x22, 0xa6, 0x0f,
-	0xb7, 0x0b, 0xf7, 0xe9, 0x48, 0x15, 0x47, 0xab, 0x8a, 0x44, 0x49, 0x02, 0xc2, 0xe3, 0x20, 0x56,
+	0x77, 0xbb, 0x70, 0x9f, 0x8e, 0x54, 0x71, 0xb4, 0xaa, 0x48, 0x94, 0x24, 0x20, 0x3c, 0x0e, 0x62,
-	0x27, 0xbc, 0x9f, 0x8f, 0x36, 0x9d, 0xee, 0xdb, 0x01, 0xe1, 0x2a, 0x66, 0x1d, 0x20, 0xc9, 0x6f,
+	0x75, 0xc2, 0xfb, 0xf9, 0x68, 0xd3, 0xe9, 0xbe, 0x1d, 0x10, 0xae, 0x62, 0xd6, 0x01, 0x92, 0xfc,
-	0xfb, 0x33, 0x58, 0x7b, 0x8a, 0x79, 0x0a, 0x17, 0xda, 0x56, 0xf3, 0x84, 0x4f, 0x36, 0xc3, 0x97,
+	0xb6, 0x3f, 0x87, 0xb5, 0xa7, 0x98, 0xa7, 0x70, 0xa1, 0x6d, 0x35, 0x4f, 0xf8, 0x64, 0x33, 0x7c,
-	0x72, 0x19, 0xde, 0xfe, 0xb3, 0x01, 0x6f, 0xe5, 0xd6, 0xbe, 0xca, 0x6d, 0x13, 0x80, 0x97, 0xae,
+	0x29, 0x97, 0xe1, 0xed, 0x3f, 0x19, 0xf0, 0x4e, 0x6e, 0xed, 0xab, 0xdc, 0x36, 0x01, 0x78, 0xe9,
-	0x02, 0xf0, 0x72, 0x1e, 0xe0, 0xf6, 0x6f, 0x0c, 0xb8, 0xfd, 0x14, 0xf3, 0x74, 0xf2, 0xb8, 0x66,
+	0x2a, 0x00, 0x2f, 0xe7, 0x01, 0x6e, 0xff, 0xc6, 0x80, 0xdb, 0x4f, 0x31, 0x4f, 0x27, 0x8f, 0x6b,
-	0x4b, 0xa0, 0xef, 0x00, 0x24, 0x49, 0x83, 0x35, 0xca, 0xeb, 0xe5, 0x56, 0xd9, 0x49, 0x49, 0xec,
+	0xb6, 0x04, 0xfa, 0x0e, 0x40, 0x92, 0x34, 0x58, 0xa3, 0xbc, 0x5e, 0x6e, 0x95, 0x9d, 0x94, 0xc4,
-	0x2f, 0x0d, 0xb8, 0x39, 0xb1, 0x7f, 0x36, 0xf7, 0x18, 0xf9, 0xdc, 0xf3, 0xbf, 0x32, 0xc7, 0x1f,
+	0xfe, 0xca, 0x80, 0x9b, 0x13, 0xfb, 0x67, 0x73, 0x8f, 0x91, 0xcf, 0x3d, 0xff, 0x29, 0x73, 0xfc,
-	0x0c, 0xb8, 0x53, 0x6c, 0x8e, 0xab, 0x38, 0xef, 0xa7, 0x6a, 0x12, 0x16, 0x28, 0x15, 0x54, 0xf3,
+	0xde, 0x80, 0x3b, 0xc5, 0xe6, 0xb8, 0x8a, 0xf3, 0x7e, 0xaa, 0x26, 0x61, 0x81, 0x52, 0x41, 0x35,
-	0xb0, 0x88, 0x13, 0x26, 0xf7, 0xd4, 0x93, 0xec, 0xaf, 0xca, 0x80, 0x76, 0x65, 0xb2, 0x90, 0x1f,
+	0x0f, 0x8b, 0x38, 0x61, 0x72, 0x4f, 0x3d, 0xc9, 0xfe, 0xa6, 0x0c, 0x68, 0x57, 0x26, 0x0b, 0xf9,
-	0x2f, 0xe2, 0x9a, 0x4b, 0x17, 0x28, 0xb9, 0x32, 0xa4, 0x72, 0x1d, 0x65, 0xc8, 0xc2, 0xa5, 0xca,
+	0xf1, 0x22, 0xae, 0xb9, 0x74, 0x81, 0x92, 0x2b, 0x43, 0x2a, 0xd7, 0x51, 0x86, 0x2c, 0x5c, 0xaa,
-	0x90, 0x3b, 0x60, 0x8a, 0xac, 0xc9, 0xb8, 0x37, 0x1c, 0x49, 0xce, 0xa8, 0x38, 0x63, 0xc1, 0x24,
+	0x0c, 0xb9, 0x03, 0xa6, 0xc8, 0x9a, 0x8c, 0x7b, 0xc3, 0x91, 0xe4, 0x8c, 0x8a, 0x33, 0x16, 0x4c,
-	0xe9, 0x2f, 0xcd, 0x49, 0xfa, 0xd5, 0x4b, 0x93, 0xfe, 0x6b, 0xb8, 0x15, 0x07, 0xb6, 0xa4, 0xf0,
+	0x92, 0xfe, 0xd2, 0x9c, 0xa4, 0x5f, 0xbd, 0x34, 0xe9, 0xbf, 0x81, 0x5b, 0x71, 0x60, 0x4b, 0x0a,
-	0x0b, 0xb8, 0x23, 0x1b, 0x0a, 0xa5, 0x7c, 0x28, 0xcc, 0x70, 0x8a, 0xfd, 0x9f, 0x12, 0xdc, 0x6c,
+	0xbf, 0x80, 0x3b, 0xb2, 0xa1, 0x50, 0xca, 0x87, 0xc2, 0x0c, 0xa7, 0xd8, 0xff, 0x2a, 0xc1, 0xcd,
-	0xc7, 0xac, 0x23, 0x48, 0x47, 0xd6, 0x0d, 0xe7, 0x47, 0xca, 0x74, 0x04, 0xa4, 0x48, 0xba, 0x3c,
+	0x76, 0xcc, 0x3a, 0x82, 0x74, 0x64, 0xdd, 0x70, 0x7e, 0xa4, 0x4c, 0x47, 0x40, 0x8a, 0xa4, 0xcb,
-	0x95, 0xa4, 0x2b, 0x59, 0x92, 0xce, 0x1e, 0x70, 0x21, 0x8f, 0x9a, 0xeb, 0x29, 0x3c, 0x5b, 0xb0,
+	0x53, 0x49, 0xba, 0x92, 0x25, 0xe9, 0xec, 0x01, 0x17, 0xf2, 0xa8, 0xb9, 0x9e, 0xc2, 0xb3, 0x05,
-	0x3a, 0x26, 0x5d, 0xcd, 0xb9, 0x4b, 0x92, 0x73, 0x97, 0x49, 0xfa, 0xf6, 0x0c, 0x3d, 0x82, 0x95,
+	0xab, 0x63, 0xd2, 0xd5, 0x9c, 0xbb, 0x24, 0x39, 0x77, 0x99, 0xa4, 0x6f, 0xcf, 0xd0, 0x23, 0x58,
-	0x84, 0x21, 0x7d, 0x45, 0x9c, 0x55, 0x89, 0x90, 0x31, 0x9d, 0xfa, 0x31, 0x73, 0x66, 0x8b, 0x08,
+	0x49, 0x18, 0xd2, 0x57, 0xc4, 0x59, 0x95, 0x08, 0x19, 0xd3, 0xa9, 0x1f, 0x33, 0x67, 0xb6, 0x88,
-	0xb3, 0xa0, 0x88, 0x48, 0x17, 0x34, 0x90, 0x29, 0x68, 0xec, 0xbf, 0x1b, 0x60, 0x25, 0x01, 0x3a,
+	0x30, 0x0b, 0x8a, 0x88, 0x74, 0x41, 0x03, 0x99, 0x82, 0xc6, 0xfe, 0xab, 0x01, 0x56, 0x12, 0xa0,
-	0x67, 0x73, 0x90, 0xf1, 0x4b, 0x29, 0xef, 0x97, 0xfb, 0x50, 0xc3, 0x81, 0xd7, 0x1d, 0x60, 0x8d,
+	0x73, 0x36, 0x07, 0x19, 0xbf, 0x94, 0xf2, 0x7e, 0xb9, 0x0f, 0x35, 0x1c, 0x78, 0xdd, 0x01, 0xd6,
-	0xdb, 0xb2, 0xc2, 0xad, 0x92, 0x29, 0xdc, 0x3e, 0x01, 0x6b, 0x5c, 0x4e, 0xc6, 0x31, 0xf8, 0x70,
+	0xb8, 0x2d, 0x2b, 0xdc, 0x2a, 0x99, 0xc2, 0xed, 0x13, 0xb0, 0xc6, 0xe5, 0x64, 0x1c, 0x83, 0x0f,
-	0x6a, 0x3d, 0x99, 0x06, 0x85, 0x03, 0x49, 0x5d, 0xc9, 0xec, 0xdf, 0x95, 0xc6, 0x34, 0xa7, 0x10,
+	0xa7, 0xd6, 0x93, 0x69, 0x50, 0x38, 0x90, 0xd4, 0x95, 0xcc, 0xfe, 0xba, 0x34, 0xa6, 0x39, 0x85,
-	0x7b, 0x95, 0x64, 0xf6, 0x0b, 0xa8, 0xe9, 0x5b, 0xa8, 0x32, 0x57, 0xa5, 0xb4, 0x1f, 0x15, 0x1d,
+	0xd8, 0xab, 0x24, 0xb3, 0x5f, 0x40, 0x4d, 0xdf, 0x42, 0x95, 0xb9, 0x2a, 0xa5, 0xfd, 0xa8, 0xe8,
-	0xab, 0x68, 0xd3, 0x8d, 0x94, 0x19, 0x3f, 0x0a, 0x78, 0x78, 0xe6, 0x58, 0x6c, 0x2c, 0x69, 0xba,
+	0x58, 0x45, 0x9b, 0x6e, 0xa4, 0xcc, 0xf8, 0x49, 0xc0, 0xc3, 0x33, 0xc7, 0x62, 0x63, 0x49, 0xd3,
-	0xb0, 0x9a, 0x57, 0x40, 0xab, 0x50, 0x3e, 0xc5, 0x67, 0xda, 0xc6, 0xe2, 0xa7, 0x48, 0xff, 0x2f,
+	0x85, 0xd5, 0xbc, 0x02, 0x5a, 0x85, 0xf2, 0x29, 0x3e, 0xd3, 0x36, 0x16, 0x3f, 0x45, 0xfa, 0x7f,
-	0x05, 0x76, 0x34, 0xeb, 0xdf, 0x3b, 0x37, 0x9f, 0xf6, 0xa9, 0xa3, 0xb4, 0x7f, 0x5c, 0xfa, 0xd0,
+	0x25, 0xb0, 0xa3, 0x59, 0xff, 0xde, 0xb9, 0xf9, 0xb4, 0x4f, 0x1d, 0xa5, 0xfd, 0xe3, 0xd2, 0xc7,
-	0xb0, 0xcf, 0x60, 0x75, 0x2f, 0xa4, 0xa3, 0x0b, 0x67, 0x52, 0x1b, 0x6a, 0xa9, 0xd2, 0x38, 0x0e,
+	0x86, 0x7d, 0x06, 0xab, 0x7b, 0x21, 0x1d, 0x5d, 0x38, 0x93, 0xda, 0x50, 0x4b, 0x95, 0xc6, 0x71,
-	0xde, 0x8c, 0x6c, 0x56, 0xf8, 0x7e, 0x06, 0x6b, 0x7b, 0x98, 0xf5, 0x42, 0xd2, 0xbd, 0x78, 0x22,
+	0xf0, 0x66, 0x64, 0xb3, 0xc2, 0xf7, 0x73, 0x58, 0xdb, 0xc3, 0xac, 0x17, 0x92, 0xee, 0xc5, 0x13,
-	0x9f, 0x51, 0x6d, 0x7c, 0x65, 0xc0, 0x5b, 0xb9, 0xb5, 0xaf, 0xe2, 0xe3, 0x9f, 0x65, 0x91, 0xa7,
+	0xf9, 0x8c, 0x6a, 0xe3, 0x1b, 0x03, 0xde, 0xc9, 0xad, 0x7d, 0x15, 0x1f, 0xff, 0x2c, 0x8b, 0x3c,
-	0x5c, 0x3c, 0xa3, 0x93, 0x49, 0x23, 0xce, 0x93, 0x2c, 0x2a, 0xbf, 0xed, 0x88, 0xcc, 0x71, 0x14,
+	0xe5, 0xe2, 0x19, 0x9d, 0x4c, 0x1a, 0x71, 0x9e, 0x64, 0x51, 0xf9, 0x6d, 0x47, 0x64, 0x8e, 0xa3,
-	0xd2, 0x63, 0x59, 0x23, 0x5e, 0xdf, 0x8d, 0xff, 0x68, 0xc0, 0xdd, 0x29, 0x7b, 0x5c, 0xe5, 0xe6,
+	0x90, 0x1e, 0xcb, 0x1a, 0xf1, 0xfa, 0x6e, 0xfc, 0x07, 0x03, 0xee, 0x4e, 0xd9, 0xe3, 0x2a, 0x37,
-	0xf9, 0xa6, 0xb7, 0x34, 0xab, 0xe9, 0x2d, 0xe7, 0x9a, 0x5e, 0xfb, 0xaf, 0x25, 0xa8, 0x77, 0x38,
+	0xcf, 0x37, 0xbd, 0xa5, 0x59, 0x4d, 0x6f, 0x39, 0xd7, 0xf4, 0xda, 0x7f, 0x2e, 0x41, 0xbd, 0xc3,
-	0x0d, 0xbd, 0x63, 0xbc, 0x4b, 0x83, 0x3e, 0x39, 0x16, 0xe9, 0x34, 0xae, 0xa3, 0x0d, 0x79, 0x8d,
+	0x69, 0xe8, 0x1d, 0xe3, 0x5d, 0x1a, 0xf4, 0xc9, 0xb1, 0x48, 0xa7, 0x71, 0x1d, 0x6d, 0xc8, 0x6b,
-	0xa4, 0x52, 0xbe, 0x0f, 0x35, 0xaf, 0xd7, 0xc3, 0x8c, 0xb9, 0xa7, 0xf8, 0x4c, 0x67, 0x09, 0xd3,
+	0x24, 0x95, 0xf2, 0x7d, 0xa8, 0x79, 0xbd, 0x1e, 0x66, 0xcc, 0x3d, 0xc5, 0x67, 0x3a, 0x4b, 0x98,
-	0xb1, 0x94, 0xec, 0x99, 0x10, 0x89, 0x0e, 0x84, 0xe1, 0x5e, 0x88, 0xb9, 0x3b, 0xd6, 0xd4, 0xd0,
+	0x8e, 0xa5, 0x64, 0xcf, 0x85, 0x48, 0x74, 0x20, 0x0c, 0xf7, 0x42, 0xcc, 0xdd, 0xb1, 0xa6, 0x86,
-	0x5a, 0x51, 0x1f, 0xb6, 0x63, 0x6d, 0x51, 0x78, 0x47, 0x0c, 0x77, 0x3a, 0x9f, 0xc8, 0xb4, 0x5d,
+	0xd6, 0x8a, 0xfa, 0xb0, 0x1d, 0x6b, 0x8b, 0xc2, 0x3b, 0x62, 0xb8, 0xd3, 0xf9, 0x54, 0xa6, 0xed,
-	0x75, 0xf4, 0x48, 0x94, 0x3d, 0xdd, 0xa8, 0x77, 0x8a, 0x79, 0x3a, 0x6d, 0x83, 0x12, 0xc9, 0xbc,
+	0xaa, 0xa3, 0x47, 0xa2, 0xec, 0xe9, 0x46, 0xbd, 0x53, 0xcc, 0xd3, 0x69, 0x1b, 0x94, 0x48, 0xe6,
-	0x7d, 0x1b, 0xcc, 0x90, 0x52, 0x2e, 0x73, 0xad, 0xe4, 0x58, 0xd3, 0xa9, 0x0a, 0x81, 0x48, 0x27,
+	0xed, 0xdb, 0x60, 0x86, 0x94, 0x72, 0x99, 0x6b, 0x25, 0xc7, 0x9a, 0x4e, 0x55, 0x08, 0x44, 0x3a,
-	0x7a, 0xd5, 0xf6, 0xf6, 0x81, 0xe6, 0x56, 0x3d, 0x12, 0xfd, 0x63, 0x7b, 0xfb, 0xe0, 0xa3, 0xc0,
+	0xd1, 0xab, 0xb6, 0xb7, 0x0f, 0x34, 0xb7, 0xea, 0x91, 0xe8, 0x1f, 0xdb, 0xdb, 0x07, 0x9f, 0x04,
-	0x1f, 0x51, 0x12, 0x70, 0x99, 0x78, 0x4d, 0x27, 0x2d, 0x12, 0xd7, 0x63, 0xca, 0x12, 0xae, 0x28,
+	0xfe, 0x88, 0x92, 0x80, 0xcb, 0xc4, 0x6b, 0x3a, 0x69, 0x91, 0xb8, 0x1e, 0x53, 0x96, 0x70, 0x45,
-	0x0b, 0x64, 0xd2, 0x35, 0x1d, 0x4b, 0xcb, 0x9e, 0x9f, 0x8d, 0xb0, 0xfd, 0xef, 0x32, 0xac, 0xaa,
+	0x59, 0x20, 0x93, 0xae, 0xe9, 0x58, 0x5a, 0xf6, 0xe2, 0x6c, 0x84, 0xed, 0x7f, 0x96, 0x61, 0x55,
-	0xda, 0x66, 0x9f, 0x76, 0x63, 0x78, 0xdc, 0x01, 0xb3, 0x37, 0x88, 0x44, 0x9b, 0xa0, 0xb1, 0x61,
+	0xd5, 0x36, 0xfb, 0xb4, 0x1b, 0xc3, 0xe3, 0x0e, 0x98, 0xbd, 0x41, 0x24, 0xda, 0x04, 0x8d, 0x0d,
-	0x3a, 0x63, 0x41, 0xb6, 0x27, 0x73, 0x47, 0x21, 0xee, 0x93, 0xd7, 0xda, 0x72, 0xe3, 0x9e, 0xec,
+	0xd3, 0x19, 0x0b, 0xb2, 0x3d, 0x99, 0x3b, 0x0a, 0x71, 0x9f, 0xbc, 0xd1, 0x96, 0x1b, 0xf7, 0x64,
-	0x48, 0x8a, 0xd3, 0x4c, 0x56, 0x9e, 0x60, 0x32, 0xdf, 0xe3, 0x9e, 0xa6, 0x97, 0x8a, 0xa4, 0x17,
+	0x47, 0x52, 0x9c, 0x66, 0xb2, 0xf2, 0x04, 0x93, 0xf9, 0x1e, 0xf7, 0x34, 0xbd, 0x54, 0x24, 0xbd,
-	0x53, 0x48, 0x14, 0xb3, 0x4c, 0x10, 0xc6, 0x42, 0x01, 0x61, 0xa4, 0x18, 0x74, 0x31, 0xcb, 0xa0,
+	0x98, 0x42, 0xa2, 0x98, 0x65, 0x82, 0x30, 0x16, 0x0a, 0x08, 0x23, 0xc5, 0xa0, 0x8b, 0x59, 0x06,
-	0x59, 0xf0, 0x2e, 0xe5, 0x79, 0xf2, 0x63, 0x58, 0x8e, 0x0d, 0xd3, 0x93, 0x18, 0x91, 0xd6, 0x2b,
+	0xcd, 0x82, 0x77, 0x29, 0xcf, 0x93, 0xcf, 0x60, 0x39, 0x36, 0x4c, 0x4f, 0x62, 0x44, 0x5a, 0xaf,
-	0x68, 0x5f, 0x64, 0x22, 0x4b, 0x83, 0xc9, 0xa9, 0xb3, 0x0c, 0xb6, 0xf2, 0x8c, 0x6b, 0x5e, 0x8a,
+	0xa0, 0x7d, 0x91, 0x89, 0x2c, 0x0d, 0x26, 0xa7, 0xce, 0x32, 0xd8, 0xca, 0x33, 0xae, 0x79, 0x29,
-	0x71, 0x73, 0xd5, 0x1e, 0x5c, 0xa6, 0xda, 0x4b, 0xb3, 0xa7, 0x95, 0x65, 0xcf, 0x4f, 0x60, 0xf5,
+	0xc6, 0xcd, 0x55, 0x7b, 0x70, 0x99, 0x6a, 0x2f, 0xcd, 0x9e, 0x56, 0x96, 0x3d, 0x3f, 0x85, 0xd5,
-	0xe7, 0x11, 0x0e, 0xcf, 0xf6, 0x69, 0x97, 0xcd, 0xe7, 0xe3, 0x26, 0x54, 0xb5, 0xa3, 0xe2, 0x4c,
+	0x9f, 0x47, 0x38, 0x3c, 0xdb, 0xa7, 0x5d, 0x36, 0x9f, 0x8f, 0x9b, 0x50, 0xd5, 0x8e, 0x8a, 0x33,
-	0x9b, 0x8c, 0xed, 0x7f, 0x1a, 0x50, 0x97, 0x61, 0xff, 0xdc, 0x63, 0xa7, 0xf1, 0xcb, 0x49, 0xec,
+	0x6d, 0x32, 0xb6, 0xff, 0x6e, 0x40, 0x5d, 0x86, 0xfd, 0x0b, 0x8f, 0x9d, 0xc6, 0x2f, 0x27, 0xb1,
-	0x65, 0x23, 0xeb, 0xe5, 0xcb, 0xf7, 0x09, 0xa9, 0xb6, 0x5f, 0xf6, 0x2c, 0xa6, 0x4e, 0x70, 0xb2,
+	0x97, 0x8d, 0xac, 0x97, 0x2f, 0xdf, 0x27, 0xa4, 0xda, 0x7e, 0xd9, 0xb3, 0x98, 0x3a, 0xc1, 0xc9,
-	0xe1, 0x2f, 0x2a, 0x3c, 0x2a, 0x85, 0x85, 0x47, 0xae, 0xe3, 0x58, 0x98, 0xe8, 0x38, 0xbe, 0x36,
+	0x86, 0xbf, 0xa8, 0xf0, 0xa8, 0x14, 0x16, 0x1e, 0xb9, 0x8e, 0x63, 0x61, 0xa2, 0xe3, 0xf8, 0xd6,
-	0xe0, 0x66, 0xca, 0x38, 0x57, 0xc9, 0x5d, 0x19, 0x93, 0x96, 0xf2, 0x26, 0xdd, 0xc9, 0xe6, 0xf4,
+	0x80, 0x9b, 0x29, 0xe3, 0x5c, 0x25, 0x77, 0x65, 0x4c, 0x5a, 0xca, 0x9b, 0x74, 0x27, 0x9b, 0xd3,
-	0x72, 0x91, 0x8f, 0x53, 0x39, 0x3d, 0x36, 0x6e, 0x26, 0xaf, 0x3f, 0x83, 0x15, 0x41, 0x9e, 0xd7,
+	0xcb, 0x45, 0x3e, 0x4e, 0xe5, 0xf4, 0xd8, 0xb8, 0x99, 0xbc, 0xfe, 0x1c, 0x56, 0x04, 0x79, 0x5e,
-	0xe3, 0xc7, 0x7f, 0x19, 0xb0, 0xb4, 0x4f, 0xbb, 0xd2, 0x83, 0x69, 0xf0, 0x18, 0xd9, 0xb7, 0xa4,
+	0x8f, 0x1f, 0xff, 0x61, 0xc0, 0xd2, 0x3e, 0xed, 0x4a, 0x0f, 0xa6, 0xc1, 0x63, 0x64, 0xdf, 0x92,
-	0x55, 0x28, 0xfb, 0x64, 0xa8, 0x13, 0xb1, 0xf8, 0x29, 0x82, 0x8b, 0x71, 0x2f, 0xe4, 0xe3, 0xd7,
+	0x56, 0xa1, 0xec, 0x93, 0xa1, 0x4e, 0xc4, 0xe2, 0xa7, 0x08, 0x2e, 0xc6, 0xbd, 0x90, 0x8f, 0x5f,
-	0x30, 0x51, 0x59, 0x09, 0x89, 0x7c, 0x4c, 0x79, 0x1b, 0xaa, 0x38, 0xf0, 0xd5, 0x47, 0x5d, 0xbe,
+	0xc3, 0x44, 0x65, 0x25, 0x24, 0xf2, 0x31, 0xe5, 0x5d, 0xa8, 0xe2, 0xc0, 0x57, 0x1f, 0x75, 0xf9,
-	0xe2, 0xc0, 0x97, 0x9f, 0xae, 0xa7, 0x23, 0x59, 0x83, 0x85, 0x11, 0x1d, 0xbf, 0x60, 0xa9, 0x81,
+	0x8a, 0x03, 0x5f, 0x7e, 0xba, 0x9e, 0x8e, 0x64, 0x0d, 0x16, 0x46, 0x74, 0xfc, 0x82, 0xa5, 0x06,
-	0xbd, 0x06, 0xe8, 0x29, 0xe6, 0xfb, 0xb4, 0x2b, 0xbc, 0x12, 0x9b, 0xc7, 0xfe, 0x47, 0x49, 0x76,
+	0xf6, 0x1a, 0xa0, 0xa7, 0x98, 0xef, 0xd3, 0xae, 0xf0, 0x4a, 0x6c, 0x1e, 0xfb, 0x6f, 0x25, 0xd9,
-	0x0b, 0x63, 0xf1, 0x55, 0x1c, 0x6c, 0x43, 0x5d, 0x31, 0xcf, 0x17, 0xb4, 0xeb, 0x06, 0x51, 0x6c,
+	0x2d, 0x8c, 0xc5, 0x57, 0x71, 0xb0, 0x0d, 0x75, 0xc5, 0x3c, 0x5f, 0xd2, 0xae, 0x1b, 0x44, 0xb1,
-	0x14, 0x4b, 0x0a, 0xf7, 0x69, 0xf7, 0x30, 0x1a, 0xa2, 0xf7, 0xe0, 0x16, 0x09, 0xdc, 0x91, 0x26,
+	0x51, 0x2c, 0x29, 0xdc, 0xa7, 0xdd, 0xc3, 0x68, 0x88, 0x3e, 0x80, 0x5b, 0x24, 0x70, 0x47, 0x9a,
-	0xc3, 0x44, 0x53, 0x59, 0x69, 0x95, 0x04, 0x31, 0x4d, 0x6a, 0xf5, 0x77, 0x61, 0x05, 0x07, 0x2f,
+	0x0c, 0x13, 0x4d, 0x65, 0xa5, 0x55, 0x12, 0xc4, 0x34, 0xa9, 0xd5, 0xdf, 0x87, 0x15, 0x1c, 0xbc,
-	0x22, 0x1c, 0xe1, 0x44, 0x55, 0xd9, 0xac, 0xae, 0xc5, 0x5a, 0x4f, 0x90, 0x9e, 0xc7, 0x4e, 0x5d,
+	0x8c, 0x70, 0x84, 0x13, 0x55, 0x65, 0xb3, 0xba, 0x16, 0x6b, 0x3d, 0x41, 0x7a, 0x1e, 0x3b, 0x75,
-	0x36, 0xa0, 0x9c, 0xe9, 0x64, 0x68, 0x0a, 0x49, 0x47, 0x08, 0xd0, 0x87, 0x60, 0x8a, 0xe9, 0x0a,
+	0xd9, 0x80, 0x72, 0xa6, 0x93, 0xa1, 0x29, 0x24, 0x1d, 0x21, 0x40, 0x1f, 0x83, 0x29, 0xa6, 0x2b,
-	0x5a, 0xaa, 0xea, 0xbf, 0x5d, 0x04, 0x2d, 0xed, 0x6f, 0xa7, 0xfa, 0x85, 0xfa, 0xc1, 0x44, 0x80,
+	0x68, 0xa9, 0xaa, 0xff, 0x76, 0x11, 0xb4, 0xb4, 0xbf, 0x9d, 0xea, 0x97, 0xea, 0x07, 0x13, 0x01,
-	0xe8, 0x3a, 0xd8, 0x27, 0xec, 0x54, 0x53, 0x0c, 0x28, 0xd1, 0x1e, 0x61, 0xa7, 0x5b, 0x7f, 0x31,
+	0xa2, 0xeb, 0x60, 0x9f, 0xb0, 0x53, 0x4d, 0x31, 0xa0, 0x44, 0x7b, 0x84, 0x9d, 0x6e, 0x7d, 0x0d,
-	0x01, 0x24, 0x22, 0x77, 0x29, 0x0d, 0x7d, 0x34, 0x90, 0x66, 0xde, 0xa5, 0xc3, 0x11, 0x0d, 0x70,
+	0x00, 0x12, 0x91, 0xbb, 0x94, 0x86, 0x3e, 0x1a, 0x48, 0x33, 0xef, 0xd2, 0xe1, 0x88, 0x06, 0x38,
-	0xc0, 0x65, 0xd8, 0x32, 0xb4, 0x91, 0xdd, 0x4c, 0x0f, 0x26, 0x15, 0xb5, 0x5b, 0x9a, 0xef, 0x14,
+	0xe0, 0x32, 0x6c, 0x19, 0xda, 0xc8, 0x6e, 0xa6, 0x07, 0x93, 0x8a, 0xda, 0x2d, 0xcd, 0xf7, 0x0a,
-	0xea, 0xe7, 0x94, 0xed, 0x1b, 0xe8, 0x85, 0xac, 0x9c, 0xc5, 0x90, 0x30, 0x4e, 0x7a, 0x6c, 0xf7,
+	0xf5, 0x73, 0xca, 0xf6, 0x0d, 0xf4, 0x52, 0x56, 0xce, 0x62, 0x48, 0x18, 0x27, 0x3d, 0xb6, 0x7b,
-	0xc4, 0x0b, 0x02, 0x3c, 0x40, 0x5b, 0x53, 0xde, 0x99, 0x8a, 0x94, 0xe3, 0x3d, 0x1f, 0x14, 0xee,
+	0xe2, 0x05, 0x01, 0x1e, 0xa0, 0xad, 0x29, 0xef, 0x4c, 0x45, 0xca, 0xf1, 0x9e, 0x0f, 0x0a, 0xf7,
-	0xd9, 0xe1, 0x21, 0x09, 0x8e, 0x63, 0x5c, 0xd8, 0x37, 0xd0, 0x73, 0xb0, 0x52, 0xcd, 0x3e, 0x7a,
+	0xec, 0xf0, 0x90, 0x04, 0xc7, 0x31, 0x2e, 0xec, 0x1b, 0xe8, 0x05, 0x58, 0xa9, 0x66, 0x1f, 0xbd,
-	0xb7, 0xc8, 0x8c, 0x93, 0xaf, 0x01, 0xcd, 0xf3, 0x00, 0x64, 0xdf, 0x40, 0x7d, 0xa8, 0x67, 0x5e,
+	0x5f, 0x64, 0xc6, 0xc9, 0xd7, 0x80, 0xe6, 0x79, 0x00, 0xb2, 0x6f, 0xa0, 0x3e, 0xd4, 0x33, 0xaf,
-	0xa3, 0x50, 0xeb, 0xbc, 0x82, 0x3d, 0xfd, 0x04, 0xd4, 0xfc, 0xee, 0x1c, 0x9a, 0xc9, 0xe9, 0x7f,
+	0x51, 0xa8, 0x75, 0x5e, 0xc1, 0x9e, 0x7e, 0x02, 0x6a, 0x7e, 0x77, 0x0e, 0xcd, 0xe4, 0xf4, 0xbf,
-	0xa5, 0x0c, 0x36, 0xf1, 0x9c, 0xb3, 0x39, 0x65, 0x91, 0x69, 0x0f, 0x4f, 0xcd, 0xc7, 0xf3, 0x4f,
+	0x52, 0x06, 0x9b, 0x78, 0xce, 0xd9, 0x9c, 0xb2, 0xc8, 0xb4, 0x87, 0xa7, 0xe6, 0xe3, 0xf9, 0x27,
-	0x48, 0x36, 0xf7, 0xc7, 0x97, 0x54, 0xe0, 0x7a, 0x34, 0xbb, 0x2b, 0x51, 0xbb, 0xb5, 0xe6, 0x6d,
+	0x24, 0x9b, 0xfb, 0xe3, 0x4b, 0x2a, 0x70, 0x3d, 0x9a, 0xdd, 0x95, 0xa8, 0xdd, 0x5a, 0xf3, 0xb6,
-	0x5f, 0xec, 0x1b, 0xe8, 0x08, 0xcc, 0xa4, 0x83, 0x40, 0xef, 0x14, 0x4d, 0xcc, 0x37, 0x18, 0x73,
+	0x2f, 0xf6, 0x0d, 0x74, 0x04, 0x66, 0xd2, 0x41, 0xa0, 0xf7, 0x8a, 0x26, 0xe6, 0x1b, 0x8c, 0x39,
-	0x38, 0x27, 0x53, 0xbc, 0x17, 0x3b, 0xa7, 0xa8, 0x77, 0x28, 0x76, 0x4e, 0x61, 0x27, 0x60, 0xdf,
+	0x9c, 0x93, 0x29, 0xde, 0x8b, 0x9d, 0x53, 0xd4, 0x3b, 0x14, 0x3b, 0xa7, 0xb0, 0x13, 0xb0, 0x6f,
-	0x40, 0xbf, 0x1e, 0x3f, 0x49, 0x66, 0x4a, 0x66, 0xf4, 0xf8, 0xbc, 0xeb, 0x17, 0x55, 0xf0, 0xcd,
+	0xa0, 0x5f, 0x8f, 0x9f, 0x24, 0x33, 0x25, 0x33, 0x7a, 0x7c, 0xde, 0xf5, 0x8b, 0x2a, 0xf8, 0xe6,
-	0xef, 0x5f, 0x60, 0x46, 0x0a, 0x1c, 0xa8, 0x73, 0x42, 0x5f, 0xa9, 0xd2, 0x25, 0x0a, 0x3d, 0x51,
+	0xf7, 0x2f, 0x30, 0x23, 0x05, 0x0e, 0xd4, 0x39, 0xa1, 0xaf, 0x55, 0xe9, 0x12, 0x85, 0x9e, 0xa8,
-	0xe9, 0x17, 0x6c, 0xae, 0x63, 0x69, 0x52, 0x75, 0xea, 0xe6, 0xe7, 0xcc, 0x48, 0x36, 0x77, 0x01,
+	0xf4, 0x0b, 0x36, 0xd7, 0xb1, 0x34, 0xa9, 0x3a, 0x75, 0xf3, 0x73, 0x66, 0x24, 0x9b, 0xbb, 0x00,
-	0x9e, 0x62, 0x7e, 0x80, 0x79, 0x48, 0x7a, 0x2c, 0x1f, 0x56, 0xe3, 0x84, 0xa1, 0x15, 0xe2, 0xad,
+	0x4f, 0x31, 0x3f, 0xc0, 0x3c, 0x24, 0x3d, 0x96, 0x0f, 0xab, 0x71, 0xc2, 0xd0, 0x0a, 0xf1, 0x56,
-	0x1e, 0xcd, 0xd4, 0x8b, 0x37, 0xd8, 0xfa, 0x7a, 0x51, 0xff, 0x7d, 0x78, 0x48, 0x7d, 0xfc, 0xff,
+	0x8f, 0x66, 0xea, 0x25, 0x1b, 0x74, 0xc1, 0xda, 0x3d, 0xc1, 0xbd, 0xd3, 0x67, 0xd8, 0x1b, 0xf0,
-	0x9f, 0xa7, 0x8e, 0xc0, 0x4c, 0x0a, 0xf7, 0xe2, 0x30, 0xc8, 0xd7, 0xf5, 0xb3, 0xc2, 0xe0, 0x73,
+	0x13, 0x54, 0x3c, 0x33, 0xa5, 0x31, 0x05, 0x7b, 0x45, 0x8a, 0xf1, 0x1e, 0x5b, 0xdf, 0x2e, 0xea,
-	0x30, 0x93, 0x4a, 0xa8, 0x78, 0xc5, 0x7c, 0x15, 0xd9, 0x7c, 0x38, 0x43, 0x2b, 0x39, 0xed, 0x21,
+	0xbf, 0x28, 0x0f, 0xa9, 0x8f, 0xff, 0xfb, 0x73, 0xe1, 0x11, 0x98, 0x49, 0x73, 0x50, 0x1c, 0x6a,
-	0x54, 0xe3, 0xca, 0x05, 0x3d, 0x98, 0x16, 0xb3, 0xe9, 0x95, 0x67, 0x9c, 0xf5, 0x97, 0x60, 0xa5,
+	0xf9, 0xde, 0x61, 0x56, 0xa8, 0x7d, 0x01, 0x66, 0x52, 0x6d, 0x15, 0xaf, 0x98, 0xaf, 0x54, 0x9b,
-	0x68, 0xbd, 0x38, 0x4b, 0x4f, 0x96, 0x03, 0xcd, 0x47, 0x33, 0xf5, 0xbe, 0x19, 0xc1, 0xb2, 0xf3,
+	0x0f, 0x67, 0x68, 0x25, 0xa7, 0x3d, 0x84, 0x6a, 0x5c, 0x1d, 0xa1, 0x07, 0xd3, 0xf2, 0x42, 0x7a,
-	0x83, 0xcf, 0xb7, 0x8e, 0x09, 0x3f, 0x89, 0xba, 0xc2, 0xb2, 0x9b, 0x4a, 0xf3, 0x3d, 0x42, 0xf5,
+	0xe5, 0x19, 0x67, 0xfd, 0x25, 0x58, 0xa9, 0xd2, 0xa1, 0x98, 0x09, 0x26, 0x4b, 0x8e, 0xe6, 0xa3,
-	0xaf, 0xcd, 0xf8, 0x94, 0x9b, 0x72, 0xa5, 0x4d, 0x69, 0xa7, 0x51, 0xb7, 0xbb, 0x28, 0x87, 0xef,
+	0x99, 0x7a, 0xff, 0x1b, 0x01, 0xb9, 0xf3, 0x83, 0x2f, 0xb6, 0x8e, 0x09, 0x3f, 0x89, 0xba, 0xc2,
-	0xff, 0x37, 0x00, 0x00, 0xff, 0xff, 0x80, 0x81, 0x8c, 0x4f, 0xfd, 0x1f, 0x00, 0x00,
+	0xb2, 0x9b, 0x4a, 0xf3, 0x03, 0x42, 0xf5, 0xaf, 0xcd, 0xf8, 0x94, 0x9b, 0x72, 0xa5, 0x4d, 0x69,
+	0xa7, 0x51, 0xb7, 0xbb, 0x28, 0x87, 0x1f, 0xfe, 0x3b, 0x00, 0x00, 0xff, 0xff, 0x56, 0x61, 0x38,
+	0x0e, 0x61, 0x20, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -2183,6 +2185,7 @@ type IndexCoordClient interface {
 	ShowConfigurations(ctx context.Context, in *internalpb.ShowConfigurationsRequest, opts ...grpc.CallOption) (*internalpb.ShowConfigurationsResponse, error)
 	// https://wiki.lfaidata.foundation/display/MIL/MEP+8+--+Add+metrics+for+proxy
 	GetMetrics(ctx context.Context, in *milvuspb.GetMetricsRequest, opts ...grpc.CallOption) (*milvuspb.GetMetricsResponse, error)
+	CheckHealth(ctx context.Context, in *milvuspb.CheckHealthRequest, opts ...grpc.CallOption) (*milvuspb.CheckHealthResponse, error)
 }
 
 type indexCoordClient struct {
@@ -2292,6 +2295,15 @@ func (c *indexCoordClient) GetMetrics(ctx context.Context, in *milvuspb.GetMetri
 	return out, nil
 }
 
+func (c *indexCoordClient) CheckHealth(ctx context.Context, in *milvuspb.CheckHealthRequest, opts ...grpc.CallOption) (*milvuspb.CheckHealthResponse, error) {
+	out := new(milvuspb.CheckHealthResponse)
+	err := c.cc.Invoke(ctx, "/milvus.proto.index.IndexCoord/CheckHealth", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 // IndexCoordServer is the server API for IndexCoord service.
 type IndexCoordServer interface {
 	GetComponentStates(context.Context, *milvuspb.GetComponentStatesRequest) (*milvuspb.ComponentStates, error)
@@ -2308,6 +2320,7 @@ type IndexCoordServer interface {
 	ShowConfigurations(context.Context, *internalpb.ShowConfigurationsRequest) (*internalpb.ShowConfigurationsResponse, error)
 	// https://wiki.lfaidata.foundation/display/MIL/MEP+8+--+Add+metrics+for+proxy
 	GetMetrics(context.Context, *milvuspb.GetMetricsRequest) (*milvuspb.GetMetricsResponse, error)
+	CheckHealth(context.Context, *milvuspb.CheckHealthRequest) (*milvuspb.CheckHealthResponse, error)
 }
 
 // UnimplementedIndexCoordServer can be embedded to have forward compatible implementations.
@@ -2347,6 +2360,9 @@ func (*UnimplementedIndexCoordServer) ShowConfigurations(ctx context.Context, re
 func (*UnimplementedIndexCoordServer) GetMetrics(ctx context.Context, req *milvuspb.GetMetricsRequest) (*milvuspb.GetMetricsResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method GetMetrics not implemented")
 }
+func (*UnimplementedIndexCoordServer) CheckHealth(ctx context.Context, req *milvuspb.CheckHealthRequest) (*milvuspb.CheckHealthResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method CheckHealth not implemented")
+}
 
 func RegisterIndexCoordServer(s *grpc.Server, srv IndexCoordServer) {
 	s.RegisterService(&_IndexCoord_serviceDesc, srv)
@@ -2550,6 +2566,24 @@ func _IndexCoord_GetMetrics_Handler(srv interface{}, ctx context.Context, dec fu
 	return interceptor(ctx, in, info, handler)
 }
 
+func _IndexCoord_CheckHealth_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(milvuspb.CheckHealthRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(IndexCoordServer).CheckHealth(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/milvus.proto.index.IndexCoord/CheckHealth",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(IndexCoordServer).CheckHealth(ctx, req.(*milvuspb.CheckHealthRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 var _IndexCoord_serviceDesc = grpc.ServiceDesc{
 	ServiceName: "milvus.proto.index.IndexCoord",
 	HandlerType: (*IndexCoordServer)(nil),
@@ -2598,6 +2632,10 @@ var _IndexCoord_serviceDesc = grpc.ServiceDesc{
 			MethodName: "GetMetrics",
 			Handler:    _IndexCoord_GetMetrics_Handler,
 		},
+		{
+			MethodName: "CheckHealth",
+			Handler:    _IndexCoord_CheckHealth_Handler,
+		},
 	},
 	Streams:  []grpc.StreamDesc{},
 	Metadata: "index_coord.proto",

internal/proto/query_coord.proto

@@ -34,6 +34,8 @@ service QueryCoord {
   // https://wiki.lfaidata.foundation/display/MIL/MEP+23+--+Multiple+memory+replication+design
   rpc GetReplicas(milvus.GetReplicasRequest) returns (milvus.GetReplicasResponse) {}
   rpc GetShardLeaders(GetShardLeadersRequest) returns (GetShardLeadersResponse) {}
+
+  rpc CheckHealth(milvus.CheckHealthRequest) returns (milvus.CheckHealthResponse) {}
 }
 
 service QueryNode {

internal/proto/querypb/query_coord.pb.go

@@ -3682,233 +3682,234 @@ func init() {
 func init() { proto.RegisterFile("query_coord.proto", fileDescriptor_aab7cc9a69ed26e8) }
 
 var fileDescriptor_aab7cc9a69ed26e8 = []byte{
-	// 3606 bytes of a gzipped FileDescriptorProto
+	// 3627 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x3b, 0x49, 0x6f, 0x1c, 0x57,
 	0x7a, 0xac, 0x5e, 0xc8, 0xee, 0xaf, 0x17, 0x16, 0x1f, 0x25, 0xaa, 0xdd, 0xd6, 0x42, 0x97, 0x16,
-	0x33, 0x94, 0x4d, 0xca, 0x94, 0x6d, 0xc8, 0xb1, 0x0d, 0x47, 0x22, 0x2d, 0x9a, 0x91, 0x44, 0x33,
+	0x33, 0x94, 0x4d, 0xca, 0x94, 0x6d, 0xc8, 0xb1, 0x0d, 0x47, 0x22, 0x2d, 0x8a, 0x91, 0x44, 0x33,
 	0xd5, 0x92, 0x12, 0x08, 0x46, 0xda, 0xd5, 0x5d, 0x8f, 0xcd, 0x82, 0xaa, 0xab, 0x5a, 0x55, 0xd5,
-	0x94, 0xe8, 0x5c, 0x73, 0x89, 0x91, 0x04, 0x48, 0x0e, 0x01, 0x02, 0x04, 0x39, 0x25, 0x40, 0x12,
+	0x94, 0xe8, 0x5c, 0x73, 0x89, 0x91, 0x04, 0x48, 0x0e, 0x39, 0x05, 0x39, 0x25, 0x40, 0x12, 0xd8,
-	0xd8, 0x41, 0x0e, 0x09, 0x90, 0x43, 0x10, 0x0c, 0x30, 0x87, 0x99, 0xd3, 0x60, 0x7e, 0xc0, 0x00,
+	0x41, 0x0e, 0x09, 0x90, 0x43, 0x10, 0x04, 0xc8, 0x21, 0x39, 0x05, 0xf3, 0x03, 0x06, 0x98, 0x1f,
-	0xf3, 0x03, 0x66, 0x80, 0x39, 0xcd, 0x61, 0x6e, 0x83, 0xb7, 0xd5, 0xfa, 0x8a, 0x6c, 0x91, 0x92,
+	0x30, 0x03, 0xcc, 0x69, 0x0e, 0x73, 0x18, 0x60, 0xf0, 0xb6, 0x5a, 0x5f, 0x91, 0x2d, 0x52, 0xf2,
-	0x97, 0xc1, 0xdc, 0xba, 0xbe, 0xb7, 0x7c, 0xdf, 0xfb, 0xf6, 0xef, 0x7b, 0xaf, 0x61, 0xee, 0xc9,
+	0x32, 0x98, 0x5b, 0xd7, 0xf7, 0x96, 0xef, 0x7b, 0xdf, 0xfe, 0x7d, 0xef, 0x35, 0xcc, 0x3d, 0x1d,
-	0x18, 0x7b, 0x07, 0xdd, 0xbe, 0xeb, 0x7a, 0xe6, 0xca, 0xc8, 0x73, 0x03, 0x17, 0xa1, 0xa1, 0x65,
+	0x63, 0xef, 0xa0, 0xdb, 0x77, 0x5d, 0xcf, 0x5c, 0x19, 0x79, 0x6e, 0xe0, 0x22, 0x34, 0xb4, 0xec,
-	0xef, 0x8f, 0x7d, 0xf6, 0xb5, 0x42, 0xc7, 0xdb, 0xf5, 0xbe, 0x3b, 0x1c, 0xba, 0x0e, 0x83, 0xb5,
+	0xfd, 0xb1, 0xcf, 0xbe, 0x56, 0xe8, 0x78, 0xbb, 0xde, 0x77, 0x87, 0x43, 0xd7, 0x61, 0xb0, 0x76,
-	0xeb, 0xf1, 0x19, 0xed, 0xa6, 0xe5, 0x04, 0xd8, 0x73, 0x0c, 0x5b, 0x8c, 0xfa, 0xfd, 0x3d, 0x3c,
+	0x3d, 0x3e, 0xa3, 0xdd, 0xb4, 0x9c, 0x00, 0x7b, 0x8e, 0x61, 0x8b, 0x51, 0xbf, 0xbf, 0x87, 0x87,
-	0x34, 0xf8, 0x97, 0x6a, 0x1a, 0x81, 0x11, 0xdf, 0x5f, 0xfb, 0x4b, 0x05, 0x16, 0x3a, 0x7b, 0xee,
+	0x06, 0xff, 0x52, 0x4d, 0x23, 0x30, 0xe2, 0xfb, 0x6b, 0x7f, 0xaa, 0xc0, 0x42, 0x67, 0xcf, 0x7d,
-	0xd3, 0x75, 0xd7, 0xb6, 0x71, 0x3f, 0xb0, 0x5c, 0xc7, 0xd7, 0xf1, 0x93, 0x31, 0xf6, 0x03, 0x74,
+	0xb6, 0xee, 0xda, 0x36, 0xee, 0x07, 0x96, 0xeb, 0xf8, 0x3a, 0x7e, 0x3a, 0xc6, 0x7e, 0x80, 0xae,
-	0x0d, 0x4a, 0x3d, 0xc3, 0xc7, 0x2d, 0x65, 0x51, 0x59, 0xaa, 0xad, 0x9d, 0x5d, 0x49, 0x50, 0xc2,
+	0x41, 0xa9, 0x67, 0xf8, 0xb8, 0xa5, 0x2c, 0x2a, 0x4b, 0xb5, 0xb5, 0xb3, 0x2b, 0x09, 0x4a, 0x38,
-	0x49, 0xb8, 0xe7, 0x0f, 0x6e, 0x19, 0x3e, 0xd6, 0xe9, 0x4c, 0x84, 0xa0, 0x64, 0xf6, 0xb6, 0x36,
+	0x09, 0xf7, 0xfd, 0xc1, 0x2d, 0xc3, 0xc7, 0x3a, 0x9d, 0x89, 0x10, 0x94, 0xcc, 0xde, 0xd6, 0x46,
-	0x5a, 0x85, 0x45, 0x65, 0xa9, 0xa8, 0xd3, 0xdf, 0xe8, 0x12, 0x34, 0xfa, 0xe1, 0xde, 0x5b, 0x1b,
+	0xab, 0xb0, 0xa8, 0x2c, 0x15, 0x75, 0xfa, 0x1b, 0x5d, 0x82, 0x46, 0x3f, 0xdc, 0x7b, 0x6b, 0xc3,
-	0x7e, 0xab, 0xb8, 0x58, 0x5c, 0x2a, 0xea, 0x49, 0xa0, 0xf6, 0x73, 0x05, 0xce, 0x64, 0xc8, 0xf0,
+	0x6f, 0x15, 0x17, 0x8b, 0x4b, 0x45, 0x3d, 0x09, 0xd4, 0x7e, 0xa2, 0xc0, 0x99, 0x0c, 0x19, 0xfe,
-	0x47, 0xae, 0xe3, 0x63, 0x74, 0x1d, 0xa6, 0xfd, 0xc0, 0x08, 0xc6, 0x3e, 0xa7, 0xe4, 0x55, 0x29,
+	0xc8, 0x75, 0x7c, 0x8c, 0xae, 0xc3, 0xb4, 0x1f, 0x18, 0xc1, 0xd8, 0xe7, 0x94, 0xbc, 0x2e, 0xa5,
-	0x25, 0x1d, 0x3a, 0x45, 0xe7, 0x53, 0xb3, 0x68, 0x0b, 0x12, 0xb4, 0xe8, 0x2d, 0x38, 0x65, 0x39,
+	0xa4, 0x43, 0xa7, 0xe8, 0x7c, 0x6a, 0x16, 0x6d, 0x41, 0x82, 0x16, 0xbd, 0x03, 0xa7, 0x2c, 0xe7,
-	0xf7, 0xf0, 0xd0, 0xf5, 0x0e, 0xba, 0x23, 0xec, 0xf5, 0xb1, 0x13, 0x18, 0x03, 0x2c, 0x68, 0x9c,
+	0x3e, 0x1e, 0xba, 0xde, 0x41, 0x77, 0x84, 0xbd, 0x3e, 0x76, 0x02, 0x63, 0x80, 0x05, 0x8d, 0xf3,
-	0x17, 0x63, 0x3b, 0xd1, 0x10, 0x7a, 0x17, 0xce, 0x30, 0x29, 0xf9, 0xd8, 0xdb, 0xb7, 0xfa, 0xb8,
+	0x62, 0x6c, 0x27, 0x1a, 0x42, 0xef, 0xc3, 0x19, 0x26, 0x25, 0x1f, 0x7b, 0xfb, 0x56, 0x1f, 0x77,
-	0x6b, 0xec, 0x1b, 0x96, 0x6d, 0xf4, 0x6c, 0xdc, 0x2a, 0x2d, 0x16, 0x97, 0x2a, 0xfa, 0x69, 0x3a,
+	0x8d, 0x7d, 0xc3, 0xb2, 0x8d, 0x9e, 0x8d, 0x5b, 0xa5, 0xc5, 0xe2, 0x52, 0x45, 0x3f, 0x4d, 0x87,
-	0xdc, 0x61, 0xa3, 0x37, 0xc5, 0xa0, 0xf6, 0xaf, 0x0a, 0x9c, 0x26, 0x27, 0xdc, 0x31, 0xbc, 0xc0,
+	0x3b, 0x6c, 0xf4, 0xa6, 0x18, 0xd4, 0xfe, 0x41, 0x81, 0xd3, 0xe4, 0x84, 0x3b, 0x86, 0x17, 0x58,
-	0x7a, 0x09, 0x7c, 0xd6, 0xa0, 0x1e, 0x3f, 0x5b, 0xab, 0x48, 0xc7, 0x12, 0x30, 0x32, 0x67, 0x24,
+	0xaf, 0x80, 0xcf, 0x1a, 0xd4, 0xe3, 0x67, 0x6b, 0x15, 0xe9, 0x58, 0x02, 0x46, 0xe6, 0x8c, 0x04,
-	0xd0, 0x13, 0x9e, 0x94, 0xe8, 0x31, 0x13, 0x30, 0xed, 0x5f, 0xb8, 0x42, 0xc4, 0xe9, 0x3c, 0x89,
+	0x7a, 0xc2, 0x93, 0x12, 0x3d, 0x66, 0x02, 0xa6, 0xfd, 0x3d, 0x57, 0x88, 0x38, 0x9d, 0x27, 0x11,
-	0x20, 0xd2, 0x38, 0x0b, 0x59, 0x9c, 0xc7, 0x10, 0x83, 0xf6, 0x65, 0x11, 0x4e, 0xdf, 0x75, 0x0d,
+	0x44, 0x1a, 0x67, 0x21, 0x8b, 0xf3, 0x18, 0x62, 0xd0, 0xbe, 0x2a, 0xc2, 0xe9, 0x7b, 0xae, 0x61,
-	0x33, 0x52, 0x98, 0x6f, 0x9e, 0x9d, 0x1f, 0xc2, 0x34, 0xb3, 0xae, 0x56, 0x89, 0xe2, 0xba, 0x9c,
+	0x46, 0x0a, 0xf3, 0xed, 0xb3, 0xf3, 0x63, 0x98, 0x66, 0xd6, 0xd5, 0x2a, 0x51, 0x5c, 0x97, 0x93,
-	0xc4, 0xc5, 0x2d, 0x2f, 0xa2, 0xb0, 0x43, 0x01, 0x3a, 0x5f, 0x84, 0x2e, 0x43, 0xd3, 0xc3, 0x23,
+	0xb8, 0xb8, 0xe5, 0x45, 0x14, 0x76, 0x28, 0x40, 0xe7, 0x8b, 0xd0, 0x65, 0x68, 0x7a, 0x78, 0x64,
-	0xdb, 0xea, 0x1b, 0x5d, 0x67, 0x3c, 0xec, 0x61, 0xaf, 0x55, 0x5e, 0x54, 0x96, 0xca, 0x7a, 0x83,
+	0x5b, 0x7d, 0xa3, 0xeb, 0x8c, 0x87, 0x3d, 0xec, 0xb5, 0xca, 0x8b, 0xca, 0x52, 0x59, 0x6f, 0x70,
-	0x43, 0xb7, 0x29, 0x10, 0x7d, 0x0e, 0x8d, 0x5d, 0x0b, 0xdb, 0x66, 0xd7, 0x72, 0x4c, 0xfc, 0x6c,
+	0xe8, 0x36, 0x05, 0xa2, 0x2f, 0xa0, 0xb1, 0x6b, 0x61, 0xdb, 0xec, 0x5a, 0x8e, 0x89, 0x9f, 0x6f,
-	0x6b, 0xa3, 0x35, 0xbd, 0x58, 0x5c, 0xaa, 0xad, 0xbd, 0xbf, 0x92, 0xf5, 0x0c, 0x2b, 0x52, 0x8e,
+	0x6d, 0xb4, 0xa6, 0x17, 0x8b, 0x4b, 0xb5, 0xb5, 0x0f, 0x57, 0xb2, 0x9e, 0x61, 0x45, 0xca, 0x91,
-	0xac, 0xdc, 0x26, 0xcb, 0xb7, 0xd8, 0xea, 0x8f, 0x9d, 0xc0, 0x3b, 0xd0, 0xeb, 0xbb, 0x31, 0x50,
+	0x95, 0xdb, 0x64, 0xf9, 0x16, 0x5b, 0xfd, 0xa9, 0x13, 0x78, 0x07, 0x7a, 0x7d, 0x37, 0x06, 0x6a,
-	0xfb, 0x23, 0x98, 0xcb, 0x4c, 0x41, 0x2a, 0x14, 0x1f, 0xe3, 0x03, 0xca, 0xc5, 0xa2, 0x4e, 0x7e,
+	0x7f, 0x02, 0x73, 0x99, 0x29, 0x48, 0x85, 0xe2, 0x13, 0x7c, 0x40, 0xb9, 0x58, 0xd4, 0xc9, 0x4f,
-	0xa2, 0x53, 0x50, 0xde, 0x37, 0xec, 0x31, 0xe6, 0x7c, 0x62, 0x1f, 0x7f, 0x58, 0xb8, 0xa1, 0x68,
+	0x74, 0x0a, 0xca, 0xfb, 0x86, 0x3d, 0xc6, 0x9c, 0x4f, 0xec, 0xe3, 0x77, 0x0b, 0x37, 0x14, 0xed,
-	0xff, 0xa4, 0x40, 0x4b, 0xc7, 0x36, 0x36, 0x7c, 0xfc, 0x6d, 0xca, 0x63, 0x01, 0xa6, 0x1d, 0xd7,
+	0x6f, 0x15, 0x68, 0xe9, 0xd8, 0xc6, 0x86, 0x8f, 0xbf, 0x4b, 0x79, 0x2c, 0xc0, 0xb4, 0xe3, 0x9a,
-	0xc4, 0x5b, 0x1b, 0x54, 0x1e, 0x45, 0x9d, 0x7f, 0x69, 0xbf, 0x51, 0xe0, 0xd4, 0x26, 0x0e, 0x88,
+	0x78, 0x6b, 0x83, 0xca, 0xa3, 0xa8, 0xf3, 0x2f, 0xed, 0x97, 0x0a, 0x9c, 0xda, 0xc4, 0x01, 0x51,
-	0x62, 0x5a, 0x7e, 0x60, 0xf5, 0x43, 0xcb, 0xfb, 0x10, 0x8a, 0x1e, 0x7e, 0xc2, 0x29, 0xbb, 0x9a,
+	0x4c, 0xcb, 0x0f, 0xac, 0x7e, 0x68, 0x79, 0x1f, 0x43, 0xd1, 0xc3, 0x4f, 0x39, 0x65, 0x57, 0x93,
-	0xa4, 0x2c, 0xf4, 0xa3, 0xb2, 0x95, 0x3a, 0x59, 0x87, 0x5e, 0x83, 0xba, 0x39, 0xb4, 0xbb, 0xfd,
+	0x94, 0x85, 0x7e, 0x54, 0xb6, 0x52, 0x27, 0xeb, 0xd0, 0x1b, 0x50, 0x37, 0x87, 0x76, 0xb7, 0xbf,
-	0x3d, 0xc3, 0x71, 0xb0, 0xcd, 0x54, 0xbb, 0xaa, 0xd7, 0xcc, 0xa1, 0xbd, 0xce, 0x41, 0xe8, 0x3c,
+	0x67, 0x38, 0x0e, 0xb6, 0x99, 0x6a, 0x57, 0xf5, 0x9a, 0x39, 0xb4, 0xd7, 0x39, 0x08, 0x9d, 0x07,
-	0x80, 0x8f, 0x07, 0x43, 0xec, 0x04, 0x91, 0xeb, 0x8b, 0x41, 0xd0, 0x32, 0xcc, 0xed, 0x7a, 0xee,
+	0xf0, 0xf1, 0x60, 0x88, 0x9d, 0x20, 0x72, 0x7d, 0x31, 0x08, 0x5a, 0x86, 0xb9, 0x5d, 0xcf, 0x1d,
-	0xb0, 0xeb, 0xef, 0x19, 0x9e, 0xd9, 0xb5, 0xb1, 0x61, 0x62, 0x8f, 0x52, 0x5f, 0xd1, 0x67, 0xc9,
+	0x76, 0xfd, 0x3d, 0xc3, 0x33, 0xbb, 0x36, 0x36, 0x4c, 0xec, 0x51, 0xea, 0x2b, 0xfa, 0x2c, 0x19,
-	0x40, 0x87, 0xc0, 0xef, 0x52, 0x30, 0xba, 0x0e, 0x65, 0xbf, 0xef, 0x8e, 0x30, 0x55, 0x93, 0xe6,
+	0xe8, 0x10, 0xf8, 0x3d, 0x0a, 0x46, 0xd7, 0xa1, 0xec, 0xf7, 0xdd, 0x11, 0xa6, 0x6a, 0xd2, 0x5c,
-	0xda, 0x39, 0x99, 0x02, 0x6c, 0x18, 0x81, 0xd1, 0x21, 0x93, 0x74, 0x36, 0x57, 0xfb, 0x4f, 0x6e,
+	0x3b, 0x27, 0x53, 0x80, 0x0d, 0x23, 0x30, 0x3a, 0x64, 0x92, 0xce, 0xe6, 0x6a, 0xff, 0xc2, 0xed,
-	0x27, 0xdf, 0x71, 0xb7, 0x13, 0xb3, 0xa5, 0xf2, 0x8b, 0xb1, 0xa5, 0xe9, 0x89, 0x6c, 0x69, 0xe6,
+	0xe4, 0x7b, 0xee, 0x76, 0x62, 0xb6, 0x54, 0x7e, 0x39, 0xb6, 0x34, 0x3d, 0x91, 0x2d, 0xcd, 0x1c,
-	0x70, 0x5b, 0xca, 0x70, 0xed, 0xe5, 0xdb, 0xd2, 0x0f, 0x22, 0x5b, 0xfa, 0xae, 0xcb, 0x2c, 0xb2,
+	0x6e, 0x4b, 0x19, 0xae, 0xbd, 0x7a, 0x5b, 0xfa, 0xef, 0xc8, 0x96, 0xbe, 0xef, 0x32, 0x8b, 0xec,
-	0xb7, 0x72, 0xc2, 0xde, 0xfe, 0x5d, 0x81, 0x57, 0x36, 0x71, 0x10, 0x92, 0x4f, 0xcc, 0x07, 0x7f,
+	0xad, 0x9c, 0xb0, 0xb7, 0x7f, 0x52, 0xe0, 0xb5, 0x4d, 0x1c, 0x84, 0xe4, 0x13, 0xf3, 0xc1, 0xdf,
-	0x47, 0xc3, 0xdd, 0xd7, 0x0a, 0xb4, 0x65, 0xb4, 0x9e, 0x24, 0xe4, 0x3d, 0x82, 0x85, 0x10, 0x47,
+	0xd3, 0x70, 0xf7, 0x8d, 0x02, 0x6d, 0x19, 0xad, 0x27, 0x09, 0x79, 0x8f, 0x61, 0x21, 0xc4, 0xd1,
-	0xd7, 0xc4, 0x7e, 0xdf, 0xb3, 0x46, 0x54, 0x8c, 0xd4, 0x43, 0xd4, 0xd6, 0x2e, 0xca, 0xd4, 0x2d,
+	0x35, 0xb1, 0xdf, 0xf7, 0xac, 0x11, 0x15, 0x23, 0xf5, 0x10, 0xb5, 0xb5, 0x8b, 0x32, 0x75, 0x4b,
-	0x4d, 0xc1, 0xe9, 0x70, 0x8b, 0x8d, 0xd8, 0x0e, 0xda, 0xdf, 0x28, 0x70, 0x9a, 0x78, 0x24, 0xee,
+	0x53, 0x70, 0x3a, 0xdc, 0x62, 0x23, 0xb6, 0x83, 0xf6, 0x17, 0x0a, 0x9c, 0x26, 0x1e, 0x89, 0xbb,
-	0x42, 0x9c, 0x5d, 0xf7, 0xf8, 0x7c, 0x4d, 0x3a, 0xa7, 0x42, 0xc6, 0x39, 0x4d, 0xc0, 0x63, 0x9a,
+	0x10, 0x67, 0xd7, 0x3d, 0x3e, 0x5f, 0x93, 0xce, 0xa9, 0x90, 0x71, 0x4e, 0x13, 0xf0, 0x98, 0xe6,
-	0x3f, 0xa6, 0xe9, 0x39, 0x09, 0xef, 0xde, 0x81, 0xb2, 0xe5, 0xec, 0xba, 0x82, 0x55, 0x17, 0x64,
+	0x8f, 0x69, 0x7a, 0x4e, 0xc2, 0xbb, 0xf7, 0xa0, 0x6c, 0x39, 0xbb, 0xae, 0x60, 0xd5, 0x05, 0x19,
-	0xac, 0x8a, 0x23, 0x63, 0xb3, 0x35, 0x87, 0x51, 0x11, 0x79, 0xcb, 0x13, 0xa8, 0x5b, 0xfa, 0xd8,
+	0xab, 0xe2, 0xc8, 0xd8, 0x6c, 0xcd, 0x61, 0x54, 0x44, 0xde, 0xf2, 0x04, 0xea, 0x96, 0x3e, 0x76,
-	0x05, 0xc9, 0xb1, 0xff, 0x5a, 0x81, 0x33, 0x19, 0x84, 0x27, 0x39, 0xf7, 0x07, 0x30, 0x4d, 0x63,
+	0x41, 0x72, 0xec, 0x3f, 0x57, 0xe0, 0x4c, 0x06, 0xe1, 0x49, 0xce, 0xfd, 0x11, 0x4c, 0xd3, 0x18,
-	0x80, 0x38, 0xf8, 0x25, 0xe9, 0xc1, 0x63, 0xe8, 0xee, 0x5a, 0x7e, 0xa0, 0xf3, 0x35, 0x9a, 0x0b,
+	0x20, 0x0e, 0x7e, 0x49, 0x7a, 0xf0, 0x18, 0xba, 0x7b, 0x96, 0x1f, 0xe8, 0x7c, 0x8d, 0xe6, 0x82,
-	0x6a, 0x7a, 0x8c, 0x44, 0x27, 0x1e, 0x99, 0xba, 0x8e, 0x31, 0x64, 0x0c, 0xa8, 0xea, 0x35, 0x0e,
+	0x9a, 0x1e, 0x23, 0xd1, 0x89, 0x47, 0xa6, 0xae, 0x63, 0x0c, 0x19, 0x03, 0xaa, 0x7a, 0x8d, 0xc3,
-	0xdb, 0x36, 0x86, 0x18, 0xbd, 0x02, 0x15, 0x62, 0xb2, 0x5d, 0xcb, 0x14, 0xe2, 0x9f, 0xa1, 0x26,
+	0xb6, 0x8d, 0x21, 0x46, 0xaf, 0x41, 0x85, 0x98, 0x6c, 0xd7, 0x32, 0x85, 0xf8, 0x67, 0xa8, 0x09,
-	0x6c, 0xfa, 0xe8, 0x1c, 0x00, 0x1d, 0x32, 0x4c, 0xd3, 0x63, 0x81, 0xab, 0xaa, 0x57, 0x09, 0xe4,
+	0x9b, 0x3e, 0x3a, 0x07, 0x40, 0x87, 0x0c, 0xd3, 0xf4, 0x58, 0xe0, 0xaa, 0xea, 0x55, 0x02, 0xb9,
-	0x26, 0x01, 0x68, 0x7f, 0xa7, 0x40, 0x9d, 0x38, 0xc8, 0x7b, 0x38, 0x30, 0x88, 0x1c, 0xd0, 0x7b,
+	0x49, 0x00, 0xda, 0x5f, 0x29, 0x50, 0x27, 0x0e, 0xf2, 0x3e, 0x0e, 0x0c, 0x22, 0x07, 0xf4, 0x01,
-	0x50, 0xb5, 0x5d, 0xc3, 0xec, 0x06, 0x07, 0x23, 0x86, 0xaa, 0x99, 0xe6, 0x75, 0xe4, 0x55, 0xef,
+	0x54, 0x6d, 0xd7, 0x30, 0xbb, 0xc1, 0xc1, 0x88, 0xa1, 0x6a, 0xa6, 0x79, 0x1d, 0x79, 0xd5, 0x07,
-	0x1f, 0x8c, 0xb0, 0x5e, 0xb1, 0xf9, 0xaf, 0x49, 0xf8, 0x9d, 0x31, 0xe5, 0xa2, 0xc4, 0x94, 0xbf,
+	0x07, 0x23, 0xac, 0x57, 0x6c, 0xfe, 0x6b, 0x12, 0x7e, 0x67, 0x4c, 0xb9, 0x28, 0x31, 0xe5, 0xaf,
-	0x2a, 0xc3, 0xc2, 0x9f, 0x1a, 0x41, 0x7f, 0x6f, 0x63, 0x28, 0xe2, 0xef, 0xf1, 0x95, 0x20, 0xf2,
+	0xcb, 0xb0, 0xf0, 0x87, 0x46, 0xd0, 0xdf, 0xdb, 0x18, 0x8a, 0xf8, 0x7b, 0x7c, 0x25, 0x88, 0x7c,
-	0x6d, 0x85, 0xb8, 0x6f, 0x7b, 0x61, 0xbe, 0x33, 0xd4, 0xf3, 0xb2, 0x4c, 0xcf, 0x49, 0x99, 0xb6,
+	0x5b, 0x21, 0xee, 0xdb, 0x5e, 0x9a, 0xef, 0x0c, 0xf5, 0xbc, 0x2c, 0xd3, 0x73, 0x52, 0xa6, 0xad,
-	0xf2, 0x90, 0x8b, 0x2a, 0xa6, 0xe7, 0xb1, 0x30, 0x39, 0x7d, 0x9c, 0x30, 0xb9, 0x0e, 0x0d, 0xfc,
+	0x3c, 0xe2, 0xa2, 0x8a, 0xe9, 0x79, 0x2c, 0x4c, 0x4e, 0x1f, 0x27, 0x4c, 0xae, 0x43, 0x03, 0x3f,
-	0xac, 0x6f, 0x8f, 0x89, 0xcc, 0x29, 0x76, 0x16, 0xff, 0xce, 0x4b, 0xb0, 0xc7, 0x8d, 0xac, 0xce,
+	0xef, 0xdb, 0x63, 0x22, 0x73, 0x8a, 0x9d, 0xc5, 0xbf, 0xf3, 0x12, 0xec, 0x71, 0x23, 0xab, 0xf3,
-	0x17, 0x6d, 0x71, 0x1a, 0x98, 0xa8, 0x87, 0x38, 0x30, 0x5a, 0x15, 0x4a, 0xc6, 0x62, 0x9e, 0xa8,
+	0x45, 0x5b, 0x9c, 0x06, 0x26, 0xea, 0x21, 0x0e, 0x8c, 0x56, 0x85, 0x92, 0xb1, 0x98, 0x27, 0x6a,
-	0x85, 0x7e, 0x30, 0x71, 0x93, 0x2f, 0x74, 0x16, 0xaa, 0x3c, 0x28, 0x6f, 0x6d, 0xb4, 0xaa, 0x94,
+	0xa1, 0x1f, 0x4c, 0xdc, 0xe4, 0x0b, 0x9d, 0x85, 0x2a, 0x0f, 0xca, 0x5b, 0x1b, 0xad, 0x2a, 0x65,
-	0x7d, 0x11, 0x00, 0x19, 0xd0, 0xe0, 0x1e, 0x88, 0x53, 0x08, 0x94, 0xc2, 0x0f, 0x64, 0x08, 0xe4,
+	0x5f, 0x04, 0x40, 0x06, 0x34, 0xb8, 0x07, 0xe2, 0x14, 0x02, 0xa5, 0xf0, 0x23, 0x19, 0x02, 0xb9,
-	0xc2, 0x8e, 0x53, 0xee, 0xf3, 0x10, 0xed, 0xc7, 0x40, 0xa4, 0x34, 0x74, 0x77, 0x77, 0x6d, 0xcb,
+	0xb0, 0xe3, 0x94, 0xfb, 0x3c, 0x44, 0xfb, 0x31, 0x10, 0x29, 0x0d, 0xdd, 0xdd, 0x5d, 0xdb, 0x72,
-	0xc1, 0xdb, 0x4c, 0xc2, 0x35, 0x4a, 0x44, 0x12, 0xd8, 0xee, 0xc2, 0x5c, 0x66, 0x23, 0x49, 0x20,
+	0xf0, 0x36, 0x93, 0x70, 0x8d, 0x12, 0x91, 0x04, 0xb6, 0xbb, 0x30, 0x97, 0xd9, 0x48, 0x12, 0xc8,
-	0x7f, 0x3b, 0x1e, 0xc8, 0x8f, 0xe6, 0x64, 0x2c, 0xd0, 0xff, 0x9b, 0x02, 0xa7, 0x1f, 0x38, 0xfe,
+	0xdf, 0x8d, 0x07, 0xf2, 0xa3, 0x39, 0x19, 0x0b, 0xf4, 0xff, 0xa8, 0xc0, 0xe9, 0x87, 0x8e, 0x3f,
-	0xb8, 0x17, 0x9e, 0xe0, 0xdb, 0xd1, 0xd6, 0xb4, 0x9f, 0x28, 0x65, 0xfc, 0x84, 0xf6, 0xff, 0x25,
+	0xee, 0x85, 0x27, 0xf8, 0x6e, 0xb4, 0x35, 0xed, 0x27, 0x4a, 0x19, 0x3f, 0xa1, 0xfd, 0x57, 0x09,
-	0x98, 0xe5, 0xa7, 0x20, 0x42, 0xa5, 0x06, 0x7f, 0x16, 0xaa, 0x61, 0xa8, 0xe0, 0x0c, 0x89, 0x00,
+	0x66, 0xf9, 0x29, 0x88, 0x50, 0xa9, 0xc1, 0x9f, 0x85, 0x6a, 0x18, 0x2a, 0x38, 0x43, 0x22, 0x00,
-	0x68, 0x11, 0x6a, 0x31, 0x75, 0xe7, 0x54, 0xc5, 0x41, 0x13, 0x91, 0x26, 0x02, 0x7f, 0x29, 0x16,
+	0x5a, 0x84, 0x5a, 0x4c, 0xdd, 0x39, 0x55, 0x71, 0xd0, 0x44, 0xa4, 0x89, 0xc0, 0x5f, 0x8a, 0x05,
-	0xf8, 0xcf, 0x01, 0xec, 0xda, 0x63, 0x7f, 0xaf, 0x1b, 0x58, 0x43, 0xcc, 0x13, 0x8f, 0x2a, 0x85,
+	0xfe, 0x73, 0x00, 0xbb, 0xf6, 0xd8, 0xdf, 0xeb, 0x06, 0xd6, 0x10, 0xf3, 0xc4, 0xa3, 0x4a, 0x21,
-	0xdc, 0xb7, 0x86, 0x18, 0xdd, 0x84, 0x7a, 0xcf, 0x72, 0x6c, 0x77, 0xd0, 0x1d, 0x19, 0xc1, 0x9e,
+	0x0f, 0xac, 0x21, 0x46, 0x37, 0xa1, 0xde, 0xb3, 0x1c, 0xdb, 0x1d, 0x74, 0x47, 0x46, 0xb0, 0xe7,
-	0xcf, 0x8b, 0x25, 0x99, 0x58, 0x68, 0x9a, 0x76, 0x8b, 0xce, 0xd5, 0x6b, 0x6c, 0xcd, 0x0e, 0x59,
+	0xf3, 0x62, 0x49, 0x26, 0x16, 0x9a, 0xa6, 0xdd, 0xa2, 0x73, 0xf5, 0x1a, 0x5b, 0xb3, 0x43, 0x96,
-	0x82, 0xce, 0x43, 0xcd, 0x19, 0x0f, 0xbb, 0xee, 0x6e, 0xd7, 0x73, 0x9f, 0x12, 0x13, 0xa1, 0x28,
+	0xa0, 0xf3, 0x50, 0x73, 0xc6, 0xc3, 0xae, 0xbb, 0xdb, 0xf5, 0xdc, 0x67, 0xc4, 0x44, 0x28, 0x0a,
-	0x9c, 0xf1, 0xf0, 0xd3, 0x5d, 0xdd, 0x7d, 0x4a, 0x5c, 0x75, 0x95, 0x38, 0x6d, 0xdf, 0x76, 0x07,
+	0x67, 0x3c, 0xfc, 0x6c, 0x57, 0x77, 0x9f, 0x11, 0x57, 0x5d, 0x25, 0x4e, 0xdb, 0xb7, 0xdd, 0x81,
-	0x7e, 0xab, 0x32, 0xd1, 0xfe, 0xd1, 0x02, 0xb2, 0xda, 0xc4, 0x76, 0x60, 0xd0, 0xd5, 0xd5, 0xc9,
+	0xdf, 0xaa, 0x4c, 0xb4, 0x7f, 0xb4, 0x80, 0xac, 0x36, 0xb1, 0x1d, 0x18, 0x74, 0x75, 0x75, 0xb2,
-	0x56, 0x87, 0x0b, 0xd0, 0x15, 0x68, 0xf6, 0xdd, 0xe1, 0xc8, 0xa0, 0x1c, 0xba, 0xed, 0xb9, 0x43,
+	0xd5, 0xe1, 0x02, 0x74, 0x05, 0x9a, 0x7d, 0x77, 0x38, 0x32, 0x28, 0x87, 0x6e, 0x7b, 0xee, 0x90,
-	0x6a, 0x1f, 0x45, 0x3d, 0x05, 0x45, 0xeb, 0x50, 0xa3, 0x29, 0x2e, 0x37, 0xa2, 0x1a, 0xc5, 0xa3,
+	0xda, 0x47, 0x51, 0x4f, 0x41, 0xd1, 0x3a, 0xd4, 0x68, 0x8a, 0xcb, 0x8d, 0xa8, 0x46, 0xf1, 0x68,
-	0xc9, 0x8c, 0x28, 0x96, 0xad, 0x12, 0x05, 0x05, 0x4b, 0xfc, 0xf4, 0x89, 0x66, 0x08, 0x5b, 0xf4,
+	0x32, 0x23, 0x8a, 0x65, 0xab, 0x44, 0x41, 0xc1, 0x12, 0x3f, 0x7d, 0xa2, 0x19, 0xc2, 0x16, 0x7d,
-	0xad, 0x2f, 0x70, 0xab, 0xce, 0xa4, 0xc8, 0x61, 0x1d, 0xeb, 0x0b, 0x4c, 0xf2, 0x6e, 0xcb, 0xf1,
+	0xeb, 0x4b, 0xdc, 0xaa, 0x33, 0x29, 0x72, 0x58, 0xc7, 0xfa, 0x12, 0x93, 0xbc, 0xdb, 0x72, 0x7c,
-	0xb1, 0x17, 0x88, 0x2a, 0xa8, 0xd5, 0xa0, 0xea, 0xd3, 0x60, 0x50, 0xae, 0xd8, 0xda, 0xaf, 0x0a,
+	0xec, 0x05, 0xa2, 0x0a, 0x6a, 0x35, 0xa8, 0xfa, 0x34, 0x18, 0x94, 0x2b, 0xb6, 0xf6, 0xf3, 0x02,
-	0xd0, 0x4c, 0x22, 0x42, 0x2d, 0x98, 0x61, 0x89, 0xb3, 0xd0, 0x1e, 0xf1, 0x49, 0xd0, 0x62, 0xc7,
+	0x34, 0x93, 0x88, 0x50, 0x0b, 0x66, 0x58, 0xe2, 0x2c, 0xb4, 0x47, 0x7c, 0x12, 0xb4, 0xd8, 0x31,
-	0xe8, 0xd9, 0x98, 0x65, 0xe9, 0x54, 0x79, 0x2a, 0x7a, 0x8d, 0xc1, 0xe8, 0x06, 0x44, 0x09, 0xd8,
+	0x7a, 0x36, 0x66, 0x59, 0x3a, 0x55, 0x9e, 0x8a, 0x5e, 0x63, 0x30, 0xba, 0x01, 0x51, 0x02, 0x76,
-	0xf1, 0xa8, 0xc6, 0x16, 0x29, 0xca, 0x2a, 0x85, 0xd0, 0xb8, 0xd6, 0x82, 0x19, 0x91, 0xe0, 0x33,
+	0x3c, 0xaa, 0xb1, 0x45, 0x8a, 0xb2, 0x4a, 0x21, 0x34, 0xae, 0xb5, 0x60, 0x46, 0x24, 0xf8, 0x4c,
-	0xd5, 0x11, 0x9f, 0x64, 0xa4, 0x37, 0xb6, 0x28, 0x56, 0xa6, 0x3a, 0xe2, 0x13, 0x6d, 0x40, 0x9d,
+	0x75, 0xc4, 0x27, 0x19, 0xe9, 0x8d, 0x2d, 0x8a, 0x95, 0xa9, 0x8e, 0xf8, 0x44, 0x1b, 0x50, 0x67,
-	0x6d, 0x39, 0x32, 0x3c, 0x63, 0x28, 0x14, 0xe7, 0x35, 0xa9, 0xf1, 0xdd, 0xc1, 0x07, 0x0f, 0x89,
+	0x5b, 0x8e, 0x0c, 0xcf, 0x18, 0x0a, 0xc5, 0x79, 0x43, 0x6a, 0x7c, 0x77, 0xf1, 0xc1, 0x23, 0x62,
-	0x1d, 0xef, 0x18, 0x96, 0xa7, 0x33, 0x46, 0xef, 0xd0, 0x55, 0x68, 0x09, 0x54, 0xb6, 0xcb, 0xae,
+	0xc7, 0x3b, 0x86, 0xe5, 0xe9, 0x8c, 0xd1, 0x3b, 0x74, 0x15, 0x5a, 0x02, 0x95, 0xed, 0xb2, 0x6b,
-	0x65, 0x63, 0xae, 0x82, 0x33, 0x34, 0x78, 0x36, 0x29, 0xfc, 0xb6, 0x65, 0x63, 0xa6, 0x65, 0xe1,
+	0xd9, 0x98, 0xab, 0xe0, 0x0c, 0x0d, 0x9e, 0x4d, 0x0a, 0xbf, 0x6d, 0xd9, 0x98, 0x69, 0x59, 0x78,
-	0x11, 0x28, 0x6b, 0x2b, 0x4c, 0xc9, 0x28, 0x84, 0x32, 0xf6, 0x22, 0x34, 0xd8, 0xf0, 0x3e, 0xf6,
+	0x04, 0xca, 0xda, 0x0a, 0x53, 0x32, 0x0a, 0xa1, 0x8c, 0xbd, 0x08, 0x0d, 0x36, 0xbc, 0x8f, 0x3d,
-	0x7c, 0xcb, 0x75, 0xb8, 0xa7, 0x64, 0x34, 0x3e, 0x64, 0x30, 0x1a, 0xbf, 0xc7, 0x43, 0xa6, 0xa6,
+	0xdf, 0x72, 0x1d, 0xee, 0x29, 0x19, 0x8d, 0x8f, 0x18, 0x8c, 0xc6, 0xef, 0xf1, 0x90, 0xa9, 0x29,
-	0xc0, 0x8e, 0xe3, 0x8c, 0x87, 0x44, 0x49, 0xb5, 0xbf, 0x2f, 0xc1, 0x3c, 0xb1, 0x55, 0x6e, 0xb6,
+	0xb0, 0xe3, 0x38, 0xe3, 0x21, 0x51, 0x52, 0xed, 0xaf, 0x4b, 0x30, 0x4f, 0x6c, 0x95, 0x9b, 0xed,
-	0x27, 0x88, 0x84, 0xe7, 0x00, 0x4c, 0x3f, 0xe8, 0x26, 0xfc, 0x4b, 0xd5, 0xf4, 0x03, 0xe6, 0x27,
+	0x09, 0x22, 0xe1, 0x39, 0x00, 0xd3, 0x0f, 0xba, 0x09, 0xff, 0x52, 0x35, 0xfd, 0x80, 0xf9, 0x49,
-	0xd1, 0x7b, 0x22, 0x90, 0x15, 0xf3, 0x73, 0xdb, 0x94, 0xef, 0xc8, 0x06, 0xb3, 0x63, 0xf5, 0x4f,
+	0xf4, 0x81, 0x08, 0x64, 0xc5, 0xfc, 0xdc, 0x36, 0xe5, 0x3b, 0xb2, 0xc1, 0xec, 0x58, 0xfd, 0x93,
-	0x2e, 0x42, 0xc3, 0x77, 0xc7, 0x5e, 0x1f, 0x77, 0x13, 0x55, 0x48, 0x9d, 0x01, 0xb7, 0xe5, 0x1e,
+	0x8b, 0xd0, 0xf0, 0xdd, 0xb1, 0xd7, 0xc7, 0xdd, 0x44, 0x15, 0x52, 0x67, 0xc0, 0x6d, 0xb9, 0x07,
-	0x70, 0x5a, 0xda, 0xc7, 0x89, 0x05, 0xb4, 0x99, 0x93, 0x05, 0xb4, 0x4a, 0x3a, 0xa0, 0xdd, 0x81,
+	0x9c, 0x96, 0xf6, 0x71, 0x62, 0x01, 0x6d, 0xe6, 0x64, 0x01, 0xad, 0x92, 0x0e, 0x68, 0x77, 0x61,
-	0x59, 0x6a, 0xbe, 0xdd, 0x91, 0xeb, 0xb3, 0x62, 0x8e, 0x5b, 0xbd, 0x96, 0xd3, 0x6f, 0xb8, 0xe7,
+	0x96, 0x9a, 0x6f, 0x77, 0xe4, 0xfa, 0xac, 0x98, 0xe3, 0x56, 0xaf, 0xe5, 0xf4, 0x1b, 0xee, 0xfb,
-	0x0f, 0x76, 0xf8, 0x54, 0xbd, 0x49, 0x97, 0x8a, 0x4f, 0x9f, 0xa8, 0xaf, 0xd0, 0x07, 0x2e, 0x6f,
+	0x83, 0x1d, 0x3e, 0x55, 0x6f, 0xd2, 0xa5, 0xe2, 0xd3, 0x27, 0xea, 0x2b, 0xf4, 0x81, 0xcb, 0x9b,
-	0xfe, 0x49, 0x98, 0xe1, 0x60, 0x6c, 0x76, 0x03, 0xcf, 0x70, 0xfc, 0x5d, 0xec, 0xd1, 0xa0, 0x56,
+	0x7f, 0x12, 0x66, 0x38, 0x18, 0x9b, 0xdd, 0xc0, 0x33, 0x1c, 0x7f, 0x17, 0x7b, 0x34, 0xa8, 0x55,
-	0xd1, 0xeb, 0x04, 0x78, 0x9f, 0xc3, 0xb4, 0x9f, 0x14, 0x60, 0x81, 0xd7, 0x96, 0x27, 0xd7, 0x8b,
+	0xf4, 0x3a, 0x01, 0x3e, 0xe0, 0x30, 0xed, 0xff, 0x0b, 0xb0, 0xc0, 0x6b, 0xcb, 0x93, 0xeb, 0x45,
-	0xbc, 0x98, 0x23, 0x9c, 0x76, 0xf1, 0x90, 0x6a, 0xad, 0x34, 0x41, 0xd6, 0x54, 0x96, 0x64, 0x4d,
+	0x5e, 0xcc, 0x11, 0x4e, 0xbb, 0x78, 0x48, 0xb5, 0x56, 0x9a, 0x20, 0x6b, 0x2a, 0x4b, 0xb2, 0xa6,
-	0xc9, 0x8a, 0x65, 0x3a, 0x53, 0xb1, 0x84, 0x2d, 0x92, 0x99, 0xc9, 0x5b, 0x24, 0xa4, 0x16, 0xa7,
+	0x64, 0xc5, 0x32, 0x9d, 0xa9, 0x58, 0xc2, 0x16, 0xc9, 0xcc, 0xe4, 0x2d, 0x12, 0x52, 0x8b, 0xd3,
-	0x69, 0x34, 0x95, 0x5d, 0x55, 0x67, 0x1f, 0x93, 0x31, 0xf4, 0x17, 0x0a, 0x34, 0x3a, 0xd8, 0xf0,
+	0x34, 0x9a, 0xca, 0xae, 0xaa, 0xb3, 0x8f, 0xc9, 0x18, 0xfa, 0x53, 0x05, 0x1a, 0x1d, 0x6c, 0x78,
-	0xfa, 0x7b, 0x82, 0x8f, 0xef, 0xc6, 0x5b, 0x4a, 0x97, 0x72, 0x44, 0x9c, 0x58, 0xf2, 0xfd, 0xe9,
+	0xfd, 0x3d, 0xc1, 0xc7, 0xf7, 0xe3, 0x2d, 0xa5, 0x4b, 0x39, 0x22, 0x4e, 0x2c, 0xf9, 0xe1, 0xf4,
-	0x25, 0xfd, 0x52, 0x81, 0xfa, 0x9f, 0x90, 0x21, 0x71, 0xd8, 0x1b, 0xf1, 0xc3, 0x5e, 0xc9, 0x39,
+	0x92, 0x7e, 0xa6, 0x40, 0xfd, 0x0f, 0xc8, 0x90, 0x38, 0xec, 0x8d, 0xf8, 0x61, 0xaf, 0xe4, 0x1c,
-	0xac, 0x8e, 0x03, 0xcf, 0xc2, 0xfb, 0xf8, 0x7b, 0x77, 0xdc, 0x1f, 0x29, 0xd0, 0xee, 0x1c, 0x38,
+	0x56, 0xc7, 0x81, 0x67, 0xe1, 0x7d, 0xfc, 0x83, 0x3b, 0xee, 0xff, 0x2a, 0xd0, 0xee, 0x1c, 0x38,
 	0x7d, 0x9d, 0xd9, 0xf2, 0xc9, 0x2d, 0xe6, 0x22, 0x34, 0xf6, 0x13, 0xa9, 0x56, 0x81, 0x2a, 0x5c,
-	0x7d, 0x3f, 0x5e, 0x93, 0xe9, 0xa0, 0x8a, 0x4e, 0x16, 0x3f, 0xac, 0x70, 0xad, 0xaf, 0xcb, 0xa8,
+	0x7d, 0x3f, 0x5e, 0x93, 0xe9, 0xa0, 0x8a, 0x4e, 0x16, 0x3f, 0xac, 0x70, 0xad, 0x6f, 0xca, 0xa8,
-	0x4e, 0x11, 0x47, 0x5d, 0xd3, 0xac, 0x97, 0x04, 0x6a, 0x7f, 0xab, 0xc0, 0xbc, 0x64, 0x22, 0x3a,
+	0x4e, 0x11, 0x47, 0x5d, 0xd3, 0xac, 0x97, 0x04, 0x6a, 0x7f, 0xa9, 0xc0, 0xbc, 0x64, 0x22, 0x3a,
 	0x03, 0x33, 0xbc, 0xfe, 0xe3, 0x31, 0x98, 0xd9, 0xb0, 0x49, 0xc4, 0x13, 0x75, 0x30, 0x2c, 0x33,
 	0x9b, 0xbf, 0x99, 0xe8, 0x02, 0xd4, 0xc2, 0x44, 0xdd, 0xcc, 0xc8, 0xc7, 0xf4, 0x51, 0x1b, 0x2a,
-	0xdc, 0x39, 0x89, 0x0a, 0x28, 0xfc, 0xd6, 0xfe, 0x4f, 0x81, 0x85, 0x4f, 0x0c, 0xc7, 0x74, 0x77,
+	0xdc, 0x39, 0x89, 0x0a, 0x28, 0xfc, 0xd6, 0xfe, 0x53, 0x81, 0x85, 0x3b, 0x86, 0x63, 0xba, 0xbb,
-	0x77, 0x4f, 0xce, 0xd6, 0x75, 0x48, 0xe4, 0xf7, 0x93, 0x76, 0x0e, 0x92, 0x45, 0xc1, 0x55, 0x98,
+	0xbb, 0x27, 0x67, 0xeb, 0x3a, 0x24, 0xf2, 0xfb, 0x49, 0x3b, 0x07, 0xc9, 0xa2, 0xe0, 0x2a, 0xcc,
-	0xf3, 0x98, 0x67, 0x34, 0x93, 0x7c, 0x2f, 0xea, 0xaa, 0x18, 0x08, 0xf9, 0xf9, 0x55, 0x01, 0x10,
+	0x79, 0xcc, 0x33, 0x9a, 0x49, 0xbe, 0x17, 0x75, 0x55, 0x0c, 0x84, 0xfc, 0xfc, 0xba, 0x00, 0x88,
-	0x09, 0x06, 0xb7, 0x0c, 0xdb, 0x70, 0xfa, 0xf8, 0xf8, 0xa4, 0x5f, 0x86, 0x66, 0x22, 0x84, 0x85,
+	0x04, 0x83, 0x5b, 0x86, 0x6d, 0x38, 0x7d, 0x7c, 0x7c, 0xd2, 0x2f, 0x43, 0x33, 0x11, 0xc2, 0xc2,
-	0xd7, 0x54, 0xf1, 0x18, 0xe6, 0xa3, 0x3b, 0xd0, 0xec, 0x31, 0x54, 0x5d, 0x0f, 0x1b, 0xbe, 0xeb,
+	0x6b, 0xaa, 0x78, 0x0c, 0xf3, 0xd1, 0x5d, 0x68, 0xf6, 0x18, 0xaa, 0xae, 0x87, 0x0d, 0xdf, 0x75,
-	0x50, 0xe7, 0xda, 0x94, 0x37, 0x09, 0xee, 0x7b, 0xd6, 0x60, 0x80, 0xbd, 0x75, 0xd7, 0x31, 0x59,
+	0xa8, 0x73, 0x6d, 0xca, 0x9b, 0x04, 0x0f, 0x3c, 0x6b, 0x30, 0xc0, 0xde, 0xba, 0xeb, 0x98, 0x2c,
-	0x10, 0x69, 0xf4, 0x04, 0x99, 0x64, 0x29, 0x11, 0x5c, 0x14, 0xcf, 0x85, 0x68, 0x20, 0x0c, 0xe8,
+	0x88, 0x34, 0x7a, 0x82, 0x4c, 0xb2, 0x94, 0x08, 0x2e, 0x8a, 0xe7, 0x42, 0x34, 0x10, 0x06, 0x74,
-	0x94, 0x15, 0x3e, 0x36, 0xec, 0x88, 0x11, 0x91, 0x37, 0x56, 0xd9, 0x40, 0x27, 0xbf, 0x47, 0x24,
+	0xca, 0x0a, 0x1f, 0x1b, 0x76, 0xc4, 0x88, 0xc8, 0x1b, 0xab, 0x6c, 0xa0, 0x93, 0xdf, 0x23, 0x92,
-	0x89, 0xaf, 0xda, 0x7f, 0x2b, 0x80, 0xc2, 0x22, 0x87, 0x16, 0x6d, 0x54, 0xfb, 0xd2, 0x4b, 0x15,
+	0xc4, 0x57, 0xed, 0xdf, 0x14, 0x40, 0x61, 0x91, 0x43, 0x8b, 0x36, 0xaa, 0x7d, 0xe9, 0xa5, 0x8a,
-	0x49, 0x50, 0x38, 0x0b, 0x55, 0x53, 0xac, 0xe4, 0xe6, 0x12, 0x01, 0xa8, 0x8f, 0xa6, 0x44, 0x77,
+	0x24, 0x28, 0x9c, 0x85, 0xaa, 0x29, 0x56, 0x72, 0x73, 0x89, 0x00, 0xd4, 0x47, 0x53, 0xa2, 0xbb,
-	0x49, 0x30, 0xc6, 0xa6, 0x28, 0x22, 0x18, 0xf0, 0x2e, 0x85, 0x25, 0xc3, 0x73, 0x29, 0x1d, 0x9e,
+	0x24, 0x18, 0x63, 0x53, 0x14, 0x11, 0x0c, 0x78, 0x8f, 0xc2, 0x92, 0xe1, 0xb9, 0x94, 0x0e, 0xcf,
-	0xe3, 0x2d, 0x90, 0x72, 0xa2, 0x05, 0xa2, 0x7d, 0x5d, 0x00, 0x95, 0xba, 0xbb, 0xf5, 0xa8, 0x0e,
+	0xf1, 0x16, 0x48, 0x39, 0xd1, 0x02, 0xd1, 0xbe, 0x29, 0x80, 0x4a, 0xdd, 0xdd, 0x7a, 0x54, 0x87,
-	0x9f, 0x88, 0xe8, 0x8b, 0xd0, 0xe0, 0x17, 0xb9, 0x09, 0xc2, 0xeb, 0x4f, 0x62, 0x9b, 0xa1, 0x6b,
+	0x4f, 0x44, 0xf4, 0x45, 0x68, 0xf0, 0x8b, 0xdc, 0x04, 0xe1, 0xf5, 0xa7, 0xb1, 0xcd, 0xd0, 0x35,
-	0x70, 0x8a, 0x4d, 0xf2, 0xb0, 0x3f, 0xb6, 0xa3, 0xfc, 0x99, 0x25, 0xb3, 0xe8, 0x09, 0xf3, 0xb3,
+	0x38, 0xc5, 0x26, 0x79, 0xd8, 0x1f, 0xdb, 0x51, 0xfe, 0xcc, 0x92, 0x59, 0xf4, 0x94, 0xf9, 0x59,
-	0x64, 0x48, 0xac, 0x78, 0x00, 0x0b, 0x03, 0xdb, 0xed, 0x19, 0x76, 0x37, 0x29, 0x1e, 0x26, 0xc3,
+	0x32, 0x24, 0x56, 0x3c, 0x84, 0x85, 0x81, 0xed, 0xf6, 0x0c, 0xbb, 0x9b, 0x14, 0x0f, 0x93, 0xe1,
-	0x09, 0x34, 0xfe, 0x14, 0x5b, 0xde, 0x89, 0xcb, 0xd0, 0x47, 0x9b, 0xa4, 0xe2, 0xc6, 0x8f, 0xc3,
+	0x04, 0x1a, 0x7f, 0x8a, 0x2d, 0xef, 0xc4, 0x65, 0xe8, 0xa3, 0x4d, 0x52, 0x71, 0xe3, 0x27, 0x61,
-	0xfc, 0x84, 0x37, 0xe0, 0x27, 0x49, 0x4f, 0xea, 0x64, 0xa1, 0xf8, 0xd2, 0xfe, 0x59, 0x81, 0xd9,
+	0x7e, 0xc2, 0x1b, 0xf0, 0x93, 0xa4, 0x27, 0x75, 0xb2, 0x50, 0x7c, 0x69, 0x7f, 0xa7, 0xc0, 0x6c,
-	0x54, 0x17, 0x33, 0x5d, 0x07, 0x2a, 0xd9, 0x3a, 0xf0, 0x06, 0x94, 0x49, 0x71, 0xc4, 0x9c, 0x61,
+	0xaa, 0x8b, 0x99, 0xae, 0x03, 0x95, 0x6c, 0x1d, 0x78, 0x03, 0xca, 0xa4, 0x38, 0x62, 0xce, 0xb0,
-	0x53, 0x5e, 0xa3, 0x24, 0x77, 0xd5, 0xd9, 0x02, 0xb4, 0x0a, 0xf3, 0x92, 0x5b, 0x43, 0xae, 0x03,
+	0x29, 0xaf, 0x51, 0x92, 0xbb, 0xea, 0x6c, 0x01, 0x5a, 0x85, 0x79, 0xc9, 0xad, 0x21, 0xd7, 0x01,
-	0x28, 0x7b, 0x69, 0xa8, 0xfd, 0xac, 0x04, 0xb5, 0x18, 0x3f, 0x8e, 0x28, 0x61, 0x27, 0x69, 0x4b,
+	0x94, 0xbd, 0x34, 0xd4, 0x7e, 0x5c, 0x82, 0x5a, 0x8c, 0x1f, 0x47, 0x94, 0xb0, 0x93, 0xb4, 0xa5,
-	0xa5, 0x8e, 0x57, 0xcc, 0x1e, 0x2f, 0xe7, 0x4e, 0x8a, 0xe8, 0xdd, 0x10, 0x0f, 0x59, 0xf2, 0xcf,
+	0x52, 0xc7, 0x2b, 0x66, 0x8f, 0x97, 0x73, 0x27, 0x45, 0xf4, 0x6e, 0x88, 0x87, 0x2c, 0xf9, 0xe7,
-	0x2b, 0x91, 0x21, 0x1e, 0xd2, 0xd4, 0x3f, 0x9e, 0xd5, 0x4f, 0x27, 0xb2, 0xfa, 0x54, 0xdd, 0x33,
+	0x95, 0xc8, 0x10, 0x0f, 0x69, 0xea, 0x1f, 0xcf, 0xea, 0xa7, 0x13, 0x59, 0x7d, 0xaa, 0xee, 0x99,
-	0x73, 0x48, 0xdd, 0x53, 0x49, 0xd6, 0x3d, 0x09, 0x3b, 0xaa, 0xa6, 0xed, 0x68, 0xd2, 0xaa, 0xf2,
+	0x39, 0xa4, 0xee, 0xa9, 0x24, 0xeb, 0x9e, 0x84, 0x1d, 0x55, 0xd3, 0x76, 0x34, 0x69, 0x55, 0x79,
-	0x1a, 0xcc, 0xf7, 0x3d, 0x6c, 0x04, 0xd8, 0xbc, 0x75, 0xb0, 0x1e, 0x0e, 0xf1, 0xcc, 0x48, 0x36,
+	0x0d, 0xe6, 0xfb, 0x1e, 0x36, 0x02, 0x6c, 0xde, 0x3a, 0x58, 0x0f, 0x87, 0x78, 0x66, 0x24, 0x1b,
-	0x84, 0x6e, 0x47, 0xed, 0x1c, 0x26, 0xe5, 0x3a, 0x95, 0xb2, 0xbc, 0xac, 0xe2, 0xb2, 0x61, 0x42,
+	0x42, 0xb7, 0xa3, 0x76, 0x0e, 0x93, 0x72, 0x9d, 0x4a, 0x59, 0x5e, 0x56, 0x71, 0xd9, 0x30, 0x21,
-	0x16, 0xee, 0x99, 0x7e, 0xa5, 0xeb, 0xd9, 0xc6, 0xb1, 0xea, 0xd9, 0x0b, 0x50, 0x13, 0xa1, 0x95,
+	0x0b, 0xf7, 0x4c, 0xbf, 0xd2, 0xf5, 0x6c, 0xe3, 0x58, 0xf5, 0xec, 0x05, 0xa8, 0x89, 0xd0, 0x4a,
-	0x98, 0x7b, 0x93, 0x79, 0x3e, 0xe1, 0x0b, 0x4c, 0x3f, 0xe1, 0x0c, 0x66, 0x93, 0xfd, 0xd0, 0x74,
+	0xcc, 0xbd, 0xc9, 0x3c, 0x9f, 0xf0, 0x05, 0xa6, 0x9f, 0x70, 0x06, 0xb3, 0xc9, 0x7e, 0x68, 0xba,
-	0x51, 0xaa, 0x66, 0x8a, 0x52, 0xed, 0xa7, 0x45, 0x68, 0x46, 0xc5, 0xca, 0xc4, 0xde, 0x62, 0x92,
+	0x28, 0x55, 0x33, 0x45, 0xa9, 0xf6, 0xa3, 0x22, 0x34, 0xa3, 0x62, 0x65, 0x62, 0x6f, 0x31, 0xc9,
-	0x0b, 0xf2, 0x6d, 0x50, 0xa3, 0x78, 0x4c, 0x19, 0x79, 0x68, 0xbd, 0x95, 0xbe, 0x4b, 0x98, 0x1d,
+	0x05, 0xf9, 0x36, 0xa8, 0x51, 0x3c, 0xa6, 0x8c, 0x3c, 0xb4, 0xde, 0x4a, 0xdf, 0x25, 0xcc, 0x8e,
-	0xa5, 0xcc, 0x32, 0xd1, 0xad, 0x2d, 0x3d, 0x57, 0xb7, 0xf6, 0x84, 0x17, 0x75, 0xd7, 0xe1, 0x74,
+	0x52, 0x66, 0x99, 0xe8, 0xd6, 0x96, 0x5e, 0xa8, 0x5b, 0x7b, 0xc2, 0x8b, 0xba, 0xeb, 0x70, 0x3a,
-	0x18, 0x67, 0x13, 0xc7, 0x66, 0xc9, 0xfc, 0x29, 0x31, 0xb8, 0x13, 0x3f, 0x7e, 0x8e, 0xa5, 0xcf,
+	0x8c, 0xb3, 0x89, 0x63, 0xb3, 0x64, 0xfe, 0x94, 0x18, 0xdc, 0x89, 0x1f, 0x3f, 0xc7, 0xd2, 0x67,
-	0xe4, 0x59, 0x7a, 0x5a, 0xd2, 0x95, 0x8c, 0xa4, 0xb3, 0xf7, 0x85, 0x55, 0xc9, 0x7d, 0xa1, 0xf6,
+	0xf2, 0x2c, 0x3d, 0x2d, 0xe9, 0x4a, 0x46, 0xd2, 0xd9, 0xfb, 0xc2, 0xaa, 0xe4, 0xbe, 0x50, 0x7b,
-	0x00, 0xe6, 0x69, 0x8b, 0xce, 0xef, 0x7b, 0x56, 0x0f, 0x87, 0xa9, 0xe9, 0x24, 0x62, 0x6d, 0x43,
+	0x08, 0xf3, 0xb4, 0x45, 0xe7, 0xf7, 0x3d, 0xab, 0x87, 0xc3, 0xd4, 0x74, 0x12, 0xb1, 0xb6, 0xa1,
-	0x25, 0x95, 0xdd, 0x86, 0xdf, 0xda, 0x97, 0x0a, 0x2c, 0x64, 0xf7, 0xa5, 0x1a, 0x13, 0xf9, 0x0b,
+	0x92, 0xca, 0x6e, 0xc3, 0x6f, 0xed, 0x2b, 0x05, 0x16, 0xb2, 0xfb, 0x52, 0x8d, 0x89, 0xfc, 0x85,
-	0x25, 0xe1, 0x2f, 0xfe, 0x0c, 0xe6, 0xa3, 0xed, 0x93, 0x79, 0x73, 0x4e, 0x66, 0x28, 0x21, 0x5c,
+	0x92, 0xf0, 0x17, 0x7f, 0x04, 0xf3, 0xd1, 0xf6, 0xc9, 0xbc, 0x39, 0x27, 0x33, 0x94, 0x10, 0xae,
-	0x47, 0xd1, 0x1e, 0x02, 0xa6, 0xfd, 0x5a, 0x09, 0x3b, 0x9d, 0x04, 0x36, 0xa0, 0x5d, 0x5e, 0x12,
+	0xa3, 0x68, 0x0f, 0x01, 0xd3, 0x7e, 0xa1, 0x84, 0x9d, 0x4e, 0x02, 0x1b, 0xd0, 0x2e, 0x2f, 0x89,
-	0xc3, 0x5c, 0xc7, 0xb6, 0x9c, 0xb0, 0xb8, 0xe6, 0x67, 0x64, 0x40, 0x5e, 0x5c, 0x7f, 0x02, 0xb3,
+	0x61, 0xae, 0x63, 0x5b, 0x4e, 0x58, 0x5c, 0xf3, 0x33, 0x32, 0x20, 0x2f, 0xae, 0xef, 0xc0, 0x2c,
-	0x7c, 0x52, 0x18, 0x8a, 0x26, 0x4c, 0xbe, 0x9a, 0x6c, 0x5d, 0x18, 0x84, 0x2e, 0x43, 0x93, 0xb7,
+	0x9f, 0x14, 0x86, 0xa2, 0x09, 0x93, 0xaf, 0x26, 0x5b, 0x17, 0x06, 0xa1, 0xcb, 0xd0, 0xe4, 0xed,
-	0x5f, 0x05, 0xbe, 0xa2, 0xa4, 0x29, 0x8b, 0xfe, 0x18, 0x54, 0x31, 0xed, 0x79, 0x83, 0xdf, 0x2c,
+	0x57, 0x81, 0xaf, 0x28, 0x69, 0xca, 0xa2, 0xdf, 0x07, 0x55, 0x4c, 0x7b, 0xd1, 0xe0, 0x37, 0xcb,
-	0x5f, 0x18, 0x26, 0x71, 0x7f, 0xa5, 0x40, 0x2b, 0x19, 0x0a, 0x63, 0xc7, 0x7f, 0xfe, 0x54, 0xee,
+	0x17, 0x86, 0x49, 0xdc, 0x9f, 0x29, 0xd0, 0x4a, 0x86, 0xc2, 0xd8, 0xf1, 0x5f, 0x3c, 0x95, 0xfb,
-	0xfd, 0xe4, 0xc5, 0xd5, 0xe5, 0x43, 0xe8, 0x89, 0xf0, 0x88, 0xeb, 0xab, 0x6d, 0x7a, 0x09, 0x49,
+	0x30, 0x79, 0x71, 0x75, 0xf9, 0x10, 0x7a, 0x22, 0x3c, 0xe2, 0xfa, 0x6a, 0x9b, 0x5e, 0x42, 0x92,
-	0x2a, 0x90, 0x0d, 0xcb, 0x0f, 0x3c, 0xab, 0x37, 0x3e, 0xd1, 0x0b, 0x0a, 0xed, 0x7f, 0x0a, 0xf0,
+	0x0a, 0x64, 0xc3, 0xf2, 0x03, 0xcf, 0xea, 0x8d, 0x4f, 0xf4, 0x82, 0x42, 0xfb, 0xf7, 0x02, 0xbc,
-	0xaa, 0x74, 0xc3, 0x93, 0x5c, 0x51, 0xe5, 0x15, 0xfc, 0xb7, 0xa0, 0x92, 0xaa, 0x54, 0xae, 0x1c,
+	0x2e, 0xdd, 0xf0, 0x24, 0x57, 0x54, 0x79, 0x05, 0xff, 0x2d, 0xa8, 0xa4, 0x2a, 0x95, 0x2b, 0x87,
-	0x72, 0x78, 0xde, 0xbb, 0x62, 0x3d, 0x14, 0xb1, 0x8e, 0xec, 0x11, 0xea, 0x74, 0x29, 0x7f, 0x0f,
+	0x1c, 0x9e, 0xf7, 0xae, 0x58, 0x0f, 0x45, 0xac, 0x23, 0x7b, 0x84, 0x3a, 0x5d, 0xca, 0xdf, 0x83,
-	0xae, 0xb4, 0x89, 0x3d, 0xc4, 0x3a, 0x74, 0x13, 0xea, 0xac, 0x0a, 0xec, 0xee, 0x5b, 0xf8, 0xa9,
+	0x2b, 0x6d, 0x62, 0x0f, 0xb1, 0x0e, 0xdd, 0x84, 0x3a, 0xab, 0x02, 0xbb, 0xfb, 0x16, 0x7e, 0x26,
-	0xb8, 0x59, 0x39, 0x2f, 0xf5, 0x6b, 0x74, 0xde, 0x43, 0x0b, 0x3f, 0xd5, 0x6b, 0x76, 0xf8, 0xdb,
+	0x6e, 0x56, 0xce, 0x4b, 0xfd, 0x1a, 0x9d, 0xf7, 0xc8, 0xc2, 0xcf, 0xf4, 0x9a, 0x1d, 0xfe, 0xf6,
-	0xd7, 0xfe, 0xa3, 0x00, 0x10, 0x8d, 0x91, 0x12, 0x34, 0x32, 0x18, 0x6e, 0x01, 0x31, 0x08, 0x89,
+	0xb5, 0x7f, 0x2e, 0x00, 0x44, 0x63, 0xa4, 0x04, 0x8d, 0x0c, 0x86, 0x5b, 0x40, 0x0c, 0x42, 0xe2,
-	0xb7, 0xc9, 0x14, 0x4f, 0x7c, 0x22, 0x3d, 0x6a, 0x9d, 0x9a, 0x96, 0x1f, 0x70, 0xbe, 0xac, 0x1e,
+	0x6d, 0x32, 0xc5, 0x13, 0x9f, 0x48, 0x8f, 0x5a, 0xa7, 0xa6, 0xe5, 0x07, 0x9c, 0x2f, 0xab, 0x87,
-	0x4e, 0x8b, 0x60, 0x11, 0x11, 0x19, 0xbb, 0xb8, 0x10, 0x25, 0x16, 0x81, 0xa0, 0x37, 0x01, 0x0d,
+	0xd3, 0x22, 0x58, 0x44, 0x44, 0xc6, 0x2e, 0x2e, 0x44, 0x89, 0x45, 0x20, 0xe8, 0x6d, 0x40, 0x03,
-	0x3c, 0xf7, 0xa9, 0xe5, 0x0c, 0xe2, 0x89, 0x39, 0xcb, 0xdf, 0xe7, 0xf8, 0x48, 0x94, 0x99, 0xb7,
+	0xcf, 0x7d, 0x66, 0x39, 0x83, 0x78, 0x62, 0xce, 0xf2, 0xf7, 0x39, 0x3e, 0x12, 0x65, 0xe6, 0xed,
-	0xbb, 0xa0, 0xa6, 0xf7, 0x93, 0xdc, 0x5f, 0xbc, 0x93, 0xbc, 0xbf, 0x38, 0xcc, 0x8c, 0xc8, 0x36,
+	0x2e, 0xa8, 0xe9, 0xfd, 0x24, 0xf7, 0x17, 0xef, 0x25, 0xef, 0x2f, 0x0e, 0x33, 0x23, 0xb2, 0x4d,
-	0xf1, 0x0b, 0x8c, 0x8f, 0xc2, 0x6c, 0x8a, 0x92, 0x97, 0xe7, 0xb9, 0x62, 0x3d, 0xab, 0x42, 0xa2,
+	0xfc, 0x02, 0xe3, 0x93, 0x30, 0x9b, 0xa2, 0xe4, 0xe5, 0x79, 0xae, 0x58, 0xcf, 0xaa, 0x90, 0xe8,
-	0x67, 0xa5, 0xfd, 0x83, 0x02, 0x28, 0xab, 0x15, 0xa8, 0x09, 0x85, 0x70, 0x93, 0xc2, 0xd6, 0x46,
+	0x59, 0x69, 0x7f, 0xa3, 0x00, 0xca, 0x6a, 0x05, 0x6a, 0x42, 0x21, 0xdc, 0xa4, 0xb0, 0xb5, 0x91,
-	0x4a, 0x0a, 0x85, 0x8c, 0x14, 0xce, 0x42, 0x35, 0x8c, 0x24, 0xdc, 0x6d, 0x44, 0x80, 0xb8, 0x8c,
+	0x92, 0x42, 0x21, 0x23, 0x85, 0xb3, 0x50, 0x0d, 0x23, 0x09, 0x77, 0x1b, 0x11, 0x20, 0x2e, 0xa3,
-	0x4a, 0x49, 0x19, 0xc5, 0x08, 0x2b, 0x27, 0x09, 0xdb, 0x03, 0x94, 0xd5, 0xb4, 0xf8, 0x4e, 0x4a,
+	0x52, 0x52, 0x46, 0x31, 0xc2, 0xca, 0x49, 0xc2, 0xf6, 0x00, 0x65, 0x35, 0x2d, 0xbe, 0x93, 0x92,
-	0x72, 0xa7, 0xa3, 0x28, 0x8c, 0x61, 0x2a, 0x26, 0x31, 0xfd, 0x58, 0x01, 0x14, 0xc5, 0xca, 0xf0,
+	0xdc, 0xe9, 0x28, 0x0a, 0x63, 0x98, 0x8a, 0x49, 0x4c, 0xff, 0xa7, 0x00, 0x8a, 0x62, 0x65, 0x78,
-	0x72, 0x65, 0x92, 0x00, 0xb3, 0x0a, 0xf3, 0xd9, 0x48, 0x2a, 0xd2, 0x07, 0x94, 0x89, 0xa3, 0xb2,
+	0xb9, 0x32, 0x49, 0x80, 0x59, 0x85, 0xf9, 0x6c, 0x24, 0x15, 0xe9, 0x03, 0xca, 0xc4, 0x51, 0x59,
-	0x98, 0x57, 0x94, 0xbd, 0x91, 0x79, 0x37, 0xf4, 0x0d, 0x2c, 0x31, 0x38, 0x9f, 0x97, 0x18, 0x24,
+	0xcc, 0x2b, 0xca, 0xde, 0xc8, 0xbc, 0x1f, 0xfa, 0x06, 0x96, 0x18, 0x9c, 0xcf, 0x4b, 0x0c, 0x92,
-	0xdd, 0x83, 0xf6, 0xbf, 0x0a, 0xcc, 0x85, 0xd8, 0x9e, 0xeb, 0x24, 0x47, 0x5f, 0x16, 0xbd, 0x64,
+	0xee, 0x41, 0xfb, 0x0f, 0x05, 0xe6, 0x42, 0x6c, 0x2f, 0x74, 0x92, 0xa3, 0x2f, 0x8b, 0x5e, 0x31,
-	0xd2, 0x3b, 0x30, 0xc3, 0xdb, 0x23, 0x19, 0xe5, 0x9b, 0xa4, 0x0a, 0x38, 0x05, 0x65, 0xa2, 0xeb,
+	0xe9, 0x1d, 0x98, 0xe1, 0xed, 0x91, 0x8c, 0xf2, 0x4d, 0x52, 0x05, 0x9c, 0x82, 0x32, 0xd1, 0x75,
-	0xa2, 0x5f, 0xc0, 0x3e, 0xb4, 0xff, 0x52, 0x00, 0x3a, 0x07, 0x4e, 0xff, 0x26, 0xd3, 0x81, 0x6b,
+	0xd1, 0x2f, 0x60, 0x1f, 0xda, 0xbf, 0x2a, 0x00, 0x9d, 0x03, 0xa7, 0x7f, 0x93, 0xe9, 0xc0, 0x35,
-	0x50, 0x3a, 0xea, 0x6e, 0x9c, 0xcc, 0xa6, 0xd9, 0x16, 0x9d, 0x39, 0x01, 0x5b, 0x12, 0x05, 0x4c,
+	0x28, 0x1d, 0x75, 0x37, 0x4e, 0x66, 0xd3, 0x6c, 0x8b, 0xce, 0x9c, 0x80, 0x2d, 0x89, 0x02, 0xa6,
-	0x31, 0x5d, 0xc0, 0xe4, 0x95, 0x1e, 0xf9, 0x7a, 0xff, 0x43, 0x05, 0xce, 0x10, 0x22, 0x5e, 0x48,
+	0x98, 0x2e, 0x60, 0xf2, 0x4a, 0x8f, 0x7c, 0xbd, 0xff, 0x1f, 0x05, 0xce, 0x10, 0x22, 0x5e, 0x4a,
 	0x10, 0x9a, 0x88, 0x75, 0x31, 0x9b, 0x2a, 0x26, 0x6d, 0xea, 0x06, 0xcc, 0xb0, 0x1a, 0x42, 0x04,
-	0x84, 0xf3, 0x79, 0x2c, 0x63, 0x0c, 0xd6, 0xc5, 0xf4, 0xe5, 0x3f, 0x82, 0x6a, 0xd8, 0xcb, 0x43,
+	0x84, 0xf3, 0x79, 0x2c, 0x63, 0x0c, 0xd6, 0xc5, 0xf4, 0xe5, 0xdf, 0x83, 0x6a, 0xd8, 0xcb, 0x43,
-	0x35, 0x98, 0x79, 0xe0, 0xdc, 0x71, 0xdc, 0xa7, 0x8e, 0x3a, 0x85, 0x66, 0xa0, 0x78, 0xd3, 0xb6,
+	0x35, 0x98, 0x79, 0xe8, 0xdc, 0x75, 0xdc, 0x67, 0x8e, 0x3a, 0x85, 0x66, 0xa0, 0x78, 0xd3, 0xb6,
 	0x55, 0x05, 0x35, 0xa0, 0xda, 0x09, 0x3c, 0x6c, 0x0c, 0x2d, 0x67, 0xa0, 0x16, 0x50, 0x13, 0xe0,
-	0x13, 0xcb, 0x0f, 0x5c, 0xcf, 0xea, 0x1b, 0xb6, 0x5a, 0x5c, 0xfe, 0x02, 0x9a, 0xc9, 0x14, 0x1a,
+	0x8e, 0xe5, 0x07, 0xae, 0x67, 0xf5, 0x0d, 0x5b, 0x2d, 0x2e, 0x7f, 0x09, 0xcd, 0x64, 0x0a, 0x8d,
-	0xd5, 0xa1, 0xb2, 0xed, 0x06, 0x1f, 0x3f, 0xb3, 0xfc, 0x40, 0x9d, 0x22, 0xf3, 0xb7, 0xdd, 0x60,
+	0xea, 0x50, 0xd9, 0x76, 0x83, 0x4f, 0x9f, 0x5b, 0x7e, 0xa0, 0x4e, 0x91, 0xf9, 0xdb, 0x6e, 0xb0,
-	0xc7, 0xc3, 0x3e, 0x76, 0x02, 0x55, 0x41, 0x00, 0xd3, 0x9f, 0x3a, 0x1b, 0x96, 0xff, 0x58, 0x2d,
+	0xe3, 0x61, 0x1f, 0x3b, 0x81, 0xaa, 0x20, 0x80, 0xe9, 0xcf, 0x9c, 0x0d, 0xcb, 0x7f, 0xa2, 0x16,
-	0xa0, 0x79, 0x5e, 0x04, 0x1b, 0xf6, 0x16, 0xcf, 0x4b, 0xd5, 0x22, 0x59, 0x1e, 0x7e, 0x95, 0x90,
+	0xd0, 0x3c, 0x2f, 0x82, 0x0d, 0x7b, 0x8b, 0xe7, 0xa5, 0x6a, 0x91, 0x2c, 0x0f, 0xbf, 0x4a, 0x48,
-	0x0a, 0xf5, 0x70, 0xca, 0xe6, 0xce, 0x03, 0xb5, 0x8c, 0xaa, 0x50, 0x66, 0x3f, 0xa7, 0x97, 0x4d,
+	0x85, 0x7a, 0x38, 0x65, 0x73, 0xe7, 0xa1, 0x5a, 0x46, 0x55, 0x28, 0xb3, 0x9f, 0xd3, 0xcb, 0x26,
-	0x50, 0xd3, 0x1d, 0x1c, 0xb2, 0x27, 0x3b, 0x44, 0x08, 0x52, 0xa7, 0xc8, 0xc9, 0x78, 0x0b, 0x4d,
+	0xa8, 0xe9, 0x0e, 0x0e, 0xd9, 0x93, 0x1d, 0x22, 0x04, 0xa9, 0x53, 0xe4, 0x64, 0xbc, 0x85, 0xa6,
-	0x55, 0xd0, 0x2c, 0xd4, 0x62, 0x0d, 0x29, 0xb5, 0x40, 0x00, 0x9b, 0xde, 0xa8, 0xcf, 0xa5, 0xc7,
+	0x2a, 0x68, 0x16, 0x6a, 0xb1, 0x86, 0x94, 0x5a, 0x20, 0x80, 0x4d, 0x6f, 0xd4, 0xe7, 0xd2, 0x63,
-	0x48, 0x20, 0x49, 0xd4, 0x06, 0xe1, 0x44, 0x69, 0xf9, 0x16, 0x54, 0x44, 0x6e, 0x4f, 0xa6, 0x72,
+	0x24, 0x90, 0x24, 0x6a, 0x83, 0x70, 0xa2, 0xb4, 0x7c, 0x0b, 0x2a, 0x22, 0xb7, 0x27, 0x53, 0x39,
-	0x16, 0x91, 0x4f, 0x75, 0x0a, 0xcd, 0x41, 0x23, 0xf1, 0xf8, 0x4d, 0x55, 0x10, 0x82, 0x66, 0xf2,
+	0x8b, 0xc8, 0xa7, 0x3a, 0x85, 0xe6, 0xa0, 0x91, 0x78, 0xfc, 0xa6, 0x2a, 0x08, 0x41, 0x33, 0xf9,
-	0x6d, 0xa9, 0x5a, 0x58, 0x5e, 0x03, 0x88, 0x6c, 0x89, 0x90, 0xb3, 0xe5, 0xec, 0x1b, 0xb6, 0x65,
+	0xb6, 0x54, 0x2d, 0x2c, 0xaf, 0x01, 0x44, 0xb6, 0x44, 0xc8, 0xd9, 0x72, 0xf6, 0x0d, 0xdb, 0x32,
-	0x32, 0xda, 0xc8, 0x10, 0xe1, 0x2e, 0xe5, 0x0e, 0x6b, 0xc5, 0xa8, 0x85, 0xe5, 0x0b, 0x50, 0x11,
+	0x19, 0x6d, 0x64, 0x88, 0x70, 0x97, 0x72, 0x87, 0xb5, 0x62, 0xd4, 0xc2, 0xf2, 0x05, 0xa8, 0x08,
-	0x5a, 0x4e, 0xe0, 0x3a, 0x1e, 0xba, 0xfb, 0x98, 0x49, 0xa6, 0x83, 0x03, 0x55, 0x59, 0xfb, 0xc7,
+	0x2d, 0x27, 0x70, 0x1d, 0x0f, 0xdd, 0x7d, 0xcc, 0x24, 0xd3, 0xc1, 0x81, 0xaa, 0xac, 0xfd, 0xaa,
-	0x06, 0x00, 0x6b, 0xba, 0xb8, 0xae, 0x67, 0x22, 0x1b, 0xd0, 0x26, 0x0e, 0x48, 0x41, 0xe9, 0x3a,
+	0x01, 0xc0, 0x9a, 0x2e, 0xae, 0xeb, 0x99, 0xc8, 0x06, 0xb4, 0x89, 0x03, 0x52, 0x50, 0xba, 0x8e,
-	0xa2, 0x18, 0xf4, 0xd1, 0x4a, 0x52, 0x15, 0xf8, 0x47, 0x76, 0x22, 0x3f, 0x7d, 0xfb, 0x92, 0x74,
+	0x28, 0x06, 0x7d, 0xb4, 0x92, 0x54, 0x05, 0xfe, 0x91, 0x9d, 0xc8, 0x4f, 0xdf, 0xbe, 0x24, 0x9d,
-	0x7e, 0x6a, 0xb2, 0x36, 0x85, 0x86, 0x14, 0xdb, 0x7d, 0x6b, 0x88, 0xef, 0x5b, 0xfd, 0xc7, 0x61,
+	0x9f, 0x9a, 0xac, 0x4d, 0xa1, 0x21, 0xc5, 0xf6, 0xc0, 0x1a, 0xe2, 0x07, 0x56, 0xff, 0x49, 0xd8,
-	0xa7, 0x26, 0xff, 0x61, 0x68, 0x6a, 0xaa, 0xc0, 0x77, 0x51, 0x8a, 0xaf, 0x13, 0x78, 0x96, 0x33,
+	0xa9, 0xc9, 0x7f, 0x18, 0x9a, 0x9a, 0x2a, 0xf0, 0x5d, 0x94, 0xe2, 0xeb, 0x04, 0x9e, 0xe5, 0x0c,
-	0x10, 0x39, 0x98, 0x36, 0x85, 0x9e, 0xa4, 0x9e, 0xa5, 0x0a, 0x84, 0x6b, 0x93, 0xbc, 0x44, 0x3d,
+	0x44, 0x0e, 0xa6, 0x4d, 0xa1, 0xa7, 0xa9, 0x67, 0xa9, 0x02, 0xe1, 0xda, 0x24, 0x2f, 0x51, 0x8f,
-	0x1e, 0x4a, 0x1b, 0x66, 0x53, 0xcf, 0xec, 0xd1, 0xb2, 0xfc, 0xa5, 0x91, 0xec, 0x2f, 0x01, 0xed,
+	0x87, 0xd2, 0x86, 0xd9, 0xd4, 0x33, 0x7b, 0xb4, 0x2c, 0x7f, 0x69, 0x24, 0xfb, 0x4b, 0x40, 0xfb,
-	0xab, 0x13, 0xcd, 0x0d, 0xb1, 0x59, 0xd0, 0x4c, 0x3e, 0x25, 0x47, 0x7f, 0x90, 0xb7, 0x41, 0xe6,
+	0xea, 0x44, 0x73, 0x43, 0x6c, 0x16, 0x34, 0x93, 0x4f, 0xc9, 0xd1, 0xef, 0xe4, 0x6d, 0x90, 0x79,
-	0xad, 0x63, 0x7b, 0x79, 0x92, 0xa9, 0x21, 0xaa, 0x47, 0x4c, 0x41, 0x8f, 0x42, 0x25, 0x7d, 0xd4,
+	0xeb, 0xd8, 0x5e, 0x9e, 0x64, 0x6a, 0x88, 0xea, 0x31, 0x53, 0xd0, 0xa3, 0x50, 0x49, 0x1f, 0x75,
-	0xd9, 0x3e, 0x2c, 0xfd, 0xd5, 0xa6, 0xd0, 0xe7, 0x30, 0x97, 0x79, 0x91, 0x89, 0xde, 0x90, 0x77,
+	0xb6, 0x0f, 0x4b, 0x7f, 0xb5, 0x29, 0xf4, 0x05, 0xcc, 0x65, 0x5e, 0x64, 0xa2, 0xb7, 0xe4, 0xdd,
-	0xe3, 0xe5, 0x0f, 0x37, 0x8f, 0xc2, 0xf0, 0x28, 0x6d, 0x5e, 0xf9, 0xd4, 0x67, 0x1e, 0x58, 0x4f,
+	0x78, 0xf9, 0xc3, 0xcd, 0xa3, 0x30, 0x3c, 0x4e, 0x9b, 0x57, 0x3e, 0xf5, 0x99, 0x07, 0xd6, 0x93,
-	0x4e, 0x7d, 0x6c, 0xfb, 0xc3, 0xa8, 0x7f, 0x6e, 0x0c, 0x63, 0x6a, 0x36, 0xe9, 0xd6, 0xdf, 0x9b,
+	0x53, 0x1f, 0xdb, 0xfe, 0x30, 0xea, 0x5f, 0x18, 0xc3, 0x98, 0x9a, 0x4d, 0xba, 0xf5, 0xf7, 0xb6,
-	0x32, 0x14, 0xb9, 0xcf, 0x42, 0xdb, 0x2b, 0x93, 0x4e, 0x8f, 0x6b, 0x57, 0xf2, 0xe5, 0xa1, 0x9c,
+	0x0c, 0x45, 0xee, 0xb3, 0xd0, 0xf6, 0xca, 0xa4, 0xd3, 0xe3, 0xda, 0x95, 0x7c, 0x79, 0x28, 0x67,
-	0x69, 0xd2, 0xd7, 0x92, 0x72, 0xed, 0x92, 0x3f, 0x64, 0xd4, 0xa6, 0xd0, 0xfd, 0x84, 0x7b, 0x45,
+	0x9a, 0xf4, 0xb5, 0xa4, 0x5c, 0xbb, 0xe4, 0x0f, 0x19, 0xb5, 0x29, 0xf4, 0x20, 0xe1, 0x5e, 0xd1,
-	0x57, 0xf2, 0x84, 0x93, 0xbc, 0x10, 0x38, 0x8a, 0x6f, 0x7f, 0x01, 0x88, 0xd9, 0x8e, 0xb3, 0x6b,
+	0x95, 0x3c, 0xe1, 0x24, 0x2f, 0x04, 0x8e, 0xe2, 0xdb, 0x9f, 0x00, 0x62, 0xb6, 0xe3, 0xec, 0x5a,
-	0x0d, 0xc6, 0x9e, 0xc1, 0x14, 0x2b, 0xcf, 0xdd, 0x64, 0xa7, 0x0a, 0x34, 0x6f, 0x3d, 0xc7, 0x8a,
+	0x83, 0xb1, 0x67, 0x30, 0xc5, 0xca, 0x73, 0x37, 0xd9, 0xa9, 0x02, 0xcd, 0x3b, 0x2f, 0xb0, 0x22,
-	0xf0, 0x48, 0x5d, 0x80, 0x4d, 0x1c, 0xdc, 0xc3, 0x81, 0x67, 0xf5, 0xfd, 0xf4, 0x89, 0x22, 0x8f,
+	0x3c, 0x52, 0x17, 0x60, 0x13, 0x07, 0xf7, 0x71, 0xe0, 0x59, 0x7d, 0x3f, 0x7d, 0xa2, 0xc8, 0xa3,
-	0xca, 0x27, 0x08, 0x54, 0xaf, 0x1f, 0x39, 0x2f, 0x44, 0xd0, 0x83, 0xda, 0x26, 0x0e, 0x78, 0x5e,
+	0xf2, 0x09, 0x02, 0xd5, 0x9b, 0x47, 0xce, 0x0b, 0x11, 0xf4, 0xa0, 0xb6, 0x89, 0x03, 0x9e, 0x57,
-	0xe5, 0xa3, 0xdc, 0x95, 0x62, 0x86, 0x40, 0xb1, 0x74, 0xf4, 0xc4, 0xb8, 0x3b, 0x4b, 0xbd, 0xc2,
+	0xf9, 0x28, 0x77, 0xa5, 0x98, 0x21, 0x50, 0x2c, 0x1d, 0x3d, 0x31, 0xee, 0xce, 0x52, 0xaf, 0x30,
-	0x44, 0xb9, 0x82, 0xcd, 0xbe, 0x0d, 0x95, 0xbb, 0xb3, 0x9c, 0x67, 0x9d, 0xda, 0xd4, 0xda, 0xd7,
+	0x51, 0xae, 0x60, 0xb3, 0x6f, 0x43, 0xe5, 0xee, 0x2c, 0xe7, 0x59, 0x27, 0x3b, 0xd1, 0xfa, 0x1e,
-	0x4d, 0xa8, 0xd2, 0xd8, 0x44, 0x02, 0xe9, 0xef, 0x43, 0xd3, 0x0b, 0x0e, 0x4d, 0x9f, 0xc1, 0x6c,
+	0xee, 0x3f, 0xb9, 0x83, 0x0d, 0x3b, 0xd8, 0xcb, 0x39, 0x51, 0x6c, 0xc6, 0xe1, 0x27, 0x4a, 0x4c,
-	0xea, 0x41, 0x9f, 0x5c, 0x96, 0xf2, 0x57, 0x7f, 0x13, 0x78, 0xd8, 0xe4, 0x63, 0x3b, 0xb9, 0xb3,
+	0x14, 0x38, 0xd6, 0xbe, 0x69, 0x42, 0x95, 0xc6, 0x3f, 0x12, 0xac, 0x7f, 0x1b, 0xfe, 0x5e, 0x72,
-	0x90, 0x3e, 0xc8, 0x3b, 0x6a, 0xef, 0x87, 0xec, 0x2d, 0x6c, 0xd8, 0xcc, 0x7a, 0x3d, 0xb7, 0xec,
+	0xf8, 0xfb, 0x1c, 0x66, 0x53, 0x8f, 0x06, 0xe5, 0xfa, 0x22, 0x7f, 0x59, 0x38, 0x81, 0x17, 0x4f,
-	0x48, 0xde, 0x75, 0x7e, 0xfb, 0x9e, 0xfb, 0xe5, 0x47, 0xb6, 0xcf, 0x60, 0x36, 0xf5, 0xe2, 0x44,
+	0x3e, 0xe8, 0x93, 0x3b, 0x24, 0xe9, 0xa3, 0xbf, 0xa3, 0xf6, 0x7e, 0xc4, 0xde, 0xdb, 0x86, 0x0d,
-	0x2e, 0x55, 0xf9, 0xb3, 0x94, 0xa3, 0x76, 0xff, 0x06, 0x43, 0x80, 0x09, 0xf3, 0x92, 0xc7, 0x00,
+	0xb3, 0x37, 0x73, 0x4b, 0x9b, 0xe4, 0x7d, 0xea, 0x77, 0x1f, 0x1d, 0x5e, 0x7d, 0xf4, 0xfc, 0x1c,
-	0x68, 0x25, 0xaf, 0x2a, 0x91, 0xbf, 0x1a, 0x38, 0xfa, 0x40, 0x8d, 0x84, 0x29, 0xa1, 0xa5, 0x3c,
+	0x66, 0x53, 0xaf, 0x5a, 0xe4, 0x52, 0x95, 0x3f, 0x7d, 0x39, 0x6a, 0xf7, 0x6f, 0x31, 0xcc, 0x98,
-	0x22, 0xd3, 0x7f, 0x49, 0x6a, 0xbf, 0x31, 0xd9, 0xff, 0x97, 0xc2, 0x03, 0x75, 0x60, 0x9a, 0xbd,
+	0x30, 0x2f, 0x79, 0x70, 0x80, 0x56, 0xf2, 0x2a, 0x1f, 0xf9, 0xcb, 0x84, 0xa3, 0x0f, 0xd4, 0x48,
-	0x43, 0x41, 0xaf, 0xc9, 0x9b, 0x3e, 0xb1, 0x37, 0x2a, 0xed, 0xa3, 0x5e, 0xb2, 0xf8, 0x63, 0x3b,
+	0x98, 0x12, 0x5a, 0xca, 0x23, 0x32, 0xfd, 0xb7, 0xa7, 0xf6, 0x5b, 0x93, 0xfd, 0x47, 0x2a, 0x3c,
-	0xf0, 0xe9, 0xa6, 0x65, 0xea, 0x21, 0x91, 0xf4, 0x01, 0x55, 0xfc, 0xf1, 0x48, 0xfb, 0xe8, 0xf7,
+	0x50, 0x07, 0xa6, 0xd9, 0x5b, 0x17, 0xf4, 0x86, 0xbc, 0xb1, 0x14, 0x7b, 0x07, 0xd3, 0x3e, 0xea,
-	0x22, 0x62, 0xd3, 0xdf, 0xed, 0x38, 0xf9, 0x0c, 0xe6, 0x25, 0xad, 0x5a, 0x94, 0x97, 0x0f, 0xe5,
+	0xb5, 0x8c, 0x3f, 0xb6, 0x03, 0x9f, 0x6e, 0x5a, 0xa6, 0x1e, 0x12, 0x49, 0x1f, 0x69, 0xc5, 0x1f,
-	0x34, 0x89, 0xdb, 0xab, 0x13, 0xcf, 0x0f, 0x31, 0xff, 0x39, 0xa8, 0xe9, 0x6a, 0x1f, 0x5d, 0xcd,
+	0xa8, 0xb4, 0x8f, 0x7e, 0x93, 0x22, 0x36, 0xfd, 0xcd, 0x8e, 0xc5, 0xcf, 0x61, 0x5e, 0xd2, 0x0e,
-	0xd3, 0x67, 0x19, 0xce, 0xc3, 0x95, 0xf9, 0xd6, 0xdb, 0x8f, 0xd6, 0x06, 0x56, 0xb0, 0x37, 0xee,
+	0x46, 0x79, 0x39, 0x57, 0x4e, 0x23, 0xba, 0xbd, 0x3a, 0xf1, 0xfc, 0x10, 0xf3, 0x1f, 0x83, 0x9a,
-	0x91, 0x91, 0x55, 0x36, 0xf5, 0x4d, 0xcb, 0xe5, 0xbf, 0x56, 0x05, 0xff, 0x57, 0xe9, 0xea, 0x55,
+	0xee, 0x28, 0xa0, 0xab, 0x79, 0xfa, 0x2c, 0xc3, 0x79, 0xb8, 0x32, 0xdf, 0x7a, 0xf7, 0xf1, 0xda,
-	0x8a, 0x6a, 0xd4, 0xeb, 0x4d, 0xd3, 0xcf, 0xeb, 0xbf, 0x0d, 0x00, 0x00, 0xff, 0xff, 0xb2, 0xc0,
+	0xc0, 0x0a, 0xf6, 0xc6, 0x3d, 0x32, 0xb2, 0xca, 0xa6, 0xbe, 0x6d, 0xb9, 0xfc, 0xd7, 0xaa, 0xe0,
-	0x8c, 0xd2, 0x0d, 0x3d, 0x00, 0x00,
+	0xff, 0x2a, 0x5d, 0xbd, 0x4a, 0x51, 0x8d, 0x7a, 0xbd, 0x69, 0xfa, 0x79, 0xfd, 0xd7, 0x01, 0x00,
+	0x00, 0xff, 0xff, 0xd8, 0xdb, 0x6b, 0x58, 0x71, 0x3d, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -3941,6 +3942,7 @@ type QueryCoordClient interface {
 	// https://wiki.lfaidata.foundation/display/MIL/MEP+23+--+Multiple+memory+replication+design
 	GetReplicas(ctx context.Context, in *milvuspb.GetReplicasRequest, opts ...grpc.CallOption) (*milvuspb.GetReplicasResponse, error)
 	GetShardLeaders(ctx context.Context, in *GetShardLeadersRequest, opts ...grpc.CallOption) (*GetShardLeadersResponse, error)
+	CheckHealth(ctx context.Context, in *milvuspb.CheckHealthRequest, opts ...grpc.CallOption) (*milvuspb.CheckHealthResponse, error)
 }
 
 type queryCoordClient struct {
@@ -4095,6 +4097,15 @@ func (c *queryCoordClient) GetShardLeaders(ctx context.Context, in *GetShardLead
 	return out, nil
 }
 
+func (c *queryCoordClient) CheckHealth(ctx context.Context, in *milvuspb.CheckHealthRequest, opts ...grpc.CallOption) (*milvuspb.CheckHealthResponse, error) {
+	out := new(milvuspb.CheckHealthResponse)
+	err := c.cc.Invoke(ctx, "/milvus.proto.query.QueryCoord/CheckHealth", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 // QueryCoordServer is the server API for QueryCoord service.
 type QueryCoordServer interface {
 	GetComponentStates(context.Context, *milvuspb.GetComponentStatesRequest) (*milvuspb.ComponentStates, error)
@@ -4115,6 +4126,7 @@ type QueryCoordServer interface {
 	// https://wiki.lfaidata.foundation/display/MIL/MEP+23+--+Multiple+memory+replication+design
 	GetReplicas(context.Context, *milvuspb.GetReplicasRequest) (*milvuspb.GetReplicasResponse, error)
 	GetShardLeaders(context.Context, *GetShardLeadersRequest) (*GetShardLeadersResponse, error)
+	CheckHealth(context.Context, *milvuspb.CheckHealthRequest) (*milvuspb.CheckHealthResponse, error)
 }
 
 // UnimplementedQueryCoordServer can be embedded to have forward compatible implementations.
@@ -4169,6 +4181,9 @@ func (*UnimplementedQueryCoordServer) GetReplicas(ctx context.Context, req *milv
 func (*UnimplementedQueryCoordServer) GetShardLeaders(ctx context.Context, req *GetShardLeadersRequest) (*GetShardLeadersResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method GetShardLeaders not implemented")
 }
+func (*UnimplementedQueryCoordServer) CheckHealth(ctx context.Context, req *milvuspb.CheckHealthRequest) (*milvuspb.CheckHealthResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method CheckHealth not implemented")
+}
 
 func RegisterQueryCoordServer(s *grpc.Server, srv QueryCoordServer) {
 	s.RegisterService(&_QueryCoord_serviceDesc, srv)
@@ -4462,6 +4477,24 @@ func _QueryCoord_GetShardLeaders_Handler(srv interface{}, ctx context.Context, d
 	return interceptor(ctx, in, info, handler)
 }
 
+func _QueryCoord_CheckHealth_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(milvuspb.CheckHealthRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(QueryCoordServer).CheckHealth(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/milvus.proto.query.QueryCoord/CheckHealth",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(QueryCoordServer).CheckHealth(ctx, req.(*milvuspb.CheckHealthRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 var _QueryCoord_serviceDesc = grpc.ServiceDesc{
 	ServiceName: "milvus.proto.query.QueryCoord",
 	HandlerType: (*QueryCoordServer)(nil),
@@ -4530,6 +4563,10 @@ var _QueryCoord_serviceDesc = grpc.ServiceDesc{
 			MethodName: "GetShardLeaders",
 			Handler:    _QueryCoord_GetShardLeaders_Handler,
 		},
+		{
+			MethodName: "CheckHealth",
+			Handler:    _QueryCoord_CheckHealth_Handler,
+		},
 	},
 	Streams:  []grpc.StreamDesc{},
 	Metadata: "query_coord.proto",

internal/proto/root_coord.proto

@@ -135,6 +135,8 @@ service RootCoord {
     rpc OperatePrivilege(milvus.OperatePrivilegeRequest) returns (common.Status) {}
     rpc SelectGrant(milvus.SelectGrantRequest) returns (milvus.SelectGrantResponse) {}
     rpc ListPolicy(internal.ListPolicyRequest) returns (internal.ListPolicyResponse) {}
+
+    rpc CheckHealth(milvus.CheckHealthRequest) returns (milvus.CheckHealthResponse) {}
 }
 
 message AllocTimestampRequest {

internal/proto/rootcoordpb/root_coord.pb.go

@@ -674,102 +674,103 @@ func init() {
 func init() { proto.RegisterFile("root_coord.proto", fileDescriptor_4513485a144f6b06) }
 
 var fileDescriptor_4513485a144f6b06 = []byte{
-	// 1515 bytes of a gzipped FileDescriptorProto
+	// 1535 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x58, 0xdb, 0x72, 0xdb, 0x36,
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x58, 0x6b, 0x93, 0xda, 0x36,
-	0x13, 0x8e, 0xa4, 0xd8, 0x96, 0x56, 0xb2, 0xe4, 0x60, 0x72, 0xd0, 0xaf, 0xe4, 0xff, 0xa3, 0x28,
+	0x17, 0x0e, 0x90, 0xbd, 0x70, 0x60, 0x61, 0xa3, 0xc9, 0x85, 0x97, 0xe4, 0x7d, 0x43, 0x48, 0xde,
-	0xf9, 0x1b, 0xe5, 0x24, 0xa7, 0xce, 0x4c, 0x9a, 0xe6, 0x2e, 0x96, 0x32, 0x8e, 0xa6, 0xf5, 0xc4,
+	0x86, 0xdc, 0xd8, 0x74, 0x33, 0x93, 0xa6, 0xf9, 0x96, 0x85, 0xcc, 0x86, 0x69, 0x77, 0xb2, 0x35,
-	0xa5, 0x92, 0x4e, 0x7a, 0xf0, 0xa8, 0x10, 0x89, 0xc8, 0x1c, 0x53, 0x84, 0x02, 0x40, 0x3e, 0x4c,
+	0x49, 0x27, 0xbd, 0xec, 0x50, 0x61, 0x2b, 0xe0, 0x59, 0x63, 0x11, 0x49, 0xec, 0x65, 0xfa, 0xa9,
-	0xaf, 0x3a, 0xd3, 0xfb, 0x3e, 0x40, 0xdf, 0xa6, 0x7d, 0x94, 0xbe, 0x48, 0x07, 0x04, 0x09, 0x91,
+	0x33, 0xfd, 0xde, 0xff, 0xd4, 0xfe, 0x94, 0xfe, 0x90, 0x76, 0x64, 0xd9, 0xc2, 0x36, 0x36, 0xeb,
-	0x14, 0x29, 0xd3, 0x49, 0xee, 0x04, 0xf0, 0xc3, 0xf7, 0x2d, 0x76, 0xb1, 0xbb, 0x80, 0x60, 0x83,
+	0x4d, 0xf2, 0x0d, 0x49, 0x8f, 0x9f, 0xe7, 0xe8, 0x1c, 0x9d, 0x73, 0x24, 0x60, 0x93, 0x51, 0x2a,
-	0x51, 0x2a, 0x86, 0x26, 0xa5, 0xcc, 0xea, 0x4c, 0x19, 0x15, 0x14, 0x5d, 0x9d, 0xd8, 0xce, 0xd1,
+	0x06, 0x26, 0xa5, 0xcc, 0x6a, 0x4f, 0x19, 0x15, 0x14, 0x5d, 0x9d, 0xd8, 0xce, 0xd1, 0x8c, 0xab,
-	0x8c, 0xab, 0x51, 0x47, 0x7e, 0xf6, 0xbe, 0x36, 0x2a, 0x26, 0x9d, 0x4c, 0xa8, 0xab, 0xe6, 0x1b,
+	0x51, 0x5b, 0x2e, 0x7b, 0xab, 0xf5, 0xb2, 0x49, 0x27, 0x13, 0xea, 0xaa, 0xf9, 0x7a, 0x39, 0x8c,
-	0x95, 0x30, 0xaa, 0x51, 0xb5, 0x5d, 0x41, 0x98, 0x8b, 0x1d, 0x7f, 0x5c, 0x9e, 0x32, 0x7a, 0x72,
+	0xaa, 0x57, 0x6c, 0x57, 0x10, 0xe6, 0x62, 0xc7, 0x1f, 0x97, 0xa6, 0x8c, 0x9e, 0x9c, 0xfa, 0x83,
-	0xea, 0x0f, 0x6a, 0x44, 0x98, 0xd6, 0x70, 0x42, 0x04, 0x56, 0x13, 0xad, 0x21, 0x5c, 0x79, 0xe1,
+	0x2a, 0x11, 0xa6, 0x35, 0x98, 0x10, 0x81, 0xd5, 0x44, 0x73, 0x00, 0x57, 0x5e, 0x38, 0x0e, 0x35,
-	0x38, 0xd4, 0x7c, 0x63, 0x4f, 0x08, 0x17, 0x78, 0x32, 0x35, 0xc8, 0x87, 0x19, 0xe1, 0x02, 0x3d,
+	0xdf, 0xd8, 0x13, 0xc2, 0x05, 0x9e, 0x4c, 0x0d, 0xf2, 0x61, 0x46, 0xb8, 0x40, 0x8f, 0xe1, 0xe2,
-	0x86, 0x8b, 0x23, 0xcc, 0x49, 0x3d, 0xd7, 0xcc, 0xb5, 0xcb, 0x5b, 0x37, 0x3a, 0x11, 0x4b, 0x7c,
+	0x10, 0x73, 0x52, 0xcb, 0x35, 0x72, 0xad, 0xd2, 0xf6, 0x8d, 0x76, 0xc4, 0x12, 0x5f, 0x7e, 0x8f,
-	0xf9, 0x5d, 0x3e, 0xde, 0xc6, 0x9c, 0x18, 0x1e, 0x12, 0x5d, 0x86, 0x15, 0x93, 0xce, 0x5c, 0x51,
+	0x8f, 0x76, 0x30, 0x27, 0x86, 0x87, 0x44, 0x97, 0x61, 0xc5, 0xa4, 0x33, 0x57, 0xd4, 0x0a, 0x8d,
-	0x2f, 0x34, 0x73, 0xed, 0x75, 0x43, 0x0d, 0x5a, 0xbf, 0xe5, 0xe0, 0x6a, 0x5c, 0x81, 0x4f, 0xa9,
+	0x5c, 0x6b, 0xc3, 0x50, 0x83, 0xe6, 0x6f, 0x39, 0xb8, 0x1a, 0x57, 0xe0, 0x53, 0xea, 0x72, 0x82,
-	0xcb, 0x09, 0x7a, 0x02, 0xab, 0x5c, 0x60, 0x31, 0xe3, 0xbe, 0xc8, 0xf5, 0x44, 0x91, 0x81, 0x07,
+	0x9e, 0xc0, 0x2a, 0x17, 0x58, 0xcc, 0xb8, 0x2f, 0x72, 0x3d, 0x51, 0xa4, 0xef, 0x41, 0x0c, 0x1f,
-	0x31, 0x7c, 0x28, 0xba, 0x01, 0x25, 0x11, 0x30, 0xd5, 0xf3, 0xcd, 0x5c, 0xfb, 0xa2, 0x31, 0x9f,
+	0x8a, 0x6e, 0x40, 0x51, 0x04, 0x4c, 0xb5, 0x7c, 0x23, 0xd7, 0xba, 0x68, 0xcc, 0x27, 0x52, 0x6c,
-	0x48, 0xb1, 0xe1, 0x1d, 0x54, 0x3d, 0x13, 0xfa, 0xbd, 0xcf, 0xb0, 0xbb, 0x7c, 0x98, 0xd9, 0x81,
+	0x78, 0x07, 0x15, 0xcf, 0x84, 0x5e, 0xf7, 0x33, 0xec, 0x2e, 0x1f, 0x66, 0x76, 0xa0, 0xaa, 0x99,
-	0x9a, 0x66, 0xfe, 0x94, 0x5d, 0x55, 0x21, 0xdf, 0xef, 0x79, 0xd4, 0x05, 0x23, 0xdf, 0xef, 0xa5,
+	0x3f, 0x65, 0x57, 0x15, 0xc8, 0xf7, 0xba, 0x1e, 0x75, 0xc1, 0xc8, 0xf7, 0xba, 0x29, 0xfb, 0xf8,
-	0xec, 0xe3, 0xaf, 0x3c, 0x54, 0xfa, 0x93, 0x29, 0x65, 0xc2, 0x20, 0x7c, 0xe6, 0x88, 0x8f, 0xd3,
+	0x33, 0x0f, 0xe5, 0xde, 0x64, 0x4a, 0x99, 0x30, 0x08, 0x9f, 0x39, 0xe2, 0xe3, 0xb4, 0xae, 0xc1,
-	0xba, 0x06, 0x6b, 0x02, 0xf3, 0xc3, 0xa1, 0x6d, 0xf9, 0x82, 0xab, 0x72, 0xd8, 0xb7, 0xd0, 0x4d,
+	0x9a, 0xc0, 0xfc, 0x70, 0x60, 0x5b, 0xbe, 0xe0, 0xaa, 0x1c, 0xf6, 0x2c, 0x74, 0x13, 0x4a, 0x16,
-	0x28, 0x5b, 0x58, 0x60, 0x97, 0x5a, 0x44, 0x7e, 0x2c, 0x78, 0x1f, 0x21, 0x98, 0xea, 0x5b, 0xe8,
+	0x16, 0xd8, 0xa5, 0x16, 0x91, 0x8b, 0x05, 0x6f, 0x11, 0x82, 0xa9, 0x9e, 0x85, 0x9e, 0xc2, 0x8a,
-	0x29, 0xac, 0x48, 0x0e, 0x52, 0xbf, 0xd8, 0xcc, 0xb5, 0xab, 0x5b, 0xcd, 0x44, 0x35, 0x65, 0xa0,
+	0xe4, 0x20, 0xb5, 0x8b, 0x8d, 0x5c, 0xab, 0xb2, 0xdd, 0x48, 0x54, 0x53, 0x06, 0x4a, 0x4d, 0x62,
-	0xd4, 0x24, 0x86, 0x82, 0xa3, 0x06, 0x14, 0x39, 0x19, 0x4f, 0x88, 0x2b, 0x78, 0x7d, 0xa5, 0x59,
+	0x28, 0x38, 0xaa, 0xc3, 0x3a, 0x27, 0xa3, 0x09, 0x71, 0x05, 0xaf, 0xad, 0x34, 0x0a, 0xad, 0x82,
-	0x68, 0x17, 0x0c, 0x3d, 0x46, 0xff, 0x81, 0x22, 0x9e, 0x09, 0x3a, 0xb4, 0x2d, 0x5e, 0x5f, 0xf5,
+	0xa1, 0xc7, 0xe8, 0x3f, 0xb0, 0x8e, 0x67, 0x82, 0x0e, 0x6c, 0x8b, 0xd7, 0x56, 0xbd, 0xb5, 0x35,
-	0xbe, 0xad, 0xc9, 0x71, 0xdf, 0xe2, 0xe8, 0x3a, 0x94, 0x18, 0x3d, 0x1e, 0x2a, 0x47, 0xac, 0x79,
+	0x39, 0xee, 0x59, 0x1c, 0x5d, 0x87, 0x22, 0xa3, 0xc7, 0x03, 0xe5, 0x88, 0x35, 0xcf, 0x9a, 0x75,
-	0xd6, 0x14, 0x19, 0x3d, 0xee, 0xca, 0x31, 0xfa, 0x0a, 0x56, 0x6c, 0xf7, 0x3d, 0xe5, 0xf5, 0x62,
+	0x46, 0x8f, 0x3b, 0x72, 0x8c, 0xbe, 0x82, 0x15, 0xdb, 0x7d, 0x4f, 0x79, 0x6d, 0xbd, 0x51, 0x68,
-	0xb3, 0xd0, 0x2e, 0x6f, 0xdd, 0x4a, 0xb4, 0xe5, 0x1b, 0x72, 0xfa, 0x3d, 0x76, 0x66, 0x64, 0x0f,
+	0x95, 0xb6, 0x6f, 0x25, 0xda, 0xf2, 0x0d, 0x39, 0xfd, 0x1e, 0x3b, 0x33, 0xb2, 0x8f, 0x6d, 0x66,
-	0xdb, 0xcc, 0x50, 0xf8, 0xd6, 0x1f, 0x39, 0xb8, 0xd6, 0x23, 0xdc, 0x64, 0xf6, 0x88, 0x0c, 0x7c,
+	0x28, 0x7c, 0xf3, 0x8f, 0x1c, 0x5c, 0xeb, 0x12, 0x6e, 0x32, 0x7b, 0x48, 0xfa, 0xbe, 0x15, 0x1f,
-	0x2b, 0x3e, 0xfe, 0x58, 0xb4, 0xa0, 0x62, 0x52, 0xc7, 0x21, 0xa6, 0xb0, 0xa9, 0xab, 0x43, 0x18,
+	0x7f, 0x2c, 0x9a, 0x50, 0x36, 0xa9, 0xe3, 0x10, 0x53, 0xd8, 0xd4, 0xd5, 0x21, 0x8c, 0xcc, 0xa1,
-	0x99, 0x43, 0xff, 0x03, 0xf0, 0xb7, 0xdb, 0xef, 0xf1, 0x7a, 0xc1, 0xdb, 0x64, 0x68, 0xa6, 0x35,
+	0xff, 0x01, 0xf8, 0xdb, 0xed, 0x75, 0x79, 0xad, 0xe0, 0x6d, 0x32, 0x34, 0xd3, 0x9c, 0x41, 0xd5,
-	0x83, 0x9a, 0x6f, 0x88, 0x24, 0xee, 0xbb, 0xef, 0xe9, 0x02, 0x6d, 0x2e, 0x81, 0xb6, 0x09, 0xe5,
+	0x37, 0x44, 0x12, 0xf7, 0xdc, 0xf7, 0x74, 0x81, 0x36, 0x97, 0x40, 0xdb, 0x80, 0xd2, 0x14, 0x33,
-	0x29, 0x66, 0xc2, 0x8e, 0x28, 0x87, 0xa7, 0x64, 0xae, 0x68, 0x19, 0x3f, 0x9c, 0xf3, 0x89, 0xd6,
+	0x61, 0x47, 0x94, 0xc3, 0x53, 0x32, 0x57, 0xb4, 0x8c, 0x1f, 0xce, 0xf9, 0x44, 0xf3, 0xef, 0x3c,
-	0x3f, 0x79, 0xa8, 0xf8, 0xba, 0x52, 0x93, 0xa3, 0x1e, 0x94, 0xe4, 0x9e, 0x86, 0xd2, 0x4f, 0xbe,
+	0x94, 0x7d, 0x5d, 0xa9, 0xc9, 0x51, 0x17, 0x8a, 0x72, 0x4f, 0x03, 0xe9, 0x27, 0xdf, 0x05, 0x77,
-	0x0b, 0xee, 0x76, 0x92, 0x2b, 0x50, 0x27, 0x66, 0xb0, 0x51, 0x1c, 0x05, 0xa6, 0xf7, 0xa0, 0x6c,
+	0xdb, 0xc9, 0x15, 0xa8, 0x1d, 0x33, 0xd8, 0x58, 0x1f, 0x06, 0xa6, 0x77, 0xa1, 0x64, 0xbb, 0x16,
-	0xbb, 0x16, 0x39, 0x19, 0xaa, 0xf0, 0xe4, 0xbd, 0xf0, 0xdc, 0x8e, 0xf2, 0xc8, 0x2a, 0xd4, 0xd1,
+	0x39, 0x19, 0xa8, 0xf0, 0xe4, 0xbd, 0xf0, 0xdc, 0x8e, 0xf2, 0xc8, 0x2a, 0xd4, 0xd6, 0xda, 0x16,
-	0xda, 0x16, 0x39, 0xf1, 0x38, 0xc0, 0x0e, 0x7e, 0x72, 0x44, 0xe0, 0x12, 0x39, 0x11, 0x0c, 0x0f,
+	0x39, 0xf1, 0x38, 0xc0, 0x0e, 0x7e, 0x72, 0x44, 0xe0, 0x12, 0x39, 0x11, 0x0c, 0x0f, 0xc2, 0x5c,
-	0xc3, 0x5c, 0x05, 0x8f, 0xeb, 0xeb, 0x33, 0x6c, 0xf2, 0x08, 0x3a, 0x2f, 0xe5, 0x6a, 0xcd, 0xcd,
+	0x05, 0x8f, 0xeb, 0xeb, 0x33, 0x6c, 0xf2, 0x08, 0xda, 0x2f, 0xe5, 0xd7, 0x9a, 0x9b, 0xbf, 0x74,
-	0x5f, 0xba, 0x82, 0x9d, 0x1a, 0x35, 0x12, 0x9d, 0x6d, 0xfc, 0x02, 0x97, 0x93, 0x80, 0x68, 0x03,
+	0x05, 0x3b, 0x35, 0xaa, 0x24, 0x3a, 0x5b, 0xff, 0x05, 0x2e, 0x27, 0x01, 0xd1, 0x26, 0x14, 0x0e,
-	0x0a, 0x87, 0xe4, 0xd4, 0x77, 0xbb, 0xfc, 0x89, 0xb6, 0x60, 0xe5, 0x48, 0x1e, 0x25, 0xcf, 0xcf,
+	0xc9, 0xa9, 0xef, 0x76, 0xf9, 0x13, 0x6d, 0xc3, 0xca, 0x91, 0x3c, 0x4a, 0x9e, 0x9f, 0x17, 0xce,
-	0x0b, 0x67, 0xc3, 0xdb, 0xd0, 0x7c, 0x27, 0x0a, 0xfa, 0x3c, 0xff, 0x2c, 0xd7, 0xfa, 0x3b, 0x0f,
+	0x86, 0xb7, 0xa1, 0xf9, 0x4e, 0x14, 0xf4, 0x79, 0xfe, 0x59, 0xae, 0xf9, 0x57, 0x1e, 0x6a, 0x8b,
-	0xf5, 0xc5, 0xe3, 0xf6, 0x29, 0xb5, 0x22, 0xcb, 0x91, 0x1b, 0xc3, 0xba, 0x1f, 0xe8, 0x88, 0xeb,
+	0xc7, 0xed, 0x53, 0x6a, 0x45, 0x96, 0x23, 0x37, 0x82, 0x0d, 0x3f, 0xd0, 0x11, 0xd7, 0xed, 0xa4,
-	0xb6, 0xd3, 0x5c, 0x97, 0x66, 0x61, 0xc4, 0xa7, 0xca, 0x87, 0x15, 0x1e, 0x9a, 0x6a, 0x10, 0xb8,
+	0xb9, 0x2e, 0xcd, 0xc2, 0x88, 0x4f, 0x95, 0x0f, 0xcb, 0x3c, 0x34, 0x55, 0x27, 0x70, 0x69, 0x01,
-	0xb4, 0x00, 0x49, 0xf0, 0xde, 0xf3, 0xa8, 0xf7, 0xee, 0x64, 0x09, 0x61, 0xd8, 0x8b, 0x16, 0x5c,
+	0x92, 0xe0, 0xbd, 0xe7, 0x51, 0xef, 0xdd, 0xc9, 0x12, 0xc2, 0xb0, 0x17, 0x2d, 0xb8, 0xbc, 0x4b,
-	0xde, 0x21, 0xa2, 0xcb, 0x88, 0x45, 0x5c, 0x61, 0x63, 0xe7, 0xe3, 0x13, 0xb6, 0x01, 0xc5, 0x19,
+	0x44, 0x87, 0x11, 0x8b, 0xb8, 0xc2, 0xc6, 0xce, 0xc7, 0x27, 0x6c, 0x1d, 0xd6, 0x67, 0x5c, 0xf6,
-	0x97, 0xfd, 0x71, 0xa2, 0x8c, 0x29, 0x19, 0x7a, 0xdc, 0xfa, 0x3d, 0x07, 0x57, 0x62, 0x32, 0x9f,
+	0xc7, 0x89, 0x32, 0xa6, 0x68, 0xe8, 0x71, 0xf3, 0xf7, 0x1c, 0x5c, 0x89, 0xc9, 0x7c, 0x4a, 0xa0,
-	0x12, 0xa8, 0x25, 0x52, 0xf2, 0xdb, 0x14, 0x73, 0x7e, 0x4c, 0x99, 0x2a, 0xb4, 0x25, 0x43, 0x8f,
+	0x96, 0x48, 0xc9, 0xb5, 0x29, 0xe6, 0xfc, 0x98, 0x32, 0x55, 0x68, 0x8b, 0x86, 0x1e, 0x6f, 0xff,
-	0xb7, 0xfe, 0xbc, 0x09, 0x25, 0x83, 0x52, 0xd1, 0x95, 0x2e, 0x41, 0x0e, 0x20, 0x69, 0x13, 0x9d,
+	0x73, 0x13, 0x8a, 0x06, 0xa5, 0xa2, 0x23, 0x5d, 0x82, 0x1c, 0x40, 0xd2, 0x26, 0x3a, 0x99, 0x52,
-	0x4c, 0xa9, 0x4b, 0x5c, 0x55, 0x58, 0x39, 0xea, 0x44, 0x0d, 0xf0, 0x07, 0x8b, 0x40, 0xdf, 0x51,
+	0x97, 0xb8, 0xaa, 0xb0, 0x72, 0xd4, 0x8e, 0x1a, 0xe0, 0x0f, 0x16, 0x81, 0xbe, 0xa3, 0xea, 0x77,
-	0x8d, 0x3b, 0x89, 0xf8, 0x18, 0xb8, 0x75, 0x01, 0x4d, 0x3c, 0x35, 0xd9, 0xab, 0xdf, 0xd8, 0xe6,
+	0x12, 0xf1, 0x31, 0x70, 0xf3, 0x02, 0x9a, 0x78, 0x6a, 0xb2, 0x57, 0xbf, 0xb1, 0xcd, 0xc3, 0xce,
-	0x61, 0xf7, 0x00, 0xbb, 0x2e, 0x71, 0xd0, 0xe3, 0xe8, 0x6a, 0x7d, 0xc3, 0x58, 0x84, 0x06, 0x7a,
+	0x18, 0xbb, 0x2e, 0x71, 0xd0, 0xe3, 0xe8, 0xd7, 0xfa, 0x86, 0xb1, 0x08, 0x0d, 0xf4, 0x6e, 0x27,
-	0xb7, 0x13, 0xf5, 0x06, 0x82, 0xd9, 0xee, 0x38, 0xf0, 0x6a, 0xeb, 0x02, 0xfa, 0xe0, 0xc5, 0x55,
+	0xea, 0xf5, 0x05, 0xb3, 0xdd, 0x51, 0xe0, 0xd5, 0xe6, 0x05, 0xf4, 0xc1, 0x8b, 0xab, 0x54, 0xb7,
-	0xaa, 0xdb, 0x5c, 0xd8, 0x26, 0x0f, 0x04, 0xb7, 0xd2, 0x05, 0x17, 0xc0, 0xe7, 0x94, 0x1c, 0xc2,
+	0xb9, 0xb0, 0x4d, 0x1e, 0x08, 0x6e, 0xa7, 0x0b, 0x2e, 0x80, 0xcf, 0x29, 0x39, 0x80, 0xcd, 0x0e,
-	0x46, 0x97, 0x11, 0x2c, 0x48, 0x57, 0x27, 0x0c, 0x7a, 0x98, 0xec, 0x9d, 0x18, 0x2c, 0x10, 0x5a,
+	0x23, 0x58, 0x90, 0x8e, 0x4e, 0x18, 0xf4, 0x30, 0xd9, 0x3b, 0x31, 0x58, 0x20, 0xb4, 0x2c, 0xf8,
-	0x16, 0xfc, 0xd6, 0x05, 0xf4, 0x13, 0x54, 0x7b, 0x8c, 0x4e, 0x43, 0xf4, 0xf7, 0x13, 0xe9, 0xa3,
+	0xcd, 0x0b, 0xe8, 0x27, 0xa8, 0x74, 0x19, 0x9d, 0x86, 0xe8, 0xef, 0x27, 0xd2, 0x47, 0x41, 0x19,
-	0xa0, 0x8c, 0xe4, 0x43, 0x58, 0x7f, 0x85, 0x79, 0x88, 0xfb, 0x5e, 0x22, 0x77, 0x04, 0x13, 0x50,
+	0xc9, 0x07, 0xb0, 0xf1, 0x0a, 0xf3, 0x10, 0xf7, 0xbd, 0x44, 0xee, 0x08, 0x26, 0xa0, 0xbe, 0x95,
-	0xdf, 0x4a, 0x84, 0x6e, 0x53, 0xea, 0x84, 0xdc, 0x73, 0x0c, 0x28, 0x28, 0x06, 0x21, 0x95, 0xe4,
+	0x08, 0xdd, 0xa1, 0xd4, 0x09, 0xb9, 0xe7, 0x18, 0x50, 0x50, 0x0c, 0x42, 0x2a, 0xc9, 0xc7, 0x6d,
-	0xe3, 0xb6, 0x08, 0x0c, 0xa4, 0x36, 0x33, 0xe3, 0xb5, 0xf0, 0x5b, 0x28, 0x2b, 0x87, 0xbf, 0x70,
+	0x11, 0x18, 0x48, 0x6d, 0x65, 0xc6, 0x6b, 0xe1, 0xb7, 0x50, 0x52, 0x0e, 0x7f, 0xe1, 0xd8, 0x98,
-	0x6c, 0xcc, 0xd1, 0xdd, 0x25, 0x21, 0xf1, 0x10, 0x19, 0x1d, 0xf6, 0x1d, 0x94, 0xa4, 0xa3, 0x15,
+	0xa3, 0xbb, 0x4b, 0x42, 0xe2, 0x21, 0x32, 0x3a, 0xec, 0x3b, 0x28, 0x4a, 0x47, 0x2b, 0xd2, 0xff,
-	0xe9, 0xff, 0x53, 0x03, 0x71, 0x1e, 0xca, 0x01, 0xc0, 0x0b, 0x47, 0x10, 0xa6, 0x38, 0xbf, 0x48,
+	0xa7, 0x06, 0xe2, 0x3c, 0x94, 0x7d, 0x80, 0x17, 0x8e, 0x20, 0x4c, 0x71, 0x7e, 0x91, 0xc8, 0x39,
-	0xe4, 0x9c, 0x03, 0x32, 0x92, 0xba, 0x50, 0x1b, 0x1c, 0xc8, 0xcb, 0x4d, 0xe0, 0x1a, 0x8e, 0x1e,
+	0x07, 0x64, 0x24, 0x75, 0xa1, 0xda, 0x1f, 0xcb, 0xcb, 0x4d, 0xe0, 0x1a, 0x8e, 0x1e, 0x24, 0x1f,
-	0x24, 0x1f, 0xe8, 0x28, 0x2a, 0xa0, 0x7f, 0x98, 0x0d, 0xac, 0xdd, 0xbd, 0x2f, 0x6f, 0xae, 0x82,
+	0xe8, 0x28, 0x2a, 0xa0, 0x7f, 0x98, 0x0d, 0xac, 0xdd, 0x7d, 0x20, 0x6f, 0xae, 0x82, 0xb0, 0x50,
-	0xb0, 0x50, 0x90, 0x1f, 0xa4, 0xef, 0xe4, 0xdc, 0xe7, 0x74, 0x1f, 0x6a, 0x2a, 0x56, 0x7b, 0xc1,
+	0x90, 0x1f, 0xa4, 0xef, 0xe4, 0xdc, 0xe7, 0xf4, 0x00, 0xaa, 0x2a, 0x56, 0xfb, 0xc1, 0x7d, 0x24,
-	0x7d, 0x24, 0x85, 0x3e, 0x86, 0xca, 0x48, 0xff, 0x03, 0xac, 0xcb, 0xa8, 0xcd, 0xc9, 0xef, 0xa5,
+	0x85, 0x3e, 0x86, 0xca, 0x48, 0xff, 0x03, 0x6c, 0xc8, 0xa8, 0xcd, 0xc9, 0xef, 0xa5, 0x46, 0xf6,
-	0x46, 0xf6, 0xbc, 0xd4, 0xfb, 0x50, 0x79, 0x85, 0xf9, 0x9c, 0xb9, 0x9d, 0x96, 0x60, 0x0b, 0xc4,
+	0xbc, 0xd4, 0x07, 0x50, 0x7e, 0x85, 0xf9, 0x9c, 0xb9, 0x95, 0x96, 0x60, 0x0b, 0xc4, 0x99, 0xf2,
-	0x99, 0xf2, 0xeb, 0x10, 0xaa, 0x32, 0x28, 0x7a, 0x31, 0x4f, 0xa9, 0x0e, 0x51, 0x50, 0x20, 0xf1,
+	0xeb, 0x10, 0x2a, 0x32, 0x28, 0xfa, 0x63, 0x9e, 0x52, 0x1d, 0xa2, 0xa0, 0x40, 0xe2, 0x41, 0x26,
-	0x20, 0x13, 0x56, 0x8b, 0x11, 0xa8, 0xc8, 0x6f, 0x41, 0x57, 0x4f, 0xd9, 0x4b, 0x18, 0x12, 0x08,
+	0xac, 0x16, 0x23, 0x50, 0x96, 0x6b, 0x41, 0x57, 0x4f, 0xd9, 0x4b, 0x18, 0x12, 0x08, 0xdd, 0xcb,
-	0xdd, 0xcb, 0x80, 0x0c, 0x55, 0xf1, 0x6a, 0xf4, 0x89, 0x87, 0x1e, 0xa5, 0x35, 0xf8, 0xc4, 0xc7,
+	0x80, 0x0c, 0x55, 0xf1, 0x4a, 0xf4, 0x89, 0x87, 0x1e, 0xa5, 0x35, 0xf8, 0xc4, 0xc7, 0x66, 0xbd,
-	0x66, 0xa3, 0x93, 0x15, 0xae, 0x25, 0x7f, 0x86, 0x35, 0xff, 0xe1, 0x15, 0x4f, 0xc0, 0xd8, 0x62,
+	0x9d, 0x15, 0xae, 0x25, 0x7f, 0x86, 0x35, 0xff, 0xe1, 0x15, 0x4f, 0xc0, 0xd8, 0xc7, 0xfa, 0xcd,
-	0xfd, 0xe6, 0x6b, 0xdc, 0x3d, 0x13, 0xa7, 0xd9, 0x31, 0x5c, 0x79, 0x3b, 0xb5, 0x64, 0xf1, 0x57,
+	0x57, 0xbf, 0x7b, 0x26, 0x4e, 0xb3, 0x63, 0xb8, 0xf2, 0x76, 0x6a, 0xc9, 0xe2, 0xaf, 0x5a, 0x4c,
-	0x2d, 0x26, 0x68, 0x72, 0xf1, 0x63, 0xa6, 0xfb, 0x52, 0x0c, 0xb7, 0xcb, 0xc7, 0x67, 0x1d, 0x33,
+	0xd0, 0xe4, 0xe2, 0xc7, 0x4c, 0xf7, 0xa5, 0x18, 0x6e, 0x8f, 0x8f, 0xce, 0x3a, 0x66, 0x0c, 0xfe,
-	0x06, 0xff, 0xed, 0xbb, 0x47, 0xd8, 0xb1, 0xad, 0x48, 0x8f, 0xd9, 0x25, 0x02, 0x77, 0xb1, 0x79,
+	0xdb, 0x73, 0x8f, 0xb0, 0x63, 0x5b, 0x91, 0x1e, 0xb3, 0x47, 0x04, 0xee, 0x60, 0x73, 0x4c, 0xe2,
-	0x40, 0xe2, 0x2d, 0x50, 0xbd, 0xe2, 0xa3, 0x4b, 0x34, 0x38, 0xe3, 0xd1, 0xfe, 0x15, 0x90, 0x2a,
+	0x2d, 0x50, 0xbd, 0xe2, 0xa3, 0x9f, 0x68, 0x70, 0xc6, 0xa3, 0xfd, 0x2b, 0x20, 0x55, 0x10, 0xdc,
-	0x08, 0xee, 0x7b, 0x7b, 0x3c, 0x63, 0x58, 0x9d, 0xbf, 0xb4, 0xe6, 0xbe, 0x08, 0x0d, 0x64, 0xbe,
+	0xf7, 0xf6, 0x68, 0xc6, 0xb0, 0x3a, 0x7f, 0x69, 0xcd, 0x7d, 0x11, 0x1a, 0xc8, 0x7c, 0x79, 0x8e,
-	0x3c, 0xc7, 0x8a, 0x50, 0xdf, 0x85, 0x1d, 0x22, 0x76, 0x89, 0x60, 0xb6, 0x99, 0x56, 0x35, 0xe7,
+	0x2f, 0x42, 0x7d, 0x17, 0x76, 0x89, 0xd8, 0x23, 0x82, 0xd9, 0x66, 0x5a, 0xd5, 0x9c, 0x03, 0x52,
-	0x80, 0x94, 0xa0, 0x25, 0xe0, 0xb4, 0xc0, 0x00, 0x56, 0xd5, 0xdb, 0x13, 0xb5, 0x12, 0x17, 0x05,
+	0x82, 0x96, 0x80, 0xd3, 0x02, 0x7d, 0x58, 0x55, 0x6f, 0x4f, 0xd4, 0x4c, 0xfc, 0x28, 0x78, 0x39,
-	0x2f, 0xe7, 0x65, 0xb7, 0x05, 0xfd, 0xba, 0x0e, 0xa5, 0xeb, 0x0e, 0x11, 0xa1, 0x37, 0x6d, 0x4a,
+	0x2f, 0xbb, 0x2d, 0xe8, 0xd7, 0x75, 0x28, 0x5d, 0x77, 0x89, 0x08, 0xbd, 0x69, 0x53, 0xd2, 0x35,
-	0xba, 0x46, 0x41, 0xcb, 0xd3, 0x35, 0x8e, 0xd5, 0x62, 0x2e, 0xd4, 0xbe, 0xb5, 0xb9, 0xff, 0xf1,
+	0x0a, 0x5a, 0x9e, 0xae, 0x71, 0xac, 0x16, 0x73, 0xa1, 0xfa, 0xad, 0xcd, 0xfd, 0xc5, 0x37, 0x98,
-	0x0d, 0xe6, 0x87, 0x69, 0x3d, 0x20, 0x86, 0x5a, 0xde, 0x03, 0x16, 0xc0, 0x21, 0x8f, 0x55, 0x0c,
+	0x1f, 0xa6, 0xf5, 0x80, 0x18, 0x6a, 0x79, 0x0f, 0x58, 0x00, 0x87, 0x3c, 0x56, 0x36, 0x88, 0x5c,
-	0x22, 0x3f, 0xf8, 0x7e, 0x4b, 0xbd, 0x96, 0x87, 0xff, 0x74, 0x38, 0xeb, 0x90, 0xbd, 0xd3, 0xf7,
+	0xf0, 0xfd, 0x96, 0x7a, 0x2d, 0x0f, 0xff, 0xe9, 0x70, 0xd6, 0x21, 0x7b, 0xa7, 0xef, 0x57, 0xfa,
-	0x2b, 0x7d, 0x8d, 0x8e, 0xf7, 0xdd, 0x79, 0xda, 0x68, 0x88, 0xbc, 0xf1, 0x67, 0x60, 0xf6, 0xb3,
+	0x1a, 0x1d, 0xef, 0xbb, 0xf3, 0xb4, 0xd1, 0x10, 0x79, 0xe3, 0xcf, 0xc0, 0xec, 0x67, 0xe5, 0xe7,
-	0xf2, 0x73, 0x33, 0x0f, 0x61, 0xa3, 0x47, 0x1c, 0x12, 0x61, 0x7e, 0x98, 0x72, 0x85, 0x89, 0xc2,
+	0x66, 0x1e, 0xc0, 0x66, 0x97, 0x38, 0x24, 0xc2, 0xfc, 0x30, 0xe5, 0x0a, 0x13, 0x85, 0x65, 0xcc,
-	0x32, 0x66, 0xde, 0x01, 0xac, 0xcb, 0x30, 0xc8, 0x75, 0x6f, 0x39, 0x61, 0x3c, 0xa5, 0x5f, 0x45,
+	0xbc, 0x31, 0x6c, 0xc8, 0x30, 0xc8, 0xef, 0xde, 0x72, 0xc2, 0x78, 0x4a, 0xbf, 0x8a, 0x60, 0x02,
-	0x30, 0x01, 0xf5, 0xfd, 0x2c, 0xd0, 0xd0, 0x19, 0x5a, 0x8f, 0x3c, 0x61, 0xe2, 0xfb, 0x98, 0x07,
+	0xea, 0xfb, 0x59, 0xa0, 0xa1, 0x33, 0xb4, 0x11, 0x79, 0xc2, 0xc4, 0xf7, 0x31, 0x0f, 0x6a, 0xd2,
-	0x35, 0xe9, 0x41, 0xd5, 0x78, 0x94, 0x11, 0x1d, 0x3a, 0x43, 0xa0, 0xc2, 0x6d, 0x50, 0x87, 0xa4,
+	0x83, 0xaa, 0xfe, 0x28, 0x23, 0x3a, 0x74, 0x86, 0x40, 0x85, 0xdb, 0xa0, 0x0e, 0x49, 0x49, 0xeb,
-	0xa4, 0xf5, 0x1c, 0x90, 0xd1, 0x5d, 0xaf, 0xa1, 0x28, 0x5b, 0xb7, 0x47, 0x79, 0x27, 0xb5, 0xb3,
+	0x39, 0x20, 0xa3, 0xbb, 0x5e, 0xc3, 0xba, 0x6c, 0xdd, 0x1e, 0xe5, 0x9d, 0xd4, 0xce, 0x7e, 0x0e,
-	0x9f, 0x83, 0x70, 0x1f, 0x6a, 0xaf, 0xa7, 0x84, 0x61, 0x41, 0xa4, 0xbf, 0x3c, 0xde, 0xe4, 0xcc,
+	0xc2, 0x03, 0xa8, 0xbe, 0x9e, 0x12, 0x86, 0x05, 0x91, 0xfe, 0xf2, 0x78, 0x93, 0x33, 0x2b, 0x86,
-	0x8a, 0xa1, 0x32, 0xdf, 0xca, 0x61, 0x40, 0x64, 0x05, 0x5f, 0xe2, 0x84, 0x39, 0x60, 0x79, 0x6d,
+	0xca, 0x7c, 0x2b, 0x87, 0x3e, 0x91, 0x15, 0x7c, 0x89, 0x13, 0xe6, 0x80, 0xe5, 0xb5, 0x2d, 0x8c,
-	0x0b, 0xe3, 0xc2, 0xc5, 0x53, 0xcd, 0x4b, 0xc3, 0x96, 0x0a, 0x78, 0x96, 0x67, 0x10, 0x50, 0xb8,
+	0x0b, 0x17, 0x4f, 0x35, 0x2f, 0x0d, 0x5b, 0x2a, 0xe0, 0x59, 0x9e, 0x41, 0x40, 0xe1, 0xc2, 0xaf,
-	0xf0, 0xab, 0xc8, 0xdf, 0xfa, 0x1e, 0xb3, 0x8f, 0x6c, 0x87, 0x8c, 0x49, 0x4a, 0x06, 0xc4, 0x61,
+	0x22, 0x7f, 0xeb, 0xfb, 0xcc, 0x3e, 0xb2, 0x1d, 0x32, 0x22, 0x29, 0x19, 0x10, 0x87, 0x65, 0x74,
-	0x19, 0x5d, 0x34, 0x82, 0xb2, 0x12, 0xde, 0x61, 0xd8, 0x15, 0x68, 0x99, 0x69, 0x1e, 0x22, 0xa0,
+	0xd1, 0x10, 0x4a, 0x4a, 0x78, 0x97, 0x61, 0x57, 0xa0, 0x65, 0xa6, 0x79, 0x88, 0x80, 0xb6, 0x75,
-	0x6d, 0x9f, 0x0d, 0xd4, 0x9b, 0x30, 0x01, 0x64, 0x5a, 0xec, 0x51, 0xc7, 0x36, 0x4f, 0xe3, 0x97,
+	0x36, 0x50, 0x6f, 0xc2, 0x04, 0x90, 0x69, 0xb1, 0x4f, 0x1d, 0xdb, 0x3c, 0x8d, 0x5f, 0x76, 0x74,
-	0x1d, 0x5d, 0x1a, 0xe6, 0x90, 0x94, 0xcb, 0x4e, 0x22, 0x32, 0x10, 0xd9, 0x7e, 0xf6, 0xe3, 0xd3,
+	0x69, 0x98, 0x43, 0x52, 0x2e, 0x3b, 0x89, 0x48, 0x2d, 0x32, 0x84, 0x52, 0x67, 0x4c, 0xcc, 0xc3,
-	0xb1, 0x2d, 0x0e, 0x66, 0x23, 0xb9, 0xc5, 0x4d, 0xb5, 0xf0, 0x91, 0x4d, 0xfd, 0x5f, 0x9b, 0xc1,
+	0x57, 0x04, 0x3b, 0x62, 0x9c, 0xf6, 0x4e, 0x99, 0x23, 0x96, 0x6f, 0x24, 0x02, 0x0c, 0x34, 0x76,
-	0xe2, 0x4d, 0x8f, 0x6b, 0x53, 0x27, 0xd0, 0x74, 0x34, 0x5a, 0xf5, 0xa6, 0x9e, 0xfc, 0x1b, 0x00,
+	0x9e, 0xfd, 0xf8, 0x74, 0x64, 0x8b, 0xf1, 0x6c, 0x28, 0xdd, 0xb8, 0xa5, 0xa0, 0x8f, 0x6c, 0xea,
-	0x00, 0xff, 0xff, 0x45, 0x45, 0x76, 0x4c, 0xe8, 0x17, 0x00, 0x00,
+	0xff, 0xda, 0x0a, 0x0c, 0xdc, 0xf2, 0xa8, 0xb6, 0x74, 0x92, 0x4e, 0x87, 0xc3, 0x55, 0x6f, 0xea,
+	0xc9, 0xbf, 0x01, 0x00, 0x00, 0xff, 0xff, 0x94, 0x82, 0xd4, 0x6e, 0x4c, 0x18, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -876,6 +877,7 @@ type RootCoordClient interface {
 	OperatePrivilege(ctx context.Context, in *milvuspb.OperatePrivilegeRequest, opts ...grpc.CallOption) (*commonpb.Status, error)
 	SelectGrant(ctx context.Context, in *milvuspb.SelectGrantRequest, opts ...grpc.CallOption) (*milvuspb.SelectGrantResponse, error)
 	ListPolicy(ctx context.Context, in *internalpb.ListPolicyRequest, opts ...grpc.CallOption) (*internalpb.ListPolicyResponse, error)
+	CheckHealth(ctx context.Context, in *milvuspb.CheckHealthRequest, opts ...grpc.CallOption) (*milvuspb.CheckHealthResponse, error)
 }
 
 type rootCoordClient struct {
@@ -1246,6 +1248,15 @@ func (c *rootCoordClient) ListPolicy(ctx context.Context, in *internalpb.ListPol
 	return out, nil
 }
 
+func (c *rootCoordClient) CheckHealth(ctx context.Context, in *milvuspb.CheckHealthRequest, opts ...grpc.CallOption) (*milvuspb.CheckHealthResponse, error) {
+	out := new(milvuspb.CheckHealthResponse)
+	err := c.cc.Invoke(ctx, "/milvus.proto.rootcoord.RootCoord/CheckHealth", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 // RootCoordServer is the server API for RootCoord service.
 type RootCoordServer interface {
 	GetComponentStates(context.Context, *milvuspb.GetComponentStatesRequest) (*milvuspb.ComponentStates, error)
@@ -1340,6 +1351,7 @@ type RootCoordServer interface {
 	OperatePrivilege(context.Context, *milvuspb.OperatePrivilegeRequest) (*commonpb.Status, error)
 	SelectGrant(context.Context, *milvuspb.SelectGrantRequest) (*milvuspb.SelectGrantResponse, error)
 	ListPolicy(context.Context, *internalpb.ListPolicyRequest) (*internalpb.ListPolicyResponse, error)
+	CheckHealth(context.Context, *milvuspb.CheckHealthRequest) (*milvuspb.CheckHealthResponse, error)
 }
 
 // UnimplementedRootCoordServer can be embedded to have forward compatible implementations.
@@ -1466,6 +1478,9 @@ func (*UnimplementedRootCoordServer) SelectGrant(ctx context.Context, req *milvu
 func (*UnimplementedRootCoordServer) ListPolicy(ctx context.Context, req *internalpb.ListPolicyRequest) (*internalpb.ListPolicyResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method ListPolicy not implemented")
 }
+func (*UnimplementedRootCoordServer) CheckHealth(ctx context.Context, req *milvuspb.CheckHealthRequest) (*milvuspb.CheckHealthResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method CheckHealth not implemented")
+}
 
 func RegisterRootCoordServer(s *grpc.Server, srv RootCoordServer) {
 	s.RegisterService(&_RootCoord_serviceDesc, srv)
@@ -2191,6 +2206,24 @@ func _RootCoord_ListPolicy_Handler(srv interface{}, ctx context.Context, dec fun
 	return interceptor(ctx, in, info, handler)
 }
 
+func _RootCoord_CheckHealth_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(milvuspb.CheckHealthRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(RootCoordServer).CheckHealth(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/milvus.proto.rootcoord.RootCoord/CheckHealth",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(RootCoordServer).CheckHealth(ctx, req.(*milvuspb.CheckHealthRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 var _RootCoord_serviceDesc = grpc.ServiceDesc{
 	ServiceName: "milvus.proto.rootcoord.RootCoord",
 	HandlerType: (*RootCoordServer)(nil),
@@ -2355,6 +2388,10 @@ var _RootCoord_serviceDesc = grpc.ServiceDesc{
 			MethodName: "ListPolicy",
 			Handler:    _RootCoord_ListPolicy_Handler,
 		},
+		{
+			MethodName: "CheckHealth",
+			Handler:    _RootCoord_CheckHealth_Handler,
+		},
 	},
 	Streams:  []grpc.StreamDesc{},
 	Metadata: "root_coord.proto",

internal/proxy/data_coord_mock_test.go

@@ -39,6 +39,7 @@ type DataCoordMock struct {
 	showConfigurationsFunc showConfigurationsFuncType
 	statisticsChannel      string
 	timeTickChannel        string
+	checkHealthFunc        func(ctx context.Context, req *milvuspb.CheckHealthRequest) (*milvuspb.CheckHealthResponse, error)
 }
 
 func (coord *DataCoordMock) updateState(state commonpb.StateCode) {
@@ -130,6 +131,13 @@ func (coord *DataCoordMock) BroadcastAlteredCollection(ctx context.Context, req
 	panic("implement me")
 }
 
+func (coord *DataCoordMock) CheckHealth(ctx context.Context, req *milvuspb.CheckHealthRequest) (*milvuspb.CheckHealthResponse, error) {
+	if coord.checkHealthFunc != nil {
+		return coord.checkHealthFunc(ctx, req)
+	}
+	return &milvuspb.CheckHealthResponse{IsHealthy: true}, nil
+}
+
 func (coord *DataCoordMock) AssignSegmentID(ctx context.Context, req *datapb.AssignSegmentIDRequest) (*datapb.AssignSegmentIDResponse, error) {
 	panic("implement me")
 }

internal/proxy/impl.go

@@ -22,6 +22,9 @@ import (
 	"fmt"
 	"os"
 	"strconv"
+	"sync"
+
+	"golang.org/x/sync/errgroup"
 
 	"github.com/golang/protobuf/proto"
 	"github.com/milvus-io/milvus-proto/go-api/commonpb"
@@ -4587,3 +4590,61 @@ func (node *Proxy) SetRates(ctx context.Context, request *proxypb.SetRatesReques
 	resp.ErrorCode = commonpb.ErrorCode_Success
 	return resp, nil
 }
+
+func (node *Proxy) CheckHealth(ctx context.Context, request *milvuspb.CheckHealthRequest) (*milvuspb.CheckHealthResponse, error) {
+	if !node.checkHealthy() {
+		reason := errorutil.UnHealthReason("proxy", node.session.ServerID, "proxy is unhealthy")
+		return &milvuspb.CheckHealthResponse{IsHealthy: false, Reasons: []string{reason}}, nil
+	}
+
+	group, ctx := errgroup.WithContext(ctx)
+	errReasons := make([]string, 0)
+
+	mu := &sync.Mutex{}
+	fn := func(role string, resp *milvuspb.CheckHealthResponse, err error) error {
+		mu.Lock()
+		defer mu.Unlock()
+
+		if err != nil {
+			log.Warn("check health fail,", zap.String("role", role), zap.Error(err))
+			errReasons = append(errReasons, fmt.Sprintf("check health fail for %s", role))
+			return err
+		}
+
+		if !resp.IsHealthy {
+			log.Warn("check health fail,", zap.String("role", role))
+			errReasons = append(errReasons, resp.Reasons...)
+		}
+		return nil
+	}
+
+	group.Go(func() error {
+		resp, err := node.rootCoord.CheckHealth(ctx, request)
+		return fn("rootcoord", resp, err)
+	})
+
+	group.Go(func() error {
+		resp, err := node.queryCoord.CheckHealth(ctx, request)
+		return fn("querycoord", resp, err)
+	})
+
+	group.Go(func() error {
+		resp, err := node.dataCoord.CheckHealth(ctx, request)
+		return fn("datacoord", resp, err)
+	})
+
+	group.Go(func() error {
+		resp, err := node.indexCoord.CheckHealth(ctx, request)
+		return fn("indexcoord", resp, err)
+	})
+
+	err := group.Wait()
+	if err != nil || len(errReasons) != 0 {
+		return &milvuspb.CheckHealthResponse{
+			IsHealthy: false,
+			Reasons:   errReasons,
+		}, nil
+	}
+
+	return &milvuspb.CheckHealthResponse{IsHealthy: true}, nil
+}

internal/proxy/impl_test.go

@@ -4,9 +4,13 @@ import (
 	"context"
 	"testing"
 
+	"github.com/pkg/errors"
+
 	"github.com/milvus-io/milvus-proto/go-api/commonpb"
+	"github.com/milvus-io/milvus-proto/go-api/milvuspb"
 	"github.com/milvus-io/milvus/internal/log"
 	"github.com/milvus-io/milvus/internal/proto/proxypb"
+	"github.com/milvus-io/milvus/internal/util/sessionutil"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -32,3 +36,68 @@ func TestProxy_InvalidateCollectionMetaCache_remove_stream(t *testing.T) {
 	assert.NoError(t, err)
 	assert.Equal(t, commonpb.ErrorCode_Success, status.GetErrorCode())
 }
+
+func TestProxy_CheckHealth(t *testing.T) {
+	t.Run("not healthy", func(t *testing.T) {
+		node := &Proxy{session: &sessionutil.Session{ServerID: 1}}
+		node.stateCode.Store(commonpb.StateCode_Abnormal)
+		ctx := context.Background()
+		resp, err := node.CheckHealth(ctx, &milvuspb.CheckHealthRequest{})
+		assert.NoError(t, err)
+		assert.Equal(t, false, resp.IsHealthy)
+		assert.Equal(t, 1, len(resp.Reasons))
+	})
+
+	t.Run("proxy health check is ok", func(t *testing.T) {
+		node := &Proxy{
+			rootCoord:  NewRootCoordMock(),
+			queryCoord: NewQueryCoordMock(),
+			dataCoord:  NewDataCoordMock(),
+			indexCoord: NewIndexCoordMock(),
+			session:    &sessionutil.Session{ServerID: 1},
+		}
+		node.stateCode.Store(commonpb.StateCode_Healthy)
+		ctx := context.Background()
+		resp, err := node.CheckHealth(ctx, &milvuspb.CheckHealthRequest{})
+		assert.NoError(t, err)
+		assert.Equal(t, true, resp.IsHealthy)
+		assert.Empty(t, resp.Reasons)
+	})
+
+	t.Run("proxy health check is fail", func(t *testing.T) {
+		checkHealthFunc1 := func(ctx context.Context,
+			req *milvuspb.CheckHealthRequest) (*milvuspb.CheckHealthResponse, error) {
+			return &milvuspb.CheckHealthResponse{
+				IsHealthy: false,
+				Reasons:   []string{"unHealth"},
+			}, nil
+		}
+
+		checkHealthFunc2 := func(ctx context.Context,
+			req *milvuspb.CheckHealthRequest) (*milvuspb.CheckHealthResponse, error) {
+			return nil, errors.New("test")
+		}
+
+		dataCoordMock := NewDataCoordMock()
+		dataCoordMock.checkHealthFunc = checkHealthFunc1
+
+		indexCoordMock := NewIndexCoordMock()
+		indexCoordMock.checkHealthFunc = checkHealthFunc2
+		node := &Proxy{
+			session: &sessionutil.Session{ServerID: 1},
+			rootCoord: NewRootCoordMock(func(mock *RootCoordMock) {
+				mock.checkHealthFunc = checkHealthFunc1
+			}),
+			queryCoord: NewQueryCoordMock(func(mock *QueryCoordMock) {
+				mock.checkHealthFunc = checkHealthFunc2
+			}),
+			dataCoord:  dataCoordMock,
+			indexCoord: indexCoordMock}
+		node.stateCode.Store(commonpb.StateCode_Healthy)
+		ctx := context.Background()
+		resp, err := node.CheckHealth(ctx, &milvuspb.CheckHealthRequest{})
+		assert.NoError(t, err)
+		assert.Equal(t, false, resp.IsHealthy)
+		assert.Equal(t, 4, len(resp.Reasons))
+	})
+}

internal/proxy/index_coord_mock_test.go

@@ -48,6 +48,7 @@ type IndexCoordMock struct {
 	timeTickChannel   string
 
 	minioBucketName string
+	checkHealthFunc func(ctx context.Context, req *milvuspb.CheckHealthRequest) (*milvuspb.CheckHealthResponse, error)
 }
 
 func (coord *IndexCoordMock) updateState(state commonpb.StateCode) {
@@ -229,6 +230,13 @@ func (coord *IndexCoordMock) GetMetrics(ctx context.Context, req *milvuspb.GetMe
 	}, nil
 }
 
+func (coord *IndexCoordMock) CheckHealth(ctx context.Context, req *milvuspb.CheckHealthRequest) (*milvuspb.CheckHealthResponse, error) {
+	if coord.checkHealthFunc != nil {
+		return coord.checkHealthFunc(ctx, req)
+	}
+	return &milvuspb.CheckHealthResponse{IsHealthy: true}, nil
+}
+
 func NewIndexCoordMock() *IndexCoordMock {
 	return &IndexCoordMock{
 		nodeID:            typeutil.UniqueID(uniquegenerator.GetUniqueIntGeneratorIns().GetInt()),

internal/proxy/query_coord_mock_test.go

@@ -71,6 +71,14 @@ type QueryCoordMock struct {
 	timeTickChannel   string
 
 	validShardLeaders bool
+	checkHealthFunc   func(ctx context.Context, req *milvuspb.CheckHealthRequest) (*milvuspb.CheckHealthResponse, error)
+}
+
+func (coord *QueryCoordMock) CheckHealth(ctx context.Context, req *milvuspb.CheckHealthRequest) (*milvuspb.CheckHealthResponse, error) {
+	if coord.checkHealthFunc != nil {
+		return coord.checkHealthFunc(ctx, req)
+	}
+	return &milvuspb.CheckHealthResponse{IsHealthy: true}, nil
 }
 
 func (coord *QueryCoordMock) updateState(state commonpb.StateCode) {

internal/proxy/rootcoord_mock_test.go

@@ -109,6 +109,7 @@ type RootCoordMock struct {
 
 	lastTs          typeutil.Timestamp
 	lastTsMtx       sync.Mutex
+	checkHealthFunc func(ctx context.Context, req *milvuspb.CheckHealthRequest) (*milvuspb.CheckHealthResponse, error)
 }
 
 func (coord *RootCoordMock) CreateAlias(ctx context.Context, req *milvuspb.CreateAliasRequest) (*commonpb.Status, error) {
@@ -1124,6 +1125,13 @@ func (coord *RootCoordMock) AlterCollection(ctx context.Context, request *milvus
 	return &commonpb.Status{}, nil
 }
 
+func (coord *RootCoordMock) CheckHealth(ctx context.Context, req *milvuspb.CheckHealthRequest) (*milvuspb.CheckHealthResponse, error) {
+	if coord.checkHealthFunc != nil {
+		return coord.checkHealthFunc(ctx, req)
+	}
+	return &milvuspb.CheckHealthResponse{IsHealthy: true}, nil
+}
+
 type DescribeCollectionFunc func(ctx context.Context, request *milvuspb.DescribeCollectionRequest) (*milvuspb.DescribeCollectionResponse, error)
 type ShowPartitionsFunc func(ctx context.Context, request *milvuspb.ShowPartitionsRequest) (*milvuspb.ShowPartitionsResponse, error)
 type ShowSegmentsFunc func(ctx context.Context, request *milvuspb.ShowSegmentsRequest) (*milvuspb.ShowSegmentsResponse, error)
@@ -1191,6 +1199,12 @@ func (m *mockRootCoord) ListPolicy(ctx context.Context, in *internalpb.ListPolic
 	return &internalpb.ListPolicyResponse{}, nil
 }
 
+func (m *mockRootCoord) CheckHealth(ctx context.Context, req *milvuspb.CheckHealthRequest) (*milvuspb.CheckHealthResponse, error) {
+	return &milvuspb.CheckHealthResponse{
+		IsHealthy: true,
+	}, nil
+}
+
 func newMockRootCoord() *mockRootCoord {
 	return &mockRootCoord{}
 }

internal/querycoordv2/services.go

@@ -20,6 +20,11 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"sync"
+
+	"github.com/milvus-io/milvus/internal/util/errorutil"
+
+	"golang.org/x/sync/errgroup"
 
 	"github.com/milvus-io/milvus-proto/go-api/commonpb"
 	"github.com/milvus-io/milvus-proto/go-api/milvuspb"
@@ -702,3 +707,35 @@ func (s *Server) GetShardLeaders(ctx context.Context, req *querypb.GetShardLeade
 	}
 	return resp, nil
 }
+
+func (s *Server) CheckHealth(ctx context.Context, req *milvuspb.CheckHealthRequest) (*milvuspb.CheckHealthResponse, error) {
+	if s.status.Load() != commonpb.StateCode_Healthy {
+		reason := errorutil.UnHealthReason("querycoord", s.session.ServerID, "querycoord is unhealthy")
+		return &milvuspb.CheckHealthResponse{IsHealthy: false, Reasons: []string{reason}}, nil
+	}
+
+	group, ctx := errgroup.WithContext(ctx)
+	errReasons := make([]string, 0, len(s.nodeMgr.GetAll()))
+
+	mu := &sync.Mutex{}
+	for _, node := range s.nodeMgr.GetAll() {
+		node := node
+		group.Go(func() error {
+			resp, err := s.cluster.GetComponentStates(ctx, node.ID())
+			isHealthy, reason := errorutil.UnHealthReasonWithComponentStatesOrErr("querynode", node.ID(), resp, err)
+			if !isHealthy {
+				mu.Lock()
+				defer mu.Unlock()
+				errReasons = append(errReasons, reason)
+			}
+			return err
+		})
+	}
+
+	err := group.Wait()
+	if err != nil || len(errReasons) != 0 {
+		return &milvuspb.CheckHealthResponse{IsHealthy: false, Reasons: errReasons}, nil
+	}
+
+	return &milvuspb.CheckHealthResponse{IsHealthy: true, Reasons: errReasons}, nil
+}

internal/querycoordv2/services_test.go

@@ -780,6 +780,47 @@ func (suite *ServiceSuite) TestGetReplicas() {
 	suite.Contains(resp.Status.Reason, ErrNotHealthy.Error())
 }
 
+func (suite *ServiceSuite) TestCheckHealth() {
+	ctx := context.Background()
+	server := suite.server
+
+	// Test for server is not healthy
+	server.UpdateStateCode(commonpb.StateCode_Initializing)
+	resp, err := server.CheckHealth(ctx, &milvuspb.CheckHealthRequest{})
+	suite.NoError(err)
+	suite.Equal(resp.IsHealthy, false)
+	suite.NotEmpty(resp.Reasons)
+
+	// Test for components state fail
+	for _, node := range suite.nodes {
+		suite.cluster.EXPECT().GetComponentStates(mock.Anything, node).Return(
+			&milvuspb.ComponentStates{
+				State:  &milvuspb.ComponentInfo{StateCode: commonpb.StateCode_Abnormal},
+				Status: &commonpb.Status{ErrorCode: commonpb.ErrorCode_Success},
+			},
+			nil).Once()
+	}
+	server.UpdateStateCode(commonpb.StateCode_Healthy)
+	resp, err = server.CheckHealth(ctx, &milvuspb.CheckHealthRequest{})
+	suite.NoError(err)
+	suite.Equal(resp.IsHealthy, false)
+	suite.NotEmpty(resp.Reasons)
+
+	// Test for server is healthy
+	for _, node := range suite.nodes {
+		suite.cluster.EXPECT().GetComponentStates(mock.Anything, node).Return(
+			&milvuspb.ComponentStates{
+				State:  &milvuspb.ComponentInfo{StateCode: commonpb.StateCode_Healthy},
+				Status: &commonpb.Status{ErrorCode: commonpb.ErrorCode_Success},
+			},
+			nil).Once()
+	}
+	resp, err = server.CheckHealth(ctx, &milvuspb.CheckHealthRequest{})
+	suite.NoError(err)
+	suite.Equal(resp.IsHealthy, true)
+	suite.Empty(resp.Reasons)
+}
+
 func (suite *ServiceSuite) TestGetShardLeaders() {
 	suite.loadAll()
 	ctx := context.Background()

internal/querycoordv2/session/cluster.go

@@ -54,6 +54,7 @@ type Cluster interface {
 	GetDataDistribution(ctx context.Context, nodeID int64, req *querypb.GetDataDistributionRequest) (*querypb.GetDataDistributionResponse, error)
 	GetMetrics(ctx context.Context, nodeID int64, req *milvuspb.GetMetricsRequest) (*milvuspb.GetMetricsResponse, error)
 	SyncDistribution(ctx context.Context, nodeID int64, req *querypb.SyncDistributionRequest) (*commonpb.Status, error)
+	GetComponentStates(ctx context.Context, nodeID int64) (*milvuspb.ComponentStates, error)
 	Start(ctx context.Context)
 	Stop()
 }
@@ -207,6 +208,22 @@ func (c *QueryCluster) SyncDistribution(ctx context.Context, nodeID int64, req *
 	return resp, err
 }
 
+func (c *QueryCluster) GetComponentStates(ctx context.Context, nodeID int64) (*milvuspb.ComponentStates, error) {
+	var (
+		resp *milvuspb.ComponentStates
+		err  error
+	)
+
+	err1 := c.send(ctx, nodeID, func(cli *grpcquerynodeclient.Client) {
+		resp, err = cli.GetComponentStates(ctx)
+	})
+
+	if err1 != nil {
+		return nil, err1
+	}
+	return resp, err
+}
+
 func (c *QueryCluster) send(ctx context.Context, nodeID int64, fn func(cli *grpcquerynodeclient.Client)) error {
 	node := c.nodeManager.Get(nodeID)
 	if node == nil {

internal/querycoordv2/session/cluster_test.go

@@ -134,6 +134,13 @@ func (suite *ClusterTestSuite) createDefaultMockServer() querypb.QueryNodeServer
 		mock.Anything,
 		mock.AnythingOfType("*querypb.SyncDistributionRequest"),
 	).Maybe().Return(succStatus, nil)
+	svr.EXPECT().GetComponentStates(
+		mock.Anything,
+		mock.AnythingOfType("*milvuspb.GetComponentStatesRequest"),
+	).Maybe().Return(&milvuspb.ComponentStates{
+		State:  &milvuspb.ComponentInfo{StateCode: commonpb.StateCode_Healthy},
+		Status: &commonpb.Status{ErrorCode: commonpb.ErrorCode_Success},
+	}, nil)
 	return svr
 }
 
@@ -172,6 +179,13 @@ func (suite *ClusterTestSuite) createFailedMockServer() querypb.QueryNodeServer
 		mock.Anything,
 		mock.AnythingOfType("*querypb.SyncDistributionRequest"),
 	).Maybe().Return(failStatus, nil)
+	svr.EXPECT().GetComponentStates(
+		mock.Anything,
+		mock.AnythingOfType("*milvuspb.GetComponentStatesRequest"),
+	).Maybe().Return(&milvuspb.ComponentStates{
+		State:  &milvuspb.ComponentInfo{StateCode: commonpb.StateCode_Abnormal},
+		Status: &commonpb.Status{ErrorCode: commonpb.ErrorCode_Success},
+	}, nil)
 	return svr
 }
 
@@ -328,6 +342,17 @@ func (suite *ClusterTestSuite) TestSyncDistribution() {
 	}, status)
 }
 
+func (suite *ClusterTestSuite) TestGetComponentStates() {
+	ctx := context.TODO()
+	status, err := suite.cluster.GetComponentStates(ctx, 0)
+	suite.NoError(err)
+	suite.Equal(status.State.GetStateCode(), commonpb.StateCode_Healthy)
+
+	status, err = suite.cluster.GetComponentStates(ctx, 1)
+	suite.NoError(err)
+	suite.Equal(status.State.GetStateCode(), commonpb.StateCode_Abnormal)
+}
+
 func TestClusterSuite(t *testing.T) {
 	suite.Run(t, new(ClusterTestSuite))
 }

internal/querycoordv2/session/mock_cluster.go

@@ -27,6 +27,53 @@ func (_m *MockCluster) EXPECT() *MockCluster_Expecter {
 	return &MockCluster_Expecter{mock: &_m.Mock}
 }
 
+// GetComponentStates provides a mock function with given fields: ctx, nodeID
+func (_m *MockCluster) GetComponentStates(ctx context.Context, nodeID int64) (*milvuspb.ComponentStates, error) {
+	ret := _m.Called(ctx, nodeID)
+
+	var r0 *milvuspb.ComponentStates
+	if rf, ok := ret.Get(0).(func(context.Context, int64) *milvuspb.ComponentStates); ok {
+		r0 = rf(ctx, nodeID)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*milvuspb.ComponentStates)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(context.Context, int64) error); ok {
+		r1 = rf(ctx, nodeID)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MockCluster_GetComponentStates_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetComponentStates'
+type MockCluster_GetComponentStates_Call struct {
+	*mock.Call
+}
+
+// GetComponentStates is a helper method to define mock.On call
+//  - ctx context.Context
+//  - nodeID int64
+func (_e *MockCluster_Expecter) GetComponentStates(ctx interface{}, nodeID interface{}) *MockCluster_GetComponentStates_Call {
+	return &MockCluster_GetComponentStates_Call{Call: _e.mock.On("GetComponentStates", ctx, nodeID)}
+}
+
+func (_c *MockCluster_GetComponentStates_Call) Run(run func(ctx context.Context, nodeID int64)) *MockCluster_GetComponentStates_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(int64))
+	})
+	return _c
+}
+
+func (_c *MockCluster_GetComponentStates_Call) Return(_a0 *milvuspb.ComponentStates, _a1 error) *MockCluster_GetComponentStates_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
 // GetDataDistribution provides a mock function with given fields: ctx, nodeID, req
 func (_m *MockCluster) GetDataDistribution(ctx context.Context, nodeID int64, req *querypb.GetDataDistributionRequest) (*querypb.GetDataDistributionResponse, error) {
 	ret := _m.Called(ctx, nodeID, req)

internal/rootcoord/mock_test.go

@@ -202,6 +202,12 @@ func (m *mockDataCoord) BroadcastAlteredCollection(ctx context.Context, req *mil
 	return m.broadCastAlteredCollectionFunc(ctx, req)
 }
 
+func (m *mockDataCoord) CheckHealth(ctx context.Context, req *milvuspb.CheckHealthRequest) (*milvuspb.CheckHealthResponse, error) {
+	return &milvuspb.CheckHealthResponse{
+		IsHealthy: true,
+	}, nil
+}
+
 type mockQueryCoord struct {
 	types.QueryCoord
 	GetSegmentInfoFunc     func(ctx context.Context, req *querypb.GetSegmentInfoRequest) (*querypb.GetSegmentInfoResponse, error)
@@ -260,6 +266,7 @@ type mockProxy struct {
 	InvalidateCollectionMetaCacheFunc func(ctx context.Context, request *proxypb.InvalidateCollMetaCacheRequest) (*commonpb.Status, error)
 	InvalidateCredentialCacheFunc     func(ctx context.Context, request *proxypb.InvalidateCredCacheRequest) (*commonpb.Status, error)
 	RefreshPolicyInfoCacheFunc        func(ctx context.Context, request *proxypb.RefreshPolicyInfoCacheRequest) (*commonpb.Status, error)
+	GetComponentStatesFunc            func(ctx context.Context) (*milvuspb.ComponentStates, error)
 }
 
 func (m mockProxy) InvalidateCollectionMetaCache(ctx context.Context, request *proxypb.InvalidateCollMetaCacheRequest) (*commonpb.Status, error) {
@@ -274,6 +281,10 @@ func (m mockProxy) RefreshPolicyInfoCache(ctx context.Context, request *proxypb.
 	return m.RefreshPolicyInfoCacheFunc(ctx, request)
 }
 
+func (m mockProxy) GetComponentStates(ctx context.Context) (*milvuspb.ComponentStates, error) {
+	return m.GetComponentStatesFunc(ctx)
+}
+
 func newMockProxy() *mockProxy {
 	r := &mockProxy{}
 	r.InvalidateCollectionMetaCacheFunc = func(ctx context.Context, request *proxypb.InvalidateCollMetaCacheRequest) (*commonpb.Status, error) {
@@ -307,6 +318,13 @@ func withValidProxyManager() Opt {
 		p.InvalidateCollectionMetaCacheFunc = func(ctx context.Context, request *proxypb.InvalidateCollMetaCacheRequest) (*commonpb.Status, error) {
 			return succStatus(), nil
 		}
+		p.GetComponentStatesFunc = func(ctx context.Context) (*milvuspb.ComponentStates, error) {
+			return &milvuspb.ComponentStates{
+				State:  &milvuspb.ComponentInfo{StateCode: commonpb.StateCode_Healthy},
+				Status: &commonpb.Status{ErrorCode: commonpb.ErrorCode_Success},
+			}, nil
+		}
+		c.proxyClientManager.proxyClient[TestProxyID] = p
 	}
 }
 
@@ -319,6 +337,12 @@ func withInvalidProxyManager() Opt {
 		p.InvalidateCollectionMetaCacheFunc = func(ctx context.Context, request *proxypb.InvalidateCollMetaCacheRequest) (*commonpb.Status, error) {
 			return succStatus(), errors.New("error mock InvalidateCollectionMetaCache")
 		}
+		p.GetComponentStatesFunc = func(ctx context.Context) (*milvuspb.ComponentStates, error) {
+			return &milvuspb.ComponentStates{
+				State:  &milvuspb.ComponentInfo{StateCode: commonpb.StateCode_Abnormal},
+				Status: &commonpb.Status{ErrorCode: commonpb.ErrorCode_Success},
+			}, nil
+		}
 		c.proxyClientManager.proxyClient[TestProxyID] = p
 	}
 }

internal/rootcoord/root_coord.go

@@ -27,6 +27,8 @@ import (
 	"syscall"
 	"time"
 
+	"golang.org/x/sync/errgroup"
+
 	"github.com/milvus-io/milvus-proto/go-api/commonpb"
 	"github.com/milvus-io/milvus-proto/go-api/milvuspb"
 	"github.com/milvus-io/milvus-proto/go-api/schemapb"
@@ -2351,3 +2353,36 @@ func (c *Core) ListPolicy(ctx context.Context, in *internalpb.ListPolicyRequest)
 		UserRoles:   userRoles,
 	}, nil
 }
+
+func (c *Core) CheckHealth(ctx context.Context, in *milvuspb.CheckHealthRequest) (*milvuspb.CheckHealthResponse, error) {
+	if _, ok := c.checkHealthy(); !ok {
+		reason := errorutil.UnHealthReason("rootcoord", c.session.ServerID, "rootcoord is unhealthy")
+		return &milvuspb.CheckHealthResponse{IsHealthy: false, Reasons: []string{reason}}, nil
+	}
+
+	mu := &sync.Mutex{}
+	group, ctx := errgroup.WithContext(ctx)
+	errReasons := make([]string, 0, len(c.proxyClientManager.proxyClient))
+
+	for nodeID, proxyClient := range c.proxyClientManager.proxyClient {
+		nodeID := nodeID
+		proxyClient := proxyClient
+		group.Go(func() error {
+			sta, err := proxyClient.GetComponentStates(ctx)
+			isHealthy, reason := errorutil.UnHealthReasonWithComponentStatesOrErr("proxy", nodeID, sta, err)
+			if !isHealthy {
+				mu.Lock()
+				defer mu.Unlock()
+				errReasons = append(errReasons, reason)
+			}
+			return err
+		})
+	}
+
+	err := group.Wait()
+	if err != nil || len(errReasons) != 0 {
+		return &milvuspb.CheckHealthResponse{IsHealthy: false, Reasons: errReasons}, nil
+	}
+
+	return &milvuspb.CheckHealthResponse{IsHealthy: true, Reasons: errReasons}, nil
+}

internal/rootcoord/root_coord_test.go

@@ -1416,3 +1416,36 @@ func TestRootCoord_AlterCollection(t *testing.T) {
 		assert.Equal(t, commonpb.ErrorCode_Success, resp.GetErrorCode())
 	})
 }
+
+func TestRootCoord_CheckHealth(t *testing.T) {
+	t.Run("not healthy", func(t *testing.T) {
+		ctx := context.Background()
+		c := newTestCore(withAbnormalCode())
+		resp, err := c.CheckHealth(ctx, &milvuspb.CheckHealthRequest{})
+		assert.NoError(t, err)
+		assert.Equal(t, false, resp.IsHealthy)
+		assert.NotEmpty(t, resp.Reasons)
+	})
+
+	t.Run("proxy health check is ok", func(t *testing.T) {
+		c := newTestCore(withHealthyCode(),
+			withValidProxyManager())
+
+		ctx := context.Background()
+		resp, err := c.CheckHealth(ctx, &milvuspb.CheckHealthRequest{})
+		assert.NoError(t, err)
+		assert.Equal(t, true, resp.IsHealthy)
+		assert.Empty(t, resp.Reasons)
+	})
+
+	t.Run("proxy health check is fail", func(t *testing.T) {
+		c := newTestCore(withHealthyCode(),
+			withInvalidProxyManager())
+
+		ctx := context.Background()
+		resp, err := c.CheckHealth(ctx, &milvuspb.CheckHealthRequest{})
+		assert.NoError(t, err)
+		assert.Equal(t, false, resp.IsHealthy)
+		assert.NotEmpty(t, resp.Reasons)
+	})
+}

internal/types/types.go

@@ -326,6 +326,8 @@ type DataCoord interface {
 	MarkSegmentsDropped(ctx context.Context, req *datapb.MarkSegmentsDroppedRequest) (*commonpb.Status, error)
 
 	BroadcastAlteredCollection(ctx context.Context, req *milvuspb.AlterCollectionRequest) (*commonpb.Status, error)
+
+	CheckHealth(ctx context.Context, req *milvuspb.CheckHealthRequest) (*milvuspb.CheckHealthResponse, error)
 }
 
 // DataCoordComponent defines the interface of DataCoord component.
@@ -424,6 +426,8 @@ type IndexCoord interface {
 
 	// GetMetrics gets the metrics about IndexCoord.
 	GetMetrics(ctx context.Context, req *milvuspb.GetMetricsRequest) (*milvuspb.GetMetricsResponse, error)
+
+	CheckHealth(ctx context.Context, req *milvuspb.CheckHealthRequest) (*milvuspb.CheckHealthResponse, error)
 }
 
 // IndexCoordComponent is used by grpc server of IndexCoord
@@ -763,6 +767,8 @@ type RootCoord interface {
 	OperatePrivilege(ctx context.Context, req *milvuspb.OperatePrivilegeRequest) (*commonpb.Status, error)
 	SelectGrant(ctx context.Context, req *milvuspb.SelectGrantRequest) (*milvuspb.SelectGrantResponse, error)
 	ListPolicy(ctx context.Context, in *internalpb.ListPolicyRequest) (*internalpb.ListPolicyResponse, error)
+
+	CheckHealth(ctx context.Context, req *milvuspb.CheckHealthRequest) (*milvuspb.CheckHealthResponse, error)
 }
 
 // RootCoordComponent is used by grpc server of RootCoord
@@ -1287,6 +1293,8 @@ type ProxyComponent interface {
 	SelectUser(ctx context.Context, req *milvuspb.SelectUserRequest) (*milvuspb.SelectUserResponse, error)
 	OperatePrivilege(ctx context.Context, req *milvuspb.OperatePrivilegeRequest) (*commonpb.Status, error)
 	SelectGrant(ctx context.Context, req *milvuspb.SelectGrantRequest) (*milvuspb.SelectGrantResponse, error)
+
+	CheckHealth(ctx context.Context, req *milvuspb.CheckHealthRequest) (*milvuspb.CheckHealthResponse, error)
 }
 
 // QueryNode is the interface `querynode` package implements
@@ -1354,6 +1362,8 @@ type QueryCoord interface {
 
 	GetReplicas(ctx context.Context, req *milvuspb.GetReplicasRequest) (*milvuspb.GetReplicasResponse, error)
 	GetShardLeaders(ctx context.Context, req *querypb.GetShardLeadersRequest) (*querypb.GetShardLeadersResponse, error)
+
+	CheckHealth(ctx context.Context, req *milvuspb.CheckHealthRequest) (*milvuspb.CheckHealthResponse, error)
 }
 
 // QueryCoordComponent is used by grpc server of QueryCoord

internal/util/errorutil/util.go

@@ -6,6 +6,8 @@ import (
 	"strings"
 
 	"github.com/milvus-io/milvus-proto/go-api/commonpb"
+	"github.com/milvus-io/milvus-proto/go-api/milvuspb"
+	"github.com/milvus-io/milvus/internal/util/typeutil"
 )
 
 // ErrorList for print error log
@@ -43,3 +45,23 @@ func UnhealthyError() error {
 func PermissionDenyError() error {
 	return errors.New("permission deny")
 }
+
+func UnHealthReason(role string, nodeID typeutil.UniqueID, reason string) string {
+	return fmt.Sprintf("role %s[nodeID: %d] is unhealthy, reason: %s", role, nodeID, reason)
+}
+
+func UnHealthReasonWithComponentStatesOrErr(role string, nodeID typeutil.UniqueID, cs *milvuspb.ComponentStates, err error) (bool, string) {
+	if err != nil {
+		return false, UnHealthReason(role, nodeID, fmt.Sprintf("inner error: %s", err.Error()))
+	}
+
+	if cs != nil && cs.GetStatus().GetErrorCode() != commonpb.ErrorCode_Success {
+		return false, UnHealthReason(role, nodeID, fmt.Sprintf("rpc status error: %d", cs.GetStatus().GetErrorCode()))
+	}
+
+	if cs != nil && cs.GetState().GetStateCode() != commonpb.StateCode_Healthy {
+		return false, UnHealthReason(role, nodeID, fmt.Sprintf("node is unhealthy, state code: %d", cs.GetState().GetStateCode()))
+	}
+
+	return true, ""
+}

internal/util/mock/grpc_datacoord_client.go

@@ -34,6 +34,10 @@ type GrpcDataCoordClient struct {
 	Err error
 }
 
+func (m *GrpcDataCoordClient) CheckHealth(ctx context.Context, in *milvuspb.CheckHealthRequest, opts ...grpc.CallOption) (*milvuspb.CheckHealthResponse, error) {
+	return &milvuspb.CheckHealthResponse{}, m.Err
+}
+
 func (m *GrpcDataCoordClient) GetComponentStates(ctx context.Context, in *milvuspb.GetComponentStatesRequest, opts ...grpc.CallOption) (*milvuspb.ComponentStates, error) {
 	return &milvuspb.ComponentStates{}, m.Err
 }

internal/util/mock/grpc_querycoord_client.go

@@ -34,6 +34,10 @@ type GrpcQueryCoordClient struct {
 	Err error
 }
 
+func (m *GrpcQueryCoordClient) CheckHealth(ctx context.Context, in *milvuspb.CheckHealthRequest, opts ...grpc.CallOption) (*milvuspb.CheckHealthResponse, error) {
+	return &milvuspb.CheckHealthResponse{}, m.Err
+}
+
 func (m *GrpcQueryCoordClient) GetComponentStates(ctx context.Context, in *milvuspb.GetComponentStatesRequest, opts ...grpc.CallOption) (*milvuspb.ComponentStates, error) {
 	return &milvuspb.ComponentStates{}, m.Err
 }

internal/util/mock/grpc_rootcoord_client.go

@@ -35,6 +35,10 @@ type GrpcRootCoordClient struct {
 	Err error
 }
 
+func (m *GrpcRootCoordClient) CheckHealth(ctx context.Context, in *milvuspb.CheckHealthRequest, opts ...grpc.CallOption) (*milvuspb.CheckHealthResponse, error) {
+	return &milvuspb.CheckHealthResponse{}, m.Err
+}
+
 func (m *GrpcRootCoordClient) CreateRole(ctx context.Context, in *milvuspb.CreateRoleRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
 	return &commonpb.Status{}, m.Err
 }