diff --git a/internal/distributed/querynode/client/client.go b/internal/distributed/querynode/client/client.go index 2ea1f0c6ef..549938fa58 100644 --- a/internal/distributed/querynode/client/client.go +++ b/internal/distributed/querynode/client/client.go @@ -215,6 +215,12 @@ func (c *Client) Search(ctx context.Context, req *querypb.SearchRequest) (*inter }) } +func (c *Client) SearchSegments(ctx context.Context, req *querypb.SearchRequest) (*internalpb.SearchResults, error) { + return wrapGrpcCall(ctx, c, func(client querypb.QueryNodeClient) (*internalpb.SearchResults, error) { + return client.SearchSegments(ctx, req) + }) +} + // Query performs replica query tasks in QueryNode. func (c *Client) Query(ctx context.Context, req *querypb.QueryRequest) (*internalpb.RetrieveResults, error) { return wrapGrpcCall(ctx, c, func(client querypb.QueryNodeClient) (*internalpb.RetrieveResults, error) { @@ -222,6 +228,12 @@ func (c *Client) Query(ctx context.Context, req *querypb.QueryRequest) (*interna }) } +func (c *Client) QuerySegments(ctx context.Context, req *querypb.QueryRequest) (*internalpb.RetrieveResults, error) { + return wrapGrpcCall(ctx, c, func(client querypb.QueryNodeClient) (*internalpb.RetrieveResults, error) { + return client.QuerySegments(ctx, req) + }) +} + // GetSegmentInfo gets the information of the specified segments in QueryNode. func (c *Client) GetSegmentInfo(ctx context.Context, req *querypb.GetSegmentInfoRequest) (*querypb.GetSegmentInfoResponse, error) { req = typeutil.Clone(req) diff --git a/internal/distributed/querynode/client/client_test.go b/internal/distributed/querynode/client/client_test.go index dae773f270..52b50e4e12 100644 --- a/internal/distributed/querynode/client/client_test.go +++ b/internal/distributed/querynode/client/client_test.go @@ -107,6 +107,12 @@ func Test_NewClient(t *testing.T) { r18, err := client.ShowConfigurations(ctx, nil) retCheck(retNotNil, r18, err) + + r19, err := client.QuerySegments(ctx, nil) + retCheck(retNotNil, r19, err) + + r20, err := client.SearchSegments(ctx, nil) + retCheck(retNotNil, r20, err) } client.grpcClient = &mock.GRPCClientBase[querypb.QueryNodeClient]{ diff --git a/internal/distributed/querynode/service.go b/internal/distributed/querynode/service.go index bd7b1f4650..76e242822b 100644 --- a/internal/distributed/querynode/service.go +++ b/internal/distributed/querynode/service.go @@ -303,11 +303,19 @@ func (s *Server) Search(ctx context.Context, req *querypb.SearchRequest) (*inter return s.querynode.Search(ctx, req) } +func (s *Server) SearchSegments(ctx context.Context, req *querypb.SearchRequest) (*internalpb.SearchResults, error) { + return s.querynode.SearchSegments(ctx, req) +} + // Query performs query of streaming/historical replica on QueryNode. func (s *Server) Query(ctx context.Context, req *querypb.QueryRequest) (*internalpb.RetrieveResults, error) { return s.querynode.Query(ctx, req) } +func (s *Server) QuerySegments(ctx context.Context, req *querypb.QueryRequest) (*internalpb.RetrieveResults, error) { + return s.querynode.QuerySegments(ctx, req) +} + // SyncReplicaSegments syncs replica segment information to shard leader func (s *Server) SyncReplicaSegments(ctx context.Context, req *querypb.SyncReplicaSegmentsRequest) (*commonpb.Status, error) { return s.querynode.SyncReplicaSegments(ctx, req) diff --git a/internal/distributed/querynode/service_test.go b/internal/distributed/querynode/service_test.go index 1c45382aff..64c1d800d2 100644 --- a/internal/distributed/querynode/service_test.go +++ b/internal/distributed/querynode/service_test.go @@ -27,6 +27,7 @@ import ( "github.com/milvus-io/milvus/pkg/util/paramtable" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/mock" clientv3 "go.etcd.io/etcd/client/v3" "github.com/milvus-io/milvus-proto/go-api/commonpb" @@ -35,136 +36,6 @@ import ( "github.com/milvus-io/milvus/internal/proto/querypb" ) -// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -type MockQueryNode struct { - states *milvuspb.ComponentStates - status *commonpb.Status - err error - initErr error - startErr error - regErr error - stopErr error - strResp *milvuspb.StringResponse - infoResp *querypb.GetSegmentInfoResponse - metricResp *milvuspb.GetMetricsResponse - configResp *internalpb.ShowConfigurationsResponse - StatsResp *internalpb.GetStatisticsResponse - searchResp *internalpb.SearchResults - queryResp *internalpb.RetrieveResults - distResp *querypb.GetDataDistributionResponse -} - -func (m *MockQueryNode) Init() error { - return m.initErr -} - -func (m *MockQueryNode) Start() error { - return m.startErr -} - -func (m *MockQueryNode) Stop() error { - return m.stopErr -} - -func (m *MockQueryNode) Register() error { - return m.regErr -} - -func (m *MockQueryNode) GetComponentStates(ctx context.Context) (*milvuspb.ComponentStates, error) { - return m.states, m.err -} - -func (m *MockQueryNode) GetStatisticsChannel(ctx context.Context) (*milvuspb.StringResponse, error) { - return m.strResp, m.err -} - -func (m *MockQueryNode) GetTimeTickChannel(ctx context.Context) (*milvuspb.StringResponse, error) { - return m.strResp, m.err -} - -func (m *MockQueryNode) WatchDmChannels(ctx context.Context, req *querypb.WatchDmChannelsRequest) (*commonpb.Status, error) { - return m.status, m.err -} - -func (m *MockQueryNode) LoadSegments(ctx context.Context, req *querypb.LoadSegmentsRequest) (*commonpb.Status, error) { - return m.status, m.err -} - -func (m *MockQueryNode) ReleaseCollection(ctx context.Context, req *querypb.ReleaseCollectionRequest) (*commonpb.Status, error) { - return m.status, m.err -} - -func (m *MockQueryNode) LoadPartitions(ctx context.Context, req *querypb.LoadPartitionsRequest) (*commonpb.Status, error) { - return m.status, m.err -} - -func (m *MockQueryNode) ReleasePartitions(ctx context.Context, req *querypb.ReleasePartitionsRequest) (*commonpb.Status, error) { - return m.status, m.err -} - -func (m *MockQueryNode) ReleaseSegments(ctx context.Context, req *querypb.ReleaseSegmentsRequest) (*commonpb.Status, error) { - return m.status, m.err -} - -func (m *MockQueryNode) GetSegmentInfo(ctx context.Context, req *querypb.GetSegmentInfoRequest) (*querypb.GetSegmentInfoResponse, error) { - return m.infoResp, m.err -} - -func (m *MockQueryNode) GetMetrics(ctx context.Context, req *milvuspb.GetMetricsRequest) (*milvuspb.GetMetricsResponse, error) { - return m.metricResp, m.err -} - -func (m *MockQueryNode) GetStatistics(ctx context.Context, req *querypb.GetStatisticsRequest) (*internalpb.GetStatisticsResponse, error) { - return m.StatsResp, m.err -} - -func (m *MockQueryNode) Search(ctx context.Context, req *querypb.SearchRequest) (*internalpb.SearchResults, error) { - return m.searchResp, m.err -} - -func (m *MockQueryNode) Query(ctx context.Context, req *querypb.QueryRequest) (*internalpb.RetrieveResults, error) { - return m.queryResp, m.err -} - -func (m *MockQueryNode) SyncReplicaSegments(ctx context.Context, req *querypb.SyncReplicaSegmentsRequest) (*commonpb.Status, error) { - return m.status, m.err -} - -func (m *MockQueryNode) SetAddress(address string) { -} - -func (m *MockQueryNode) GetAddress() string { - return "" -} - -func (m *MockQueryNode) SetEtcdClient(client *clientv3.Client) { -} - -func (m *MockQueryNode) UpdateStateCode(code commonpb.StateCode) { -} - -func (m *MockQueryNode) SetRootCoord(rc types.RootCoord) error { - return m.err -} - -func (m *MockQueryNode) ShowConfigurations(ctx context.Context, req *internalpb.ShowConfigurationsRequest) (*internalpb.ShowConfigurationsResponse, error) { - return m.configResp, m.err -} - -func (m *MockQueryNode) UnsubDmChannel(ctx context.Context, req *querypb.UnsubDmChannelRequest) (*commonpb.Status, error) { - return m.status, m.err -} -func (m *MockQueryNode) GetDataDistribution(context.Context, *querypb.GetDataDistributionRequest) (*querypb.GetDataDistributionResponse, error) { - return m.distResp, m.err -} -func (m *MockQueryNode) SyncDistribution(context.Context, *querypb.SyncDistributionRequest) (*commonpb.Status, error) { - return m.status, m.err -} - -func (m *MockQueryNode) Delete(context.Context, *querypb.DeleteRequest) (*commonpb.Status, error) { - return m.status, m.err -} - type MockRootCoord struct { types.RootCoord initErr error @@ -213,16 +84,15 @@ func Test_NewServer(t *testing.T) { assert.Nil(t, err) assert.NotNil(t, server) - mqn := &MockQueryNode{ - states: &milvuspb.ComponentStates{State: &milvuspb.ComponentInfo{StateCode: commonpb.StateCode_Healthy}}, - status: &commonpb.Status{ErrorCode: commonpb.ErrorCode_Success}, - err: nil, - strResp: &milvuspb.StringResponse{Status: &commonpb.Status{ErrorCode: commonpb.ErrorCode_Success}}, - infoResp: &querypb.GetSegmentInfoResponse{Status: &commonpb.Status{ErrorCode: commonpb.ErrorCode_Success}}, - metricResp: &milvuspb.GetMetricsResponse{Status: &commonpb.Status{ErrorCode: commonpb.ErrorCode_Success}}, - configResp: &internalpb.ShowConfigurationsResponse{Status: &commonpb.Status{ErrorCode: commonpb.ErrorCode_Success}}, - } - server.querynode = mqn + mockQN := types.NewMockQueryNode(t) + mockQN.EXPECT().Start().Return(nil).Maybe() + mockQN.EXPECT().Stop().Return(nil).Maybe() + mockQN.EXPECT().Register().Return(nil).Maybe() + mockQN.EXPECT().SetEtcdClient(mock.Anything).Maybe() + mockQN.EXPECT().SetAddress(mock.Anything).Maybe() + mockQN.EXPECT().UpdateStateCode(mock.Anything).Maybe() + mockQN.EXPECT().Init().Return(nil).Maybe() + server.querynode = mockQN t.Run("Run", func(t *testing.T) { err = server.Run() @@ -230,6 +100,10 @@ func Test_NewServer(t *testing.T) { }) t.Run("GetComponentStates", func(t *testing.T) { + mockQN.EXPECT().GetComponentStates(mock.Anything).Return(&milvuspb.ComponentStates{ + State: &milvuspb.ComponentInfo{ + StateCode: commonpb.StateCode_Healthy, + }}, nil) req := &milvuspb.GetComponentStatesRequest{} states, err := server.GetComponentStates(ctx, req) assert.Nil(t, err) @@ -237,6 +111,7 @@ func Test_NewServer(t *testing.T) { }) t.Run("GetStatisticsChannel", func(t *testing.T) { + mockQN.EXPECT().GetStatisticsChannel(mock.Anything).Return(&milvuspb.StringResponse{Status: &commonpb.Status{ErrorCode: commonpb.ErrorCode_Success}}, nil) req := &internalpb.GetStatisticsChannelRequest{} resp, err := server.GetStatisticsChannel(ctx, req) assert.Nil(t, err) @@ -244,6 +119,7 @@ func Test_NewServer(t *testing.T) { }) t.Run("GetTimeTickChannel", func(t *testing.T) { + mockQN.EXPECT().GetTimeTickChannel(mock.Anything).Return(&milvuspb.StringResponse{Status: &commonpb.Status{ErrorCode: commonpb.ErrorCode_Success}}, nil) req := &internalpb.GetTimeTickChannelRequest{} resp, err := server.GetTimeTickChannel(ctx, req) assert.Nil(t, err) @@ -251,6 +127,7 @@ func Test_NewServer(t *testing.T) { }) t.Run("WatchDmChannels", func(t *testing.T) { + mockQN.EXPECT().WatchDmChannels(mock.Anything, mock.Anything).Return(&commonpb.Status{ErrorCode: commonpb.ErrorCode_Success}, nil) req := &querypb.WatchDmChannelsRequest{} resp, err := server.WatchDmChannels(ctx, req) assert.Nil(t, err) @@ -258,6 +135,7 @@ func Test_NewServer(t *testing.T) { }) t.Run("LoadSegments", func(t *testing.T) { + mockQN.EXPECT().LoadSegments(mock.Anything, mock.Anything).Return(&commonpb.Status{ErrorCode: commonpb.ErrorCode_Success}, nil) req := &querypb.LoadSegmentsRequest{} resp, err := server.LoadSegments(ctx, req) assert.Nil(t, err) @@ -265,6 +143,7 @@ func Test_NewServer(t *testing.T) { }) t.Run("ReleaseCollection", func(t *testing.T) { + mockQN.EXPECT().ReleaseCollection(mock.Anything, mock.Anything).Return(&commonpb.Status{ErrorCode: commonpb.ErrorCode_Success}, nil) req := &querypb.ReleaseCollectionRequest{} resp, err := server.ReleaseCollection(ctx, req) assert.Nil(t, err) @@ -272,6 +151,7 @@ func Test_NewServer(t *testing.T) { }) t.Run("LoadPartitions", func(t *testing.T) { + mockQN.EXPECT().LoadPartitions(mock.Anything, mock.Anything).Return(&commonpb.Status{ErrorCode: commonpb.ErrorCode_Success}, nil) req := &querypb.LoadPartitionsRequest{} resp, err := server.LoadPartitions(ctx, req) assert.Nil(t, err) @@ -279,6 +159,7 @@ func Test_NewServer(t *testing.T) { }) t.Run("ReleasePartitions", func(t *testing.T) { + mockQN.EXPECT().ReleasePartitions(mock.Anything, mock.Anything).Return(&commonpb.Status{ErrorCode: commonpb.ErrorCode_Success}, nil) req := &querypb.ReleasePartitionsRequest{} resp, err := server.ReleasePartitions(ctx, req) assert.Nil(t, err) @@ -286,6 +167,7 @@ func Test_NewServer(t *testing.T) { }) t.Run("ReleaseSegments", func(t *testing.T) { + mockQN.EXPECT().ReleaseSegments(mock.Anything, mock.Anything).Return(&commonpb.Status{ErrorCode: commonpb.ErrorCode_Success}, nil) req := &querypb.ReleaseSegmentsRequest{} resp, err := server.ReleaseSegments(ctx, req) assert.Nil(t, err) @@ -293,6 +175,8 @@ func Test_NewServer(t *testing.T) { }) t.Run("GetSegmentInfo", func(t *testing.T) { + mockQN.EXPECT().GetSegmentInfo(mock.Anything, mock.Anything).Return(&querypb.GetSegmentInfoResponse{ + Status: &commonpb.Status{ErrorCode: commonpb.ErrorCode_Success}}, nil) req := &querypb.GetSegmentInfoRequest{} resp, err := server.GetSegmentInfo(ctx, req) assert.Nil(t, err) @@ -300,6 +184,8 @@ func Test_NewServer(t *testing.T) { }) t.Run("GetMetrics", func(t *testing.T) { + mockQN.EXPECT().GetMetrics(mock.Anything, mock.Anything).Return( + &milvuspb.GetMetricsResponse{Status: &commonpb.Status{ErrorCode: commonpb.ErrorCode_Success}}, nil) req := &milvuspb.GetMetricsRequest{ Request: "", } @@ -309,20 +195,43 @@ func Test_NewServer(t *testing.T) { }) t.Run("Search", func(t *testing.T) { + mockQN.EXPECT().Search(mock.Anything, mock.Anything).Return(&internalpb.SearchResults{ + Status: &commonpb.Status{ErrorCode: commonpb.ErrorCode_Success}}, nil) req := &querypb.SearchRequest{} resp, err := server.Search(ctx, req) assert.NoError(t, err) assert.Equal(t, commonpb.ErrorCode_Success, resp.GetStatus().GetErrorCode()) }) + t.Run("SearchSegments", func(t *testing.T) { + mockQN.EXPECT().SearchSegments(mock.Anything, mock.Anything).Return(&internalpb.SearchResults{ + Status: &commonpb.Status{ErrorCode: commonpb.ErrorCode_Success}}, nil) + req := &querypb.SearchRequest{} + resp, err := server.SearchSegments(ctx, req) + assert.NoError(t, err) + assert.Equal(t, commonpb.ErrorCode_Success, resp.GetStatus().GetErrorCode()) + }) + t.Run("Query", func(t *testing.T) { + mockQN.EXPECT().Query(mock.Anything, mock.Anything).Return(&internalpb.RetrieveResults{ + Status: &commonpb.Status{ErrorCode: commonpb.ErrorCode_Success}}, nil) req := &querypb.QueryRequest{} resp, err := server.Query(ctx, req) assert.NoError(t, err) assert.Equal(t, commonpb.ErrorCode_Success, resp.GetStatus().GetErrorCode()) }) + t.Run("QuerySegments", func(t *testing.T) { + mockQN.EXPECT().QuerySegments(mock.Anything, mock.Anything).Return(&internalpb.RetrieveResults{ + Status: &commonpb.Status{ErrorCode: commonpb.ErrorCode_Success}}, nil) + req := &querypb.QueryRequest{} + resp, err := server.QuerySegments(ctx, req) + assert.NoError(t, err) + assert.Equal(t, commonpb.ErrorCode_Success, resp.GetStatus().GetErrorCode()) + }) + t.Run("SyncReplicaSegments", func(t *testing.T) { + mockQN.EXPECT().SyncReplicaSegments(mock.Anything, mock.Anything).Return(&commonpb.Status{ErrorCode: commonpb.ErrorCode_Success}, nil) req := &querypb.SyncReplicaSegmentsRequest{} resp, err := server.SyncReplicaSegments(ctx, req) assert.NoError(t, err) @@ -330,6 +239,9 @@ func Test_NewServer(t *testing.T) { }) t.Run("ShowConfigurtaions", func(t *testing.T) { + mockQN.EXPECT().ShowConfigurations(mock.Anything, mock.Anything).Return(&internalpb.ShowConfigurationsResponse{ + Status: &commonpb.Status{ErrorCode: commonpb.ErrorCode_Success}, + }, nil) req := &internalpb.ShowConfigurationsRequest{ Pattern: "Cache", } @@ -348,15 +260,21 @@ func Test_Run(t *testing.T) { assert.Nil(t, err) assert.NotNil(t, server) - server.querynode = &MockQueryNode{startErr: errors.New("Failed")} + mockQN := types.NewMockQueryNode(t) + mockQN.EXPECT().Start().Return(errors.New("Failed")).Maybe() + mockQN.EXPECT().Stop().Return(errors.New("Failed")).Maybe() + mockQN.EXPECT().Register().Return(errors.New("Failed")).Maybe() + mockQN.EXPECT().SetEtcdClient(mock.Anything).Maybe() + mockQN.EXPECT().SetAddress(mock.Anything).Maybe() + mockQN.EXPECT().UpdateStateCode(mock.Anything).Maybe() + mockQN.EXPECT().Init().Return(nil).Maybe() + server.querynode = mockQN err = server.Run() assert.Error(t, err) - server.querynode = &MockQueryNode{regErr: errors.New("Failed")} err = server.Run() assert.Error(t, err) - server.querynode = &MockQueryNode{stopErr: errors.New("Failed")} err = server.Stop() assert.Error(t, err) } diff --git a/internal/proto/query_coord.proto b/internal/proto/query_coord.proto index 869297836a..cb0ec09556 100644 --- a/internal/proto/query_coord.proto +++ b/internal/proto/query_coord.proto @@ -65,7 +65,9 @@ service QueryNode { rpc GetStatistics(GetStatisticsRequest) returns (internal.GetStatisticsResponse) {} rpc Search(SearchRequest) returns (internal.SearchResults) {} + rpc SearchSegments(SearchRequest) returns (internal.SearchResults) {} rpc Query(QueryRequest) returns (internal.RetrieveResults) {} + rpc QuerySegments(QueryRequest) returns (internal.RetrieveResults) {} rpc ShowConfigurations(internal.ShowConfigurationsRequest) returns (internal.ShowConfigurationsResponse){} // https://wiki.lfaidata.foundation/display/MIL/MEP+8+--+Add+metrics+for+proxy diff --git a/internal/proto/querypb/query_coord.pb.go b/internal/proto/querypb/query_coord.pb.go index 6c00368e34..c4b4267c33 100644 --- a/internal/proto/querypb/query_coord.pb.go +++ b/internal/proto/querypb/query_coord.pb.go @@ -4487,157 +4487,157 @@ func init() { func init() { proto.RegisterFile("query_coord.proto", fileDescriptor_aab7cc9a69ed26e8) } var fileDescriptor_aab7cc9a69ed26e8 = []byte{ - // 4599 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x3c, 0x4b, 0x6f, 0x24, 0x49, - 0x5a, 0x9d, 0xf5, 0xb0, 0xab, 0xbe, 0x7a, 0x3a, 0x6c, 0x77, 0xd7, 0xd6, 0x76, 0xf7, 0x78, 0xb2, - 0xe7, 0xe1, 0xf5, 0xcc, 0xd8, 0xbd, 0xee, 0xdd, 0xd9, 0xde, 0x9d, 0x59, 0x0d, 0xdd, 0xf6, 0x74, - 0x8f, 0x77, 0x7a, 0x3c, 0x26, 0xdd, 0xdd, 0x8b, 0x46, 0xb3, 0x5b, 0x9b, 0xae, 0x0c, 0x97, 0x53, - 0x9d, 0x8f, 0xea, 0x8c, 0x2c, 0xbb, 0x3d, 0x48, 0x9c, 0xb8, 0xb0, 0x02, 0x04, 0x27, 0x38, 0x20, - 0x0e, 0x20, 0xa4, 0x05, 0xc1, 0x0d, 0x24, 0x0e, 0x1c, 0x38, 0x01, 0x02, 0xf1, 0xb8, 0x20, 0xfe, - 0x00, 0x1c, 0x90, 0x40, 0x9c, 0x56, 0x68, 0x6e, 0x28, 0x1e, 0xf9, 0x88, 0xcc, 0x28, 0x57, 0xd9, - 0xd5, 0xb3, 0x33, 0x83, 0xf6, 0x56, 0xf9, 0xc5, 0xe3, 0xfb, 0xe2, 0x7b, 0xc5, 0xf7, 0x7d, 0x11, - 0x51, 0xb0, 0xf0, 0x74, 0x84, 0x83, 0xd3, 0x5e, 0xdf, 0xf7, 0x03, 0x6b, 0x7d, 0x18, 0xf8, 0xa1, - 0x8f, 0x90, 0x6b, 0x3b, 0xc7, 0x23, 0xc2, 0xbf, 0xd6, 0x59, 0x7b, 0xb7, 0xde, 0xf7, 0x5d, 0xd7, - 0xf7, 0x38, 0xac, 0x5b, 0x4f, 0xf7, 0xe8, 0x36, 0x6d, 0x2f, 0xc4, 0x81, 0x67, 0x3a, 0x51, 0x2b, - 0xe9, 0x1f, 0x61, 0xd7, 0x14, 0x5f, 0x55, 0x97, 0x0c, 0xc4, 0xcf, 0xb6, 0x65, 0x86, 0x66, 0x1a, - 0x55, 0x77, 0xc1, 0xf6, 0x2c, 0xfc, 0x2c, 0x0d, 0xd2, 0x7f, 0x55, 0x83, 0xcb, 0xfb, 0x47, 0xfe, - 0xc9, 0x96, 0xef, 0x38, 0xb8, 0x1f, 0xda, 0xbe, 0x47, 0x0c, 0xfc, 0x74, 0x84, 0x49, 0x88, 0x6e, - 0x42, 0xe9, 0xc0, 0x24, 0xb8, 0xa3, 0xad, 0x68, 0xab, 0xb5, 0xcd, 0xab, 0xeb, 0x12, 0x9d, 0x82, - 0xc0, 0x0f, 0xc8, 0xe0, 0xae, 0x49, 0xb0, 0xc1, 0x7a, 0x22, 0x04, 0x25, 0xeb, 0x60, 0x67, 0xbb, - 0x53, 0x58, 0xd1, 0x56, 0x8b, 0x06, 0xfb, 0x8d, 0x5e, 0x82, 0x46, 0x3f, 0x9e, 0x7b, 0x67, 0x9b, - 0x74, 0x8a, 0x2b, 0xc5, 0xd5, 0xa2, 0x21, 0x03, 0xf5, 0x1f, 0x17, 0xe0, 0x4a, 0x8e, 0x0c, 0x32, - 0xf4, 0x3d, 0x82, 0xd1, 0x2d, 0x98, 0x23, 0xa1, 0x19, 0x8e, 0x88, 0xa0, 0xe4, 0xab, 0x4a, 0x4a, - 0xf6, 0x59, 0x17, 0x43, 0x74, 0xcd, 0xa3, 0x2d, 0x28, 0xd0, 0xa2, 0xaf, 0xc3, 0x92, 0xed, 0x7d, - 0x80, 0x5d, 0x3f, 0x38, 0xed, 0x0d, 0x71, 0xd0, 0xc7, 0x5e, 0x68, 0x0e, 0x70, 0x44, 0xe3, 0x62, - 0xd4, 0xb6, 0x97, 0x34, 0xa1, 0x37, 0xe1, 0x0a, 0x97, 0x21, 0xc1, 0xc1, 0xb1, 0xdd, 0xc7, 0x3d, - 0xf3, 0xd8, 0xb4, 0x1d, 0xf3, 0xc0, 0xc1, 0x9d, 0xd2, 0x4a, 0x71, 0xb5, 0x62, 0x2c, 0xb3, 0xe6, - 0x7d, 0xde, 0x7a, 0x27, 0x6a, 0x44, 0x5f, 0x83, 0x76, 0x80, 0x0f, 0x03, 0x4c, 0x8e, 0x7a, 0xc3, - 0xc0, 0x1f, 0x04, 0x98, 0x90, 0x4e, 0x99, 0xa1, 0x69, 0x09, 0xf8, 0x9e, 0x00, 0xeb, 0x7f, 0xa4, - 0xc1, 0x32, 0x65, 0xc6, 0x9e, 0x19, 0x84, 0xf6, 0x67, 0x20, 0x12, 0x1d, 0xea, 0x69, 0x36, 0x74, - 0x8a, 0xac, 0x4d, 0x82, 0xd1, 0x3e, 0xc3, 0x08, 0x3d, 0x65, 0x5f, 0x89, 0x91, 0x2a, 0xc1, 0xf4, - 0x7f, 0x16, 0xba, 0x93, 0xa6, 0x73, 0x16, 0x99, 0x65, 0x71, 0x16, 0xf2, 0x38, 0x2f, 0x22, 0x31, - 0x15, 0xe7, 0x4b, 0x6a, 0xce, 0xff, 0x63, 0x11, 0x96, 0x1f, 0xf8, 0xa6, 0x95, 0xa8, 0xe1, 0xcf, - 0x9e, 0xf3, 0xdf, 0x85, 0x39, 0x6e, 0xd1, 0x9d, 0x12, 0xc3, 0xf5, 0xb2, 0x8c, 0x4b, 0x58, 0x7b, - 0x42, 0xe1, 0x3e, 0x03, 0x18, 0x62, 0x10, 0x7a, 0x19, 0x9a, 0x01, 0x1e, 0x3a, 0x76, 0xdf, 0xec, - 0x79, 0x23, 0xf7, 0x00, 0x07, 0x9d, 0xf2, 0x8a, 0xb6, 0x5a, 0x36, 0x1a, 0x02, 0xba, 0xcb, 0x80, - 0xe8, 0x47, 0xd0, 0x38, 0xb4, 0xb1, 0x63, 0xf5, 0x98, 0x4b, 0xd8, 0xd9, 0xee, 0xcc, 0xad, 0x14, - 0x57, 0x6b, 0x9b, 0x6f, 0xad, 0xe7, 0xbd, 0xd1, 0xba, 0x92, 0x23, 0xeb, 0xf7, 0xe8, 0xf0, 0x1d, - 0x3e, 0xfa, 0x5d, 0x2f, 0x0c, 0x4e, 0x8d, 0xfa, 0x61, 0x0a, 0x84, 0x3a, 0x30, 0x2f, 0xd8, 0xdb, - 0x99, 0x5f, 0xd1, 0x56, 0x2b, 0x46, 0xf4, 0x89, 0x5e, 0x85, 0x56, 0x80, 0x89, 0x3f, 0x0a, 0xfa, - 0xb8, 0x37, 0x08, 0xfc, 0xd1, 0x90, 0x74, 0x2a, 0x2b, 0xc5, 0xd5, 0xaa, 0xd1, 0x8c, 0xc0, 0xf7, - 0x19, 0xb4, 0xfb, 0x0e, 0x2c, 0xe4, 0xb0, 0xa0, 0x36, 0x14, 0x9f, 0xe0, 0x53, 0x26, 0x88, 0xa2, - 0x41, 0x7f, 0xa2, 0x25, 0x28, 0x1f, 0x9b, 0xce, 0x08, 0x0b, 0x56, 0xf3, 0x8f, 0xef, 0x14, 0x6e, - 0x6b, 0xfa, 0xef, 0x69, 0xd0, 0x31, 0xb0, 0x83, 0x4d, 0x82, 0x3f, 0x4f, 0x91, 0x5e, 0x86, 0x39, - 0xcf, 0xb7, 0xf0, 0xce, 0x36, 0x13, 0x69, 0xd1, 0x10, 0x5f, 0xfa, 0xa7, 0x1a, 0x2c, 0xdd, 0xc7, - 0x21, 0x35, 0x03, 0x9b, 0x84, 0x76, 0x3f, 0xb6, 0xf3, 0xef, 0x42, 0x31, 0xc0, 0x4f, 0x05, 0x65, - 0xaf, 0xc9, 0x94, 0xc5, 0xee, 0x5f, 0x35, 0xd2, 0xa0, 0xe3, 0xd0, 0x8b, 0x50, 0xb7, 0x5c, 0xa7, - 0xd7, 0x3f, 0x32, 0x3d, 0x0f, 0x3b, 0xdc, 0x90, 0xaa, 0x46, 0xcd, 0x72, 0x9d, 0x2d, 0x01, 0x42, - 0xd7, 0x01, 0x08, 0x1e, 0xb8, 0xd8, 0x0b, 0x13, 0x9f, 0x9c, 0x82, 0xa0, 0x35, 0x58, 0x38, 0x0c, - 0x7c, 0xb7, 0x47, 0x8e, 0xcc, 0xc0, 0xea, 0x39, 0xd8, 0xb4, 0x70, 0xc0, 0xa8, 0xaf, 0x18, 0x2d, - 0xda, 0xb0, 0x4f, 0xe1, 0x0f, 0x18, 0x18, 0xdd, 0x82, 0x32, 0xe9, 0xfb, 0x43, 0xcc, 0x34, 0xad, - 0xb9, 0x79, 0x4d, 0xa5, 0x43, 0xdb, 0x66, 0x68, 0xee, 0xd3, 0x4e, 0x06, 0xef, 0xab, 0xff, 0x65, - 0x89, 0x9b, 0xda, 0x17, 0xdc, 0xc9, 0xa5, 0xcc, 0xb1, 0xfc, 0x7c, 0xcc, 0x71, 0x6e, 0x2a, 0x73, - 0x9c, 0x3f, 0xdb, 0x1c, 0x73, 0x5c, 0x3b, 0x8f, 0x39, 0x56, 0x26, 0x9a, 0x63, 0x55, 0x65, 0x8e, - 0xe8, 0x5d, 0x68, 0xf1, 0x00, 0xc2, 0xf6, 0x0e, 0xfd, 0x9e, 0x63, 0x93, 0xb0, 0x03, 0x8c, 0xcc, - 0x6b, 0x59, 0x0d, 0xb5, 0xf0, 0xb3, 0x75, 0x8e, 0xd8, 0x3b, 0xf4, 0x8d, 0x86, 0x1d, 0xfd, 0x7c, - 0x60, 0x93, 0x70, 0x76, 0xab, 0xfe, 0xeb, 0xc4, 0xaa, 0xbf, 0xe8, 0xda, 0x93, 0x58, 0x7e, 0x59, - 0xb2, 0xfc, 0x3f, 0xd6, 0xe0, 0x2b, 0xf7, 0x71, 0x18, 0x93, 0x4f, 0x0d, 0x19, 0x7f, 0x41, 0xb7, - 0xf9, 0x3f, 0xd3, 0xa0, 0xab, 0xa2, 0x75, 0x96, 0xad, 0xfe, 0x23, 0xb8, 0x1c, 0xe3, 0xe8, 0x59, - 0x98, 0xf4, 0x03, 0x7b, 0xc8, 0xc4, 0xc8, 0x7c, 0x55, 0x6d, 0xf3, 0x86, 0x4a, 0xf1, 0xb3, 0x14, - 0x2c, 0xc7, 0x53, 0x6c, 0xa7, 0x66, 0xd0, 0x7f, 0x43, 0x83, 0x65, 0xea, 0x1b, 0x85, 0x33, 0xa3, - 0x1a, 0x78, 0x61, 0xbe, 0xca, 0x6e, 0xb2, 0x90, 0x73, 0x93, 0x53, 0xf0, 0x98, 0x85, 0xd8, 0x59, - 0x7a, 0x66, 0xe1, 0xdd, 0x37, 0xa1, 0x4c, 0x0d, 0x30, 0x62, 0xd5, 0x0b, 0x2a, 0x56, 0xa5, 0x91, - 0xf1, 0xde, 0xba, 0xc7, 0xa9, 0x48, 0xfc, 0xf6, 0x0c, 0xea, 0x96, 0x5d, 0x76, 0x41, 0xb1, 0xec, - 0x5f, 0xd7, 0xe0, 0x4a, 0x0e, 0xe1, 0x2c, 0xeb, 0x7e, 0x1b, 0xe6, 0xd8, 0x6e, 0x14, 0x2d, 0xfc, - 0x25, 0xe5, 0xc2, 0x53, 0xe8, 0xa8, 0xb7, 0x31, 0xc4, 0x18, 0xdd, 0x87, 0x76, 0xb6, 0x8d, 0xee, - 0x93, 0x62, 0x8f, 0xec, 0x79, 0xa6, 0xcb, 0x19, 0x50, 0x35, 0x6a, 0x02, 0xb6, 0x6b, 0xba, 0x18, - 0x7d, 0x05, 0x2a, 0xd4, 0x64, 0x7b, 0xb6, 0x15, 0x89, 0x7f, 0x9e, 0x99, 0xb0, 0x45, 0xd0, 0x35, - 0x00, 0xd6, 0x64, 0x5a, 0x56, 0xc0, 0xb7, 0xd0, 0xaa, 0x51, 0xa5, 0x90, 0x3b, 0x14, 0xa0, 0xff, - 0xae, 0x06, 0xd7, 0xf7, 0x4f, 0xbd, 0xfe, 0x2e, 0x3e, 0xd9, 0x0a, 0xb0, 0x19, 0xe2, 0xc4, 0x69, - 0x7f, 0xa6, 0x8c, 0x47, 0x2b, 0x50, 0x4b, 0xd9, 0xaf, 0x50, 0xc9, 0x34, 0x48, 0xff, 0x6d, 0x0d, - 0xea, 0x74, 0x17, 0xf9, 0x00, 0x87, 0x26, 0x55, 0x11, 0xf4, 0x6d, 0xa8, 0x3a, 0xbe, 0x69, 0xf5, - 0xc2, 0xd3, 0x21, 0xa7, 0xa6, 0x99, 0xa5, 0x26, 0xd9, 0x7a, 0x1e, 0x9e, 0x0e, 0xb1, 0x51, 0x71, - 0xc4, 0xaf, 0xa9, 0x28, 0xca, 0x7a, 0x99, 0xa2, 0xc2, 0xcb, 0xfc, 0x4d, 0x19, 0x2e, 0x7f, 0xdf, - 0x0c, 0xfb, 0x47, 0xdb, 0x6e, 0x14, 0xa4, 0x5c, 0x9c, 0x4d, 0x89, 0xdb, 0x2d, 0xa4, 0xdd, 0xee, - 0x73, 0x73, 0xeb, 0xb1, 0x09, 0x96, 0x55, 0x26, 0x48, 0xf3, 0xee, 0xf5, 0xc7, 0x42, 0x8b, 0x52, - 0x26, 0x98, 0x8a, 0x25, 0xe6, 0x2e, 0x12, 0x4b, 0x6c, 0x41, 0x03, 0x3f, 0xeb, 0x3b, 0x23, 0xaa, - 0x8e, 0x0c, 0x3b, 0x0f, 0x12, 0xae, 0x2b, 0xb0, 0xa7, 0xed, 0xbf, 0x2e, 0x06, 0xed, 0x08, 0x1a, - 0xb8, 0xa8, 0x5d, 0x1c, 0x9a, 0x2c, 0x12, 0xa8, 0x6d, 0xae, 0x8c, 0x13, 0x75, 0xa4, 0x1f, 0x5c, - 0xdc, 0xf4, 0x0b, 0x5d, 0x85, 0xaa, 0x88, 0x5c, 0x76, 0xb6, 0x3b, 0x55, 0xc6, 0xbe, 0x04, 0x80, - 0x4c, 0x68, 0x08, 0xe7, 0x28, 0x28, 0xe4, 0xf1, 0xc1, 0xdb, 0x2a, 0x04, 0x6a, 0x61, 0xa7, 0x29, - 0x27, 0x22, 0x8e, 0x21, 0x29, 0x10, 0x4d, 0xec, 0xfd, 0xc3, 0x43, 0xc7, 0xf6, 0xf0, 0x2e, 0x97, - 0x70, 0x8d, 0x11, 0x21, 0x03, 0x69, 0xb4, 0x73, 0x8c, 0x03, 0x62, 0xfb, 0x5e, 0xa7, 0xce, 0xda, - 0xa3, 0xcf, 0x6e, 0x0f, 0x16, 0x72, 0x28, 0x14, 0xd1, 0xc7, 0x37, 0xd2, 0xd1, 0xc7, 0x64, 0x1e, - 0xa7, 0xa2, 0x93, 0x9f, 0x68, 0xb0, 0xfc, 0xc8, 0x23, 0xa3, 0x83, 0x78, 0x6d, 0x9f, 0x8f, 0x1e, - 0x67, 0x9d, 0x5b, 0x29, 0xe7, 0xdc, 0xf4, 0xbf, 0x2f, 0x43, 0x4b, 0xac, 0x82, 0x8a, 0x9b, 0xb9, - 0x82, 0xab, 0x50, 0x8d, 0xf7, 0x37, 0xc1, 0x90, 0x04, 0x90, 0xf5, 0x2d, 0x85, 0x9c, 0x6f, 0x99, - 0x8a, 0xb4, 0x28, 0x5a, 0x29, 0xa5, 0xa2, 0x95, 0x6b, 0x00, 0x87, 0xce, 0x88, 0x1c, 0xf5, 0x42, - 0xdb, 0xc5, 0x22, 0x5a, 0xaa, 0x32, 0xc8, 0x43, 0xdb, 0xc5, 0xe8, 0x0e, 0xd4, 0x0f, 0x6c, 0xcf, - 0xf1, 0x07, 0xbd, 0xa1, 0x19, 0x1e, 0x11, 0x91, 0xae, 0xaa, 0xc4, 0xc2, 0x62, 0xcb, 0xbb, 0xac, - 0xaf, 0x51, 0xe3, 0x63, 0xf6, 0xe8, 0x10, 0x74, 0x1d, 0x6a, 0xde, 0xc8, 0xed, 0xf9, 0x87, 0xbd, - 0xc0, 0x3f, 0x21, 0x2c, 0x29, 0x2d, 0x1a, 0x55, 0x6f, 0xe4, 0x7e, 0x78, 0x68, 0xf8, 0x27, 0x74, - 0x7f, 0xa9, 0xd2, 0x9d, 0x86, 0x38, 0xfe, 0x80, 0x27, 0xa4, 0x93, 0xe7, 0x4f, 0x06, 0xd0, 0xd1, - 0x16, 0x76, 0x42, 0x93, 0x8d, 0xae, 0x4e, 0x37, 0x3a, 0x1e, 0x80, 0x5e, 0x81, 0x66, 0xdf, 0x77, - 0x87, 0x26, 0xe3, 0xd0, 0xbd, 0xc0, 0x77, 0x99, 0xe5, 0x14, 0x8d, 0x0c, 0x14, 0x6d, 0x41, 0x2d, - 0x09, 0xc1, 0x49, 0xa7, 0xc6, 0xf0, 0xe8, 0x2a, 0xf3, 0x4a, 0x85, 0xd8, 0x54, 0x41, 0x21, 0x8e, - 0xc1, 0x09, 0xd5, 0x8c, 0xc8, 0x4a, 0x89, 0xfd, 0x09, 0x16, 0x16, 0x52, 0x13, 0xb0, 0x7d, 0xfb, - 0x13, 0x4c, 0xd3, 0x16, 0xdb, 0x23, 0x38, 0x08, 0xa3, 0x24, 0xb2, 0xd3, 0x60, 0xea, 0xd3, 0xe0, - 0x50, 0xa1, 0xd8, 0x68, 0x1b, 0x9a, 0x24, 0x34, 0x83, 0xb0, 0x37, 0xf4, 0x09, 0x53, 0x80, 0x4e, - 0x93, 0xe9, 0x76, 0x26, 0x21, 0x70, 0xc9, 0x80, 0x2a, 0xf6, 0x9e, 0xe8, 0x64, 0x34, 0xd8, 0xa0, - 0xe8, 0x93, 0xce, 0xc2, 0x38, 0x91, 0xcc, 0xd2, 0x9a, 0x6a, 0x16, 0x36, 0x28, 0xfa, 0xd4, 0xff, - 0xa7, 0x00, 0x4d, 0x79, 0xd1, 0xd4, 0x0b, 0xf0, 0x1c, 0x28, 0xd2, 0xe4, 0xe8, 0x93, 0xb2, 0x00, - 0x7b, 0xe6, 0x81, 0x83, 0x79, 0xc2, 0xc5, 0x14, 0xb9, 0x62, 0xd4, 0x38, 0x8c, 0x4d, 0x40, 0x15, - 0x92, 0xb3, 0x9a, 0x59, 0x4f, 0x91, 0x2d, 0xbf, 0xca, 0x20, 0x2c, 0x30, 0xe8, 0xc0, 0x7c, 0x94, - 0xab, 0x71, 0x35, 0x8e, 0x3e, 0x69, 0xcb, 0xc1, 0xc8, 0x66, 0x58, 0xb9, 0x1a, 0x47, 0x9f, 0x68, - 0x1b, 0xea, 0x7c, 0xca, 0xa1, 0x19, 0x98, 0x6e, 0xa4, 0xc4, 0x2f, 0x2a, 0x1d, 0xc1, 0xfb, 0xf8, - 0xf4, 0x31, 0xf5, 0x29, 0x7b, 0xa6, 0x1d, 0x18, 0x5c, 0xe8, 0x7b, 0x6c, 0x14, 0x5a, 0x85, 0x36, - 0x9f, 0xe5, 0xd0, 0x76, 0xb0, 0x30, 0x87, 0x79, 0x9e, 0xb0, 0x31, 0xf8, 0x3d, 0xdb, 0xc1, 0x5c, - 0xe3, 0xe3, 0x25, 0x30, 0x31, 0x57, 0xb8, 0xc2, 0x33, 0x08, 0x13, 0xf2, 0x0d, 0xe0, 0x99, 0x59, - 0x2f, 0x72, 0x95, 0xdc, 0x9f, 0x73, 0x1a, 0x1f, 0x73, 0x18, 0x0b, 0x80, 0x46, 0x2e, 0x37, 0x19, - 0xe0, 0xcb, 0xf1, 0x46, 0x2e, 0x35, 0x18, 0xfd, 0x1f, 0x4a, 0xb0, 0x48, 0xfd, 0x86, 0x70, 0x21, - 0x33, 0xec, 0xd7, 0xd7, 0x00, 0x2c, 0x12, 0xf6, 0x24, 0x5f, 0x57, 0xb5, 0x48, 0x28, 0xbc, 0xf9, - 0xb7, 0xa3, 0xed, 0xb6, 0x38, 0x3e, 0x39, 0xc8, 0xf8, 0xb1, 0xfc, 0x96, 0x7b, 0xa1, 0x6a, 0xda, - 0x0d, 0x68, 0x88, 0xcc, 0x58, 0x4a, 0xe3, 0xea, 0x1c, 0xb8, 0xab, 0xf6, 0xc6, 0x73, 0xca, 0xaa, - 0x5e, 0x6a, 0xdb, 0x9d, 0x9f, 0x6d, 0xdb, 0xad, 0x64, 0xb7, 0xdd, 0x7b, 0xd0, 0x92, 0x0d, 0x28, - 0xf2, 0x40, 0x13, 0x2c, 0xa8, 0x29, 0x59, 0x10, 0x49, 0xef, 0x9a, 0x20, 0xed, 0x9a, 0x94, 0x0f, - 0x1e, 0xc6, 0x56, 0x2f, 0x0c, 0x4c, 0x8f, 0x1c, 0xe2, 0x80, 0xed, 0xba, 0x15, 0xa3, 0x4e, 0x81, - 0x0f, 0x05, 0x0c, 0xbd, 0x0d, 0xc0, 0xd6, 0xc8, 0x8b, 0x41, 0xf5, 0xf1, 0xc5, 0x20, 0xa6, 0x34, - 0xac, 0x18, 0xc4, 0x98, 0xc2, 0x7e, 0xea, 0xff, 0x54, 0x80, 0xcb, 0x22, 0xab, 0x9f, 0x5d, 0xa1, - 0xc6, 0x6d, 0x9c, 0xd1, 0xce, 0x53, 0x3c, 0x23, 0x4f, 0x2e, 0x4d, 0x11, 0x14, 0x96, 0x15, 0x41, - 0xa1, 0x9c, 0x2b, 0xce, 0xe5, 0x72, 0xc5, 0xb8, 0x4c, 0x36, 0x3f, 0x7d, 0x99, 0x0c, 0x2d, 0x41, - 0x99, 0x25, 0x30, 0x4c, 0xe8, 0x55, 0x83, 0x7f, 0x4c, 0x25, 0x0e, 0xfd, 0x77, 0x0a, 0xd0, 0xd8, - 0xc7, 0x66, 0xd0, 0x3f, 0x8a, 0xf8, 0xf8, 0x66, 0xba, 0xac, 0xf8, 0xd2, 0x98, 0xb2, 0xa2, 0x34, - 0xe4, 0x4b, 0x53, 0x4f, 0xa4, 0x08, 0x42, 0x3f, 0x34, 0x63, 0x2a, 0x7b, 0xde, 0xc8, 0x15, 0xb5, - 0xb6, 0x16, 0x6b, 0x10, 0xa4, 0xee, 0x8e, 0x5c, 0xfd, 0xbf, 0x34, 0xa8, 0xff, 0x22, 0x9d, 0x26, + // 4620 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x7c, 0xcb, 0x6f, 0x1c, 0x47, + 0x7a, 0xb8, 0x7a, 0x1e, 0xe4, 0xcc, 0x37, 0x4f, 0x16, 0x49, 0x69, 0x76, 0x56, 0x92, 0xe9, 0x96, + 0x1f, 0x5c, 0xda, 0x26, 0xb5, 0xd4, 0xae, 0x57, 0xbb, 0xf6, 0xc2, 0x3f, 0x89, 0xb4, 0x64, 0xae, + 0x65, 0x9a, 0xdb, 0x94, 0xb4, 0x3f, 0x38, 0xde, 0x9d, 0x6d, 0x4e, 0x17, 0x87, 0x0d, 0xf5, 0x63, + 0xd4, 0xd5, 0x43, 0x8a, 0x0e, 0x90, 0x53, 0x2e, 0x59, 0xe4, 0x79, 0x4a, 0x0e, 0x41, 0x0e, 0x09, + 0x02, 0x6c, 0x82, 0xe4, 0x96, 0x00, 0x39, 0xe4, 0x90, 0x53, 0x12, 0x24, 0xc8, 0xe3, 0x96, 0x7f, + 0x20, 0x39, 0x04, 0x48, 0x90, 0xd3, 0x22, 0xf0, 0x2d, 0xa8, 0x47, 0x3f, 0xaa, 0xbb, 0x86, 0x33, + 0xe4, 0xc8, 0x6b, 0x3b, 0xc8, 0x6d, 0xfa, 0xab, 0xc7, 0xf7, 0xd5, 0xf7, 0xaa, 0xef, 0xfb, 0xaa, + 0x6a, 0x60, 0xe1, 0xe9, 0x08, 0x07, 0xa7, 0xbd, 0xbe, 0xef, 0x07, 0xd6, 0xfa, 0x30, 0xf0, 0x43, + 0x1f, 0x21, 0xd7, 0x76, 0x8e, 0x47, 0x84, 0x7f, 0xad, 0xb3, 0xf6, 0x6e, 0xbd, 0xef, 0xbb, 0xae, + 0xef, 0x71, 0x58, 0xb7, 0x9e, 0xee, 0xd1, 0x6d, 0xda, 0x5e, 0x88, 0x03, 0xcf, 0x74, 0xa2, 0x56, + 0xd2, 0x3f, 0xc2, 0xae, 0x29, 0xbe, 0xaa, 0x2e, 0x19, 0x88, 0x9f, 0x6d, 0xcb, 0x0c, 0xcd, 0x34, + 0xaa, 0xee, 0x82, 0xed, 0x59, 0xf8, 0x59, 0x1a, 0xa4, 0xff, 0xb2, 0x06, 0x97, 0xf7, 0x8f, 0xfc, + 0x93, 0x2d, 0xdf, 0x71, 0x70, 0x3f, 0xb4, 0x7d, 0x8f, 0x18, 0xf8, 0xe9, 0x08, 0x93, 0x10, 0xdd, + 0x84, 0xd2, 0x81, 0x49, 0x70, 0x47, 0x5b, 0xd1, 0x56, 0x6b, 0x9b, 0x57, 0xd7, 0x25, 0x3a, 0x05, + 0x81, 0x1f, 0x90, 0xc1, 0x5d, 0x93, 0x60, 0x83, 0xf5, 0x44, 0x08, 0x4a, 0xd6, 0xc1, 0xce, 0x76, + 0xa7, 0xb0, 0xa2, 0xad, 0x16, 0x0d, 0xf6, 0x1b, 0xbd, 0x04, 0x8d, 0x7e, 0x3c, 0xf7, 0xce, 0x36, + 0xe9, 0x14, 0x57, 0x8a, 0xab, 0x45, 0x43, 0x06, 0xea, 0x3f, 0x29, 0xc0, 0x95, 0x1c, 0x19, 0x64, + 0xe8, 0x7b, 0x04, 0xa3, 0x5b, 0x30, 0x47, 0x42, 0x33, 0x1c, 0x11, 0x41, 0xc9, 0x57, 0x95, 0x94, + 0xec, 0xb3, 0x2e, 0x86, 0xe8, 0x9a, 0x47, 0x5b, 0x50, 0xa0, 0x45, 0x5f, 0x87, 0x25, 0xdb, 0xfb, + 0x00, 0xbb, 0x7e, 0x70, 0xda, 0x1b, 0xe2, 0xa0, 0x8f, 0xbd, 0xd0, 0x1c, 0xe0, 0x88, 0xc6, 0xc5, + 0xa8, 0x6d, 0x2f, 0x69, 0x42, 0x6f, 0xc2, 0x15, 0x2e, 0x43, 0x82, 0x83, 0x63, 0xbb, 0x8f, 0x7b, + 0xe6, 0xb1, 0x69, 0x3b, 0xe6, 0x81, 0x83, 0x3b, 0xa5, 0x95, 0xe2, 0x6a, 0xc5, 0x58, 0x66, 0xcd, + 0xfb, 0xbc, 0xf5, 0x4e, 0xd4, 0x88, 0xbe, 0x06, 0xed, 0x00, 0x1f, 0x06, 0x98, 0x1c, 0xf5, 0x86, + 0x81, 0x3f, 0x08, 0x30, 0x21, 0x9d, 0x32, 0x43, 0xd3, 0x12, 0xf0, 0x3d, 0x01, 0xd6, 0xff, 0x50, + 0x83, 0x65, 0xca, 0x8c, 0x3d, 0x33, 0x08, 0xed, 0xcf, 0x40, 0x24, 0x3a, 0xd4, 0xd3, 0x6c, 0xe8, + 0x14, 0x59, 0x9b, 0x04, 0xa3, 0x7d, 0x86, 0x11, 0x7a, 0xca, 0xbe, 0x12, 0x23, 0x55, 0x82, 0xe9, + 0xff, 0x24, 0x74, 0x27, 0x4d, 0xe7, 0x2c, 0x32, 0xcb, 0xe2, 0x2c, 0xe4, 0x71, 0x5e, 0x44, 0x62, + 0x2a, 0xce, 0x97, 0xd4, 0x9c, 0xff, 0x87, 0x22, 0x2c, 0x3f, 0xf0, 0x4d, 0x2b, 0x51, 0xc3, 0x9f, + 0x3f, 0xe7, 0xbf, 0x0b, 0x73, 0xdc, 0xa2, 0x3b, 0x25, 0x86, 0xeb, 0x65, 0x19, 0x97, 0xb0, 0xf6, + 0x84, 0xc2, 0x7d, 0x06, 0x30, 0xc4, 0x20, 0xf4, 0x32, 0x34, 0x03, 0x3c, 0x74, 0xec, 0xbe, 0xd9, + 0xf3, 0x46, 0xee, 0x01, 0x0e, 0x3a, 0xe5, 0x15, 0x6d, 0xb5, 0x6c, 0x34, 0x04, 0x74, 0x97, 0x01, + 0xd1, 0x8f, 0xa1, 0x71, 0x68, 0x63, 0xc7, 0xea, 0x31, 0x97, 0xb0, 0xb3, 0xdd, 0x99, 0x5b, 0x29, + 0xae, 0xd6, 0x36, 0xdf, 0x5a, 0xcf, 0x7b, 0xa3, 0x75, 0x25, 0x47, 0xd6, 0xef, 0xd1, 0xe1, 0x3b, + 0x7c, 0xf4, 0xbb, 0x5e, 0x18, 0x9c, 0x1a, 0xf5, 0xc3, 0x14, 0x08, 0x75, 0x60, 0x5e, 0xb0, 0xb7, + 0x33, 0xbf, 0xa2, 0xad, 0x56, 0x8c, 0xe8, 0x13, 0xbd, 0x0a, 0xad, 0x00, 0x13, 0x7f, 0x14, 0xf4, + 0x71, 0x6f, 0x10, 0xf8, 0xa3, 0x21, 0xe9, 0x54, 0x56, 0x8a, 0xab, 0x55, 0xa3, 0x19, 0x81, 0xef, + 0x33, 0x68, 0xf7, 0x1d, 0x58, 0xc8, 0x61, 0x41, 0x6d, 0x28, 0x3e, 0xc1, 0xa7, 0x4c, 0x10, 0x45, + 0x83, 0xfe, 0x44, 0x4b, 0x50, 0x3e, 0x36, 0x9d, 0x11, 0x16, 0xac, 0xe6, 0x1f, 0xdf, 0x29, 0xdc, + 0xd6, 0xf4, 0xdf, 0xd5, 0xa0, 0x63, 0x60, 0x07, 0x9b, 0x04, 0x7f, 0x9e, 0x22, 0xbd, 0x0c, 0x73, + 0x9e, 0x6f, 0xe1, 0x9d, 0x6d, 0x26, 0xd2, 0xa2, 0x21, 0xbe, 0xf4, 0x4f, 0x35, 0x58, 0xba, 0x8f, + 0x43, 0x6a, 0x06, 0x36, 0x09, 0xed, 0x7e, 0x6c, 0xe7, 0xdf, 0x85, 0x62, 0x80, 0x9f, 0x0a, 0xca, + 0x5e, 0x93, 0x29, 0x8b, 0xdd, 0xbf, 0x6a, 0xa4, 0x41, 0xc7, 0xa1, 0x17, 0xa1, 0x6e, 0xb9, 0x4e, + 0xaf, 0x7f, 0x64, 0x7a, 0x1e, 0x76, 0xb8, 0x21, 0x55, 0x8d, 0x9a, 0xe5, 0x3a, 0x5b, 0x02, 0x84, + 0xae, 0x03, 0x10, 0x3c, 0x70, 0xb1, 0x17, 0x26, 0x3e, 0x39, 0x05, 0x41, 0x6b, 0xb0, 0x70, 0x18, + 0xf8, 0x6e, 0x8f, 0x1c, 0x99, 0x81, 0xd5, 0x73, 0xb0, 0x69, 0xe1, 0x80, 0x51, 0x5f, 0x31, 0x5a, + 0xb4, 0x61, 0x9f, 0xc2, 0x1f, 0x30, 0x30, 0xba, 0x05, 0x65, 0xd2, 0xf7, 0x87, 0x98, 0x69, 0x5a, + 0x73, 0xf3, 0x9a, 0x4a, 0x87, 0xb6, 0xcd, 0xd0, 0xdc, 0xa7, 0x9d, 0x0c, 0xde, 0x57, 0xff, 0x8b, + 0x12, 0x37, 0xb5, 0x2f, 0xb8, 0x93, 0x4b, 0x99, 0x63, 0xf9, 0xf9, 0x98, 0xe3, 0xdc, 0x54, 0xe6, + 0x38, 0x7f, 0xb6, 0x39, 0xe6, 0xb8, 0x76, 0x1e, 0x73, 0xac, 0x4c, 0x34, 0xc7, 0xaa, 0xca, 0x1c, + 0xd1, 0xbb, 0xd0, 0xe2, 0x01, 0x84, 0xed, 0x1d, 0xfa, 0x3d, 0xc7, 0x26, 0x61, 0x07, 0x18, 0x99, + 0xd7, 0xb2, 0x1a, 0x6a, 0xe1, 0x67, 0xeb, 0x1c, 0xb1, 0x77, 0xe8, 0x1b, 0x0d, 0x3b, 0xfa, 0xf9, + 0xc0, 0x26, 0xe1, 0xec, 0x56, 0xfd, 0x57, 0x89, 0x55, 0x7f, 0xd1, 0xb5, 0x27, 0xb1, 0xfc, 0xb2, + 0x64, 0xf9, 0x7f, 0xa4, 0xc1, 0x57, 0xee, 0xe3, 0x30, 0x26, 0x9f, 0x1a, 0x32, 0xfe, 0x82, 0x6e, + 0xf3, 0x7f, 0xaa, 0x41, 0x57, 0x45, 0xeb, 0x2c, 0x5b, 0xfd, 0x47, 0x70, 0x39, 0xc6, 0xd1, 0xb3, + 0x30, 0xe9, 0x07, 0xf6, 0x90, 0x89, 0x91, 0xf9, 0xaa, 0xda, 0xe6, 0x0d, 0x95, 0xe2, 0x67, 0x29, + 0x58, 0x8e, 0xa7, 0xd8, 0x4e, 0xcd, 0xa0, 0xff, 0x9a, 0x06, 0xcb, 0xd4, 0x37, 0x0a, 0x67, 0x46, + 0x35, 0xf0, 0xc2, 0x7c, 0x95, 0xdd, 0x64, 0x21, 0xe7, 0x26, 0xa7, 0xe0, 0x31, 0x0b, 0xb1, 0xb3, + 0xf4, 0xcc, 0xc2, 0xbb, 0x6f, 0x42, 0x99, 0x1a, 0x60, 0xc4, 0xaa, 0x17, 0x54, 0xac, 0x4a, 0x23, + 0xe3, 0xbd, 0x75, 0x8f, 0x53, 0x91, 0xf8, 0xed, 0x19, 0xd4, 0x2d, 0xbb, 0xec, 0x82, 0x62, 0xd9, + 0xbf, 0xaa, 0xc1, 0x95, 0x1c, 0xc2, 0x59, 0xd6, 0xfd, 0x36, 0xcc, 0xb1, 0xdd, 0x28, 0x5a, 0xf8, + 0x4b, 0xca, 0x85, 0xa7, 0xd0, 0x51, 0x6f, 0x63, 0x88, 0x31, 0xba, 0x0f, 0xed, 0x6c, 0x1b, 0xdd, + 0x27, 0xc5, 0x1e, 0xd9, 0xf3, 0x4c, 0x97, 0x33, 0xa0, 0x6a, 0xd4, 0x04, 0x6c, 0xd7, 0x74, 0x31, + 0xfa, 0x0a, 0x54, 0xa8, 0xc9, 0xf6, 0x6c, 0x2b, 0x12, 0xff, 0x3c, 0x33, 0x61, 0x8b, 0xa0, 0x6b, + 0x00, 0xac, 0xc9, 0xb4, 0xac, 0x80, 0x6f, 0xa1, 0x55, 0xa3, 0x4a, 0x21, 0x77, 0x28, 0x40, 0xff, + 0x1d, 0x0d, 0xae, 0xef, 0x9f, 0x7a, 0xfd, 0x5d, 0x7c, 0xb2, 0x15, 0x60, 0x33, 0xc4, 0x89, 0xd3, + 0xfe, 0x4c, 0x19, 0x8f, 0x56, 0xa0, 0x96, 0xb2, 0x5f, 0xa1, 0x92, 0x69, 0x90, 0xfe, 0x5b, 0x1a, + 0xd4, 0xe9, 0x2e, 0xf2, 0x01, 0x0e, 0x4d, 0xaa, 0x22, 0xe8, 0xdb, 0x50, 0x75, 0x7c, 0xd3, 0xea, + 0x85, 0xa7, 0x43, 0x4e, 0x4d, 0x33, 0x4b, 0x4d, 0xb2, 0xf5, 0x3c, 0x3c, 0x1d, 0x62, 0xa3, 0xe2, + 0x88, 0x5f, 0x53, 0x51, 0x94, 0xf5, 0x32, 0x45, 0x85, 0x97, 0xf9, 0xeb, 0x32, 0x5c, 0xfe, 0x81, + 0x19, 0xf6, 0x8f, 0xb6, 0xdd, 0x28, 0x48, 0xb9, 0x38, 0x9b, 0x12, 0xb7, 0x5b, 0x48, 0xbb, 0xdd, + 0xe7, 0xe6, 0xd6, 0x63, 0x13, 0x2c, 0xab, 0x4c, 0x90, 0xe6, 0xdd, 0xeb, 0x8f, 0x85, 0x16, 0xa5, + 0x4c, 0x30, 0x15, 0x4b, 0xcc, 0x5d, 0x24, 0x96, 0xd8, 0x82, 0x06, 0x7e, 0xd6, 0x77, 0x46, 0x54, + 0x1d, 0x19, 0x76, 0x1e, 0x24, 0x5c, 0x57, 0x60, 0x4f, 0xdb, 0x7f, 0x5d, 0x0c, 0xda, 0x11, 0x34, + 0x70, 0x51, 0xbb, 0x38, 0x34, 0x59, 0x24, 0x50, 0xdb, 0x5c, 0x19, 0x27, 0xea, 0x48, 0x3f, 0xb8, + 0xb8, 0xe9, 0x17, 0xba, 0x0a, 0x55, 0x11, 0xb9, 0xec, 0x6c, 0x77, 0xaa, 0x8c, 0x7d, 0x09, 0x00, + 0x99, 0xd0, 0x10, 0xce, 0x51, 0x50, 0xc8, 0xe3, 0x83, 0xb7, 0x55, 0x08, 0xd4, 0xc2, 0x4e, 0x53, + 0x4e, 0x44, 0x1c, 0x43, 0x52, 0x20, 0x9a, 0xd8, 0xfb, 0x87, 0x87, 0x8e, 0xed, 0xe1, 0x5d, 0x2e, + 0xe1, 0x1a, 0x23, 0x42, 0x06, 0xd2, 0x68, 0xe7, 0x18, 0x07, 0xc4, 0xf6, 0xbd, 0x4e, 0x9d, 0xb5, + 0x47, 0x9f, 0xdd, 0x1e, 0x2c, 0xe4, 0x50, 0x28, 0xa2, 0x8f, 0x6f, 0xa4, 0xa3, 0x8f, 0xc9, 0x3c, + 0x4e, 0x45, 0x27, 0x3f, 0xd5, 0x60, 0xf9, 0x91, 0x47, 0x46, 0x07, 0xf1, 0xda, 0x3e, 0x1f, 0x3d, + 0xce, 0x3a, 0xb7, 0x52, 0xce, 0xb9, 0xe9, 0x7f, 0x57, 0x86, 0x96, 0x58, 0x05, 0x15, 0x37, 0x73, + 0x05, 0x57, 0xa1, 0x1a, 0xef, 0x6f, 0x82, 0x21, 0x09, 0x20, 0xeb, 0x5b, 0x0a, 0x39, 0xdf, 0x32, + 0x15, 0x69, 0x51, 0xb4, 0x52, 0x4a, 0x45, 0x2b, 0xd7, 0x00, 0x0e, 0x9d, 0x11, 0x39, 0xea, 0x85, + 0xb6, 0x8b, 0x45, 0xb4, 0x54, 0x65, 0x90, 0x87, 0xb6, 0x8b, 0xd1, 0x1d, 0xa8, 0x1f, 0xd8, 0x9e, + 0xe3, 0x0f, 0x7a, 0x43, 0x33, 0x3c, 0x22, 0x22, 0x5d, 0x55, 0x89, 0x85, 0xc5, 0x96, 0x77, 0x59, + 0x5f, 0xa3, 0xc6, 0xc7, 0xec, 0xd1, 0x21, 0xe8, 0x3a, 0xd4, 0xbc, 0x91, 0xdb, 0xf3, 0x0f, 0x7b, + 0x81, 0x7f, 0x42, 0x58, 0x52, 0x5a, 0x34, 0xaa, 0xde, 0xc8, 0xfd, 0xf0, 0xd0, 0xf0, 0x4f, 0xe8, + 0xfe, 0x52, 0xa5, 0x3b, 0x0d, 0x71, 0xfc, 0x01, 0x4f, 0x48, 0x27, 0xcf, 0x9f, 0x0c, 0xa0, 0xa3, + 0x2d, 0xec, 0x84, 0x26, 0x1b, 0x5d, 0x9d, 0x6e, 0x74, 0x3c, 0x00, 0xbd, 0x02, 0xcd, 0xbe, 0xef, + 0x0e, 0x4d, 0xc6, 0xa1, 0x7b, 0x81, 0xef, 0x32, 0xcb, 0x29, 0x1a, 0x19, 0x28, 0xda, 0x82, 0x5a, + 0x12, 0x82, 0x93, 0x4e, 0x8d, 0xe1, 0xd1, 0x55, 0xe6, 0x95, 0x0a, 0xb1, 0xa9, 0x82, 0x42, 0x1c, + 0x83, 0x13, 0xaa, 0x19, 0x91, 0x95, 0x12, 0xfb, 0x13, 0x2c, 0x2c, 0xa4, 0x26, 0x60, 0xfb, 0xf6, + 0x27, 0x98, 0xa6, 0x2d, 0xb6, 0x47, 0x70, 0x10, 0x46, 0x49, 0x64, 0xa7, 0xc1, 0xd4, 0xa7, 0xc1, + 0xa1, 0x42, 0xb1, 0xd1, 0x36, 0x34, 0x49, 0x68, 0x06, 0x61, 0x6f, 0xe8, 0x13, 0xa6, 0x00, 0x9d, + 0x26, 0xd3, 0xed, 0x4c, 0x42, 0xe0, 0x92, 0x01, 0x55, 0xec, 0x3d, 0xd1, 0xc9, 0x68, 0xb0, 0x41, + 0xd1, 0x27, 0x9d, 0x85, 0x71, 0x22, 0x99, 0xa5, 0x35, 0xd5, 0x2c, 0x6c, 0x50, 0xf4, 0xa9, 0xff, + 0x57, 0x01, 0x9a, 0xf2, 0xa2, 0xa9, 0x17, 0xe0, 0x39, 0x50, 0xa4, 0xc9, 0xd1, 0x27, 0x65, 0x01, + 0xf6, 0xcc, 0x03, 0x07, 0xf3, 0x84, 0x8b, 0x29, 0x72, 0xc5, 0xa8, 0x71, 0x18, 0x9b, 0x80, 0x2a, + 0x24, 0x67, 0x35, 0xb3, 0x9e, 0x22, 0x5b, 0x7e, 0x95, 0x41, 0x58, 0x60, 0xd0, 0x81, 0xf9, 0x28, + 0x57, 0xe3, 0x6a, 0x1c, 0x7d, 0xd2, 0x96, 0x83, 0x91, 0xcd, 0xb0, 0x72, 0x35, 0x8e, 0x3e, 0xd1, + 0x36, 0xd4, 0xf9, 0x94, 0x43, 0x33, 0x30, 0xdd, 0x48, 0x89, 0x5f, 0x54, 0x3a, 0x82, 0xf7, 0xf1, + 0xe9, 0x63, 0xea, 0x53, 0xf6, 0x4c, 0x3b, 0x30, 0xb8, 0xd0, 0xf7, 0xd8, 0x28, 0xb4, 0x0a, 0x6d, + 0x3e, 0xcb, 0xa1, 0xed, 0x60, 0x61, 0x0e, 0xf3, 0x3c, 0x61, 0x63, 0xf0, 0x7b, 0xb6, 0x83, 0xb9, + 0xc6, 0xc7, 0x4b, 0x60, 0x62, 0xae, 0x70, 0x85, 0x67, 0x10, 0x26, 0xe4, 0x1b, 0xc0, 0x33, 0xb3, + 0x5e, 0xe4, 0x2a, 0xb9, 0x3f, 0xe7, 0x34, 0x3e, 0xe6, 0x30, 0x16, 0x00, 0x8d, 0x5c, 0x6e, 0x32, + 0xc0, 0x97, 0xe3, 0x8d, 0x5c, 0x6a, 0x30, 0xfa, 0xdf, 0x97, 0x60, 0x91, 0xfa, 0x0d, 0xe1, 0x42, + 0x66, 0xd8, 0xaf, 0xaf, 0x01, 0x58, 0x24, 0xec, 0x49, 0xbe, 0xae, 0x6a, 0x91, 0x50, 0x78, 0xf3, + 0x6f, 0x47, 0xdb, 0x6d, 0x71, 0x7c, 0x72, 0x90, 0xf1, 0x63, 0xf9, 0x2d, 0xf7, 0x42, 0xd5, 0xb4, + 0x1b, 0xd0, 0x10, 0x99, 0xb1, 0x94, 0xc6, 0xd5, 0x39, 0x70, 0x57, 0xed, 0x8d, 0xe7, 0x94, 0x55, + 0xbd, 0xd4, 0xb6, 0x3b, 0x3f, 0xdb, 0xb6, 0x5b, 0xc9, 0x6e, 0xbb, 0xf7, 0xa0, 0x25, 0x1b, 0x50, + 0xe4, 0x81, 0x26, 0x58, 0x50, 0x53, 0xb2, 0x20, 0x92, 0xde, 0x35, 0x41, 0xda, 0x35, 0x29, 0x1f, + 0x3c, 0x8c, 0xad, 0x5e, 0x18, 0x98, 0x1e, 0x39, 0xc4, 0x01, 0xdb, 0x75, 0x2b, 0x46, 0x9d, 0x02, + 0x1f, 0x0a, 0x18, 0x7a, 0x1b, 0x80, 0xad, 0x91, 0x17, 0x83, 0xea, 0xe3, 0x8b, 0x41, 0x4c, 0x69, + 0x58, 0x31, 0x88, 0x31, 0x85, 0xfd, 0xd4, 0xff, 0xb1, 0x00, 0x97, 0x45, 0x56, 0x3f, 0xbb, 0x42, + 0x8d, 0xdb, 0x38, 0xa3, 0x9d, 0xa7, 0x78, 0x46, 0x9e, 0x5c, 0x9a, 0x22, 0x28, 0x2c, 0x2b, 0x82, + 0x42, 0x39, 0x57, 0x9c, 0xcb, 0xe5, 0x8a, 0x71, 0x99, 0x6c, 0x7e, 0xfa, 0x32, 0x19, 0x5a, 0x82, + 0x32, 0x4b, 0x60, 0x98, 0xd0, 0xab, 0x06, 0xff, 0x98, 0x4a, 0x1c, 0xfa, 0x6f, 0x17, 0xa0, 0xb1, + 0x8f, 0xcd, 0xa0, 0x7f, 0x14, 0xf1, 0xf1, 0xcd, 0x74, 0x59, 0xf1, 0xa5, 0x31, 0x65, 0x45, 0x69, + 0xc8, 0x97, 0xa6, 0x9e, 0x48, 0x11, 0x84, 0x7e, 0x68, 0xc6, 0x54, 0xf6, 0xbc, 0x91, 0x2b, 0x6a, + 0x6d, 0x2d, 0xd6, 0x20, 0x48, 0xdd, 0x1d, 0xb9, 0xfa, 0x7f, 0x68, 0x50, 0xff, 0x3e, 0x9d, 0x26, 0x62, 0xcc, 0xed, 0x34, 0x63, 0x5e, 0x19, 0xc3, 0x18, 0x03, 0x87, 0x81, 0x8d, 0x8f, 0xf1, 0x97, - 0xae, 0xd4, 0xfa, 0xb7, 0x1a, 0x74, 0x69, 0x26, 0x6a, 0x70, 0x87, 0x31, 0xbb, 0x75, 0xdd, 0x80, + 0xae, 0xd4, 0xfa, 0x37, 0x1a, 0x74, 0x69, 0x26, 0x6a, 0x70, 0x87, 0x31, 0xbb, 0x75, 0xdd, 0x80, 0xc6, 0xb1, 0x14, 0x5b, 0x16, 0x98, 0x72, 0xd6, 0x8f, 0xd3, 0x99, 0xb3, 0x01, 0xed, 0xa8, 0xf2, 0x29, 0x16, 0x1b, 0xf9, 0xef, 0x57, 0x55, 0x54, 0x67, 0x88, 0x63, 0xfe, 0xaf, 0x15, 0xc8, 0x40, - 0xfd, 0x37, 0x35, 0x58, 0x54, 0x74, 0x44, 0x57, 0x60, 0x5e, 0x64, 0xe9, 0x62, 0xa3, 0xe7, 0xf6, + 0xfd, 0xd7, 0x35, 0x58, 0x54, 0x74, 0x44, 0x57, 0x60, 0x5e, 0x64, 0xe9, 0x62, 0xa3, 0xe7, 0xf6, 0x6e, 0x51, 0xf1, 0x24, 0x75, 0x26, 0xdb, 0xca, 0x07, 0xac, 0x16, 0x7a, 0x01, 0x6a, 0x71, 0xce, 0x62, 0xe5, 0xe4, 0x63, 0x11, 0xd4, 0x85, 0x8a, 0x70, 0x83, 0x51, 0x32, 0x18, 0x7f, 0xeb, 0x4f, 0x00, 0xdd, 0xc7, 0xc9, 0xa6, 0x33, 0x0b, 0x47, 0x13, 0x7f, 0x93, 0x10, 0x9a, 0x76, 0x42, 0x96, - 0xfe, 0xef, 0x1a, 0x2c, 0x4a, 0xd8, 0x66, 0xa9, 0xa6, 0x24, 0x1b, 0x63, 0xe1, 0x22, 0x1b, 0xa3, + 0xfe, 0xaf, 0x1a, 0x2c, 0x4a, 0xd8, 0x66, 0xa9, 0xa6, 0x24, 0x1b, 0x63, 0xe1, 0x22, 0x1b, 0xa3, 0x54, 0x31, 0x28, 0x9e, 0xab, 0x62, 0x70, 0x1d, 0x20, 0xe6, 0x7f, 0xc4, 0xd1, 0x14, 0x44, 0xff, - 0x2b, 0x0d, 0x2e, 0xbf, 0x67, 0x7a, 0x96, 0x7f, 0x78, 0x38, 0xbb, 0xaa, 0x6e, 0x81, 0x94, 0x3e, + 0x4b, 0x0d, 0x2e, 0xbf, 0x67, 0x7a, 0x96, 0x7f, 0x78, 0x38, 0xbb, 0xaa, 0x6e, 0x81, 0x94, 0x3e, 0x4e, 0x5b, 0x33, 0x93, 0x73, 0xce, 0xd7, 0x60, 0x21, 0xe0, 0x3b, 0x93, 0x25, 0xeb, 0x72, 0xd1, - 0x68, 0x47, 0x0d, 0xb1, 0x8e, 0xfe, 0x69, 0x01, 0x10, 0x5d, 0xf5, 0x5d, 0xd3, 0x31, 0xbd, 0x3e, + 0x68, 0x47, 0x0d, 0xb1, 0x8e, 0xfe, 0x49, 0x01, 0x10, 0x5d, 0xf5, 0x5d, 0xd3, 0x31, 0xbd, 0x3e, 0xbe, 0x38, 0xe9, 0x2f, 0x43, 0x53, 0x8a, 0x3d, 0xe2, 0x33, 0xec, 0x74, 0xf0, 0x41, 0xd0, 0xfb, 0xd0, 0x3c, 0xe0, 0xa8, 0x7a, 0x01, 0x36, 0x89, 0xef, 0x09, 0x71, 0x28, 0xcb, 0x63, 0x0f, 0x03, 0x7b, 0x30, 0xc0, 0xc1, 0x96, 0xef, 0x59, 0x22, 0x88, 0x3e, 0x88, 0xc8, 0xa4, 0x43, 0xa9, 0x31, 0x24, 0x81, 0x58, 0x2c, 0x9c, 0x38, 0x12, 0x63, 0xac, 0x20, 0xd8, 0x74, 0x12, 0x46, 0x24, 0xbb, - 0x61, 0x9b, 0x37, 0xec, 0x8f, 0xaf, 0x8e, 0x2a, 0x02, 0x23, 0xfd, 0xcf, 0x35, 0x40, 0x71, 0xa6, + 0x61, 0x9b, 0x37, 0xec, 0x8f, 0xaf, 0x8e, 0x2a, 0x02, 0x23, 0xfd, 0xcf, 0x34, 0x40, 0x71, 0xa6, 0xcc, 0x6a, 0x02, 0xcc, 0xa2, 0xb3, 0x43, 0x35, 0xc5, 0xa6, 0x7c, 0x15, 0xaa, 0x56, 0x34, 0x52, 0xb8, 0xa0, 0x04, 0xc0, 0xf6, 0x48, 0x46, 0x74, 0x8f, 0x6a, 0x1e, 0xb6, 0xa2, 0x4c, 0x94, 0x03, 0x1f, 0x30, 0x98, 0x1c, 0x57, 0x95, 0xb2, 0x71, 0x55, 0xba, 0xf8, 0x57, 0x96, 0x8a, 0x7f, 0xfa, - 0x4f, 0x0a, 0xd0, 0x66, 0x5b, 0xc8, 0x56, 0x52, 0xe6, 0x99, 0x8a, 0xe8, 0x1b, 0xd0, 0x10, 0x77, + 0x4f, 0x0b, 0xd0, 0x66, 0x5b, 0xc8, 0x56, 0x52, 0xe6, 0x99, 0x8a, 0xe8, 0x1b, 0xd0, 0x10, 0x77, 0x40, 0x24, 0xc2, 0xeb, 0x4f, 0x53, 0x93, 0xa1, 0x9b, 0xb0, 0xc4, 0x3b, 0x05, 0x98, 0x8c, 0x9c, 0x24, 0x09, 0xe3, 0x59, 0x08, 0x7a, 0xca, 0xf7, 0x2e, 0xda, 0x14, 0x8d, 0x78, 0x04, 0x97, 0x07, 0x8e, 0x7f, 0x60, 0x3a, 0x3d, 0x59, 0x3c, 0x5c, 0x86, 0x53, 0x68, 0xfc, 0x12, 0x1f, 0xbe, 0x9f, 0x96, 0x21, 0x41, 0x77, 0xa1, 0x41, 0x30, 0x7e, 0x92, 0x64, 0x66, 0xe5, 0x69, 0x32, 0xb3, 0x3a, - 0x1d, 0x13, 0x27, 0x66, 0xbf, 0xaf, 0x41, 0x2b, 0x53, 0xba, 0xcf, 0xd6, 0x11, 0xb4, 0x7c, 0x1d, + 0x1d, 0x13, 0x27, 0x66, 0xbf, 0xa7, 0x41, 0x2b, 0x53, 0xba, 0xcf, 0xd6, 0x11, 0xb4, 0x7c, 0x1d, 0xe1, 0x36, 0x94, 0xa9, 0xa7, 0xe2, 0x7b, 0x4b, 0x53, 0x9d, 0xe3, 0xca, 0xb3, 0x1a, 0x7c, 0x00, - 0xda, 0x80, 0x45, 0xc5, 0x15, 0x01, 0x21, 0x7e, 0x94, 0xbf, 0x21, 0xa0, 0xff, 0xb4, 0x04, 0xb5, + 0xda, 0x80, 0x45, 0xc5, 0x15, 0x01, 0x21, 0x7e, 0x94, 0xbf, 0x21, 0xa0, 0xff, 0xac, 0x04, 0xb5, 0x14, 0x2b, 0x26, 0x94, 0x40, 0x9e, 0x4b, 0x09, 0x76, 0xdc, 0x91, 0x30, 0x55, 0x39, 0x17, 0xbb, 0x3c, 0x61, 0x13, 0xd9, 0xa3, 0x8b, 0x5d, 0x96, 0xae, 0xa5, 0x33, 0xb1, 0x39, 0x29, 0x13, 0xcb, 0xe4, 0xaa, 0xf3, 0x67, 0xe4, 0xaa, 0x15, 0x39, 0x57, 0x95, 0x4c, 0xa8, 0x9a, 0x35, 0xa1, 0x69, @@ -4646,136 +4646,137 @@ var fileDescriptor_aab7cc9a69ed26e8 = []byte{ 0x1c, 0x79, 0x66, 0xf6, 0x95, 0xad, 0x87, 0x34, 0x2e, 0x54, 0x0f, 0x79, 0x01, 0x6a, 0x51, 0xa4, 0x42, 0x2d, 0xbd, 0xc9, 0x9d, 0x5e, 0xe4, 0x06, 0x2c, 0x22, 0xf9, 0x81, 0x96, 0x7c, 0x08, 0x90, 0x2d, 0x24, 0xb4, 0xf3, 0x85, 0x84, 0x2b, 0x30, 0x6f, 0x93, 0xde, 0xa1, 0xf9, 0x04, 0x77, 0x16, - 0x58, 0xeb, 0x9c, 0x4d, 0xee, 0x99, 0x4f, 0xb0, 0xfe, 0x2f, 0x45, 0x68, 0x26, 0x1b, 0xec, 0xd4, + 0x58, 0xeb, 0x9c, 0x4d, 0xee, 0x99, 0x4f, 0xb0, 0xfe, 0xcf, 0x45, 0x68, 0x26, 0x1b, 0xec, 0xd4, 0x1e, 0x64, 0x9a, 0x6b, 0x32, 0xbb, 0xd0, 0x4e, 0xe2, 0x1e, 0xc6, 0xe1, 0x33, 0x93, 0xe7, 0xec, 0xc9, 0x5a, 0x6b, 0x98, 0xb1, 0x57, 0x69, 0xbb, 0x2f, 0x9d, 0x6b, 0xbb, 0x9f, 0xf1, 0x00, 0xfd, 0x16, 0x2c, 0xc7, 0x7b, 0xaf, 0xb4, 0x6c, 0x9e, 0x60, 0x2d, 0x45, 0x8d, 0x7b, 0xe9, 0xe5, 0x8f, 0x71, 0x01, 0xf3, 0xe3, 0x5c, 0x40, 0x56, 0x05, 0x2a, 0x39, 0x15, 0xc8, 0x9f, 0xe3, 0x57, 0x15, 0xe7, 0xf8, 0xfa, 0x23, 0x58, 0x64, 0xb5, 0x5f, 0xd2, 0x0f, 0xec, 0x03, 0x1c, 0xa7, 0x00, 0xd3, - 0x88, 0xb5, 0x0b, 0x95, 0x4c, 0x16, 0x11, 0x7f, 0xeb, 0x3f, 0xd6, 0xe0, 0x72, 0x7e, 0x5e, 0xa6, - 0x31, 0x89, 0x23, 0xd1, 0x24, 0x47, 0xf2, 0x4b, 0xb0, 0x98, 0x8a, 0x28, 0xa5, 0x99, 0xc7, 0x44, - 0xe0, 0x0a, 0xc2, 0x0d, 0x94, 0xcc, 0x11, 0xc1, 0xf4, 0x9f, 0x6a, 0x71, 0x09, 0x9d, 0xc2, 0x06, - 0xec, 0x60, 0x81, 0xee, 0x6b, 0xbe, 0xe7, 0xd8, 0x5e, 0x5c, 0x29, 0x11, 0x6b, 0xe4, 0x40, 0x51, - 0x29, 0x79, 0x0f, 0x5a, 0xa2, 0x53, 0xbc, 0x3d, 0x4d, 0x19, 0x90, 0x35, 0xf9, 0xb8, 0x78, 0x63, - 0x7a, 0x19, 0x9a, 0xa2, 0xe2, 0x1f, 0xe1, 0x2b, 0xaa, 0xce, 0x01, 0xbe, 0x07, 0xed, 0xa8, 0xdb, - 0x79, 0x37, 0xc4, 0x96, 0x18, 0x18, 0x07, 0x76, 0xbf, 0xa6, 0x41, 0x47, 0xde, 0x1e, 0x53, 0xcb, - 0x3f, 0x7f, 0x78, 0xf7, 0x96, 0x7c, 0x8c, 0xfb, 0xf2, 0x19, 0xf4, 0x24, 0x78, 0xa2, 0xc3, 0xdc, - 0xdf, 0x2a, 0xb0, 0x33, 0x79, 0x9a, 0xea, 0x6d, 0xdb, 0x24, 0x0c, 0xec, 0x83, 0xd1, 0x6c, 0x07, - 0x8b, 0x26, 0xd4, 0xfa, 0x47, 0xb8, 0xff, 0x64, 0xe8, 0xdb, 0x89, 0x54, 0xde, 0x51, 0xd1, 0x34, - 0x1e, 0xed, 0xfa, 0x56, 0x32, 0x03, 0x3f, 0xba, 0x49, 0xcf, 0xd9, 0xfd, 0x01, 0xb4, 0xb3, 0x1d, - 0xd2, 0x07, 0x2f, 0x55, 0x7e, 0xf0, 0x72, 0x4b, 0x3e, 0x78, 0x99, 0x10, 0x69, 0xa4, 0xce, 0x5d, - 0xfe, 0xa2, 0x00, 0x5f, 0x55, 0xd2, 0x36, 0x4b, 0x96, 0x34, 0xae, 0x8e, 0x74, 0x17, 0x2a, 0x99, - 0xa4, 0xf6, 0x95, 0x33, 0xe4, 0x27, 0x6a, 0xa9, 0xbc, 0xa6, 0x47, 0x92, 0xd8, 0x2a, 0x31, 0xf8, - 0xd2, 0xf8, 0x39, 0x84, 0xdd, 0x49, 0x73, 0x44, 0xe3, 0xd0, 0x1d, 0xa8, 0xf3, 0x82, 0x41, 0xef, - 0xd8, 0xc6, 0x27, 0xd1, 0x79, 0xe4, 0x75, 0xa5, 0x6b, 0x66, 0xfd, 0x1e, 0xdb, 0xf8, 0xc4, 0xa8, - 0x39, 0xf1, 0x6f, 0xa2, 0xff, 0x77, 0x11, 0x20, 0x69, 0xa3, 0xd9, 0x59, 0x62, 0xf3, 0xc2, 0x88, - 0x53, 0x10, 0x1a, 0x4b, 0xc8, 0x91, 0x6b, 0xf4, 0x89, 0x8c, 0xe4, 0x58, 0xc1, 0xb2, 0x49, 0x28, - 0xf8, 0xb2, 0x71, 0x36, 0x2d, 0x11, 0x8b, 0xa8, 0xc8, 0x84, 0xce, 0x90, 0x04, 0x82, 0xde, 0x00, - 0x34, 0x08, 0xfc, 0x13, 0xdb, 0x1b, 0xa4, 0xf3, 0x0d, 0x9e, 0x96, 0x2c, 0x88, 0x96, 0x54, 0xc2, - 0xf1, 0x43, 0x68, 0x67, 0xba, 0x47, 0x2c, 0xb9, 0x35, 0x81, 0x8c, 0xfb, 0xd2, 0x5c, 0x42, 0x7d, - 0x5b, 0x32, 0x06, 0xd2, 0xed, 0x41, 0x3b, 0x4b, 0xaf, 0xe2, 0xec, 0xf0, 0x9b, 0xb2, 0x0a, 0x9f, - 0xe5, 0x69, 0xe8, 0x34, 0x29, 0x25, 0xee, 0x9a, 0xb0, 0xa4, 0xa2, 0x44, 0x81, 0xe4, 0xc2, 0x76, - 0xf2, 0x4e, 0x1c, 0xec, 0x32, 0x0e, 0x8f, 0xdb, 0x3f, 0x52, 0xb5, 0xe0, 0x82, 0x54, 0x0b, 0xd6, - 0xff, 0x4e, 0x03, 0x94, 0x57, 0x6c, 0xd4, 0x84, 0x42, 0x3c, 0x49, 0x61, 0x67, 0x3b, 0xa3, 0x48, - 0x85, 0x9c, 0x22, 0x5d, 0x85, 0x6a, 0xbc, 0x9f, 0x0b, 0xe7, 0x9d, 0x00, 0xd2, 0x6a, 0x56, 0x92, - 0xd5, 0x2c, 0x45, 0x58, 0x59, 0x2e, 0x52, 0xdf, 0x84, 0x25, 0xc7, 0x24, 0x61, 0x8f, 0xd7, 0xc2, - 0x43, 0xdb, 0xc5, 0x24, 0x34, 0xdd, 0x21, 0x0b, 0x96, 0x4b, 0x06, 0xa2, 0x6d, 0xdb, 0xb4, 0xe9, - 0x61, 0xd4, 0xa2, 0x1f, 0x01, 0xca, 0x9b, 0x57, 0x1a, 0xb7, 0x26, 0xe3, 0x9e, 0xb4, 0xa6, 0x14, - 0x6d, 0x45, 0x99, 0x69, 0x7f, 0x58, 0x04, 0x94, 0xc4, 0x38, 0xf1, 0x69, 0xeb, 0x34, 0x81, 0xc1, - 0x06, 0x2c, 0xe6, 0x23, 0xa0, 0x28, 0xec, 0x43, 0xb9, 0xf8, 0x47, 0x15, 0xab, 0x14, 0x55, 0x77, - 0x0e, 0xdf, 0x8c, 0x1d, 0x22, 0x0f, 0xe8, 0xae, 0x8f, 0x2d, 0xd5, 0xcb, 0x3e, 0xf1, 0x07, 0xd9, - 0xbb, 0x8a, 0xdc, 0xc2, 0x6e, 0x2b, 0x9d, 0x57, 0x6e, 0xc9, 0x13, 0x2f, 0x2a, 0x4a, 0xa1, 0xe6, - 0xdc, 0x79, 0x42, 0xcd, 0xd9, 0x6f, 0x16, 0xfe, 0x5b, 0x01, 0x16, 0x62, 0x46, 0x9e, 0x4b, 0x48, - 0x93, 0x0f, 0xc6, 0x3f, 0x63, 0xa9, 0x7c, 0xac, 0x96, 0xca, 0xb7, 0xce, 0x0c, 0xf7, 0xa7, 0x15, - 0xca, 0xec, 0x9c, 0xfd, 0x04, 0xe6, 0x45, 0xe1, 0x36, 0xe7, 0x28, 0xa6, 0x49, 0xa8, 0x97, 0xa0, - 0x4c, 0xfd, 0x52, 0x54, 0x75, 0xe3, 0x1f, 0x9c, 0xa5, 0xe9, 0x9b, 0xab, 0xc2, 0x57, 0x34, 0xa4, - 0x8b, 0xab, 0xfa, 0x7f, 0x6a, 0x00, 0xfb, 0xa7, 0x5e, 0xff, 0x0e, 0x37, 0xd2, 0x9b, 0x50, 0x9a, - 0x74, 0xcf, 0x89, 0xf6, 0x66, 0xba, 0xc5, 0x7a, 0x4e, 0x21, 0x5c, 0xa9, 0x64, 0x50, 0xcc, 0x96, - 0x0c, 0xc6, 0x25, 0xfb, 0xe3, 0x5d, 0xd9, 0xb7, 0xa0, 0x44, 0x03, 0x3d, 0x71, 0x4f, 0x68, 0xaa, - 0x03, 0x4f, 0x36, 0x40, 0xff, 0xb4, 0x00, 0x57, 0x28, 0xf5, 0xcf, 0x27, 0x2a, 0x9c, 0x46, 0x34, - 0x29, 0x6f, 0x59, 0x94, 0xbd, 0xe5, 0x6d, 0x98, 0xe7, 0xe9, 0x7e, 0x14, 0xdf, 0x5c, 0x1f, 0xc7, - 0x6b, 0x2e, 0x19, 0x23, 0xea, 0x3e, 0x6b, 0xce, 0x28, 0x1d, 0xb6, 0xce, 0xcd, 0x76, 0xd8, 0x3a, - 0x9f, 0x2d, 0x0a, 0xa6, 0x84, 0x56, 0x91, 0x7d, 0xfc, 0x23, 0x68, 0x18, 0x69, 0xc5, 0x43, 0x08, - 0x4a, 0xa9, 0x7b, 0x85, 0xec, 0x37, 0x4b, 0xf3, 0xcc, 0xa1, 0xd9, 0xb7, 0xc3, 0x53, 0xc6, 0xce, - 0xb2, 0x11, 0x7f, 0xab, 0xb5, 0x5c, 0xff, 0x5f, 0x0d, 0x2e, 0x47, 0x87, 0x7a, 0xc2, 0x86, 0x2e, - 0x2e, 0xd1, 0x4d, 0x58, 0x16, 0x06, 0x93, 0xb1, 0x1c, 0x1e, 0xcc, 0x2d, 0x72, 0x98, 0xbc, 0x8c, - 0x4d, 0x58, 0x0e, 0xcd, 0x60, 0x80, 0xc3, 0xec, 0x18, 0x2e, 0xef, 0x45, 0xde, 0x28, 0x8f, 0x99, - 0xe6, 0x50, 0xf5, 0x05, 0x7e, 0x21, 0x47, 0xb0, 0x56, 0x98, 0x00, 0x78, 0x23, 0x57, 0xac, 0x52, - 0x3f, 0x81, 0xab, 0xfc, 0x66, 0xef, 0x81, 0x4c, 0xd1, 0x4c, 0x35, 0x75, 0xe5, 0xba, 0x33, 0x1e, - 0xe3, 0x0f, 0x34, 0xb8, 0x36, 0x06, 0xf3, 0x2c, 0xd9, 0xc4, 0x03, 0x25, 0xf6, 0x31, 0xb9, 0x9f, - 0x84, 0x97, 0xdf, 0xa3, 0x97, 0x89, 0xfc, 0xb4, 0x04, 0x0b, 0xb9, 0x4e, 0xe7, 0xd6, 0xb9, 0xd7, - 0x01, 0x51, 0x21, 0xc4, 0xaf, 0xd8, 0x58, 0x3a, 0x2d, 0xb6, 0xa6, 0xb6, 0x37, 0x72, 0xe3, 0x17, - 0x6c, 0x34, 0xa3, 0x46, 0x36, 0xef, 0xcd, 0x2b, 0xea, 0xb1, 0xe4, 0x4a, 0xe3, 0x1f, 0x2b, 0xe4, - 0x08, 0x5c, 0xdf, 0x1d, 0xb9, 0xbc, 0xf8, 0x2e, 0xa4, 0xcc, 0xb7, 0x1b, 0x8a, 0x4a, 0x02, 0xa3, - 0x43, 0x58, 0x60, 0xd7, 0xb5, 0x46, 0xe1, 0xc0, 0xa7, 0x01, 0x3d, 0xa3, 0x8b, 0x6f, 0x6a, 0xdf, - 0x99, 0x1a, 0xd3, 0x87, 0x62, 0x34, 0x25, 0x5e, 0xc4, 0xf4, 0x9e, 0x0c, 0x8d, 0xf0, 0xd8, 0x5e, - 0xdf, 0x77, 0x63, 0x3c, 0x73, 0xe7, 0xc4, 0xb3, 0x23, 0x46, 0xcb, 0x78, 0xd2, 0xd0, 0xee, 0x16, - 0x2c, 0x2b, 0x97, 0x3e, 0x69, 0x1b, 0x2d, 0xa7, 0xf3, 0x83, 0xbb, 0xb0, 0xa4, 0x5a, 0xd5, 0x05, - 0xe6, 0xc8, 0x51, 0x7c, 0x9e, 0x39, 0xf4, 0x3f, 0x29, 0x40, 0x63, 0x1b, 0x3b, 0x38, 0xc4, 0x9f, - 0xed, 0x99, 0x67, 0xee, 0x00, 0xb7, 0x98, 0x3f, 0xc0, 0xcd, 0x9d, 0x46, 0x97, 0x14, 0xa7, 0xd1, - 0xd7, 0xe2, 0x43, 0x78, 0x3a, 0x4b, 0x59, 0xde, 0xa1, 0x2d, 0xf4, 0x16, 0xd4, 0x87, 0x81, 0xed, - 0x9a, 0xc1, 0x69, 0xef, 0x09, 0x3e, 0x25, 0x62, 0xd3, 0xe8, 0x28, 0xb7, 0x9d, 0x9d, 0x6d, 0x62, - 0xd4, 0x44, 0xef, 0xf7, 0xf1, 0x29, 0x3b, 0xe0, 0x8f, 0x93, 0x0d, 0x7e, 0x15, 0xab, 0x64, 0xa4, - 0x20, 0x6b, 0x2b, 0x50, 0x8d, 0x6f, 0xbc, 0xa0, 0x0a, 0x94, 0xee, 0x8d, 0x1c, 0xa7, 0x7d, 0x09, - 0x55, 0xa1, 0xcc, 0xd2, 0x91, 0xb6, 0xb6, 0xf6, 0x0b, 0x50, 0x8d, 0x4f, 0xed, 0x51, 0x0d, 0xe6, - 0x1f, 0x79, 0xef, 0x7b, 0xfe, 0x89, 0xd7, 0xbe, 0x84, 0xe6, 0xa1, 0x78, 0xc7, 0x71, 0xda, 0x1a, - 0x6a, 0x40, 0x75, 0x3f, 0x0c, 0xb0, 0x49, 0x65, 0xd6, 0x2e, 0xa0, 0x26, 0xc0, 0x7b, 0x36, 0x09, - 0xfd, 0xc0, 0xee, 0x9b, 0x4e, 0xbb, 0xb8, 0xf6, 0x09, 0x34, 0xe5, 0x22, 0x2e, 0xaa, 0x43, 0x65, - 0xd7, 0x0f, 0xdf, 0x7d, 0x66, 0x93, 0xb0, 0x7d, 0x89, 0xf6, 0xdf, 0xf5, 0xc3, 0xbd, 0x00, 0x13, - 0xec, 0x85, 0x6d, 0x0d, 0x01, 0xcc, 0x7d, 0xe8, 0x6d, 0xdb, 0xe4, 0x49, 0xbb, 0x80, 0x16, 0xc5, - 0xf9, 0x8c, 0xe9, 0xec, 0x88, 0xca, 0x68, 0xbb, 0x48, 0x87, 0xc7, 0x5f, 0x25, 0xd4, 0x86, 0x7a, - 0xdc, 0xe5, 0xfe, 0xde, 0xa3, 0x76, 0x99, 0x52, 0xcf, 0x7f, 0xce, 0xad, 0x59, 0xd0, 0xce, 0x9e, - 0x2b, 0xd2, 0x39, 0xf9, 0x22, 0x62, 0x50, 0xfb, 0x12, 0x5d, 0x99, 0x38, 0xd8, 0x6d, 0x6b, 0xa8, - 0x05, 0xb5, 0xd4, 0x31, 0x69, 0xbb, 0x40, 0x01, 0xf7, 0x83, 0x61, 0x5f, 0x28, 0x14, 0x27, 0x81, - 0x6a, 0xe7, 0x36, 0xe5, 0x44, 0x69, 0xed, 0x2e, 0x54, 0xa2, 0x90, 0x9f, 0x76, 0x15, 0x2c, 0xa2, - 0x9f, 0xed, 0x4b, 0x68, 0x01, 0x1a, 0xd2, 0xb3, 0xa8, 0xb6, 0x86, 0x10, 0x34, 0xe5, 0x87, 0x8b, - 0xed, 0xc2, 0xda, 0x26, 0x40, 0x12, 0x3a, 0x53, 0x72, 0x76, 0xbc, 0x63, 0xd3, 0xb1, 0x2d, 0x4e, - 0x1b, 0x6d, 0xa2, 0xdc, 0x65, 0xdc, 0xe1, 0x86, 0xda, 0x2e, 0xac, 0xad, 0x41, 0x25, 0x0a, 0x07, - 0x29, 0xdc, 0xc0, 0xae, 0x7f, 0x8c, 0xb9, 0x64, 0xf6, 0x31, 0x65, 0x65, 0x15, 0xca, 0x77, 0x5c, - 0xec, 0x59, 0xed, 0xc2, 0xe6, 0x7f, 0x2c, 0x02, 0xf0, 0x53, 0x41, 0xdf, 0x0f, 0x2c, 0xe4, 0xb0, - 0xdb, 0x01, 0x5b, 0xbe, 0x3b, 0xf4, 0xbd, 0xe8, 0xc8, 0x82, 0xa0, 0xf5, 0x4c, 0xaa, 0xce, 0x3f, - 0xf2, 0x1d, 0x05, 0x23, 0xba, 0x2f, 0x29, 0xfb, 0x67, 0x3a, 0xeb, 0x97, 0x90, 0xcb, 0xb0, 0xd1, - 0xe4, 0xf6, 0xa1, 0xdd, 0x7f, 0x12, 0x1f, 0x25, 0x8e, 0x7f, 0x3d, 0x98, 0xe9, 0x1a, 0xe1, 0xbb, - 0xa1, 0xc4, 0xb7, 0x1f, 0x06, 0xb6, 0x37, 0x88, 0xf6, 0x3f, 0xfd, 0x12, 0x7a, 0x9a, 0x79, 0xbb, - 0x18, 0x21, 0xdc, 0x9c, 0xe6, 0xb9, 0xe2, 0xc5, 0x50, 0x3a, 0xd0, 0xca, 0x3c, 0x12, 0x47, 0x6b, - 0xea, 0x47, 0x20, 0xaa, 0x07, 0xed, 0xdd, 0xd7, 0xa6, 0xea, 0x1b, 0x63, 0xb3, 0xa1, 0x29, 0xbf, - 0x6e, 0x46, 0x5f, 0x1b, 0x37, 0x41, 0xee, 0x19, 0x5a, 0x77, 0x6d, 0x9a, 0xae, 0x31, 0xaa, 0x8f, - 0xb8, 0xae, 0x4e, 0x42, 0xa5, 0x7c, 0xf9, 0xd7, 0x3d, 0x2b, 0xf4, 0xd0, 0x2f, 0xa1, 0x1f, 0xd1, - 0x28, 0x21, 0xf3, 0x58, 0x0e, 0xbd, 0xae, 0xde, 0xd9, 0xd4, 0x6f, 0xea, 0x26, 0x61, 0xf8, 0x28, - 0x6b, 0x69, 0xe3, 0xa9, 0xcf, 0xbd, 0xc2, 0x9d, 0x9e, 0xfa, 0xd4, 0xf4, 0x67, 0x51, 0x7f, 0x6e, - 0x0c, 0x0e, 0x4f, 0x98, 0x14, 0xcf, 0x74, 0xb2, 0xaa, 0x9c, 0xe4, 0x2b, 0xe3, 0xdf, 0xf4, 0x4c, - 0xc2, 0x36, 0x62, 0x46, 0x9a, 0x3d, 0x0e, 0x7f, 0x63, 0x4c, 0xa1, 0x5d, 0xfd, 0x3e, 0xb0, 0xbb, - 0x3e, 0x6d, 0xf7, 0xb4, 0x2e, 0xcb, 0x4f, 0xd0, 0xd4, 0x22, 0x52, 0x3e, 0x9b, 0x53, 0xeb, 0xb2, - 0xfa, 0x45, 0x9b, 0x7e, 0x09, 0x3d, 0x94, 0xfc, 0x3a, 0x7a, 0x65, 0x9c, 0x2a, 0xc8, 0xf7, 0x63, - 0x26, 0xf1, 0xed, 0x97, 0x01, 0x71, 0x4b, 0xf5, 0x0e, 0xed, 0xc1, 0x28, 0x30, 0xb9, 0x1a, 0x8f, - 0x73, 0x6e, 0xf9, 0xae, 0x11, 0x9a, 0xaf, 0x9f, 0x63, 0x44, 0xbc, 0xa4, 0x1e, 0xc0, 0x7d, 0x1c, - 0x7e, 0x80, 0xc3, 0xc0, 0xee, 0x93, 0xec, 0x8a, 0x12, 0xff, 0x2d, 0x3a, 0x44, 0xa8, 0x5e, 0x9d, - 0xd8, 0x2f, 0x46, 0x70, 0x00, 0xb5, 0xfb, 0x34, 0x83, 0x62, 0x51, 0x21, 0x41, 0x63, 0x47, 0x46, - 0x3d, 0x22, 0x14, 0xab, 0x93, 0x3b, 0xa6, 0x9d, 0x67, 0xe6, 0x39, 0x1e, 0x1a, 0x2b, 0xd8, 0xfc, - 0x23, 0x41, 0xb5, 0xf3, 0x1c, 0xf3, 0xbe, 0x8f, 0xaf, 0x88, 0x1d, 0xf6, 0xbc, 0x87, 0x4d, 0x27, - 0x3c, 0x1a, 0xb3, 0xa2, 0x54, 0x8f, 0xb3, 0x57, 0x24, 0x75, 0x8c, 0x71, 0x60, 0x58, 0xe4, 0x56, - 0x28, 0xa7, 0x9e, 0x1b, 0xea, 0x29, 0xf2, 0x3d, 0xa7, 0x54, 0x3d, 0x13, 0x16, 0xb6, 0x03, 0x7f, - 0x28, 0x23, 0x79, 0x43, 0x89, 0x24, 0xd7, 0x6f, 0x4a, 0x14, 0xdf, 0x87, 0x7a, 0x94, 0xe1, 0xb3, - 0x9c, 0x44, 0xcd, 0x85, 0x74, 0x97, 0x29, 0x27, 0xfe, 0x18, 0x5a, 0x99, 0xd2, 0x81, 0x5a, 0xe8, - 0xea, 0xfa, 0xc2, 0xa4, 0xd9, 0x4f, 0x00, 0xb1, 0x37, 0x96, 0xf2, 0x33, 0x71, 0x75, 0x7c, 0x93, - 0xef, 0x18, 0x21, 0xd9, 0x98, 0xba, 0x7f, 0x2c, 0xf9, 0x5f, 0x81, 0x65, 0x65, 0x7a, 0x9e, 0x75, - 0x08, 0xe2, 0x42, 0xec, 0x19, 0x35, 0x84, 0xac, 0x43, 0x38, 0x73, 0x44, 0x84, 0x7f, 0xf3, 0x5f, - 0x5b, 0x50, 0x65, 0x71, 0x1e, 0x93, 0xd6, 0xcf, 0xc3, 0xbc, 0xe7, 0x1b, 0xe6, 0x7d, 0x0c, 0xad, - 0xcc, 0xe3, 0x40, 0xb5, 0xd2, 0xaa, 0x5f, 0x10, 0x4e, 0x11, 0xad, 0xc8, 0xcf, 0xf3, 0xd4, 0x5b, - 0xa1, 0xf2, 0x09, 0xdf, 0xa4, 0xb9, 0x1f, 0xf3, 0x77, 0xb5, 0xf1, 0x2d, 0x85, 0x57, 0xc7, 0x16, - 0xef, 0xe5, 0x8b, 0xad, 0x9f, 0x7f, 0x14, 0xf4, 0xe5, 0x8e, 0x40, 0x3f, 0x86, 0x56, 0xe6, 0xe9, - 0x88, 0x5a, 0x63, 0xd4, 0xef, 0x4b, 0x26, 0xcd, 0xfe, 0x33, 0x0c, 0x9e, 0x2c, 0x58, 0x54, 0xdc, - 0xd4, 0x47, 0xeb, 0xe3, 0x02, 0x51, 0xf5, 0x95, 0xfe, 0xc9, 0x0b, 0x6a, 0x48, 0x66, 0x9a, 0xdd, - 0x6f, 0x12, 0x22, 0xb3, 0xff, 0x2f, 0xd3, 0x7d, 0x7d, 0xba, 0x3f, 0xa3, 0x89, 0x17, 0xb4, 0x0f, - 0x73, 0xfc, 0x41, 0x09, 0x7a, 0x51, 0x7d, 0x88, 0x91, 0x7a, 0x6c, 0xd2, 0x9d, 0xf4, 0x24, 0x85, - 0x8c, 0x9c, 0x90, 0xb0, 0x49, 0xcb, 0xcc, 0xfb, 0x22, 0x65, 0x55, 0x3f, 0xfd, 0xb2, 0xa3, 0x3b, - 0xf9, 0x31, 0x47, 0x34, 0xe9, 0xff, 0xef, 0x08, 0xf3, 0x19, 0x7b, 0x3a, 0x90, 0xbd, 0x1c, 0x83, - 0xd6, 0xcf, 0x77, 0xc3, 0xa7, 0xbb, 0x31, 0x75, 0xff, 0x18, 0xf3, 0x0f, 0xa1, 0x9d, 0x3d, 0x90, - 0x42, 0xaf, 0x8d, 0xd3, 0x67, 0x15, 0xce, 0x09, 0xca, 0xfc, 0x3d, 0x98, 0xe3, 0x95, 0x48, 0xb5, - 0x86, 0x49, 0x55, 0xca, 0x09, 0x73, 0xdd, 0xfd, 0xc6, 0x47, 0x9b, 0x03, 0x3b, 0x3c, 0x1a, 0x1d, - 0xd0, 0x96, 0x0d, 0xde, 0xf5, 0x0d, 0xdb, 0x17, 0xbf, 0x36, 0x22, 0x59, 0x6e, 0xb0, 0xd1, 0x1b, - 0x0c, 0xc1, 0xf0, 0xe0, 0x60, 0x8e, 0x7d, 0xde, 0xfa, 0xbf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x65, - 0x0a, 0x38, 0xc2, 0xdd, 0x4f, 0x00, 0x00, + 0x88, 0xb5, 0x0b, 0x95, 0x4c, 0x16, 0x11, 0x7f, 0xeb, 0x3f, 0xd1, 0xe0, 0x72, 0x7e, 0x5e, 0xa6, + 0x31, 0x89, 0x23, 0xd1, 0x24, 0x47, 0xf2, 0xff, 0x61, 0x31, 0x15, 0x51, 0x4a, 0x33, 0x8f, 0x89, + 0xc0, 0x15, 0x84, 0x1b, 0x28, 0x99, 0x23, 0x82, 0xe9, 0x3f, 0xd3, 0xe2, 0x12, 0x3a, 0x85, 0x0d, + 0xd8, 0xc1, 0x02, 0xdd, 0xd7, 0x7c, 0xcf, 0xb1, 0xbd, 0xb8, 0x52, 0x22, 0xd6, 0xc8, 0x81, 0xa2, + 0x52, 0xf2, 0x1e, 0xb4, 0x44, 0xa7, 0x78, 0x7b, 0x9a, 0x32, 0x20, 0x6b, 0xf2, 0x71, 0xf1, 0xc6, + 0xf4, 0x32, 0x34, 0x45, 0xc5, 0x3f, 0xc2, 0x57, 0x54, 0x9d, 0x03, 0x7c, 0x0f, 0xda, 0x51, 0xb7, + 0xf3, 0x6e, 0x88, 0x2d, 0x31, 0x30, 0x0e, 0xec, 0x7e, 0x45, 0x83, 0x8e, 0xbc, 0x3d, 0xa6, 0x96, + 0x7f, 0xfe, 0xf0, 0xee, 0x2d, 0xf9, 0x18, 0xf7, 0xe5, 0x33, 0xe8, 0x49, 0xf0, 0x44, 0x87, 0xb9, + 0xbf, 0x59, 0x60, 0x67, 0xf2, 0x34, 0xd5, 0xdb, 0xb6, 0x49, 0x18, 0xd8, 0x07, 0xa3, 0xd9, 0x0e, + 0x16, 0x4d, 0xa8, 0xf5, 0x8f, 0x70, 0xff, 0xc9, 0xd0, 0xb7, 0x13, 0xa9, 0xbc, 0xa3, 0xa2, 0x69, + 0x3c, 0xda, 0xf5, 0xad, 0x64, 0x06, 0x7e, 0x74, 0x93, 0x9e, 0xb3, 0xfb, 0x43, 0x68, 0x67, 0x3b, + 0xa4, 0x0f, 0x5e, 0xaa, 0xfc, 0xe0, 0xe5, 0x96, 0x7c, 0xf0, 0x32, 0x21, 0xd2, 0x48, 0x9d, 0xbb, + 0xfc, 0x79, 0x01, 0xbe, 0xaa, 0xa4, 0x6d, 0x96, 0x2c, 0x69, 0x5c, 0x1d, 0xe9, 0x2e, 0x54, 0x32, + 0x49, 0xed, 0x2b, 0x67, 0xc8, 0x4f, 0xd4, 0x52, 0x79, 0x4d, 0x8f, 0x24, 0xb1, 0x55, 0x62, 0xf0, + 0xa5, 0xf1, 0x73, 0x08, 0xbb, 0x93, 0xe6, 0x88, 0xc6, 0xa1, 0x3b, 0x50, 0xe7, 0x05, 0x83, 0xde, + 0xb1, 0x8d, 0x4f, 0xa2, 0xf3, 0xc8, 0xeb, 0x4a, 0xd7, 0xcc, 0xfa, 0x3d, 0xb6, 0xf1, 0x89, 0x51, + 0x73, 0xe2, 0xdf, 0x44, 0xff, 0xcf, 0x22, 0x40, 0xd2, 0x46, 0xb3, 0xb3, 0xc4, 0xe6, 0x85, 0x11, + 0xa7, 0x20, 0x34, 0x96, 0x90, 0x23, 0xd7, 0xe8, 0x13, 0x19, 0xc9, 0xb1, 0x82, 0x65, 0x93, 0x50, + 0xf0, 0x65, 0xe3, 0x6c, 0x5a, 0x22, 0x16, 0x51, 0x91, 0x09, 0x9d, 0x21, 0x09, 0x04, 0xbd, 0x01, + 0x68, 0x10, 0xf8, 0x27, 0xb6, 0x37, 0x48, 0xe7, 0x1b, 0x3c, 0x2d, 0x59, 0x10, 0x2d, 0xa9, 0x84, + 0xe3, 0x47, 0xd0, 0xce, 0x74, 0x8f, 0x58, 0x72, 0x6b, 0x02, 0x19, 0xf7, 0xa5, 0xb9, 0x84, 0xfa, + 0xb6, 0x64, 0x0c, 0xa4, 0xdb, 0x83, 0x76, 0x96, 0x5e, 0xc5, 0xd9, 0xe1, 0x37, 0x65, 0x15, 0x3e, + 0xcb, 0xd3, 0xd0, 0x69, 0x52, 0x4a, 0xdc, 0x35, 0x61, 0x49, 0x45, 0x89, 0x02, 0xc9, 0x85, 0xed, + 0xe4, 0x9d, 0x38, 0xd8, 0x65, 0x1c, 0x1e, 0xb7, 0x7f, 0xa4, 0x6a, 0xc1, 0x05, 0xa9, 0x16, 0xac, + 0xff, 0xad, 0x06, 0x28, 0xaf, 0xd8, 0xa8, 0x09, 0x85, 0x78, 0x92, 0xc2, 0xce, 0x76, 0x46, 0x91, + 0x0a, 0x39, 0x45, 0xba, 0x0a, 0xd5, 0x78, 0x3f, 0x17, 0xce, 0x3b, 0x01, 0xa4, 0xd5, 0xac, 0x24, + 0xab, 0x59, 0x8a, 0xb0, 0xb2, 0x5c, 0xa4, 0xbe, 0x09, 0x4b, 0x8e, 0x49, 0xc2, 0x1e, 0xaf, 0x85, + 0x87, 0xb6, 0x8b, 0x49, 0x68, 0xba, 0x43, 0x16, 0x2c, 0x97, 0x0c, 0x44, 0xdb, 0xb6, 0x69, 0xd3, + 0xc3, 0xa8, 0x45, 0x3f, 0x02, 0x94, 0x37, 0xaf, 0x34, 0x6e, 0x4d, 0xc6, 0x3d, 0x69, 0x4d, 0x29, + 0xda, 0x8a, 0x32, 0xd3, 0xfe, 0xa0, 0x08, 0x28, 0x89, 0x71, 0xe2, 0xd3, 0xd6, 0x69, 0x02, 0x83, + 0x0d, 0x58, 0xcc, 0x47, 0x40, 0x51, 0xd8, 0x87, 0x72, 0xf1, 0x8f, 0x2a, 0x56, 0x29, 0xaa, 0xee, + 0x1c, 0xbe, 0x19, 0x3b, 0x44, 0x1e, 0xd0, 0x5d, 0x1f, 0x5b, 0xaa, 0x97, 0x7d, 0xe2, 0x0f, 0xb3, + 0x77, 0x15, 0xb9, 0x85, 0xdd, 0x56, 0x3a, 0xaf, 0xdc, 0x92, 0x27, 0x5e, 0x54, 0x94, 0x42, 0xcd, + 0xb9, 0xf3, 0x84, 0x9a, 0xb3, 0xdf, 0x2c, 0xfc, 0x97, 0x02, 0x2c, 0xc4, 0x8c, 0x3c, 0x97, 0x90, + 0x26, 0x1f, 0x8c, 0x7f, 0xc6, 0x52, 0xf9, 0x58, 0x2d, 0x95, 0x6f, 0x9d, 0x19, 0xee, 0x4f, 0x2b, + 0x94, 0xd9, 0x39, 0xfb, 0x09, 0xcc, 0x8b, 0xc2, 0x6d, 0xce, 0x51, 0x4c, 0x93, 0x50, 0x2f, 0x41, + 0x99, 0xfa, 0xa5, 0xa8, 0xea, 0xc6, 0x3f, 0x38, 0x4b, 0xd3, 0x37, 0x57, 0x85, 0xaf, 0x68, 0x48, + 0x17, 0x57, 0xf5, 0x7f, 0xd7, 0x00, 0xf6, 0x4f, 0xbd, 0xfe, 0x1d, 0x6e, 0xa4, 0x37, 0xa1, 0x34, + 0xe9, 0x9e, 0x13, 0xed, 0xcd, 0x74, 0x8b, 0xf5, 0x9c, 0x42, 0xb8, 0x52, 0xc9, 0xa0, 0x98, 0x2d, + 0x19, 0x8c, 0x4b, 0xf6, 0xc7, 0xbb, 0xb2, 0x6f, 0x41, 0x89, 0x06, 0x7a, 0xe2, 0x9e, 0xd0, 0x54, + 0x07, 0x9e, 0x6c, 0x80, 0xfe, 0x69, 0x01, 0xae, 0x50, 0xea, 0x9f, 0x4f, 0x54, 0x38, 0x8d, 0x68, + 0x52, 0xde, 0xb2, 0x28, 0x7b, 0xcb, 0xdb, 0x30, 0xcf, 0xd3, 0xfd, 0x28, 0xbe, 0xb9, 0x3e, 0x8e, + 0xd7, 0x5c, 0x32, 0x46, 0xd4, 0x7d, 0xd6, 0x9c, 0x51, 0x3a, 0x6c, 0x9d, 0x9b, 0xed, 0xb0, 0x75, + 0x3e, 0x5b, 0x14, 0x4c, 0x09, 0xad, 0x22, 0xfb, 0xf8, 0x47, 0xd0, 0x30, 0xd2, 0x8a, 0x87, 0x10, + 0x94, 0x52, 0xf7, 0x0a, 0xd9, 0x6f, 0x96, 0xe6, 0x99, 0x43, 0xb3, 0x6f, 0x87, 0xa7, 0x8c, 0x9d, + 0x65, 0x23, 0xfe, 0x56, 0x6b, 0xb9, 0xfe, 0xdf, 0x1a, 0x5c, 0x8e, 0x0e, 0xf5, 0x84, 0x0d, 0x5d, + 0x5c, 0xa2, 0x9b, 0xb0, 0x2c, 0x0c, 0x26, 0x63, 0x39, 0x3c, 0x98, 0x5b, 0xe4, 0x30, 0x79, 0x19, + 0x9b, 0xb0, 0x1c, 0x9a, 0xc1, 0x00, 0x87, 0xd9, 0x31, 0x5c, 0xde, 0x8b, 0xbc, 0x51, 0x1e, 0x33, + 0xcd, 0xa1, 0xea, 0x0b, 0xfc, 0x42, 0x8e, 0x60, 0xad, 0x30, 0x01, 0xf0, 0x46, 0xae, 0x58, 0xa5, + 0x7e, 0x02, 0x57, 0xf9, 0xcd, 0xde, 0x03, 0x99, 0xa2, 0x99, 0x6a, 0xea, 0xca, 0x75, 0x67, 0x3c, + 0xc6, 0xef, 0x6b, 0x70, 0x6d, 0x0c, 0xe6, 0x59, 0xb2, 0x89, 0x07, 0x4a, 0xec, 0x63, 0x72, 0x3f, + 0x09, 0x2f, 0xbf, 0x47, 0x2f, 0x13, 0xf9, 0x69, 0x09, 0x16, 0x72, 0x9d, 0xce, 0xad, 0x73, 0xaf, + 0x03, 0xa2, 0x42, 0x88, 0x5f, 0xb1, 0xb1, 0x74, 0x5a, 0x6c, 0x4d, 0x6d, 0x6f, 0xe4, 0xc6, 0x2f, + 0xd8, 0x68, 0x46, 0x8d, 0x6c, 0xde, 0x9b, 0x57, 0xd4, 0x63, 0xc9, 0x95, 0xc6, 0x3f, 0x56, 0xc8, + 0x11, 0xb8, 0xbe, 0x3b, 0x72, 0x79, 0xf1, 0x5d, 0x48, 0x99, 0x6f, 0x37, 0x14, 0x95, 0x04, 0x46, + 0x87, 0xb0, 0xc0, 0xae, 0x6b, 0x8d, 0xc2, 0x81, 0x4f, 0x03, 0x7a, 0x46, 0x17, 0xdf, 0xd4, 0xbe, + 0x33, 0x35, 0xa6, 0x0f, 0xc5, 0x68, 0x4a, 0xbc, 0x88, 0xe9, 0x3d, 0x19, 0x1a, 0xe1, 0xb1, 0xbd, + 0xbe, 0xef, 0xc6, 0x78, 0xe6, 0xce, 0x89, 0x67, 0x47, 0x8c, 0x96, 0xf1, 0xa4, 0xa1, 0xdd, 0x2d, + 0x58, 0x56, 0x2e, 0x7d, 0xd2, 0x36, 0x5a, 0x4e, 0xe7, 0x07, 0x77, 0x61, 0x49, 0xb5, 0xaa, 0x0b, + 0xcc, 0x91, 0xa3, 0xf8, 0x3c, 0x73, 0xe8, 0x7f, 0x5c, 0x80, 0xc6, 0x36, 0x76, 0x70, 0x88, 0x3f, + 0xdb, 0x33, 0xcf, 0xdc, 0x01, 0x6e, 0x31, 0x7f, 0x80, 0x9b, 0x3b, 0x8d, 0x2e, 0x29, 0x4e, 0xa3, + 0xaf, 0xc5, 0x87, 0xf0, 0x74, 0x96, 0xb2, 0xbc, 0x43, 0x5b, 0xe8, 0x2d, 0xa8, 0x0f, 0x03, 0xdb, + 0x35, 0x83, 0xd3, 0xde, 0x13, 0x7c, 0x4a, 0xc4, 0xa6, 0xd1, 0x51, 0x6e, 0x3b, 0x3b, 0xdb, 0xc4, + 0xa8, 0x89, 0xde, 0xef, 0xe3, 0x53, 0x76, 0xc0, 0x1f, 0x27, 0x1b, 0xfc, 0x2a, 0x56, 0xc9, 0x48, + 0x41, 0xd6, 0x56, 0xa0, 0x1a, 0xdf, 0x78, 0x41, 0x15, 0x28, 0xdd, 0x1b, 0x39, 0x4e, 0xfb, 0x12, + 0xaa, 0x42, 0x99, 0xa5, 0x23, 0x6d, 0x6d, 0xed, 0xff, 0x41, 0x35, 0x3e, 0xb5, 0x47, 0x35, 0x98, + 0x7f, 0xe4, 0xbd, 0xef, 0xf9, 0x27, 0x5e, 0xfb, 0x12, 0x9a, 0x87, 0xe2, 0x1d, 0xc7, 0x69, 0x6b, + 0xa8, 0x01, 0xd5, 0xfd, 0x30, 0xc0, 0x26, 0x95, 0x59, 0xbb, 0x80, 0x9a, 0x00, 0xef, 0xd9, 0x24, + 0xf4, 0x03, 0xbb, 0x6f, 0x3a, 0xed, 0xe2, 0xda, 0x27, 0xd0, 0x94, 0x8b, 0xb8, 0xa8, 0x0e, 0x95, + 0x5d, 0x3f, 0x7c, 0xf7, 0x99, 0x4d, 0xc2, 0xf6, 0x25, 0xda, 0x7f, 0xd7, 0x0f, 0xf7, 0x02, 0x4c, + 0xb0, 0x17, 0xb6, 0x35, 0x04, 0x30, 0xf7, 0xa1, 0xb7, 0x6d, 0x93, 0x27, 0xed, 0x02, 0x5a, 0x14, + 0xe7, 0x33, 0xa6, 0xb3, 0x23, 0x2a, 0xa3, 0xed, 0x22, 0x1d, 0x1e, 0x7f, 0x95, 0x50, 0x1b, 0xea, + 0x71, 0x97, 0xfb, 0x7b, 0x8f, 0xda, 0x65, 0x4a, 0x3d, 0xff, 0x39, 0xb7, 0x66, 0x41, 0x3b, 0x7b, + 0xae, 0x48, 0xe7, 0xe4, 0x8b, 0x88, 0x41, 0xed, 0x4b, 0x74, 0x65, 0xe2, 0x60, 0xb7, 0xad, 0xa1, + 0x16, 0xd4, 0x52, 0xc7, 0xa4, 0xed, 0x02, 0x05, 0xdc, 0x0f, 0x86, 0x7d, 0xa1, 0x50, 0x9c, 0x04, + 0xaa, 0x9d, 0xdb, 0x94, 0x13, 0xa5, 0xb5, 0xbb, 0x50, 0x89, 0x42, 0x7e, 0xda, 0x55, 0xb0, 0x88, + 0x7e, 0xb6, 0x2f, 0xa1, 0x05, 0x68, 0x48, 0xcf, 0xa2, 0xda, 0x1a, 0x42, 0xd0, 0x94, 0x1f, 0x2e, + 0xb6, 0x0b, 0x6b, 0x9b, 0x00, 0x49, 0xe8, 0x4c, 0xc9, 0xd9, 0xf1, 0x8e, 0x4d, 0xc7, 0xb6, 0x38, + 0x6d, 0xb4, 0x89, 0x72, 0x97, 0x71, 0x87, 0x1b, 0x6a, 0xbb, 0xb0, 0xb6, 0x06, 0x95, 0x28, 0x1c, + 0xa4, 0x70, 0x03, 0xbb, 0xfe, 0x31, 0xe6, 0x92, 0xd9, 0xc7, 0x94, 0x95, 0x55, 0x28, 0xdf, 0x71, + 0xb1, 0x67, 0xb5, 0x0b, 0x9b, 0xff, 0xb6, 0x08, 0xc0, 0x4f, 0x05, 0x7d, 0x3f, 0xb0, 0x90, 0xc3, + 0x6e, 0x07, 0x6c, 0xf9, 0xee, 0xd0, 0xf7, 0xa2, 0x23, 0x0b, 0x82, 0xd6, 0x33, 0xa9, 0x3a, 0xff, + 0xc8, 0x77, 0x14, 0x8c, 0xe8, 0xbe, 0xa4, 0xec, 0x9f, 0xe9, 0xac, 0x5f, 0x42, 0x2e, 0xc3, 0x46, + 0x93, 0xdb, 0x87, 0x76, 0xff, 0x49, 0x7c, 0x94, 0x38, 0xfe, 0xf5, 0x60, 0xa6, 0x6b, 0x84, 0xef, + 0x86, 0x12, 0xdf, 0x7e, 0x18, 0xd8, 0xde, 0x20, 0xda, 0xff, 0xf4, 0x4b, 0xe8, 0x69, 0xe6, 0xed, + 0x62, 0x84, 0x70, 0x73, 0x9a, 0xe7, 0x8a, 0x17, 0x43, 0xe9, 0x40, 0x2b, 0xf3, 0x48, 0x1c, 0xad, + 0xa9, 0x1f, 0x81, 0xa8, 0x1e, 0xb4, 0x77, 0x5f, 0x9b, 0xaa, 0x6f, 0x8c, 0xcd, 0x86, 0xa6, 0xfc, + 0xba, 0x19, 0x7d, 0x6d, 0xdc, 0x04, 0xb9, 0x67, 0x68, 0xdd, 0xb5, 0x69, 0xba, 0xc6, 0xa8, 0x3e, + 0xe2, 0xba, 0x3a, 0x09, 0x95, 0xf2, 0xe5, 0x5f, 0xf7, 0xac, 0xd0, 0x43, 0xbf, 0x84, 0x7e, 0x4c, + 0xa3, 0x84, 0xcc, 0x63, 0x39, 0xf4, 0xba, 0x7a, 0x67, 0x53, 0xbf, 0xa9, 0x9b, 0x84, 0xe1, 0xa3, + 0xac, 0xa5, 0x8d, 0xa7, 0x3e, 0xf7, 0x0a, 0x77, 0x7a, 0xea, 0x53, 0xd3, 0x9f, 0x45, 0xfd, 0xb9, + 0x31, 0x38, 0x3c, 0x61, 0x52, 0x3c, 0xd3, 0xc9, 0xaa, 0x72, 0x92, 0xaf, 0x8c, 0x7f, 0xd3, 0x33, + 0x09, 0xdb, 0x88, 0x19, 0x69, 0xf6, 0x38, 0xfc, 0x8d, 0x31, 0x85, 0x76, 0xf5, 0xfb, 0xc0, 0xee, + 0xfa, 0xb4, 0xdd, 0xd3, 0xba, 0x2c, 0x3f, 0x41, 0x53, 0x8b, 0x48, 0xf9, 0x6c, 0x4e, 0xad, 0xcb, + 0xea, 0x17, 0x6d, 0xfa, 0x25, 0xf4, 0x50, 0xf2, 0xeb, 0xe8, 0x95, 0x71, 0xaa, 0x20, 0xdf, 0x8f, + 0x99, 0xc4, 0xb7, 0x5f, 0x04, 0xc4, 0x2d, 0xd5, 0x3b, 0xb4, 0x07, 0xa3, 0xc0, 0xe4, 0x6a, 0x3c, + 0xce, 0xb9, 0xe5, 0xbb, 0x46, 0x68, 0xbe, 0x7e, 0x8e, 0x11, 0xf1, 0x92, 0x7a, 0x00, 0xf7, 0x71, + 0xf8, 0x01, 0x0e, 0x03, 0xbb, 0x4f, 0xb2, 0x2b, 0x4a, 0xfc, 0xb7, 0xe8, 0x10, 0xa1, 0x7a, 0x75, + 0x62, 0xbf, 0x18, 0xc1, 0x01, 0xd4, 0xee, 0xd3, 0x0c, 0x8a, 0x45, 0x85, 0x04, 0x8d, 0x1d, 0x19, + 0xf5, 0x88, 0x50, 0xac, 0x4e, 0xee, 0x98, 0x76, 0x9e, 0x99, 0xe7, 0x78, 0x68, 0xac, 0x60, 0xf3, + 0x8f, 0x04, 0xd5, 0xce, 0x73, 0xcc, 0xfb, 0x3e, 0xbe, 0x22, 0x76, 0xd8, 0xf3, 0x1e, 0x36, 0x9d, + 0xf0, 0x68, 0xcc, 0x8a, 0x52, 0x3d, 0xce, 0x5e, 0x91, 0xd4, 0x31, 0xc6, 0x81, 0x61, 0x91, 0x5b, + 0xa1, 0x9c, 0x7a, 0x6e, 0xa8, 0xa7, 0xc8, 0xf7, 0x9c, 0x52, 0xf5, 0x4c, 0x58, 0xd8, 0x0e, 0xfc, + 0xa1, 0x8c, 0xe4, 0x0d, 0x25, 0x92, 0x5c, 0xbf, 0x29, 0x51, 0xfc, 0x00, 0xea, 0x51, 0x86, 0xcf, + 0x72, 0x12, 0x35, 0x17, 0xd2, 0x5d, 0xa6, 0x9c, 0xf8, 0x63, 0x68, 0x65, 0x4a, 0x07, 0x6a, 0xa1, + 0xab, 0xeb, 0x0b, 0x93, 0x66, 0x3f, 0x01, 0xc4, 0xde, 0x58, 0xca, 0xcf, 0xc4, 0xd5, 0xf1, 0x4d, + 0xbe, 0x63, 0x84, 0x64, 0x63, 0xea, 0xfe, 0xb1, 0xe4, 0x7f, 0x09, 0x96, 0x95, 0xe9, 0x79, 0xd6, + 0x21, 0x88, 0x0b, 0xb1, 0x67, 0xd4, 0x10, 0xb2, 0x0e, 0xe1, 0xcc, 0x11, 0x11, 0xfe, 0xcd, 0xdf, + 0x58, 0x80, 0x2a, 0x8b, 0xf3, 0x98, 0xb4, 0xfe, 0x2f, 0xcc, 0x7b, 0xbe, 0x61, 0xde, 0xc7, 0xd0, + 0xca, 0x3c, 0x0e, 0x54, 0x2b, 0xad, 0xfa, 0x05, 0xe1, 0x14, 0xd1, 0x8a, 0xfc, 0x3c, 0x4f, 0xbd, + 0x15, 0x2a, 0x9f, 0xf0, 0x4d, 0x9a, 0xfb, 0x31, 0x7f, 0x57, 0x1b, 0xdf, 0x52, 0x78, 0x75, 0x6c, + 0xf1, 0x5e, 0xbe, 0xd8, 0xfa, 0xf9, 0x47, 0x41, 0x5f, 0xee, 0x08, 0xf4, 0x63, 0x68, 0x65, 0x9e, + 0x8e, 0xa8, 0x35, 0x46, 0xfd, 0xbe, 0x64, 0xd2, 0xec, 0x3f, 0xc7, 0xe0, 0xc9, 0x82, 0x45, 0xc5, + 0x4d, 0x7d, 0xb4, 0x3e, 0x2e, 0x10, 0x55, 0x5f, 0xe9, 0x9f, 0xbc, 0xa0, 0x86, 0x64, 0xa6, 0xd9, + 0xfd, 0x26, 0x21, 0x32, 0xfb, 0xff, 0x32, 0xdd, 0xd7, 0xa7, 0xfb, 0x33, 0x9a, 0x78, 0x41, 0xfb, + 0x30, 0xc7, 0x1f, 0x94, 0xa0, 0x17, 0xd5, 0x87, 0x18, 0xa9, 0xc7, 0x26, 0xdd, 0x49, 0x4f, 0x52, + 0xc8, 0xc8, 0x09, 0x29, 0xfd, 0xbf, 0x00, 0x4d, 0x0e, 0x8a, 0x19, 0xf4, 0x1c, 0x27, 0xdf, 0x87, + 0x32, 0x73, 0xed, 0x48, 0x79, 0x64, 0x90, 0x7e, 0x36, 0xd2, 0x9d, 0xfc, 0x52, 0x24, 0xa1, 0xb8, + 0xf1, 0x7d, 0xfe, 0xb7, 0x60, 0x82, 0xe0, 0xe7, 0x39, 0xf9, 0xff, 0xee, 0xd8, 0xf8, 0x19, 0x7b, + 0xf4, 0x90, 0xbd, 0xd6, 0x83, 0xd6, 0xcf, 0x77, 0x37, 0xa9, 0xbb, 0x31, 0x75, 0xff, 0x18, 0xf3, + 0x8f, 0xa0, 0x9d, 0x3d, 0x4a, 0x43, 0xaf, 0x8d, 0xb3, 0x44, 0x15, 0xce, 0x09, 0x66, 0xf8, 0x3d, + 0x98, 0xe3, 0x35, 0x54, 0xb5, 0xfa, 0x4a, 0xf5, 0xd5, 0x09, 0x73, 0xdd, 0xfd, 0xc6, 0x47, 0x9b, + 0x03, 0x3b, 0x3c, 0x1a, 0x1d, 0xd0, 0x96, 0x0d, 0xde, 0xf5, 0x0d, 0xdb, 0x17, 0xbf, 0x36, 0x22, + 0x59, 0x6e, 0xb0, 0xd1, 0x1b, 0x0c, 0xc1, 0xf0, 0xe0, 0x60, 0x8e, 0x7d, 0xde, 0xfa, 0x9f, 0x00, + 0x00, 0x00, 0xff, 0xff, 0x3a, 0x4f, 0x90, 0xb0, 0x97, 0x50, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -5708,7 +5709,9 @@ type QueryNodeClient interface { SyncReplicaSegments(ctx context.Context, in *SyncReplicaSegmentsRequest, opts ...grpc.CallOption) (*commonpb.Status, error) GetStatistics(ctx context.Context, in *GetStatisticsRequest, opts ...grpc.CallOption) (*internalpb.GetStatisticsResponse, error) Search(ctx context.Context, in *SearchRequest, opts ...grpc.CallOption) (*internalpb.SearchResults, error) + SearchSegments(ctx context.Context, in *SearchRequest, opts ...grpc.CallOption) (*internalpb.SearchResults, error) Query(ctx context.Context, in *QueryRequest, opts ...grpc.CallOption) (*internalpb.RetrieveResults, error) + QuerySegments(ctx context.Context, in *QueryRequest, opts ...grpc.CallOption) (*internalpb.RetrieveResults, error) 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) @@ -5851,6 +5854,15 @@ func (c *queryNodeClient) Search(ctx context.Context, in *SearchRequest, opts .. return out, nil } +func (c *queryNodeClient) SearchSegments(ctx context.Context, in *SearchRequest, opts ...grpc.CallOption) (*internalpb.SearchResults, error) { + out := new(internalpb.SearchResults) + err := c.cc.Invoke(ctx, "/milvus.proto.query.QueryNode/SearchSegments", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + func (c *queryNodeClient) Query(ctx context.Context, in *QueryRequest, opts ...grpc.CallOption) (*internalpb.RetrieveResults, error) { out := new(internalpb.RetrieveResults) err := c.cc.Invoke(ctx, "/milvus.proto.query.QueryNode/Query", in, out, opts...) @@ -5860,6 +5872,15 @@ func (c *queryNodeClient) Query(ctx context.Context, in *QueryRequest, opts ...g return out, nil } +func (c *queryNodeClient) QuerySegments(ctx context.Context, in *QueryRequest, opts ...grpc.CallOption) (*internalpb.RetrieveResults, error) { + out := new(internalpb.RetrieveResults) + err := c.cc.Invoke(ctx, "/milvus.proto.query.QueryNode/QuerySegments", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + func (c *queryNodeClient) ShowConfigurations(ctx context.Context, in *internalpb.ShowConfigurationsRequest, opts ...grpc.CallOption) (*internalpb.ShowConfigurationsResponse, error) { out := new(internalpb.ShowConfigurationsResponse) err := c.cc.Invoke(ctx, "/milvus.proto.query.QueryNode/ShowConfigurations", in, out, opts...) @@ -5921,7 +5942,9 @@ type QueryNodeServer interface { SyncReplicaSegments(context.Context, *SyncReplicaSegmentsRequest) (*commonpb.Status, error) GetStatistics(context.Context, *GetStatisticsRequest) (*internalpb.GetStatisticsResponse, error) Search(context.Context, *SearchRequest) (*internalpb.SearchResults, error) + SearchSegments(context.Context, *SearchRequest) (*internalpb.SearchResults, error) Query(context.Context, *QueryRequest) (*internalpb.RetrieveResults, error) + QuerySegments(context.Context, *QueryRequest) (*internalpb.RetrieveResults, error) 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) @@ -5976,9 +5999,15 @@ func (*UnimplementedQueryNodeServer) GetStatistics(ctx context.Context, req *Get func (*UnimplementedQueryNodeServer) Search(ctx context.Context, req *SearchRequest) (*internalpb.SearchResults, error) { return nil, status.Errorf(codes.Unimplemented, "method Search not implemented") } +func (*UnimplementedQueryNodeServer) SearchSegments(ctx context.Context, req *SearchRequest) (*internalpb.SearchResults, error) { + return nil, status.Errorf(codes.Unimplemented, "method SearchSegments not implemented") +} func (*UnimplementedQueryNodeServer) Query(ctx context.Context, req *QueryRequest) (*internalpb.RetrieveResults, error) { return nil, status.Errorf(codes.Unimplemented, "method Query not implemented") } +func (*UnimplementedQueryNodeServer) QuerySegments(ctx context.Context, req *QueryRequest) (*internalpb.RetrieveResults, error) { + return nil, status.Errorf(codes.Unimplemented, "method QuerySegments not implemented") +} func (*UnimplementedQueryNodeServer) ShowConfigurations(ctx context.Context, req *internalpb.ShowConfigurationsRequest) (*internalpb.ShowConfigurationsResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method ShowConfigurations not implemented") } @@ -6251,6 +6280,24 @@ func _QueryNode_Search_Handler(srv interface{}, ctx context.Context, dec func(in return interceptor(ctx, in, info, handler) } +func _QueryNode_SearchSegments_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(SearchRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryNodeServer).SearchSegments(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/milvus.proto.query.QueryNode/SearchSegments", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryNodeServer).SearchSegments(ctx, req.(*SearchRequest)) + } + return interceptor(ctx, in, info, handler) +} + func _QueryNode_Query_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(QueryRequest) if err := dec(in); err != nil { @@ -6269,6 +6316,24 @@ func _QueryNode_Query_Handler(srv interface{}, ctx context.Context, dec func(int return interceptor(ctx, in, info, handler) } +func _QueryNode_QuerySegments_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryNodeServer).QuerySegments(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/milvus.proto.query.QueryNode/QuerySegments", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryNodeServer).QuerySegments(ctx, req.(*QueryRequest)) + } + return interceptor(ctx, in, info, handler) +} + func _QueryNode_ShowConfigurations_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(internalpb.ShowConfigurationsRequest) if err := dec(in); err != nil { @@ -6419,10 +6484,18 @@ var _QueryNode_serviceDesc = grpc.ServiceDesc{ MethodName: "Search", Handler: _QueryNode_Search_Handler, }, + { + MethodName: "SearchSegments", + Handler: _QueryNode_SearchSegments_Handler, + }, { MethodName: "Query", Handler: _QueryNode_Query_Handler, }, + { + MethodName: "QuerySegments", + Handler: _QueryNode_QuerySegments_Handler, + }, { MethodName: "ShowConfigurations", Handler: _QueryNode_ShowConfigurations_Handler, diff --git a/internal/proxy/query_node_mock_test.go b/internal/proxy/query_node_mock_test.go deleted file mode 100644 index c30f0c5585..0000000000 --- a/internal/proxy/query_node_mock_test.go +++ /dev/null @@ -1,141 +0,0 @@ -// Licensed to the LF AI & Data foundation under one -// or more contributor license agreements. See the NOTICE file -// distributed with this work for additional information -// regarding copyright ownership. The ASF licenses this file -// to you under the Apache License, Version 2.0 (the -// "License"); you may not use this file except in compliance -// with the License. You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package proxy - -import ( - "context" - "sync/atomic" - - "github.com/milvus-io/milvus/internal/types" - - "github.com/milvus-io/milvus-proto/go-api/commonpb" - "github.com/milvus-io/milvus-proto/go-api/milvuspb" - "github.com/milvus-io/milvus/internal/proto/internalpb" - "github.com/milvus-io/milvus/internal/proto/querypb" - "github.com/milvus-io/milvus/pkg/util/typeutil" -) - -var _ types.QueryNode = &QueryNodeMock{} - -type QueryNodeMock struct { - nodeID typeutil.UniqueID - address string - - state atomic.Value // internal.StateCode - - withStatisticsResponse *internalpb.GetStatisticsResponse - withSearchResult *internalpb.SearchResults - withQueryResult *internalpb.RetrieveResults - queryError error - searchError error - statisticsError error -} - -func (m *QueryNodeMock) GetStatistics(ctx context.Context, req *querypb.GetStatisticsRequest) (*internalpb.GetStatisticsResponse, error) { - if m.statisticsError != nil { - return nil, m.statisticsError - } - return m.withStatisticsResponse, nil -} - -func (m *QueryNodeMock) Search(ctx context.Context, req *querypb.SearchRequest) (*internalpb.SearchResults, error) { - if m.searchError != nil { - return nil, m.searchError - } - return m.withSearchResult, nil -} - -func (m *QueryNodeMock) Query(ctx context.Context, req *querypb.QueryRequest) (*internalpb.RetrieveResults, error) { - if m.queryError != nil { - return nil, m.queryError - } - return m.withQueryResult, nil -} - -func (m *QueryNodeMock) SyncReplicaSegments(ctx context.Context, req *querypb.SyncReplicaSegmentsRequest) (*commonpb.Status, error) { - return &commonpb.Status{}, nil -} - -// TODO -func (m *QueryNodeMock) WatchDmChannels(ctx context.Context, req *querypb.WatchDmChannelsRequest) (*commonpb.Status, error) { - return nil, nil -} - -// TODO -func (m *QueryNodeMock) LoadSegments(ctx context.Context, req *querypb.LoadSegmentsRequest) (*commonpb.Status, error) { - return nil, nil -} - -// TODO -func (m *QueryNodeMock) ReleaseCollection(ctx context.Context, req *querypb.ReleaseCollectionRequest) (*commonpb.Status, error) { - return nil, nil -} - -func (m *QueryNodeMock) LoadPartitions(ctx context.Context, req *querypb.LoadPartitionsRequest) (*commonpb.Status, error) { - return nil, nil -} - -// TODO -func (m *QueryNodeMock) ReleasePartitions(ctx context.Context, req *querypb.ReleasePartitionsRequest) (*commonpb.Status, error) { - return nil, nil -} - -// TODO -func (m *QueryNodeMock) ReleaseSegments(ctx context.Context, req *querypb.ReleaseSegmentsRequest) (*commonpb.Status, error) { - return nil, nil -} - -// TODO -func (m *QueryNodeMock) GetSegmentInfo(ctx context.Context, req *querypb.GetSegmentInfoRequest) (*querypb.GetSegmentInfoResponse, error) { - return nil, nil -} - -// TODO -func (m *QueryNodeMock) GetMetrics(ctx context.Context, req *milvuspb.GetMetricsRequest) (*milvuspb.GetMetricsResponse, error) { - return nil, nil -} - -func (m *QueryNodeMock) Init() error { return nil } -func (m *QueryNodeMock) Start() error { return nil } -func (m *QueryNodeMock) Stop() error { return nil } -func (m *QueryNodeMock) Register() error { return nil } -func (m *QueryNodeMock) GetComponentStates(ctx context.Context) (*milvuspb.ComponentStates, error) { - return nil, nil -} -func (m *QueryNodeMock) GetStatisticsChannel(ctx context.Context) (*milvuspb.StringResponse, error) { - return nil, nil -} -func (m *QueryNodeMock) GetTimeTickChannel(ctx context.Context) (*milvuspb.StringResponse, error) { - return nil, nil -} -func (m *QueryNodeMock) ShowConfigurations(ctx context.Context, req *internalpb.ShowConfigurationsRequest) (*internalpb.ShowConfigurationsResponse, error) { - return nil, nil -} - -func (m *QueryNodeMock) UnsubDmChannel(ctx context.Context, req *querypb.UnsubDmChannelRequest) (*commonpb.Status, error) { - return nil, nil -} -func (m *QueryNodeMock) GetDataDistribution(context.Context, *querypb.GetDataDistributionRequest) (*querypb.GetDataDistributionResponse, error) { - return nil, nil -} -func (m *QueryNodeMock) SyncDistribution(context.Context, *querypb.SyncDistributionRequest) (*commonpb.Status, error) { - return nil, nil -} - -func (m *QueryNodeMock) Delete(context.Context, *querypb.DeleteRequest) (*commonpb.Status, error) { - return nil, nil -} diff --git a/internal/proxy/task_policies_test.go b/internal/proxy/task_policies_test.go index a9d267b94e..7f77095cd7 100644 --- a/internal/proxy/task_policies_test.go +++ b/internal/proxy/task_policies_test.go @@ -53,10 +53,6 @@ func TestRoundRobinPolicy(t *testing.T) { assert.True(t, strings.Contains(err.Error(), mockerr.Error())) } -func mockQueryNodeCreator(ctx context.Context, address string) (types.QueryNode, error) { - return &QueryNodeMock{address: address}, nil -} - type mockQuery struct { mu sync.Mutex queryset map[UniqueID][]string diff --git a/internal/proxy/task_query_test.go b/internal/proxy/task_query_test.go index ba1abd807c..d776ee7200 100644 --- a/internal/proxy/task_query_test.go +++ b/internal/proxy/task_query_test.go @@ -7,6 +7,7 @@ import ( "testing" "time" + "github.com/cockroachdb/errors" "github.com/golang/protobuf/proto" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/mock" @@ -34,7 +35,7 @@ func TestQueryTask_all(t *testing.T) { rc = NewRootCoordMock() qc = types.NewMockQueryCoord(t) - qn = &QueryNodeMock{} + qn = getQueryNode() shardsNum = common.DefaultShardsNum collectionName = t.Name() + funcutil.GenRandomStr() @@ -209,27 +210,29 @@ func TestQueryTask_all(t *testing.T) { result1.FieldsData = append(result1.FieldsData, generateFieldData(schemapb.DataType_Int64, common.TimeStampFieldName, hitNum)) task.RetrieveRequest.OutputFieldsId = append(task.RetrieveRequest.OutputFieldsId, common.TimeStampField) task.ctx = ctx - qn.queryError = fmt.Errorf("mock error") + qn.ExpectedCalls = nil + qn.EXPECT().Query(mock.Anything, mock.Anything).Return(nil, errors.New("mock error")) assert.Error(t, task.Execute(ctx)) - qn.queryError = nil - qn.withQueryResult = &internalpb.RetrieveResults{ + qn.ExpectedCalls = nil + qn.EXPECT().Query(mock.Anything, mock.Anything).Return(&internalpb.RetrieveResults{ Status: &commonpb.Status{ ErrorCode: commonpb.ErrorCode_NotShardLeader, }, - } + }, nil) err = task.Execute(ctx) assert.True(t, strings.Contains(err.Error(), errInvalidShardLeaders.Error())) - qn.withQueryResult = &internalpb.RetrieveResults{ + qn.ExpectedCalls = nil + qn.EXPECT().Query(mock.Anything, mock.Anything).Return(&internalpb.RetrieveResults{ Status: &commonpb.Status{ ErrorCode: commonpb.ErrorCode_UnexpectedError, }, - } + }, nil) assert.Error(t, task.Execute(ctx)) - qn.withQueryResult = result1 - + qn.ExpectedCalls = nil + qn.EXPECT().Query(mock.Anything, mock.Anything).Return(result1, nil) assert.NoError(t, task.Execute(ctx)) task.queryParams = &queryParams{ diff --git a/internal/proxy/task_search_test.go b/internal/proxy/task_search_test.go index f9c52209a2..bd644e45cc 100644 --- a/internal/proxy/task_search_test.go +++ b/internal/proxy/task_search_test.go @@ -8,6 +8,7 @@ import ( "testing" "time" + "github.com/cockroachdb/errors" "github.com/golang/protobuf/proto" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/mock" @@ -237,6 +238,12 @@ func getQueryCoord() *types.MockQueryCoord { return qc } +func getQueryNode() *types.MockQueryNode { + qn := &types.MockQueryNode{} + + return qn +} + func TestSearchTaskV2_Execute(t *testing.T) { var ( @@ -1516,7 +1523,7 @@ func TestSearchTask_ErrExecute(t *testing.T) { rc = NewRootCoordMock() qc = getQueryCoord() - qn = &QueryNodeMock{} + qn = getQueryNode() shardsNum = int32(2) collectionName = t.Name() + funcutil.GenRandomStr() @@ -1643,31 +1650,32 @@ func TestSearchTask_ErrExecute(t *testing.T) { assert.Error(t, task.Execute(ctx)) task.searchShardPolicy = RoundRobinPolicy - qn.searchError = fmt.Errorf("mock error") + qn.EXPECT().Search(mock.Anything, mock.Anything).Return(nil, errors.New("mock error")) assert.Error(t, task.Execute(ctx)) - qn.searchError = nil - qn.withSearchResult = &internalpb.SearchResults{ + qn.ExpectedCalls = nil + qn.EXPECT().Search(mock.Anything, mock.Anything).Return(&internalpb.SearchResults{ Status: &commonpb.Status{ ErrorCode: commonpb.ErrorCode_NotShardLeader, }, - } + }, nil) err = task.Execute(ctx) assert.True(t, strings.Contains(err.Error(), errInvalidShardLeaders.Error())) - qn.withSearchResult = &internalpb.SearchResults{ + qn.ExpectedCalls = nil + qn.EXPECT().Search(mock.Anything, mock.Anything).Return(&internalpb.SearchResults{ Status: &commonpb.Status{ ErrorCode: commonpb.ErrorCode_UnexpectedError, }, - } + }, nil) assert.Error(t, task.Execute(ctx)) - result1 := &internalpb.SearchResults{ + qn.ExpectedCalls = nil + qn.EXPECT().Search(mock.Anything, mock.Anything).Return(&internalpb.SearchResults{ Status: &commonpb.Status{ ErrorCode: commonpb.ErrorCode_Success, }, - } - qn.withSearchResult = result1 + }, nil) assert.NoError(t, task.Execute(ctx)) } diff --git a/internal/querycoordv2/mocks/mock_querynode.go b/internal/querycoordv2/mocks/mock_querynode_server.go similarity index 75% rename from internal/querycoordv2/mocks/mock_querynode.go rename to internal/querycoordv2/mocks/mock_querynode_server.go index 3df2e85f97..530b309ec5 100644 --- a/internal/querycoordv2/mocks/mock_querynode.go +++ b/internal/querycoordv2/mocks/mock_querynode_server.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.16.0. DO NOT EDIT. +// Code generated by mockery v2.21.1. DO NOT EDIT. package mocks @@ -34,6 +34,10 @@ func (_m *MockQueryNodeServer) Delete(_a0 context.Context, _a1 *querypb.DeleteRe ret := _m.Called(_a0, _a1) var r0 *commonpb.Status + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *querypb.DeleteRequest) (*commonpb.Status, error)); ok { + return rf(_a0, _a1) + } if rf, ok := ret.Get(0).(func(context.Context, *querypb.DeleteRequest) *commonpb.Status); ok { r0 = rf(_a0, _a1) } else { @@ -42,7 +46,6 @@ func (_m *MockQueryNodeServer) Delete(_a0 context.Context, _a1 *querypb.DeleteRe } } - var r1 error if rf, ok := ret.Get(1).(func(context.Context, *querypb.DeleteRequest) error); ok { r1 = rf(_a0, _a1) } else { @@ -76,11 +79,20 @@ func (_c *MockQueryNodeServer_Delete_Call) Return(_a0 *commonpb.Status, _a1 erro return _c } +func (_c *MockQueryNodeServer_Delete_Call) RunAndReturn(run func(context.Context, *querypb.DeleteRequest) (*commonpb.Status, error)) *MockQueryNodeServer_Delete_Call { + _c.Call.Return(run) + return _c +} + // GetComponentStates provides a mock function with given fields: _a0, _a1 func (_m *MockQueryNodeServer) GetComponentStates(_a0 context.Context, _a1 *milvuspb.GetComponentStatesRequest) (*milvuspb.ComponentStates, error) { ret := _m.Called(_a0, _a1) var r0 *milvuspb.ComponentStates + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.GetComponentStatesRequest) (*milvuspb.ComponentStates, error)); ok { + return rf(_a0, _a1) + } if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.GetComponentStatesRequest) *milvuspb.ComponentStates); ok { r0 = rf(_a0, _a1) } else { @@ -89,7 +101,6 @@ func (_m *MockQueryNodeServer) GetComponentStates(_a0 context.Context, _a1 *milv } } - var r1 error if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.GetComponentStatesRequest) error); ok { r1 = rf(_a0, _a1) } else { @@ -123,11 +134,20 @@ func (_c *MockQueryNodeServer_GetComponentStates_Call) Return(_a0 *milvuspb.Comp return _c } +func (_c *MockQueryNodeServer_GetComponentStates_Call) RunAndReturn(run func(context.Context, *milvuspb.GetComponentStatesRequest) (*milvuspb.ComponentStates, error)) *MockQueryNodeServer_GetComponentStates_Call { + _c.Call.Return(run) + return _c +} + // GetDataDistribution provides a mock function with given fields: _a0, _a1 func (_m *MockQueryNodeServer) GetDataDistribution(_a0 context.Context, _a1 *querypb.GetDataDistributionRequest) (*querypb.GetDataDistributionResponse, error) { ret := _m.Called(_a0, _a1) var r0 *querypb.GetDataDistributionResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *querypb.GetDataDistributionRequest) (*querypb.GetDataDistributionResponse, error)); ok { + return rf(_a0, _a1) + } if rf, ok := ret.Get(0).(func(context.Context, *querypb.GetDataDistributionRequest) *querypb.GetDataDistributionResponse); ok { r0 = rf(_a0, _a1) } else { @@ -136,7 +156,6 @@ func (_m *MockQueryNodeServer) GetDataDistribution(_a0 context.Context, _a1 *que } } - var r1 error if rf, ok := ret.Get(1).(func(context.Context, *querypb.GetDataDistributionRequest) error); ok { r1 = rf(_a0, _a1) } else { @@ -170,11 +189,20 @@ func (_c *MockQueryNodeServer_GetDataDistribution_Call) Return(_a0 *querypb.GetD return _c } +func (_c *MockQueryNodeServer_GetDataDistribution_Call) RunAndReturn(run func(context.Context, *querypb.GetDataDistributionRequest) (*querypb.GetDataDistributionResponse, error)) *MockQueryNodeServer_GetDataDistribution_Call { + _c.Call.Return(run) + return _c +} + // GetMetrics provides a mock function with given fields: _a0, _a1 func (_m *MockQueryNodeServer) GetMetrics(_a0 context.Context, _a1 *milvuspb.GetMetricsRequest) (*milvuspb.GetMetricsResponse, error) { ret := _m.Called(_a0, _a1) var r0 *milvuspb.GetMetricsResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.GetMetricsRequest) (*milvuspb.GetMetricsResponse, error)); ok { + return rf(_a0, _a1) + } if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.GetMetricsRequest) *milvuspb.GetMetricsResponse); ok { r0 = rf(_a0, _a1) } else { @@ -183,7 +211,6 @@ func (_m *MockQueryNodeServer) GetMetrics(_a0 context.Context, _a1 *milvuspb.Get } } - var r1 error if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.GetMetricsRequest) error); ok { r1 = rf(_a0, _a1) } else { @@ -217,11 +244,20 @@ func (_c *MockQueryNodeServer_GetMetrics_Call) Return(_a0 *milvuspb.GetMetricsRe return _c } +func (_c *MockQueryNodeServer_GetMetrics_Call) RunAndReturn(run func(context.Context, *milvuspb.GetMetricsRequest) (*milvuspb.GetMetricsResponse, error)) *MockQueryNodeServer_GetMetrics_Call { + _c.Call.Return(run) + return _c +} + // GetSegmentInfo provides a mock function with given fields: _a0, _a1 func (_m *MockQueryNodeServer) GetSegmentInfo(_a0 context.Context, _a1 *querypb.GetSegmentInfoRequest) (*querypb.GetSegmentInfoResponse, error) { ret := _m.Called(_a0, _a1) var r0 *querypb.GetSegmentInfoResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *querypb.GetSegmentInfoRequest) (*querypb.GetSegmentInfoResponse, error)); ok { + return rf(_a0, _a1) + } if rf, ok := ret.Get(0).(func(context.Context, *querypb.GetSegmentInfoRequest) *querypb.GetSegmentInfoResponse); ok { r0 = rf(_a0, _a1) } else { @@ -230,7 +266,6 @@ func (_m *MockQueryNodeServer) GetSegmentInfo(_a0 context.Context, _a1 *querypb. } } - var r1 error if rf, ok := ret.Get(1).(func(context.Context, *querypb.GetSegmentInfoRequest) error); ok { r1 = rf(_a0, _a1) } else { @@ -264,11 +299,20 @@ func (_c *MockQueryNodeServer_GetSegmentInfo_Call) Return(_a0 *querypb.GetSegmen return _c } +func (_c *MockQueryNodeServer_GetSegmentInfo_Call) RunAndReturn(run func(context.Context, *querypb.GetSegmentInfoRequest) (*querypb.GetSegmentInfoResponse, error)) *MockQueryNodeServer_GetSegmentInfo_Call { + _c.Call.Return(run) + return _c +} + // GetStatistics provides a mock function with given fields: _a0, _a1 func (_m *MockQueryNodeServer) GetStatistics(_a0 context.Context, _a1 *querypb.GetStatisticsRequest) (*internalpb.GetStatisticsResponse, error) { ret := _m.Called(_a0, _a1) var r0 *internalpb.GetStatisticsResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *querypb.GetStatisticsRequest) (*internalpb.GetStatisticsResponse, error)); ok { + return rf(_a0, _a1) + } if rf, ok := ret.Get(0).(func(context.Context, *querypb.GetStatisticsRequest) *internalpb.GetStatisticsResponse); ok { r0 = rf(_a0, _a1) } else { @@ -277,7 +321,6 @@ func (_m *MockQueryNodeServer) GetStatistics(_a0 context.Context, _a1 *querypb.G } } - var r1 error if rf, ok := ret.Get(1).(func(context.Context, *querypb.GetStatisticsRequest) error); ok { r1 = rf(_a0, _a1) } else { @@ -311,11 +354,20 @@ func (_c *MockQueryNodeServer_GetStatistics_Call) Return(_a0 *internalpb.GetStat return _c } +func (_c *MockQueryNodeServer_GetStatistics_Call) RunAndReturn(run func(context.Context, *querypb.GetStatisticsRequest) (*internalpb.GetStatisticsResponse, error)) *MockQueryNodeServer_GetStatistics_Call { + _c.Call.Return(run) + return _c +} + // GetStatisticsChannel provides a mock function with given fields: _a0, _a1 func (_m *MockQueryNodeServer) GetStatisticsChannel(_a0 context.Context, _a1 *internalpb.GetStatisticsChannelRequest) (*milvuspb.StringResponse, error) { ret := _m.Called(_a0, _a1) var r0 *milvuspb.StringResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *internalpb.GetStatisticsChannelRequest) (*milvuspb.StringResponse, error)); ok { + return rf(_a0, _a1) + } if rf, ok := ret.Get(0).(func(context.Context, *internalpb.GetStatisticsChannelRequest) *milvuspb.StringResponse); ok { r0 = rf(_a0, _a1) } else { @@ -324,7 +376,6 @@ func (_m *MockQueryNodeServer) GetStatisticsChannel(_a0 context.Context, _a1 *in } } - var r1 error if rf, ok := ret.Get(1).(func(context.Context, *internalpb.GetStatisticsChannelRequest) error); ok { r1 = rf(_a0, _a1) } else { @@ -358,11 +409,20 @@ func (_c *MockQueryNodeServer_GetStatisticsChannel_Call) Return(_a0 *milvuspb.St return _c } +func (_c *MockQueryNodeServer_GetStatisticsChannel_Call) RunAndReturn(run func(context.Context, *internalpb.GetStatisticsChannelRequest) (*milvuspb.StringResponse, error)) *MockQueryNodeServer_GetStatisticsChannel_Call { + _c.Call.Return(run) + return _c +} + // GetTimeTickChannel provides a mock function with given fields: _a0, _a1 func (_m *MockQueryNodeServer) GetTimeTickChannel(_a0 context.Context, _a1 *internalpb.GetTimeTickChannelRequest) (*milvuspb.StringResponse, error) { ret := _m.Called(_a0, _a1) var r0 *milvuspb.StringResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *internalpb.GetTimeTickChannelRequest) (*milvuspb.StringResponse, error)); ok { + return rf(_a0, _a1) + } if rf, ok := ret.Get(0).(func(context.Context, *internalpb.GetTimeTickChannelRequest) *milvuspb.StringResponse); ok { r0 = rf(_a0, _a1) } else { @@ -371,7 +431,6 @@ func (_m *MockQueryNodeServer) GetTimeTickChannel(_a0 context.Context, _a1 *inte } } - var r1 error if rf, ok := ret.Get(1).(func(context.Context, *internalpb.GetTimeTickChannelRequest) error); ok { r1 = rf(_a0, _a1) } else { @@ -405,11 +464,20 @@ func (_c *MockQueryNodeServer_GetTimeTickChannel_Call) Return(_a0 *milvuspb.Stri return _c } +func (_c *MockQueryNodeServer_GetTimeTickChannel_Call) RunAndReturn(run func(context.Context, *internalpb.GetTimeTickChannelRequest) (*milvuspb.StringResponse, error)) *MockQueryNodeServer_GetTimeTickChannel_Call { + _c.Call.Return(run) + return _c +} + // LoadPartitions provides a mock function with given fields: _a0, _a1 func (_m *MockQueryNodeServer) LoadPartitions(_a0 context.Context, _a1 *querypb.LoadPartitionsRequest) (*commonpb.Status, error) { ret := _m.Called(_a0, _a1) var r0 *commonpb.Status + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *querypb.LoadPartitionsRequest) (*commonpb.Status, error)); ok { + return rf(_a0, _a1) + } if rf, ok := ret.Get(0).(func(context.Context, *querypb.LoadPartitionsRequest) *commonpb.Status); ok { r0 = rf(_a0, _a1) } else { @@ -418,7 +486,6 @@ func (_m *MockQueryNodeServer) LoadPartitions(_a0 context.Context, _a1 *querypb. } } - var r1 error if rf, ok := ret.Get(1).(func(context.Context, *querypb.LoadPartitionsRequest) error); ok { r1 = rf(_a0, _a1) } else { @@ -452,11 +519,20 @@ func (_c *MockQueryNodeServer_LoadPartitions_Call) Return(_a0 *commonpb.Status, return _c } +func (_c *MockQueryNodeServer_LoadPartitions_Call) RunAndReturn(run func(context.Context, *querypb.LoadPartitionsRequest) (*commonpb.Status, error)) *MockQueryNodeServer_LoadPartitions_Call { + _c.Call.Return(run) + return _c +} + // LoadSegments provides a mock function with given fields: _a0, _a1 func (_m *MockQueryNodeServer) LoadSegments(_a0 context.Context, _a1 *querypb.LoadSegmentsRequest) (*commonpb.Status, error) { ret := _m.Called(_a0, _a1) var r0 *commonpb.Status + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *querypb.LoadSegmentsRequest) (*commonpb.Status, error)); ok { + return rf(_a0, _a1) + } if rf, ok := ret.Get(0).(func(context.Context, *querypb.LoadSegmentsRequest) *commonpb.Status); ok { r0 = rf(_a0, _a1) } else { @@ -465,7 +541,6 @@ func (_m *MockQueryNodeServer) LoadSegments(_a0 context.Context, _a1 *querypb.Lo } } - var r1 error if rf, ok := ret.Get(1).(func(context.Context, *querypb.LoadSegmentsRequest) error); ok { r1 = rf(_a0, _a1) } else { @@ -499,11 +574,20 @@ func (_c *MockQueryNodeServer_LoadSegments_Call) Return(_a0 *commonpb.Status, _a return _c } +func (_c *MockQueryNodeServer_LoadSegments_Call) RunAndReturn(run func(context.Context, *querypb.LoadSegmentsRequest) (*commonpb.Status, error)) *MockQueryNodeServer_LoadSegments_Call { + _c.Call.Return(run) + return _c +} + // Query provides a mock function with given fields: _a0, _a1 func (_m *MockQueryNodeServer) Query(_a0 context.Context, _a1 *querypb.QueryRequest) (*internalpb.RetrieveResults, error) { ret := _m.Called(_a0, _a1) var r0 *internalpb.RetrieveResults + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *querypb.QueryRequest) (*internalpb.RetrieveResults, error)); ok { + return rf(_a0, _a1) + } if rf, ok := ret.Get(0).(func(context.Context, *querypb.QueryRequest) *internalpb.RetrieveResults); ok { r0 = rf(_a0, _a1) } else { @@ -512,7 +596,6 @@ func (_m *MockQueryNodeServer) Query(_a0 context.Context, _a1 *querypb.QueryRequ } } - var r1 error if rf, ok := ret.Get(1).(func(context.Context, *querypb.QueryRequest) error); ok { r1 = rf(_a0, _a1) } else { @@ -546,11 +629,75 @@ func (_c *MockQueryNodeServer_Query_Call) Return(_a0 *internalpb.RetrieveResults return _c } +func (_c *MockQueryNodeServer_Query_Call) RunAndReturn(run func(context.Context, *querypb.QueryRequest) (*internalpb.RetrieveResults, error)) *MockQueryNodeServer_Query_Call { + _c.Call.Return(run) + return _c +} + +// QuerySegments provides a mock function with given fields: _a0, _a1 +func (_m *MockQueryNodeServer) QuerySegments(_a0 context.Context, _a1 *querypb.QueryRequest) (*internalpb.RetrieveResults, error) { + ret := _m.Called(_a0, _a1) + + var r0 *internalpb.RetrieveResults + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *querypb.QueryRequest) (*internalpb.RetrieveResults, error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *querypb.QueryRequest) *internalpb.RetrieveResults); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*internalpb.RetrieveResults) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *querypb.QueryRequest) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockQueryNodeServer_QuerySegments_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'QuerySegments' +type MockQueryNodeServer_QuerySegments_Call struct { + *mock.Call +} + +// QuerySegments is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *querypb.QueryRequest +func (_e *MockQueryNodeServer_Expecter) QuerySegments(_a0 interface{}, _a1 interface{}) *MockQueryNodeServer_QuerySegments_Call { + return &MockQueryNodeServer_QuerySegments_Call{Call: _e.mock.On("QuerySegments", _a0, _a1)} +} + +func (_c *MockQueryNodeServer_QuerySegments_Call) Run(run func(_a0 context.Context, _a1 *querypb.QueryRequest)) *MockQueryNodeServer_QuerySegments_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*querypb.QueryRequest)) + }) + return _c +} + +func (_c *MockQueryNodeServer_QuerySegments_Call) Return(_a0 *internalpb.RetrieveResults, _a1 error) *MockQueryNodeServer_QuerySegments_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockQueryNodeServer_QuerySegments_Call) RunAndReturn(run func(context.Context, *querypb.QueryRequest) (*internalpb.RetrieveResults, error)) *MockQueryNodeServer_QuerySegments_Call { + _c.Call.Return(run) + return _c +} + // ReleaseCollection provides a mock function with given fields: _a0, _a1 func (_m *MockQueryNodeServer) ReleaseCollection(_a0 context.Context, _a1 *querypb.ReleaseCollectionRequest) (*commonpb.Status, error) { ret := _m.Called(_a0, _a1) var r0 *commonpb.Status + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *querypb.ReleaseCollectionRequest) (*commonpb.Status, error)); ok { + return rf(_a0, _a1) + } if rf, ok := ret.Get(0).(func(context.Context, *querypb.ReleaseCollectionRequest) *commonpb.Status); ok { r0 = rf(_a0, _a1) } else { @@ -559,7 +706,6 @@ func (_m *MockQueryNodeServer) ReleaseCollection(_a0 context.Context, _a1 *query } } - var r1 error if rf, ok := ret.Get(1).(func(context.Context, *querypb.ReleaseCollectionRequest) error); ok { r1 = rf(_a0, _a1) } else { @@ -593,11 +739,20 @@ func (_c *MockQueryNodeServer_ReleaseCollection_Call) Return(_a0 *commonpb.Statu return _c } +func (_c *MockQueryNodeServer_ReleaseCollection_Call) RunAndReturn(run func(context.Context, *querypb.ReleaseCollectionRequest) (*commonpb.Status, error)) *MockQueryNodeServer_ReleaseCollection_Call { + _c.Call.Return(run) + return _c +} + // ReleasePartitions provides a mock function with given fields: _a0, _a1 func (_m *MockQueryNodeServer) ReleasePartitions(_a0 context.Context, _a1 *querypb.ReleasePartitionsRequest) (*commonpb.Status, error) { ret := _m.Called(_a0, _a1) var r0 *commonpb.Status + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *querypb.ReleasePartitionsRequest) (*commonpb.Status, error)); ok { + return rf(_a0, _a1) + } if rf, ok := ret.Get(0).(func(context.Context, *querypb.ReleasePartitionsRequest) *commonpb.Status); ok { r0 = rf(_a0, _a1) } else { @@ -606,7 +761,6 @@ func (_m *MockQueryNodeServer) ReleasePartitions(_a0 context.Context, _a1 *query } } - var r1 error if rf, ok := ret.Get(1).(func(context.Context, *querypb.ReleasePartitionsRequest) error); ok { r1 = rf(_a0, _a1) } else { @@ -640,11 +794,20 @@ func (_c *MockQueryNodeServer_ReleasePartitions_Call) Return(_a0 *commonpb.Statu return _c } +func (_c *MockQueryNodeServer_ReleasePartitions_Call) RunAndReturn(run func(context.Context, *querypb.ReleasePartitionsRequest) (*commonpb.Status, error)) *MockQueryNodeServer_ReleasePartitions_Call { + _c.Call.Return(run) + return _c +} + // ReleaseSegments provides a mock function with given fields: _a0, _a1 func (_m *MockQueryNodeServer) ReleaseSegments(_a0 context.Context, _a1 *querypb.ReleaseSegmentsRequest) (*commonpb.Status, error) { ret := _m.Called(_a0, _a1) var r0 *commonpb.Status + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *querypb.ReleaseSegmentsRequest) (*commonpb.Status, error)); ok { + return rf(_a0, _a1) + } if rf, ok := ret.Get(0).(func(context.Context, *querypb.ReleaseSegmentsRequest) *commonpb.Status); ok { r0 = rf(_a0, _a1) } else { @@ -653,7 +816,6 @@ func (_m *MockQueryNodeServer) ReleaseSegments(_a0 context.Context, _a1 *querypb } } - var r1 error if rf, ok := ret.Get(1).(func(context.Context, *querypb.ReleaseSegmentsRequest) error); ok { r1 = rf(_a0, _a1) } else { @@ -687,11 +849,20 @@ func (_c *MockQueryNodeServer_ReleaseSegments_Call) Return(_a0 *commonpb.Status, return _c } +func (_c *MockQueryNodeServer_ReleaseSegments_Call) RunAndReturn(run func(context.Context, *querypb.ReleaseSegmentsRequest) (*commonpb.Status, error)) *MockQueryNodeServer_ReleaseSegments_Call { + _c.Call.Return(run) + return _c +} + // Search provides a mock function with given fields: _a0, _a1 func (_m *MockQueryNodeServer) Search(_a0 context.Context, _a1 *querypb.SearchRequest) (*internalpb.SearchResults, error) { ret := _m.Called(_a0, _a1) var r0 *internalpb.SearchResults + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *querypb.SearchRequest) (*internalpb.SearchResults, error)); ok { + return rf(_a0, _a1) + } if rf, ok := ret.Get(0).(func(context.Context, *querypb.SearchRequest) *internalpb.SearchResults); ok { r0 = rf(_a0, _a1) } else { @@ -700,7 +871,6 @@ func (_m *MockQueryNodeServer) Search(_a0 context.Context, _a1 *querypb.SearchRe } } - var r1 error if rf, ok := ret.Get(1).(func(context.Context, *querypb.SearchRequest) error); ok { r1 = rf(_a0, _a1) } else { @@ -734,11 +904,75 @@ func (_c *MockQueryNodeServer_Search_Call) Return(_a0 *internalpb.SearchResults, return _c } +func (_c *MockQueryNodeServer_Search_Call) RunAndReturn(run func(context.Context, *querypb.SearchRequest) (*internalpb.SearchResults, error)) *MockQueryNodeServer_Search_Call { + _c.Call.Return(run) + return _c +} + +// SearchSegments provides a mock function with given fields: _a0, _a1 +func (_m *MockQueryNodeServer) SearchSegments(_a0 context.Context, _a1 *querypb.SearchRequest) (*internalpb.SearchResults, error) { + ret := _m.Called(_a0, _a1) + + var r0 *internalpb.SearchResults + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *querypb.SearchRequest) (*internalpb.SearchResults, error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *querypb.SearchRequest) *internalpb.SearchResults); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*internalpb.SearchResults) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *querypb.SearchRequest) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockQueryNodeServer_SearchSegments_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SearchSegments' +type MockQueryNodeServer_SearchSegments_Call struct { + *mock.Call +} + +// SearchSegments is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *querypb.SearchRequest +func (_e *MockQueryNodeServer_Expecter) SearchSegments(_a0 interface{}, _a1 interface{}) *MockQueryNodeServer_SearchSegments_Call { + return &MockQueryNodeServer_SearchSegments_Call{Call: _e.mock.On("SearchSegments", _a0, _a1)} +} + +func (_c *MockQueryNodeServer_SearchSegments_Call) Run(run func(_a0 context.Context, _a1 *querypb.SearchRequest)) *MockQueryNodeServer_SearchSegments_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*querypb.SearchRequest)) + }) + return _c +} + +func (_c *MockQueryNodeServer_SearchSegments_Call) Return(_a0 *internalpb.SearchResults, _a1 error) *MockQueryNodeServer_SearchSegments_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockQueryNodeServer_SearchSegments_Call) RunAndReturn(run func(context.Context, *querypb.SearchRequest) (*internalpb.SearchResults, error)) *MockQueryNodeServer_SearchSegments_Call { + _c.Call.Return(run) + return _c +} + // ShowConfigurations provides a mock function with given fields: _a0, _a1 func (_m *MockQueryNodeServer) ShowConfigurations(_a0 context.Context, _a1 *internalpb.ShowConfigurationsRequest) (*internalpb.ShowConfigurationsResponse, error) { ret := _m.Called(_a0, _a1) var r0 *internalpb.ShowConfigurationsResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *internalpb.ShowConfigurationsRequest) (*internalpb.ShowConfigurationsResponse, error)); ok { + return rf(_a0, _a1) + } if rf, ok := ret.Get(0).(func(context.Context, *internalpb.ShowConfigurationsRequest) *internalpb.ShowConfigurationsResponse); ok { r0 = rf(_a0, _a1) } else { @@ -747,7 +981,6 @@ func (_m *MockQueryNodeServer) ShowConfigurations(_a0 context.Context, _a1 *inte } } - var r1 error if rf, ok := ret.Get(1).(func(context.Context, *internalpb.ShowConfigurationsRequest) error); ok { r1 = rf(_a0, _a1) } else { @@ -781,11 +1014,20 @@ func (_c *MockQueryNodeServer_ShowConfigurations_Call) Return(_a0 *internalpb.Sh return _c } +func (_c *MockQueryNodeServer_ShowConfigurations_Call) RunAndReturn(run func(context.Context, *internalpb.ShowConfigurationsRequest) (*internalpb.ShowConfigurationsResponse, error)) *MockQueryNodeServer_ShowConfigurations_Call { + _c.Call.Return(run) + return _c +} + // SyncDistribution provides a mock function with given fields: _a0, _a1 func (_m *MockQueryNodeServer) SyncDistribution(_a0 context.Context, _a1 *querypb.SyncDistributionRequest) (*commonpb.Status, error) { ret := _m.Called(_a0, _a1) var r0 *commonpb.Status + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *querypb.SyncDistributionRequest) (*commonpb.Status, error)); ok { + return rf(_a0, _a1) + } if rf, ok := ret.Get(0).(func(context.Context, *querypb.SyncDistributionRequest) *commonpb.Status); ok { r0 = rf(_a0, _a1) } else { @@ -794,7 +1036,6 @@ func (_m *MockQueryNodeServer) SyncDistribution(_a0 context.Context, _a1 *queryp } } - var r1 error if rf, ok := ret.Get(1).(func(context.Context, *querypb.SyncDistributionRequest) error); ok { r1 = rf(_a0, _a1) } else { @@ -828,11 +1069,20 @@ func (_c *MockQueryNodeServer_SyncDistribution_Call) Return(_a0 *commonpb.Status return _c } +func (_c *MockQueryNodeServer_SyncDistribution_Call) RunAndReturn(run func(context.Context, *querypb.SyncDistributionRequest) (*commonpb.Status, error)) *MockQueryNodeServer_SyncDistribution_Call { + _c.Call.Return(run) + return _c +} + // SyncReplicaSegments provides a mock function with given fields: _a0, _a1 func (_m *MockQueryNodeServer) SyncReplicaSegments(_a0 context.Context, _a1 *querypb.SyncReplicaSegmentsRequest) (*commonpb.Status, error) { ret := _m.Called(_a0, _a1) var r0 *commonpb.Status + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *querypb.SyncReplicaSegmentsRequest) (*commonpb.Status, error)); ok { + return rf(_a0, _a1) + } if rf, ok := ret.Get(0).(func(context.Context, *querypb.SyncReplicaSegmentsRequest) *commonpb.Status); ok { r0 = rf(_a0, _a1) } else { @@ -841,7 +1091,6 @@ func (_m *MockQueryNodeServer) SyncReplicaSegments(_a0 context.Context, _a1 *que } } - var r1 error if rf, ok := ret.Get(1).(func(context.Context, *querypb.SyncReplicaSegmentsRequest) error); ok { r1 = rf(_a0, _a1) } else { @@ -875,11 +1124,20 @@ func (_c *MockQueryNodeServer_SyncReplicaSegments_Call) Return(_a0 *commonpb.Sta return _c } +func (_c *MockQueryNodeServer_SyncReplicaSegments_Call) RunAndReturn(run func(context.Context, *querypb.SyncReplicaSegmentsRequest) (*commonpb.Status, error)) *MockQueryNodeServer_SyncReplicaSegments_Call { + _c.Call.Return(run) + return _c +} + // UnsubDmChannel provides a mock function with given fields: _a0, _a1 func (_m *MockQueryNodeServer) UnsubDmChannel(_a0 context.Context, _a1 *querypb.UnsubDmChannelRequest) (*commonpb.Status, error) { ret := _m.Called(_a0, _a1) var r0 *commonpb.Status + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *querypb.UnsubDmChannelRequest) (*commonpb.Status, error)); ok { + return rf(_a0, _a1) + } if rf, ok := ret.Get(0).(func(context.Context, *querypb.UnsubDmChannelRequest) *commonpb.Status); ok { r0 = rf(_a0, _a1) } else { @@ -888,7 +1146,6 @@ func (_m *MockQueryNodeServer) UnsubDmChannel(_a0 context.Context, _a1 *querypb. } } - var r1 error if rf, ok := ret.Get(1).(func(context.Context, *querypb.UnsubDmChannelRequest) error); ok { r1 = rf(_a0, _a1) } else { @@ -922,11 +1179,20 @@ func (_c *MockQueryNodeServer_UnsubDmChannel_Call) Return(_a0 *commonpb.Status, return _c } +func (_c *MockQueryNodeServer_UnsubDmChannel_Call) RunAndReturn(run func(context.Context, *querypb.UnsubDmChannelRequest) (*commonpb.Status, error)) *MockQueryNodeServer_UnsubDmChannel_Call { + _c.Call.Return(run) + return _c +} + // WatchDmChannels provides a mock function with given fields: _a0, _a1 func (_m *MockQueryNodeServer) WatchDmChannels(_a0 context.Context, _a1 *querypb.WatchDmChannelsRequest) (*commonpb.Status, error) { ret := _m.Called(_a0, _a1) var r0 *commonpb.Status + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *querypb.WatchDmChannelsRequest) (*commonpb.Status, error)); ok { + return rf(_a0, _a1) + } if rf, ok := ret.Get(0).(func(context.Context, *querypb.WatchDmChannelsRequest) *commonpb.Status); ok { r0 = rf(_a0, _a1) } else { @@ -935,7 +1201,6 @@ func (_m *MockQueryNodeServer) WatchDmChannels(_a0 context.Context, _a1 *querypb } } - var r1 error if rf, ok := ret.Get(1).(func(context.Context, *querypb.WatchDmChannelsRequest) error); ok { r1 = rf(_a0, _a1) } else { @@ -969,6 +1234,11 @@ func (_c *MockQueryNodeServer_WatchDmChannels_Call) Return(_a0 *commonpb.Status, return _c } +func (_c *MockQueryNodeServer_WatchDmChannels_Call) RunAndReturn(run func(context.Context, *querypb.WatchDmChannelsRequest) (*commonpb.Status, error)) *MockQueryNodeServer_WatchDmChannels_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewMockQueryNodeServer interface { mock.TestingT Cleanup(func()) diff --git a/internal/querynodev2/cluster/mock_worker.go b/internal/querynodev2/cluster/mock_worker.go index e6888184b0..cf8bfa945a 100644 --- a/internal/querynodev2/cluster/mock_worker.go +++ b/internal/querynodev2/cluster/mock_worker.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.16.0. DO NOT EDIT. +// Code generated by mockery v2.21.1. DO NOT EDIT. package cluster @@ -44,8 +44,8 @@ type MockWorker_Delete_Call struct { } // Delete is a helper method to define mock.On call -// - ctx context.Context -// - req *querypb.DeleteRequest +// - ctx context.Context +// - req *querypb.DeleteRequest func (_e *MockWorker_Expecter) Delete(ctx interface{}, req interface{}) *MockWorker_Delete_Call { return &MockWorker_Delete_Call{Call: _e.mock.On("Delete", ctx, req)} } @@ -62,11 +62,20 @@ func (_c *MockWorker_Delete_Call) Return(_a0 error) *MockWorker_Delete_Call { return _c } +func (_c *MockWorker_Delete_Call) RunAndReturn(run func(context.Context, *querypb.DeleteRequest) error) *MockWorker_Delete_Call { + _c.Call.Return(run) + return _c +} + // GetStatistics provides a mock function with given fields: ctx, req func (_m *MockWorker) GetStatistics(ctx context.Context, req *querypb.GetStatisticsRequest) (*internalpb.GetStatisticsResponse, error) { ret := _m.Called(ctx, req) var r0 *internalpb.GetStatisticsResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *querypb.GetStatisticsRequest) (*internalpb.GetStatisticsResponse, error)); ok { + return rf(ctx, req) + } if rf, ok := ret.Get(0).(func(context.Context, *querypb.GetStatisticsRequest) *internalpb.GetStatisticsResponse); ok { r0 = rf(ctx, req) } else { @@ -75,7 +84,6 @@ func (_m *MockWorker) GetStatistics(ctx context.Context, req *querypb.GetStatist } } - var r1 error if rf, ok := ret.Get(1).(func(context.Context, *querypb.GetStatisticsRequest) error); ok { r1 = rf(ctx, req) } else { @@ -91,8 +99,8 @@ type MockWorker_GetStatistics_Call struct { } // GetStatistics is a helper method to define mock.On call -// - ctx context.Context -// - req *querypb.GetStatisticsRequest +// - ctx context.Context +// - req *querypb.GetStatisticsRequest func (_e *MockWorker_Expecter) GetStatistics(ctx interface{}, req interface{}) *MockWorker_GetStatistics_Call { return &MockWorker_GetStatistics_Call{Call: _e.mock.On("GetStatistics", ctx, req)} } @@ -109,6 +117,11 @@ func (_c *MockWorker_GetStatistics_Call) Return(_a0 *internalpb.GetStatisticsRes return _c } +func (_c *MockWorker_GetStatistics_Call) RunAndReturn(run func(context.Context, *querypb.GetStatisticsRequest) (*internalpb.GetStatisticsResponse, error)) *MockWorker_GetStatistics_Call { + _c.Call.Return(run) + return _c +} + // IsHealthy provides a mock function with given fields: func (_m *MockWorker) IsHealthy() bool { ret := _m.Called() @@ -145,6 +158,11 @@ func (_c *MockWorker_IsHealthy_Call) Return(_a0 bool) *MockWorker_IsHealthy_Call return _c } +func (_c *MockWorker_IsHealthy_Call) RunAndReturn(run func() bool) *MockWorker_IsHealthy_Call { + _c.Call.Return(run) + return _c +} + // LoadSegments provides a mock function with given fields: _a0, _a1 func (_m *MockWorker) LoadSegments(_a0 context.Context, _a1 *querypb.LoadSegmentsRequest) error { ret := _m.Called(_a0, _a1) @@ -165,8 +183,8 @@ type MockWorker_LoadSegments_Call struct { } // LoadSegments is a helper method to define mock.On call -// - _a0 context.Context -// - _a1 *querypb.LoadSegmentsRequest +// - _a0 context.Context +// - _a1 *querypb.LoadSegmentsRequest func (_e *MockWorker_Expecter) LoadSegments(_a0 interface{}, _a1 interface{}) *MockWorker_LoadSegments_Call { return &MockWorker_LoadSegments_Call{Call: _e.mock.On("LoadSegments", _a0, _a1)} } @@ -183,11 +201,20 @@ func (_c *MockWorker_LoadSegments_Call) Return(_a0 error) *MockWorker_LoadSegmen return _c } -// Query provides a mock function with given fields: ctx, req -func (_m *MockWorker) Query(ctx context.Context, req *querypb.QueryRequest) (*internalpb.RetrieveResults, error) { +func (_c *MockWorker_LoadSegments_Call) RunAndReturn(run func(context.Context, *querypb.LoadSegmentsRequest) error) *MockWorker_LoadSegments_Call { + _c.Call.Return(run) + return _c +} + +// QuerySegments provides a mock function with given fields: ctx, req +func (_m *MockWorker) QuerySegments(ctx context.Context, req *querypb.QueryRequest) (*internalpb.RetrieveResults, error) { ret := _m.Called(ctx, req) var r0 *internalpb.RetrieveResults + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *querypb.QueryRequest) (*internalpb.RetrieveResults, error)); ok { + return rf(ctx, req) + } if rf, ok := ret.Get(0).(func(context.Context, *querypb.QueryRequest) *internalpb.RetrieveResults); ok { r0 = rf(ctx, req) } else { @@ -196,7 +223,6 @@ func (_m *MockWorker) Query(ctx context.Context, req *querypb.QueryRequest) (*in } } - var r1 error if rf, ok := ret.Get(1).(func(context.Context, *querypb.QueryRequest) error); ok { r1 = rf(ctx, req) } else { @@ -206,30 +232,35 @@ func (_m *MockWorker) Query(ctx context.Context, req *querypb.QueryRequest) (*in return r0, r1 } -// MockWorker_Query_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Query' -type MockWorker_Query_Call struct { +// MockWorker_QuerySegments_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'QuerySegments' +type MockWorker_QuerySegments_Call struct { *mock.Call } -// Query is a helper method to define mock.On call -// - ctx context.Context -// - req *querypb.QueryRequest -func (_e *MockWorker_Expecter) Query(ctx interface{}, req interface{}) *MockWorker_Query_Call { - return &MockWorker_Query_Call{Call: _e.mock.On("Query", ctx, req)} +// QuerySegments is a helper method to define mock.On call +// - ctx context.Context +// - req *querypb.QueryRequest +func (_e *MockWorker_Expecter) QuerySegments(ctx interface{}, req interface{}) *MockWorker_QuerySegments_Call { + return &MockWorker_QuerySegments_Call{Call: _e.mock.On("QuerySegments", ctx, req)} } -func (_c *MockWorker_Query_Call) Run(run func(ctx context.Context, req *querypb.QueryRequest)) *MockWorker_Query_Call { +func (_c *MockWorker_QuerySegments_Call) Run(run func(ctx context.Context, req *querypb.QueryRequest)) *MockWorker_QuerySegments_Call { _c.Call.Run(func(args mock.Arguments) { run(args[0].(context.Context), args[1].(*querypb.QueryRequest)) }) return _c } -func (_c *MockWorker_Query_Call) Return(_a0 *internalpb.RetrieveResults, _a1 error) *MockWorker_Query_Call { +func (_c *MockWorker_QuerySegments_Call) Return(_a0 *internalpb.RetrieveResults, _a1 error) *MockWorker_QuerySegments_Call { _c.Call.Return(_a0, _a1) return _c } +func (_c *MockWorker_QuerySegments_Call) RunAndReturn(run func(context.Context, *querypb.QueryRequest) (*internalpb.RetrieveResults, error)) *MockWorker_QuerySegments_Call { + _c.Call.Return(run) + return _c +} + // ReleaseSegments provides a mock function with given fields: _a0, _a1 func (_m *MockWorker) ReleaseSegments(_a0 context.Context, _a1 *querypb.ReleaseSegmentsRequest) error { ret := _m.Called(_a0, _a1) @@ -250,8 +281,8 @@ type MockWorker_ReleaseSegments_Call struct { } // ReleaseSegments is a helper method to define mock.On call -// - _a0 context.Context -// - _a1 *querypb.ReleaseSegmentsRequest +// - _a0 context.Context +// - _a1 *querypb.ReleaseSegmentsRequest func (_e *MockWorker_Expecter) ReleaseSegments(_a0 interface{}, _a1 interface{}) *MockWorker_ReleaseSegments_Call { return &MockWorker_ReleaseSegments_Call{Call: _e.mock.On("ReleaseSegments", _a0, _a1)} } @@ -268,11 +299,20 @@ func (_c *MockWorker_ReleaseSegments_Call) Return(_a0 error) *MockWorker_Release return _c } -// Search provides a mock function with given fields: ctx, req -func (_m *MockWorker) Search(ctx context.Context, req *querypb.SearchRequest) (*internalpb.SearchResults, error) { +func (_c *MockWorker_ReleaseSegments_Call) RunAndReturn(run func(context.Context, *querypb.ReleaseSegmentsRequest) error) *MockWorker_ReleaseSegments_Call { + _c.Call.Return(run) + return _c +} + +// SearchSegments provides a mock function with given fields: ctx, req +func (_m *MockWorker) SearchSegments(ctx context.Context, req *querypb.SearchRequest) (*internalpb.SearchResults, error) { ret := _m.Called(ctx, req) var r0 *internalpb.SearchResults + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *querypb.SearchRequest) (*internalpb.SearchResults, error)); ok { + return rf(ctx, req) + } if rf, ok := ret.Get(0).(func(context.Context, *querypb.SearchRequest) *internalpb.SearchResults); ok { r0 = rf(ctx, req) } else { @@ -281,7 +321,6 @@ func (_m *MockWorker) Search(ctx context.Context, req *querypb.SearchRequest) (* } } - var r1 error if rf, ok := ret.Get(1).(func(context.Context, *querypb.SearchRequest) error); ok { r1 = rf(ctx, req) } else { @@ -291,30 +330,35 @@ func (_m *MockWorker) Search(ctx context.Context, req *querypb.SearchRequest) (* return r0, r1 } -// MockWorker_Search_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Search' -type MockWorker_Search_Call struct { +// MockWorker_SearchSegments_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SearchSegments' +type MockWorker_SearchSegments_Call struct { *mock.Call } -// Search is a helper method to define mock.On call -// - ctx context.Context -// - req *querypb.SearchRequest -func (_e *MockWorker_Expecter) Search(ctx interface{}, req interface{}) *MockWorker_Search_Call { - return &MockWorker_Search_Call{Call: _e.mock.On("Search", ctx, req)} +// SearchSegments is a helper method to define mock.On call +// - ctx context.Context +// - req *querypb.SearchRequest +func (_e *MockWorker_Expecter) SearchSegments(ctx interface{}, req interface{}) *MockWorker_SearchSegments_Call { + return &MockWorker_SearchSegments_Call{Call: _e.mock.On("SearchSegments", ctx, req)} } -func (_c *MockWorker_Search_Call) Run(run func(ctx context.Context, req *querypb.SearchRequest)) *MockWorker_Search_Call { +func (_c *MockWorker_SearchSegments_Call) Run(run func(ctx context.Context, req *querypb.SearchRequest)) *MockWorker_SearchSegments_Call { _c.Call.Run(func(args mock.Arguments) { run(args[0].(context.Context), args[1].(*querypb.SearchRequest)) }) return _c } -func (_c *MockWorker_Search_Call) Return(_a0 *internalpb.SearchResults, _a1 error) *MockWorker_Search_Call { +func (_c *MockWorker_SearchSegments_Call) Return(_a0 *internalpb.SearchResults, _a1 error) *MockWorker_SearchSegments_Call { _c.Call.Return(_a0, _a1) return _c } +func (_c *MockWorker_SearchSegments_Call) RunAndReturn(run func(context.Context, *querypb.SearchRequest) (*internalpb.SearchResults, error)) *MockWorker_SearchSegments_Call { + _c.Call.Return(run) + return _c +} + // Stop provides a mock function with given fields: func (_m *MockWorker) Stop() { _m.Called() @@ -342,6 +386,11 @@ func (_c *MockWorker_Stop_Call) Return() *MockWorker_Stop_Call { return _c } +func (_c *MockWorker_Stop_Call) RunAndReturn(run func()) *MockWorker_Stop_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewMockWorker interface { mock.TestingT Cleanup(func()) diff --git a/internal/querynodev2/cluster/worker.go b/internal/querynodev2/cluster/worker.go index 03dc2ba0e4..69556e5c0b 100644 --- a/internal/querynodev2/cluster/worker.go +++ b/internal/querynodev2/cluster/worker.go @@ -28,6 +28,7 @@ import ( "github.com/milvus-io/milvus/internal/proto/querypb" "github.com/milvus-io/milvus/internal/types" "github.com/milvus-io/milvus/pkg/log" + "github.com/milvus-io/milvus/pkg/util/funcutil" "github.com/milvus-io/milvus/pkg/util/merr" ) @@ -36,8 +37,8 @@ type Worker interface { LoadSegments(context.Context, *querypb.LoadSegmentsRequest) error ReleaseSegments(context.Context, *querypb.ReleaseSegmentsRequest) error Delete(ctx context.Context, req *querypb.DeleteRequest) error - Search(ctx context.Context, req *querypb.SearchRequest) (*internalpb.SearchResults, error) - Query(ctx context.Context, req *querypb.QueryRequest) (*internalpb.RetrieveResults, error) + SearchSegments(ctx context.Context, req *querypb.SearchRequest) (*internalpb.SearchResults, error) + QuerySegments(ctx context.Context, req *querypb.QueryRequest) (*internalpb.RetrieveResults, error) GetStatistics(ctx context.Context, req *querypb.GetStatisticsRequest) (*internalpb.GetStatisticsResponse, error) IsHealthy() bool @@ -117,12 +118,24 @@ func (w *remoteWorker) Delete(ctx context.Context, req *querypb.DeleteRequest) e return nil } -func (w *remoteWorker) Search(ctx context.Context, req *querypb.SearchRequest) (*internalpb.SearchResults, error) { - return w.client.Search(ctx, req) +func (w *remoteWorker) SearchSegments(ctx context.Context, req *querypb.SearchRequest) (*internalpb.SearchResults, error) { + ret, err := w.client.SearchSegments(ctx, req) + if err != nil && funcutil.IsGrpcErr(err) { + // for compatible with rolling upgrade from version before v2.2.9 + return w.client.Search(ctx, req) + } + + return ret, err } -func (w *remoteWorker) Query(ctx context.Context, req *querypb.QueryRequest) (*internalpb.RetrieveResults, error) { - return w.client.Query(ctx, req) +func (w *remoteWorker) QuerySegments(ctx context.Context, req *querypb.QueryRequest) (*internalpb.RetrieveResults, error) { + ret, err := w.client.QuerySegments(ctx, req) + if err != nil && funcutil.IsGrpcErr(err) { + // for compatible with rolling upgrade from version before v2.2.9 + return w.client.Query(ctx, req) + } + + return ret, err } func (w *remoteWorker) GetStatistics(ctx context.Context, req *querypb.GetStatisticsRequest) (*internalpb.GetStatisticsResponse, error) { diff --git a/internal/querynodev2/cluster/worker_test.go b/internal/querynodev2/cluster/worker_test.go index cc303a45c5..88912eb166 100644 --- a/internal/querynodev2/cluster/worker_test.go +++ b/internal/querynodev2/cluster/worker_test.go @@ -23,6 +23,8 @@ import ( "testing" "github.com/cockroachdb/errors" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/status" commonpb "github.com/milvus-io/milvus-proto/go-api/commonpb" internalpb "github.com/milvus-io/milvus/internal/proto/internalpb" @@ -183,12 +185,12 @@ func (s *RemoteWorkerSuite) TestSearch() { result = &internalpb.SearchResults{ Status: &commonpb.Status{ErrorCode: commonpb.ErrorCode_Success}, } - s.mockClient.EXPECT().Search(mock.Anything, mock.AnythingOfType("*querypb.SearchRequest")). + s.mockClient.EXPECT().SearchSegments(mock.Anything, mock.AnythingOfType("*querypb.SearchRequest")). Return(result, err) ctx, cancel := context.WithCancel(context.Background()) defer cancel() - sr, serr := s.worker.Search(ctx, &querypb.SearchRequest{}) + sr, serr := s.worker.SearchSegments(ctx, &querypb.SearchRequest{}) s.Equal(err, serr) s.Equal(result, sr) @@ -199,12 +201,12 @@ func (s *RemoteWorkerSuite) TestSearch() { var result *internalpb.SearchResults err := errors.New("mocked error") - s.mockClient.EXPECT().Search(mock.Anything, mock.AnythingOfType("*querypb.SearchRequest")). + s.mockClient.EXPECT().SearchSegments(mock.Anything, mock.AnythingOfType("*querypb.SearchRequest")). Return(result, err) ctx, cancel := context.WithCancel(context.Background()) defer cancel() - sr, serr := s.worker.Search(ctx, &querypb.SearchRequest{}) + sr, serr := s.worker.SearchSegments(ctx, &querypb.SearchRequest{}) s.Equal(err, serr) s.Equal(result, sr) @@ -219,12 +221,32 @@ func (s *RemoteWorkerSuite) TestSearch() { result = &internalpb.SearchResults{ Status: &commonpb.Status{ErrorCode: commonpb.ErrorCode_UnexpectedError}, } + s.mockClient.EXPECT().SearchSegments(mock.Anything, mock.AnythingOfType("*querypb.SearchRequest")). + Return(result, err) + + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + sr, serr := s.worker.SearchSegments(ctx, &querypb.SearchRequest{}) + + s.Equal(err, serr) + s.Equal(result, sr) + }) + + s.Run("client_search_compatible", func() { + defer func() { s.mockClient.ExpectedCalls = nil }() + + var result *internalpb.SearchResults + var err error + + grpcErr := status.Error(codes.NotFound, "method not implemented") + s.mockClient.EXPECT().SearchSegments(mock.Anything, mock.AnythingOfType("*querypb.SearchRequest")). + Return(result, grpcErr) s.mockClient.EXPECT().Search(mock.Anything, mock.AnythingOfType("*querypb.SearchRequest")). Return(result, err) ctx, cancel := context.WithCancel(context.Background()) defer cancel() - sr, serr := s.worker.Search(ctx, &querypb.SearchRequest{}) + sr, serr := s.worker.SearchSegments(ctx, &querypb.SearchRequest{}) s.Equal(err, serr) s.Equal(result, sr) @@ -241,12 +263,12 @@ func (s *RemoteWorkerSuite) TestQuery() { result = &internalpb.RetrieveResults{ Status: &commonpb.Status{ErrorCode: commonpb.ErrorCode_Success}, } - s.mockClient.EXPECT().Query(mock.Anything, mock.AnythingOfType("*querypb.QueryRequest")). + s.mockClient.EXPECT().QuerySegments(mock.Anything, mock.AnythingOfType("*querypb.QueryRequest")). Return(result, err) ctx, cancel := context.WithCancel(context.Background()) defer cancel() - sr, serr := s.worker.Query(ctx, &querypb.QueryRequest{}) + sr, serr := s.worker.QuerySegments(ctx, &querypb.QueryRequest{}) s.Equal(err, serr) s.Equal(result, sr) @@ -258,12 +280,12 @@ func (s *RemoteWorkerSuite) TestQuery() { var result *internalpb.RetrieveResults err := errors.New("mocked error") - s.mockClient.EXPECT().Query(mock.Anything, mock.AnythingOfType("*querypb.QueryRequest")). + s.mockClient.EXPECT().QuerySegments(mock.Anything, mock.AnythingOfType("*querypb.QueryRequest")). Return(result, err) ctx, cancel := context.WithCancel(context.Background()) defer cancel() - sr, serr := s.worker.Query(ctx, &querypb.QueryRequest{}) + sr, serr := s.worker.QuerySegments(ctx, &querypb.QueryRequest{}) s.Equal(err, serr) s.Equal(result, sr) @@ -278,12 +300,32 @@ func (s *RemoteWorkerSuite) TestQuery() { result = &internalpb.RetrieveResults{ Status: &commonpb.Status{ErrorCode: commonpb.ErrorCode_UnexpectedError}, } + s.mockClient.EXPECT().QuerySegments(mock.Anything, mock.AnythingOfType("*querypb.QueryRequest")). + Return(result, err) + + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + sr, serr := s.worker.QuerySegments(ctx, &querypb.QueryRequest{}) + + s.Equal(err, serr) + s.Equal(result, sr) + }) + + s.Run("client_query_compatible", func() { + defer func() { s.mockClient.ExpectedCalls = nil }() + + var result *internalpb.RetrieveResults + var err error + + grpcErr := status.Error(codes.NotFound, "method not implemented") + s.mockClient.EXPECT().QuerySegments(mock.Anything, mock.AnythingOfType("*querypb.QueryRequest")). + Return(result, grpcErr) s.mockClient.EXPECT().Query(mock.Anything, mock.AnythingOfType("*querypb.QueryRequest")). Return(result, err) ctx, cancel := context.WithCancel(context.Background()) defer cancel() - sr, serr := s.worker.Query(ctx, &querypb.QueryRequest{}) + sr, serr := s.worker.QuerySegments(ctx, &querypb.QueryRequest{}) s.Equal(err, serr) s.Equal(result, sr) diff --git a/internal/querynodev2/delegator/delegator.go b/internal/querynodev2/delegator/delegator.go index 2b2268768d..e900c45c7b 100644 --- a/internal/querynodev2/delegator/delegator.go +++ b/internal/querynodev2/delegator/delegator.go @@ -175,21 +175,23 @@ func (sd *shardDelegator) SyncDistribution(ctx context.Context, entries ...Segme sd.distribution.AddDistributions(entries...) } -func modifySearchRequest(req *querypb.SearchRequest, scope querypb.DataScope, segmentIDs []int64, targetID int64) *querypb.SearchRequest { +func (sd *shardDelegator) modifySearchRequest(req *querypb.SearchRequest, scope querypb.DataScope, segmentIDs []int64, targetID int64) *querypb.SearchRequest { nodeReq := proto.Clone(req).(*querypb.SearchRequest) nodeReq.Scope = scope nodeReq.Req.Base.TargetID = targetID nodeReq.SegmentIDs = segmentIDs nodeReq.FromShardLeader = true + nodeReq.DmlChannels = []string{sd.vchannelName} return nodeReq } -func modifyQueryRequest(req *querypb.QueryRequest, scope querypb.DataScope, segmentIDs []int64, targetID int64) *querypb.QueryRequest { +func (sd *shardDelegator) modifyQueryRequest(req *querypb.QueryRequest, scope querypb.DataScope, segmentIDs []int64, targetID int64) *querypb.QueryRequest { nodeReq := proto.Clone(req).(*querypb.QueryRequest) nodeReq.Scope = scope nodeReq.Req.Base.TargetID = targetID nodeReq.SegmentIDs = segmentIDs nodeReq.FromShardLeader = true + nodeReq.DmlChannels = []string{sd.vchannelName} return nodeReq } @@ -225,14 +227,14 @@ func (sd *shardDelegator) Search(ctx context.Context, req *querypb.SearchRequest if req.Req.IgnoreGrowing { growing = []SegmentEntry{} } - tasks, err := organizeSubTask(req, sealed, growing, sd.workerManager, modifySearchRequest) + tasks, err := organizeSubTask(req, sealed, growing, sd.workerManager, sd.modifySearchRequest) if err != nil { log.Warn("Search organizeSubTask failed", zap.Error(err)) return nil, err } results, err := executeSubTasks(ctx, tasks, func(ctx context.Context, req *querypb.SearchRequest, worker cluster.Worker) (*internalpb.SearchResults, error) { - return worker.Search(ctx, req) + return worker.SearchSegments(ctx, req) }, "Search", log) if err != nil { log.Warn("Delegator search failed", zap.Error(err)) @@ -280,14 +282,14 @@ func (sd *shardDelegator) Query(ctx context.Context, req *querypb.QueryRequest) zap.Int("sealedNum", len(sealed)), zap.Int("growingNum", len(growing)), ) - tasks, err := organizeSubTask(req, sealed, growing, sd.workerManager, modifyQueryRequest) + tasks, err := organizeSubTask(req, sealed, growing, sd.workerManager, sd.modifyQueryRequest) if err != nil { log.Warn("query organizeSubTask failed", zap.Error(err)) return nil, err } results, err := executeSubTasks(ctx, tasks, func(ctx context.Context, req *querypb.QueryRequest, worker cluster.Worker) (*internalpb.RetrieveResults, error) { - return worker.Query(ctx, req) + return worker.QuerySegments(ctx, req) }, "Query", log) if err != nil { log.Warn("Delegator query failed", zap.Error(err)) diff --git a/internal/querynodev2/delegator/delegator_test.go b/internal/querynodev2/delegator/delegator_test.go index 28847beeb0..aaa42c227f 100644 --- a/internal/querynodev2/delegator/delegator_test.go +++ b/internal/querynodev2/delegator/delegator_test.go @@ -248,7 +248,7 @@ func (s *DelegatorSuite) TestSearch() { workers[1] = worker1 workers[2] = worker2 - worker1.EXPECT().Search(mock.Anything, mock.AnythingOfType("*querypb.SearchRequest")). + worker1.EXPECT().SearchSegments(mock.Anything, mock.AnythingOfType("*querypb.SearchRequest")). Run(func(_ context.Context, req *querypb.SearchRequest) { s.EqualValues(1, req.Req.GetBase().GetTargetID()) s.True(req.GetFromShardLeader()) @@ -261,7 +261,7 @@ func (s *DelegatorSuite) TestSearch() { s.ElementsMatch([]int64{1000, 1001}, req.GetSegmentIDs()) } }).Return(&internalpb.SearchResults{}, nil) - worker2.EXPECT().Search(mock.Anything, mock.AnythingOfType("*querypb.SearchRequest")). + worker2.EXPECT().SearchSegments(mock.Anything, mock.AnythingOfType("*querypb.SearchRequest")). Run(func(_ context.Context, req *querypb.SearchRequest) { s.EqualValues(2, req.Req.GetBase().GetTargetID()) s.True(req.GetFromShardLeader()) @@ -296,9 +296,9 @@ func (s *DelegatorSuite) TestSearch() { workers[1] = worker1 workers[2] = worker2 - worker1.EXPECT().Search(mock.Anything, mock.AnythingOfType("*querypb.SearchRequest")). + worker1.EXPECT().SearchSegments(mock.Anything, mock.AnythingOfType("*querypb.SearchRequest")). Return(&internalpb.SearchResults{}, nil) - worker2.EXPECT().Search(mock.Anything, mock.AnythingOfType("*querypb.SearchRequest")). + worker2.EXPECT().SearchSegments(mock.Anything, mock.AnythingOfType("*querypb.SearchRequest")). Return(&internalpb.SearchResults{}, nil) s.workerManager.EXPECT().GetWorker(mock.AnythingOfType("int64")).Call.Return(func(nodeID int64) cluster.Worker { @@ -329,8 +329,8 @@ func (s *DelegatorSuite) TestSearch() { workers[1] = worker1 workers[2] = worker2 - worker1.EXPECT().Search(mock.Anything, mock.AnythingOfType("*querypb.SearchRequest")).Return(nil, errors.New("mock error")) - worker2.EXPECT().Search(mock.Anything, mock.AnythingOfType("*querypb.SearchRequest")). + worker1.EXPECT().SearchSegments(mock.Anything, mock.AnythingOfType("*querypb.SearchRequest")).Return(nil, errors.New("mock error")) + worker2.EXPECT().SearchSegments(mock.Anything, mock.AnythingOfType("*querypb.SearchRequest")). Run(func(_ context.Context, req *querypb.SearchRequest) { s.EqualValues(2, req.Req.GetBase().GetTargetID()) s.True(req.GetFromShardLeader()) @@ -364,13 +364,13 @@ func (s *DelegatorSuite) TestSearch() { workers[1] = worker1 workers[2] = worker2 - worker1.EXPECT().Search(mock.Anything, mock.AnythingOfType("*querypb.SearchRequest")).Return(&internalpb.SearchResults{ + worker1.EXPECT().SearchSegments(mock.Anything, mock.AnythingOfType("*querypb.SearchRequest")).Return(&internalpb.SearchResults{ Status: &commonpb.Status{ ErrorCode: commonpb.ErrorCode_UnexpectedError, Reason: "mocked error", }, }, nil) - worker2.EXPECT().Search(mock.Anything, mock.AnythingOfType("*querypb.SearchRequest")). + worker2.EXPECT().SearchSegments(mock.Anything, mock.AnythingOfType("*querypb.SearchRequest")). Run(func(_ context.Context, req *querypb.SearchRequest) { s.EqualValues(2, req.Req.GetBase().GetTargetID()) s.True(req.GetFromShardLeader()) @@ -500,7 +500,7 @@ func (s *DelegatorSuite) TestQuery() { workers[1] = worker1 workers[2] = worker2 - worker1.EXPECT().Query(mock.Anything, mock.AnythingOfType("*querypb.QueryRequest")). + worker1.EXPECT().QuerySegments(mock.Anything, mock.AnythingOfType("*querypb.QueryRequest")). Run(func(_ context.Context, req *querypb.QueryRequest) { s.EqualValues(1, req.Req.GetBase().GetTargetID()) s.True(req.GetFromShardLeader()) @@ -513,7 +513,7 @@ func (s *DelegatorSuite) TestQuery() { s.ElementsMatch([]int64{1000, 1001}, req.GetSegmentIDs()) } }).Return(&internalpb.RetrieveResults{}, nil) - worker2.EXPECT().Query(mock.Anything, mock.AnythingOfType("*querypb.QueryRequest")). + worker2.EXPECT().QuerySegments(mock.Anything, mock.AnythingOfType("*querypb.QueryRequest")). Run(func(_ context.Context, req *querypb.QueryRequest) { s.EqualValues(2, req.Req.GetBase().GetTargetID()) s.True(req.GetFromShardLeader()) @@ -548,9 +548,9 @@ func (s *DelegatorSuite) TestQuery() { workers[1] = worker1 workers[2] = worker2 - worker1.EXPECT().Query(mock.Anything, mock.AnythingOfType("*querypb.QueryRequest")). + worker1.EXPECT().QuerySegments(mock.Anything, mock.AnythingOfType("*querypb.QueryRequest")). Return(&internalpb.RetrieveResults{}, nil) - worker2.EXPECT().Query(mock.Anything, mock.AnythingOfType("*querypb.QueryRequest")). + worker2.EXPECT().QuerySegments(mock.Anything, mock.AnythingOfType("*querypb.QueryRequest")). Return(&internalpb.RetrieveResults{}, nil) s.workerManager.EXPECT().GetWorker(mock.AnythingOfType("int64")).Call.Return(func(nodeID int64) cluster.Worker { @@ -581,8 +581,8 @@ func (s *DelegatorSuite) TestQuery() { workers[1] = worker1 workers[2] = worker2 - worker1.EXPECT().Query(mock.Anything, mock.AnythingOfType("*querypb.QueryRequest")).Return(nil, errors.New("mock error")) - worker2.EXPECT().Query(mock.Anything, mock.AnythingOfType("*querypb.QueryRequest")). + worker1.EXPECT().QuerySegments(mock.Anything, mock.AnythingOfType("*querypb.QueryRequest")).Return(nil, errors.New("mock error")) + worker2.EXPECT().QuerySegments(mock.Anything, mock.AnythingOfType("*querypb.QueryRequest")). Run(func(_ context.Context, req *querypb.QueryRequest) { s.EqualValues(2, req.Req.GetBase().GetTargetID()) s.True(req.GetFromShardLeader()) @@ -613,13 +613,13 @@ func (s *DelegatorSuite) TestQuery() { workers[1] = worker1 workers[2] = worker2 - worker1.EXPECT().Query(mock.Anything, mock.AnythingOfType("*querypb.QueryRequest")).Return(&internalpb.RetrieveResults{ + worker1.EXPECT().QuerySegments(mock.Anything, mock.AnythingOfType("*querypb.QueryRequest")).Return(&internalpb.RetrieveResults{ Status: &commonpb.Status{ ErrorCode: commonpb.ErrorCode_UnexpectedError, Reason: "mocked error", }, }, nil) - worker2.EXPECT().Query(mock.Anything, mock.AnythingOfType("*querypb.QueryRequest")). + worker2.EXPECT().QuerySegments(mock.Anything, mock.AnythingOfType("*querypb.QueryRequest")). Run(func(_ context.Context, req *querypb.QueryRequest) { s.EqualValues(2, req.Req.GetBase().GetTargetID()) s.True(req.GetFromShardLeader()) diff --git a/internal/querynodev2/handlers.go b/internal/querynodev2/handlers.go index ea21ec5360..d3aacaa948 100644 --- a/internal/querynodev2/handlers.go +++ b/internal/querynodev2/handlers.go @@ -33,7 +33,6 @@ import ( "github.com/milvus-io/milvus/internal/proto/segcorepb" "github.com/milvus-io/milvus/internal/querynodev2/delegator" "github.com/milvus-io/milvus/internal/querynodev2/segments" - "github.com/milvus-io/milvus/internal/querynodev2/tasks" "github.com/milvus-io/milvus/internal/util" "github.com/milvus-io/milvus/pkg/common" "github.com/milvus-io/milvus/pkg/log" @@ -139,30 +138,6 @@ func (node *QueryNode) queryChannel(ctx context.Context, req *querypb.QueryReque queryCtx, cancel := context.WithCancel(ctx) defer cancel() - // TODO From Shard Delegator - if req.FromShardLeader { - tr := timerecord.NewTimeRecorder("queryChannel") - results, err := node.querySegments(queryCtx, req) - if err != nil { - log.Warn("failed to query channel", zap.Error(err)) - failRet.Status.Reason = err.Error() - return failRet, nil - } - - tr.CtxElapse(ctx, fmt.Sprintf("do query done, traceID = %s, fromSharedLeader = %t, vChannel = %s, segmentIDs = %v", - traceID, - req.GetFromShardLeader(), - channel, - req.GetSegmentIDs(), - )) - - failRet.Status.ErrorCode = commonpb.ErrorCode_Success - // TODO QueryNodeSQLatencyInQueue QueryNodeReduceLatency - latency := tr.ElapseSpan() - metrics.QueryNodeSQReqLatency.WithLabelValues(fmt.Sprint(paramtable.GetNodeID()), metrics.QueryLabel, metrics.FromLeader).Observe(float64(latency.Milliseconds())) - metrics.QueryNodeSQCount.WithLabelValues(fmt.Sprint(paramtable.GetNodeID()), metrics.QueryLabel, metrics.SuccessLabel).Inc() - return results, nil - } // From Proxy tr := timerecord.NewTimeRecorder("queryDelegator") // get delegator @@ -343,41 +318,6 @@ func (node *QueryNode) searchChannel(ctx context.Context, req *querypb.SearchReq searchCtx, cancel := context.WithCancel(ctx) defer cancel() - if req.GetFromShardLeader() { - tr := timerecord.NewTimeRecorder("searchChannel") - log.Debug("search channel...") - - collection := node.manager.Collection.Get(req.Req.GetCollectionID()) - if collection == nil { - log.Warn("failed to search channel", zap.Error(segments.ErrCollectionNotFound)) - return nil, segments.WrapCollectionNotFound(req.GetReq().GetCollectionID()) - } - - task := tasks.NewSearchTask(searchCtx, collection, node.manager, req) - if !node.scheduler.Add(task) { - err := merr.WrapErrTaskQueueFull() - log.Warn("failed to search channel", zap.Error(err)) - return nil, err - } - - err := task.Wait() - if err != nil { - log.Warn("failed to search channel", zap.Error(err)) - return nil, err - } - - tr.CtxElapse(ctx, fmt.Sprintf("search channel done, channel = %s, segmentIDs = %v", - channel, - req.GetSegmentIDs(), - )) - - // TODO QueryNodeSQLatencyInQueue QueryNodeReduceLatency - latency := tr.ElapseSpan() - metrics.QueryNodeSQReqLatency.WithLabelValues(fmt.Sprint(paramtable.GetNodeID()), metrics.SearchLabel, metrics.FromLeader).Observe(float64(latency.Milliseconds())) - metrics.QueryNodeSQCount.WithLabelValues(fmt.Sprint(paramtable.GetNodeID()), metrics.SearchLabel, metrics.SuccessLabel).Inc() - return task.Result(), nil - } - // From Proxy tr := timerecord.NewTimeRecorder("searchDelegator") // get delegator diff --git a/internal/querynodev2/local_worker.go b/internal/querynodev2/local_worker.go index 895e9255d6..dcfdfcbebd 100644 --- a/internal/querynodev2/local_worker.go +++ b/internal/querynodev2/local_worker.go @@ -75,12 +75,12 @@ func (w *LocalWorker) Delete(ctx context.Context, req *querypb.DeleteRequest) er return nil } -func (w *LocalWorker) Search(ctx context.Context, req *querypb.SearchRequest) (*internalpb.SearchResults, error) { - return w.node.Search(ctx, req) +func (w *LocalWorker) SearchSegments(ctx context.Context, req *querypb.SearchRequest) (*internalpb.SearchResults, error) { + return w.node.SearchSegments(ctx, req) } -func (w *LocalWorker) Query(ctx context.Context, req *querypb.QueryRequest) (*internalpb.RetrieveResults, error) { - return w.node.Query(ctx, req) +func (w *LocalWorker) QuerySegments(ctx context.Context, req *querypb.QueryRequest) (*internalpb.RetrieveResults, error) { + return w.node.querySegments(ctx, req) } func (w *LocalWorker) GetStatistics(ctx context.Context, req *querypb.GetStatisticsRequest) (*internalpb.GetStatisticsResponse, error) { diff --git a/internal/querynodev2/services.go b/internal/querynodev2/services.go index 79d33cedc9..1d36117975 100644 --- a/internal/querynodev2/services.go +++ b/internal/querynodev2/services.go @@ -25,6 +25,7 @@ import ( "github.com/golang/protobuf/proto" "github.com/samber/lo" + "go.opentelemetry.io/otel/trace" "go.uber.org/zap" "golang.org/x/sync/errgroup" @@ -38,6 +39,7 @@ import ( "github.com/milvus-io/milvus/internal/querynodev2/collector" "github.com/milvus-io/milvus/internal/querynodev2/delegator" "github.com/milvus-io/milvus/internal/querynodev2/segments" + "github.com/milvus-io/milvus/internal/querynodev2/tasks" "github.com/milvus-io/milvus/internal/storage" "github.com/milvus-io/milvus/internal/util" "github.com/milvus-io/milvus/pkg/common" @@ -626,8 +628,68 @@ func (node *QueryNode) GetSegmentInfo(ctx context.Context, in *querypb.GetSegmen }, nil } +// only used for shard delegator search segments from worker +func (node *QueryNode) SearchSegments(ctx context.Context, req *querypb.SearchRequest) (*internalpb.SearchResults, error) { + channel := req.GetDmlChannels()[0] + log := log.Ctx(ctx).With( + zap.Int64("msgID", req.GetReq().GetBase().GetMsgID()), + zap.Int64("collectionID", req.Req.GetCollectionID()), + zap.String("channel", channel), + zap.String("scope", req.GetScope().String()), + ) + + if !node.lifetime.Add(commonpbutil.IsHealthy) { + return nil, merr.WrapErrServiceNotReady(fmt.Sprintf("node id: %d is unhealthy", paramtable.GetNodeID())) + } + defer node.lifetime.Done() + + log.Debug("start to search segments on worker", + zap.Int64s("segmentIDs", req.GetSegmentIDs()), + ) + searchCtx, cancel := context.WithCancel(ctx) + defer cancel() + + tr := timerecord.NewTimeRecorder("searchChannel") + log.Debug("search channel...") + + collection := node.manager.Collection.Get(req.Req.GetCollectionID()) + if collection == nil { + log.Warn("failed to search channel", zap.Error(segments.ErrCollectionNotFound)) + return nil, segments.WrapCollectionNotFound(req.GetReq().GetCollectionID()) + } + + task := tasks.NewSearchTask(searchCtx, collection, node.manager, req) + if !node.scheduler.Add(task) { + err := merr.WrapErrTaskQueueFull() + log.Warn("failed to search channel", zap.Error(err)) + return nil, err + } + + err := task.Wait() + if err != nil { + log.Warn("failed to search channel", zap.Error(err)) + return nil, err + } + + tr.CtxElapse(ctx, fmt.Sprintf("search channel done, channel = %s, segmentIDs = %v", + channel, + req.GetSegmentIDs(), + )) + + // TODO QueryNodeSQLatencyInQueue QueryNodeReduceLatency + latency := tr.ElapseSpan() + metrics.QueryNodeSQReqLatency.WithLabelValues(fmt.Sprint(paramtable.GetNodeID()), metrics.SearchLabel, metrics.FromLeader).Observe(float64(latency.Milliseconds())) + metrics.QueryNodeSQCount.WithLabelValues(fmt.Sprint(paramtable.GetNodeID()), metrics.SearchLabel, metrics.SuccessLabel).Inc() + return task.Result(), nil +} + // Search performs replica search tasks. func (node *QueryNode) Search(ctx context.Context, req *querypb.SearchRequest) (*internalpb.SearchResults, error) { + if req.FromShardLeader { + // for compatible with rolling upgrade from version before v2.2.9 + return node.SearchSegments(ctx, req) + } + log := log.Ctx(ctx).With( zap.Int64("collectionID", req.GetReq().GetCollectionID()), zap.Strings("channels", req.GetDmlChannels()), @@ -721,8 +783,71 @@ func (node *QueryNode) Search(ctx context.Context, req *querypb.SearchRequest) ( return ret, nil } +// only used for delegator query segments from worker +func (node *QueryNode) QuerySegments(ctx context.Context, req *querypb.QueryRequest) (*internalpb.RetrieveResults, error) { + metrics.QueryNodeSQCount.WithLabelValues(fmt.Sprint(paramtable.GetNodeID()), metrics.QueryLabel, metrics.TotalLabel).Inc() + failRet := WrapRetrieveResult(commonpb.ErrorCode_UnexpectedError, "") + msgID := req.Req.Base.GetMsgID() + traceID := trace.SpanFromContext(ctx).SpanContext().TraceID() + channel := req.GetDmlChannels()[0] + log := log.Ctx(ctx).With( + zap.Int64("msgID", msgID), + zap.Int64("collectionID", req.GetReq().GetCollectionID()), + zap.String("channel", channel), + zap.String("scope", req.GetScope().String()), + ) + + defer func() { + if failRet.Status.ErrorCode != commonpb.ErrorCode_Success { + metrics.QueryNodeSQCount.WithLabelValues(fmt.Sprint(paramtable.GetNodeID()), metrics.SearchLabel, metrics.FailLabel).Inc() + } + }() + + if !node.lifetime.Add(commonpbutil.IsHealthy) { + err := merr.WrapErrServiceUnavailable(fmt.Sprintf("node id: %d is unhealthy", paramtable.GetNodeID())) + failRet.Status = merr.Status(err) + return failRet, nil + } + defer node.lifetime.Done() + + log.Debug("start do query with channel", + zap.Bool("fromShardLeader", req.GetFromShardLeader()), + zap.Int64s("segmentIDs", req.GetSegmentIDs()), + ) + // add cancel when error occurs + queryCtx, cancel := context.WithCancel(ctx) + defer cancel() + + tr := timerecord.NewTimeRecorder("queryChannel") + results, err := node.querySegments(queryCtx, req) + if err != nil { + log.Warn("failed to query channel", zap.Error(err)) + failRet.Status.Reason = err.Error() + return failRet, nil + } + + tr.CtxElapse(ctx, fmt.Sprintf("do query done, traceID = %s, fromSharedLeader = %t, vChannel = %s, segmentIDs = %v", + traceID, + req.GetFromShardLeader(), + channel, + req.GetSegmentIDs(), + )) + + failRet.Status.ErrorCode = commonpb.ErrorCode_Success + // TODO QueryNodeSQLatencyInQueue QueryNodeReduceLatency + latency := tr.ElapseSpan() + metrics.QueryNodeSQReqLatency.WithLabelValues(fmt.Sprint(paramtable.GetNodeID()), metrics.QueryLabel, metrics.FromLeader).Observe(float64(latency.Milliseconds())) + metrics.QueryNodeSQCount.WithLabelValues(fmt.Sprint(paramtable.GetNodeID()), metrics.QueryLabel, metrics.SuccessLabel).Inc() + return results, nil +} + // Query performs replica query tasks. func (node *QueryNode) Query(ctx context.Context, req *querypb.QueryRequest) (*internalpb.RetrieveResults, error) { + if req.FromShardLeader { + // for compatible with rolling upgrade from version before v2.2.9 + return node.querySegments(ctx, req) + } + log := log.Ctx(ctx).With( zap.Int64("collectionID", req.GetReq().GetCollectionID()), zap.Strings("shards", req.GetDmlChannels()), diff --git a/internal/querynodev2/services_test.go b/internal/querynodev2/services_test.go index 0eddb8cf7d..53d84adf03 100644 --- a/internal/querynodev2/services_test.go +++ b/internal/querynodev2/services_test.go @@ -967,6 +967,27 @@ func (suite *ServiceSuite) TestSearch_Failed() { suite.Equal(commonpb.ErrorCode_NotReadyServe, resp.Status.GetErrorCode()) } +func (suite *ServiceSuite) TestSearchSegments_Normal() { + ctx := context.Background() + // pre + suite.TestWatchDmChannelsInt64() + suite.TestLoadSegments_Int64() + + // data + schema := segments.GenTestCollectionSchema(suite.collectionName, schemapb.DataType_Int64) + creq, err := suite.genCSearchRequest(10, IndexFaissIDMap, schema) + req := &querypb.SearchRequest{ + Req: creq, + FromShardLeader: true, + DmlChannels: []string{suite.vchannel}, + } + suite.NoError(err) + + rsp, err := suite.node.SearchSegments(ctx, req) + suite.NoError(err) + suite.Equal(commonpb.ErrorCode_Success, rsp.GetStatus().GetErrorCode()) +} + // Test Query func (suite *ServiceSuite) genCQueryRequest(nq int64, indexType string, schema *schemapb.CollectionSchema) (*internalpb.RetrieveRequest, error) { expr, err := genSimpleRetrievePlanExpr(schema) @@ -1045,6 +1066,27 @@ func (suite *ServiceSuite) TestQuery_Failed() { suite.Equal(commonpb.ErrorCode_NotReadyServe, resp.Status.GetErrorCode()) } +func (suite *ServiceSuite) TestQuerySegments_Normal() { + ctx := context.Background() + // pre + suite.TestWatchDmChannelsInt64() + suite.TestLoadSegments_Int64() + + // data + schema := segments.GenTestCollectionSchema(suite.collectionName, schemapb.DataType_Int64) + creq, err := suite.genCQueryRequest(10, IndexFaissIDMap, schema) + suite.NoError(err) + req := &querypb.QueryRequest{ + Req: creq, + FromShardLeader: true, + DmlChannels: []string{suite.vchannel}, + } + + rsp, err := suite.node.QuerySegments(ctx, req) + suite.NoError(err) + suite.Equal(commonpb.ErrorCode_Success, rsp.GetStatus().GetErrorCode()) +} + func (suite *ServiceSuite) TestSyncReplicaSegments_Normal() { ctx := context.Background() req := &querypb.SyncReplicaSegmentsRequest{} diff --git a/internal/types/mock_querynode.go b/internal/types/mock_querynode.go index ac765fab5b..4da3bd5d89 100644 --- a/internal/types/mock_querynode.go +++ b/internal/types/mock_querynode.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.16.0. DO NOT EDIT. +// Code generated by mockery v2.21.1. DO NOT EDIT. package types @@ -35,6 +35,10 @@ func (_m *MockQueryNode) Delete(_a0 context.Context, _a1 *querypb.DeleteRequest) ret := _m.Called(_a0, _a1) var r0 *commonpb.Status + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *querypb.DeleteRequest) (*commonpb.Status, error)); ok { + return rf(_a0, _a1) + } if rf, ok := ret.Get(0).(func(context.Context, *querypb.DeleteRequest) *commonpb.Status); ok { r0 = rf(_a0, _a1) } else { @@ -43,7 +47,6 @@ func (_m *MockQueryNode) Delete(_a0 context.Context, _a1 *querypb.DeleteRequest) } } - var r1 error if rf, ok := ret.Get(1).(func(context.Context, *querypb.DeleteRequest) error); ok { r1 = rf(_a0, _a1) } else { @@ -59,8 +62,8 @@ type MockQueryNode_Delete_Call struct { } // Delete is a helper method to define mock.On call -// - _a0 context.Context -// - _a1 *querypb.DeleteRequest +// - _a0 context.Context +// - _a1 *querypb.DeleteRequest func (_e *MockQueryNode_Expecter) Delete(_a0 interface{}, _a1 interface{}) *MockQueryNode_Delete_Call { return &MockQueryNode_Delete_Call{Call: _e.mock.On("Delete", _a0, _a1)} } @@ -77,6 +80,11 @@ func (_c *MockQueryNode_Delete_Call) Return(_a0 *commonpb.Status, _a1 error) *Mo return _c } +func (_c *MockQueryNode_Delete_Call) RunAndReturn(run func(context.Context, *querypb.DeleteRequest) (*commonpb.Status, error)) *MockQueryNode_Delete_Call { + _c.Call.Return(run) + return _c +} + // GetAddress provides a mock function with given fields: func (_m *MockQueryNode) GetAddress() string { ret := _m.Called() @@ -113,11 +121,20 @@ func (_c *MockQueryNode_GetAddress_Call) Return(_a0 string) *MockQueryNode_GetAd return _c } +func (_c *MockQueryNode_GetAddress_Call) RunAndReturn(run func() string) *MockQueryNode_GetAddress_Call { + _c.Call.Return(run) + return _c +} + // GetComponentStates provides a mock function with given fields: ctx func (_m *MockQueryNode) GetComponentStates(ctx context.Context) (*milvuspb.ComponentStates, error) { ret := _m.Called(ctx) var r0 *milvuspb.ComponentStates + var r1 error + if rf, ok := ret.Get(0).(func(context.Context) (*milvuspb.ComponentStates, error)); ok { + return rf(ctx) + } if rf, ok := ret.Get(0).(func(context.Context) *milvuspb.ComponentStates); ok { r0 = rf(ctx) } else { @@ -126,7 +143,6 @@ func (_m *MockQueryNode) GetComponentStates(ctx context.Context) (*milvuspb.Comp } } - var r1 error if rf, ok := ret.Get(1).(func(context.Context) error); ok { r1 = rf(ctx) } else { @@ -142,7 +158,7 @@ type MockQueryNode_GetComponentStates_Call struct { } // GetComponentStates is a helper method to define mock.On call -// - ctx context.Context +// - ctx context.Context func (_e *MockQueryNode_Expecter) GetComponentStates(ctx interface{}) *MockQueryNode_GetComponentStates_Call { return &MockQueryNode_GetComponentStates_Call{Call: _e.mock.On("GetComponentStates", ctx)} } @@ -159,11 +175,20 @@ func (_c *MockQueryNode_GetComponentStates_Call) Return(_a0 *milvuspb.ComponentS return _c } +func (_c *MockQueryNode_GetComponentStates_Call) RunAndReturn(run func(context.Context) (*milvuspb.ComponentStates, error)) *MockQueryNode_GetComponentStates_Call { + _c.Call.Return(run) + return _c +} + // GetDataDistribution provides a mock function with given fields: _a0, _a1 func (_m *MockQueryNode) GetDataDistribution(_a0 context.Context, _a1 *querypb.GetDataDistributionRequest) (*querypb.GetDataDistributionResponse, error) { ret := _m.Called(_a0, _a1) var r0 *querypb.GetDataDistributionResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *querypb.GetDataDistributionRequest) (*querypb.GetDataDistributionResponse, error)); ok { + return rf(_a0, _a1) + } if rf, ok := ret.Get(0).(func(context.Context, *querypb.GetDataDistributionRequest) *querypb.GetDataDistributionResponse); ok { r0 = rf(_a0, _a1) } else { @@ -172,7 +197,6 @@ func (_m *MockQueryNode) GetDataDistribution(_a0 context.Context, _a1 *querypb.G } } - var r1 error if rf, ok := ret.Get(1).(func(context.Context, *querypb.GetDataDistributionRequest) error); ok { r1 = rf(_a0, _a1) } else { @@ -188,8 +212,8 @@ type MockQueryNode_GetDataDistribution_Call struct { } // GetDataDistribution is a helper method to define mock.On call -// - _a0 context.Context -// - _a1 *querypb.GetDataDistributionRequest +// - _a0 context.Context +// - _a1 *querypb.GetDataDistributionRequest func (_e *MockQueryNode_Expecter) GetDataDistribution(_a0 interface{}, _a1 interface{}) *MockQueryNode_GetDataDistribution_Call { return &MockQueryNode_GetDataDistribution_Call{Call: _e.mock.On("GetDataDistribution", _a0, _a1)} } @@ -206,11 +230,20 @@ func (_c *MockQueryNode_GetDataDistribution_Call) Return(_a0 *querypb.GetDataDis return _c } +func (_c *MockQueryNode_GetDataDistribution_Call) RunAndReturn(run func(context.Context, *querypb.GetDataDistributionRequest) (*querypb.GetDataDistributionResponse, error)) *MockQueryNode_GetDataDistribution_Call { + _c.Call.Return(run) + return _c +} + // GetMetrics provides a mock function with given fields: ctx, req func (_m *MockQueryNode) GetMetrics(ctx context.Context, req *milvuspb.GetMetricsRequest) (*milvuspb.GetMetricsResponse, error) { ret := _m.Called(ctx, req) var r0 *milvuspb.GetMetricsResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.GetMetricsRequest) (*milvuspb.GetMetricsResponse, error)); ok { + return rf(ctx, req) + } if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.GetMetricsRequest) *milvuspb.GetMetricsResponse); ok { r0 = rf(ctx, req) } else { @@ -219,7 +252,6 @@ func (_m *MockQueryNode) GetMetrics(ctx context.Context, req *milvuspb.GetMetric } } - var r1 error if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.GetMetricsRequest) error); ok { r1 = rf(ctx, req) } else { @@ -235,8 +267,8 @@ type MockQueryNode_GetMetrics_Call struct { } // GetMetrics is a helper method to define mock.On call -// - ctx context.Context -// - req *milvuspb.GetMetricsRequest +// - ctx context.Context +// - req *milvuspb.GetMetricsRequest func (_e *MockQueryNode_Expecter) GetMetrics(ctx interface{}, req interface{}) *MockQueryNode_GetMetrics_Call { return &MockQueryNode_GetMetrics_Call{Call: _e.mock.On("GetMetrics", ctx, req)} } @@ -253,11 +285,20 @@ func (_c *MockQueryNode_GetMetrics_Call) Return(_a0 *milvuspb.GetMetricsResponse return _c } +func (_c *MockQueryNode_GetMetrics_Call) RunAndReturn(run func(context.Context, *milvuspb.GetMetricsRequest) (*milvuspb.GetMetricsResponse, error)) *MockQueryNode_GetMetrics_Call { + _c.Call.Return(run) + return _c +} + // GetSegmentInfo provides a mock function with given fields: ctx, req func (_m *MockQueryNode) GetSegmentInfo(ctx context.Context, req *querypb.GetSegmentInfoRequest) (*querypb.GetSegmentInfoResponse, error) { ret := _m.Called(ctx, req) var r0 *querypb.GetSegmentInfoResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *querypb.GetSegmentInfoRequest) (*querypb.GetSegmentInfoResponse, error)); ok { + return rf(ctx, req) + } if rf, ok := ret.Get(0).(func(context.Context, *querypb.GetSegmentInfoRequest) *querypb.GetSegmentInfoResponse); ok { r0 = rf(ctx, req) } else { @@ -266,7 +307,6 @@ func (_m *MockQueryNode) GetSegmentInfo(ctx context.Context, req *querypb.GetSeg } } - var r1 error if rf, ok := ret.Get(1).(func(context.Context, *querypb.GetSegmentInfoRequest) error); ok { r1 = rf(ctx, req) } else { @@ -282,8 +322,8 @@ type MockQueryNode_GetSegmentInfo_Call struct { } // GetSegmentInfo is a helper method to define mock.On call -// - ctx context.Context -// - req *querypb.GetSegmentInfoRequest +// - ctx context.Context +// - req *querypb.GetSegmentInfoRequest func (_e *MockQueryNode_Expecter) GetSegmentInfo(ctx interface{}, req interface{}) *MockQueryNode_GetSegmentInfo_Call { return &MockQueryNode_GetSegmentInfo_Call{Call: _e.mock.On("GetSegmentInfo", ctx, req)} } @@ -300,11 +340,20 @@ func (_c *MockQueryNode_GetSegmentInfo_Call) Return(_a0 *querypb.GetSegmentInfoR return _c } +func (_c *MockQueryNode_GetSegmentInfo_Call) RunAndReturn(run func(context.Context, *querypb.GetSegmentInfoRequest) (*querypb.GetSegmentInfoResponse, error)) *MockQueryNode_GetSegmentInfo_Call { + _c.Call.Return(run) + return _c +} + // GetStatistics provides a mock function with given fields: ctx, req func (_m *MockQueryNode) GetStatistics(ctx context.Context, req *querypb.GetStatisticsRequest) (*internalpb.GetStatisticsResponse, error) { ret := _m.Called(ctx, req) var r0 *internalpb.GetStatisticsResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *querypb.GetStatisticsRequest) (*internalpb.GetStatisticsResponse, error)); ok { + return rf(ctx, req) + } if rf, ok := ret.Get(0).(func(context.Context, *querypb.GetStatisticsRequest) *internalpb.GetStatisticsResponse); ok { r0 = rf(ctx, req) } else { @@ -313,7 +362,6 @@ func (_m *MockQueryNode) GetStatistics(ctx context.Context, req *querypb.GetStat } } - var r1 error if rf, ok := ret.Get(1).(func(context.Context, *querypb.GetStatisticsRequest) error); ok { r1 = rf(ctx, req) } else { @@ -329,8 +377,8 @@ type MockQueryNode_GetStatistics_Call struct { } // GetStatistics is a helper method to define mock.On call -// - ctx context.Context -// - req *querypb.GetStatisticsRequest +// - ctx context.Context +// - req *querypb.GetStatisticsRequest func (_e *MockQueryNode_Expecter) GetStatistics(ctx interface{}, req interface{}) *MockQueryNode_GetStatistics_Call { return &MockQueryNode_GetStatistics_Call{Call: _e.mock.On("GetStatistics", ctx, req)} } @@ -347,11 +395,20 @@ func (_c *MockQueryNode_GetStatistics_Call) Return(_a0 *internalpb.GetStatistics return _c } +func (_c *MockQueryNode_GetStatistics_Call) RunAndReturn(run func(context.Context, *querypb.GetStatisticsRequest) (*internalpb.GetStatisticsResponse, error)) *MockQueryNode_GetStatistics_Call { + _c.Call.Return(run) + return _c +} + // GetStatisticsChannel provides a mock function with given fields: ctx func (_m *MockQueryNode) GetStatisticsChannel(ctx context.Context) (*milvuspb.StringResponse, error) { ret := _m.Called(ctx) var r0 *milvuspb.StringResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context) (*milvuspb.StringResponse, error)); ok { + return rf(ctx) + } if rf, ok := ret.Get(0).(func(context.Context) *milvuspb.StringResponse); ok { r0 = rf(ctx) } else { @@ -360,7 +417,6 @@ func (_m *MockQueryNode) GetStatisticsChannel(ctx context.Context) (*milvuspb.St } } - var r1 error if rf, ok := ret.Get(1).(func(context.Context) error); ok { r1 = rf(ctx) } else { @@ -376,7 +432,7 @@ type MockQueryNode_GetStatisticsChannel_Call struct { } // GetStatisticsChannel is a helper method to define mock.On call -// - ctx context.Context +// - ctx context.Context func (_e *MockQueryNode_Expecter) GetStatisticsChannel(ctx interface{}) *MockQueryNode_GetStatisticsChannel_Call { return &MockQueryNode_GetStatisticsChannel_Call{Call: _e.mock.On("GetStatisticsChannel", ctx)} } @@ -393,11 +449,20 @@ func (_c *MockQueryNode_GetStatisticsChannel_Call) Return(_a0 *milvuspb.StringRe return _c } +func (_c *MockQueryNode_GetStatisticsChannel_Call) RunAndReturn(run func(context.Context) (*milvuspb.StringResponse, error)) *MockQueryNode_GetStatisticsChannel_Call { + _c.Call.Return(run) + return _c +} + // GetTimeTickChannel provides a mock function with given fields: ctx func (_m *MockQueryNode) GetTimeTickChannel(ctx context.Context) (*milvuspb.StringResponse, error) { ret := _m.Called(ctx) var r0 *milvuspb.StringResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context) (*milvuspb.StringResponse, error)); ok { + return rf(ctx) + } if rf, ok := ret.Get(0).(func(context.Context) *milvuspb.StringResponse); ok { r0 = rf(ctx) } else { @@ -406,7 +471,6 @@ func (_m *MockQueryNode) GetTimeTickChannel(ctx context.Context) (*milvuspb.Stri } } - var r1 error if rf, ok := ret.Get(1).(func(context.Context) error); ok { r1 = rf(ctx) } else { @@ -422,7 +486,7 @@ type MockQueryNode_GetTimeTickChannel_Call struct { } // GetTimeTickChannel is a helper method to define mock.On call -// - ctx context.Context +// - ctx context.Context func (_e *MockQueryNode_Expecter) GetTimeTickChannel(ctx interface{}) *MockQueryNode_GetTimeTickChannel_Call { return &MockQueryNode_GetTimeTickChannel_Call{Call: _e.mock.On("GetTimeTickChannel", ctx)} } @@ -439,6 +503,11 @@ func (_c *MockQueryNode_GetTimeTickChannel_Call) Return(_a0 *milvuspb.StringResp return _c } +func (_c *MockQueryNode_GetTimeTickChannel_Call) RunAndReturn(run func(context.Context) (*milvuspb.StringResponse, error)) *MockQueryNode_GetTimeTickChannel_Call { + _c.Call.Return(run) + return _c +} + // Init provides a mock function with given fields: func (_m *MockQueryNode) Init() error { ret := _m.Called() @@ -475,11 +544,20 @@ func (_c *MockQueryNode_Init_Call) Return(_a0 error) *MockQueryNode_Init_Call { return _c } +func (_c *MockQueryNode_Init_Call) RunAndReturn(run func() error) *MockQueryNode_Init_Call { + _c.Call.Return(run) + return _c +} + // LoadPartitions provides a mock function with given fields: ctx, req func (_m *MockQueryNode) LoadPartitions(ctx context.Context, req *querypb.LoadPartitionsRequest) (*commonpb.Status, error) { ret := _m.Called(ctx, req) var r0 *commonpb.Status + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *querypb.LoadPartitionsRequest) (*commonpb.Status, error)); ok { + return rf(ctx, req) + } if rf, ok := ret.Get(0).(func(context.Context, *querypb.LoadPartitionsRequest) *commonpb.Status); ok { r0 = rf(ctx, req) } else { @@ -488,7 +566,6 @@ func (_m *MockQueryNode) LoadPartitions(ctx context.Context, req *querypb.LoadPa } } - var r1 error if rf, ok := ret.Get(1).(func(context.Context, *querypb.LoadPartitionsRequest) error); ok { r1 = rf(ctx, req) } else { @@ -504,8 +581,8 @@ type MockQueryNode_LoadPartitions_Call struct { } // LoadPartitions is a helper method to define mock.On call -// - ctx context.Context -// - req *querypb.LoadPartitionsRequest +// - ctx context.Context +// - req *querypb.LoadPartitionsRequest func (_e *MockQueryNode_Expecter) LoadPartitions(ctx interface{}, req interface{}) *MockQueryNode_LoadPartitions_Call { return &MockQueryNode_LoadPartitions_Call{Call: _e.mock.On("LoadPartitions", ctx, req)} } @@ -522,11 +599,20 @@ func (_c *MockQueryNode_LoadPartitions_Call) Return(_a0 *commonpb.Status, _a1 er return _c } +func (_c *MockQueryNode_LoadPartitions_Call) RunAndReturn(run func(context.Context, *querypb.LoadPartitionsRequest) (*commonpb.Status, error)) *MockQueryNode_LoadPartitions_Call { + _c.Call.Return(run) + return _c +} + // LoadSegments provides a mock function with given fields: ctx, req func (_m *MockQueryNode) LoadSegments(ctx context.Context, req *querypb.LoadSegmentsRequest) (*commonpb.Status, error) { ret := _m.Called(ctx, req) var r0 *commonpb.Status + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *querypb.LoadSegmentsRequest) (*commonpb.Status, error)); ok { + return rf(ctx, req) + } if rf, ok := ret.Get(0).(func(context.Context, *querypb.LoadSegmentsRequest) *commonpb.Status); ok { r0 = rf(ctx, req) } else { @@ -535,7 +621,6 @@ func (_m *MockQueryNode) LoadSegments(ctx context.Context, req *querypb.LoadSegm } } - var r1 error if rf, ok := ret.Get(1).(func(context.Context, *querypb.LoadSegmentsRequest) error); ok { r1 = rf(ctx, req) } else { @@ -551,8 +636,8 @@ type MockQueryNode_LoadSegments_Call struct { } // LoadSegments is a helper method to define mock.On call -// - ctx context.Context -// - req *querypb.LoadSegmentsRequest +// - ctx context.Context +// - req *querypb.LoadSegmentsRequest func (_e *MockQueryNode_Expecter) LoadSegments(ctx interface{}, req interface{}) *MockQueryNode_LoadSegments_Call { return &MockQueryNode_LoadSegments_Call{Call: _e.mock.On("LoadSegments", ctx, req)} } @@ -569,11 +654,20 @@ func (_c *MockQueryNode_LoadSegments_Call) Return(_a0 *commonpb.Status, _a1 erro return _c } +func (_c *MockQueryNode_LoadSegments_Call) RunAndReturn(run func(context.Context, *querypb.LoadSegmentsRequest) (*commonpb.Status, error)) *MockQueryNode_LoadSegments_Call { + _c.Call.Return(run) + return _c +} + // Query provides a mock function with given fields: ctx, req func (_m *MockQueryNode) Query(ctx context.Context, req *querypb.QueryRequest) (*internalpb.RetrieveResults, error) { ret := _m.Called(ctx, req) var r0 *internalpb.RetrieveResults + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *querypb.QueryRequest) (*internalpb.RetrieveResults, error)); ok { + return rf(ctx, req) + } if rf, ok := ret.Get(0).(func(context.Context, *querypb.QueryRequest) *internalpb.RetrieveResults); ok { r0 = rf(ctx, req) } else { @@ -582,7 +676,6 @@ func (_m *MockQueryNode) Query(ctx context.Context, req *querypb.QueryRequest) ( } } - var r1 error if rf, ok := ret.Get(1).(func(context.Context, *querypb.QueryRequest) error); ok { r1 = rf(ctx, req) } else { @@ -598,8 +691,8 @@ type MockQueryNode_Query_Call struct { } // Query is a helper method to define mock.On call -// - ctx context.Context -// - req *querypb.QueryRequest +// - ctx context.Context +// - req *querypb.QueryRequest func (_e *MockQueryNode_Expecter) Query(ctx interface{}, req interface{}) *MockQueryNode_Query_Call { return &MockQueryNode_Query_Call{Call: _e.mock.On("Query", ctx, req)} } @@ -616,6 +709,66 @@ func (_c *MockQueryNode_Query_Call) Return(_a0 *internalpb.RetrieveResults, _a1 return _c } +func (_c *MockQueryNode_Query_Call) RunAndReturn(run func(context.Context, *querypb.QueryRequest) (*internalpb.RetrieveResults, error)) *MockQueryNode_Query_Call { + _c.Call.Return(run) + return _c +} + +// QuerySegments provides a mock function with given fields: ctx, req +func (_m *MockQueryNode) QuerySegments(ctx context.Context, req *querypb.QueryRequest) (*internalpb.RetrieveResults, error) { + ret := _m.Called(ctx, req) + + var r0 *internalpb.RetrieveResults + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *querypb.QueryRequest) (*internalpb.RetrieveResults, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, *querypb.QueryRequest) *internalpb.RetrieveResults); ok { + r0 = rf(ctx, req) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*internalpb.RetrieveResults) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *querypb.QueryRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockQueryNode_QuerySegments_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'QuerySegments' +type MockQueryNode_QuerySegments_Call struct { + *mock.Call +} + +// QuerySegments is a helper method to define mock.On call +// - ctx context.Context +// - req *querypb.QueryRequest +func (_e *MockQueryNode_Expecter) QuerySegments(ctx interface{}, req interface{}) *MockQueryNode_QuerySegments_Call { + return &MockQueryNode_QuerySegments_Call{Call: _e.mock.On("QuerySegments", ctx, req)} +} + +func (_c *MockQueryNode_QuerySegments_Call) Run(run func(ctx context.Context, req *querypb.QueryRequest)) *MockQueryNode_QuerySegments_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*querypb.QueryRequest)) + }) + return _c +} + +func (_c *MockQueryNode_QuerySegments_Call) Return(_a0 *internalpb.RetrieveResults, _a1 error) *MockQueryNode_QuerySegments_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockQueryNode_QuerySegments_Call) RunAndReturn(run func(context.Context, *querypb.QueryRequest) (*internalpb.RetrieveResults, error)) *MockQueryNode_QuerySegments_Call { + _c.Call.Return(run) + return _c +} + // Register provides a mock function with given fields: func (_m *MockQueryNode) Register() error { ret := _m.Called() @@ -652,11 +805,20 @@ func (_c *MockQueryNode_Register_Call) Return(_a0 error) *MockQueryNode_Register return _c } +func (_c *MockQueryNode_Register_Call) RunAndReturn(run func() error) *MockQueryNode_Register_Call { + _c.Call.Return(run) + return _c +} + // ReleaseCollection provides a mock function with given fields: ctx, req func (_m *MockQueryNode) ReleaseCollection(ctx context.Context, req *querypb.ReleaseCollectionRequest) (*commonpb.Status, error) { ret := _m.Called(ctx, req) var r0 *commonpb.Status + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *querypb.ReleaseCollectionRequest) (*commonpb.Status, error)); ok { + return rf(ctx, req) + } if rf, ok := ret.Get(0).(func(context.Context, *querypb.ReleaseCollectionRequest) *commonpb.Status); ok { r0 = rf(ctx, req) } else { @@ -665,7 +827,6 @@ func (_m *MockQueryNode) ReleaseCollection(ctx context.Context, req *querypb.Rel } } - var r1 error if rf, ok := ret.Get(1).(func(context.Context, *querypb.ReleaseCollectionRequest) error); ok { r1 = rf(ctx, req) } else { @@ -681,8 +842,8 @@ type MockQueryNode_ReleaseCollection_Call struct { } // ReleaseCollection is a helper method to define mock.On call -// - ctx context.Context -// - req *querypb.ReleaseCollectionRequest +// - ctx context.Context +// - req *querypb.ReleaseCollectionRequest func (_e *MockQueryNode_Expecter) ReleaseCollection(ctx interface{}, req interface{}) *MockQueryNode_ReleaseCollection_Call { return &MockQueryNode_ReleaseCollection_Call{Call: _e.mock.On("ReleaseCollection", ctx, req)} } @@ -699,11 +860,20 @@ func (_c *MockQueryNode_ReleaseCollection_Call) Return(_a0 *commonpb.Status, _a1 return _c } +func (_c *MockQueryNode_ReleaseCollection_Call) RunAndReturn(run func(context.Context, *querypb.ReleaseCollectionRequest) (*commonpb.Status, error)) *MockQueryNode_ReleaseCollection_Call { + _c.Call.Return(run) + return _c +} + // ReleasePartitions provides a mock function with given fields: ctx, req func (_m *MockQueryNode) ReleasePartitions(ctx context.Context, req *querypb.ReleasePartitionsRequest) (*commonpb.Status, error) { ret := _m.Called(ctx, req) var r0 *commonpb.Status + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *querypb.ReleasePartitionsRequest) (*commonpb.Status, error)); ok { + return rf(ctx, req) + } if rf, ok := ret.Get(0).(func(context.Context, *querypb.ReleasePartitionsRequest) *commonpb.Status); ok { r0 = rf(ctx, req) } else { @@ -712,7 +882,6 @@ func (_m *MockQueryNode) ReleasePartitions(ctx context.Context, req *querypb.Rel } } - var r1 error if rf, ok := ret.Get(1).(func(context.Context, *querypb.ReleasePartitionsRequest) error); ok { r1 = rf(ctx, req) } else { @@ -728,8 +897,8 @@ type MockQueryNode_ReleasePartitions_Call struct { } // ReleasePartitions is a helper method to define mock.On call -// - ctx context.Context -// - req *querypb.ReleasePartitionsRequest +// - ctx context.Context +// - req *querypb.ReleasePartitionsRequest func (_e *MockQueryNode_Expecter) ReleasePartitions(ctx interface{}, req interface{}) *MockQueryNode_ReleasePartitions_Call { return &MockQueryNode_ReleasePartitions_Call{Call: _e.mock.On("ReleasePartitions", ctx, req)} } @@ -746,11 +915,20 @@ func (_c *MockQueryNode_ReleasePartitions_Call) Return(_a0 *commonpb.Status, _a1 return _c } +func (_c *MockQueryNode_ReleasePartitions_Call) RunAndReturn(run func(context.Context, *querypb.ReleasePartitionsRequest) (*commonpb.Status, error)) *MockQueryNode_ReleasePartitions_Call { + _c.Call.Return(run) + return _c +} + // ReleaseSegments provides a mock function with given fields: ctx, req func (_m *MockQueryNode) ReleaseSegments(ctx context.Context, req *querypb.ReleaseSegmentsRequest) (*commonpb.Status, error) { ret := _m.Called(ctx, req) var r0 *commonpb.Status + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *querypb.ReleaseSegmentsRequest) (*commonpb.Status, error)); ok { + return rf(ctx, req) + } if rf, ok := ret.Get(0).(func(context.Context, *querypb.ReleaseSegmentsRequest) *commonpb.Status); ok { r0 = rf(ctx, req) } else { @@ -759,7 +937,6 @@ func (_m *MockQueryNode) ReleaseSegments(ctx context.Context, req *querypb.Relea } } - var r1 error if rf, ok := ret.Get(1).(func(context.Context, *querypb.ReleaseSegmentsRequest) error); ok { r1 = rf(ctx, req) } else { @@ -775,8 +952,8 @@ type MockQueryNode_ReleaseSegments_Call struct { } // ReleaseSegments is a helper method to define mock.On call -// - ctx context.Context -// - req *querypb.ReleaseSegmentsRequest +// - ctx context.Context +// - req *querypb.ReleaseSegmentsRequest func (_e *MockQueryNode_Expecter) ReleaseSegments(ctx interface{}, req interface{}) *MockQueryNode_ReleaseSegments_Call { return &MockQueryNode_ReleaseSegments_Call{Call: _e.mock.On("ReleaseSegments", ctx, req)} } @@ -793,11 +970,20 @@ func (_c *MockQueryNode_ReleaseSegments_Call) Return(_a0 *commonpb.Status, _a1 e return _c } +func (_c *MockQueryNode_ReleaseSegments_Call) RunAndReturn(run func(context.Context, *querypb.ReleaseSegmentsRequest) (*commonpb.Status, error)) *MockQueryNode_ReleaseSegments_Call { + _c.Call.Return(run) + return _c +} + // Search provides a mock function with given fields: ctx, req func (_m *MockQueryNode) Search(ctx context.Context, req *querypb.SearchRequest) (*internalpb.SearchResults, error) { ret := _m.Called(ctx, req) var r0 *internalpb.SearchResults + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *querypb.SearchRequest) (*internalpb.SearchResults, error)); ok { + return rf(ctx, req) + } if rf, ok := ret.Get(0).(func(context.Context, *querypb.SearchRequest) *internalpb.SearchResults); ok { r0 = rf(ctx, req) } else { @@ -806,7 +992,6 @@ func (_m *MockQueryNode) Search(ctx context.Context, req *querypb.SearchRequest) } } - var r1 error if rf, ok := ret.Get(1).(func(context.Context, *querypb.SearchRequest) error); ok { r1 = rf(ctx, req) } else { @@ -822,8 +1007,8 @@ type MockQueryNode_Search_Call struct { } // Search is a helper method to define mock.On call -// - ctx context.Context -// - req *querypb.SearchRequest +// - ctx context.Context +// - req *querypb.SearchRequest func (_e *MockQueryNode_Expecter) Search(ctx interface{}, req interface{}) *MockQueryNode_Search_Call { return &MockQueryNode_Search_Call{Call: _e.mock.On("Search", ctx, req)} } @@ -840,6 +1025,66 @@ func (_c *MockQueryNode_Search_Call) Return(_a0 *internalpb.SearchResults, _a1 e return _c } +func (_c *MockQueryNode_Search_Call) RunAndReturn(run func(context.Context, *querypb.SearchRequest) (*internalpb.SearchResults, error)) *MockQueryNode_Search_Call { + _c.Call.Return(run) + return _c +} + +// SearchSegments provides a mock function with given fields: ctx, req +func (_m *MockQueryNode) SearchSegments(ctx context.Context, req *querypb.SearchRequest) (*internalpb.SearchResults, error) { + ret := _m.Called(ctx, req) + + var r0 *internalpb.SearchResults + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *querypb.SearchRequest) (*internalpb.SearchResults, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, *querypb.SearchRequest) *internalpb.SearchResults); ok { + r0 = rf(ctx, req) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*internalpb.SearchResults) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *querypb.SearchRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockQueryNode_SearchSegments_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SearchSegments' +type MockQueryNode_SearchSegments_Call struct { + *mock.Call +} + +// SearchSegments is a helper method to define mock.On call +// - ctx context.Context +// - req *querypb.SearchRequest +func (_e *MockQueryNode_Expecter) SearchSegments(ctx interface{}, req interface{}) *MockQueryNode_SearchSegments_Call { + return &MockQueryNode_SearchSegments_Call{Call: _e.mock.On("SearchSegments", ctx, req)} +} + +func (_c *MockQueryNode_SearchSegments_Call) Run(run func(ctx context.Context, req *querypb.SearchRequest)) *MockQueryNode_SearchSegments_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*querypb.SearchRequest)) + }) + return _c +} + +func (_c *MockQueryNode_SearchSegments_Call) Return(_a0 *internalpb.SearchResults, _a1 error) *MockQueryNode_SearchSegments_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockQueryNode_SearchSegments_Call) RunAndReturn(run func(context.Context, *querypb.SearchRequest) (*internalpb.SearchResults, error)) *MockQueryNode_SearchSegments_Call { + _c.Call.Return(run) + return _c +} + // SetAddress provides a mock function with given fields: address func (_m *MockQueryNode) SetAddress(address string) { _m.Called(address) @@ -851,7 +1096,7 @@ type MockQueryNode_SetAddress_Call struct { } // SetAddress is a helper method to define mock.On call -// - address string +// - address string func (_e *MockQueryNode_Expecter) SetAddress(address interface{}) *MockQueryNode_SetAddress_Call { return &MockQueryNode_SetAddress_Call{Call: _e.mock.On("SetAddress", address)} } @@ -868,6 +1113,11 @@ func (_c *MockQueryNode_SetAddress_Call) Return() *MockQueryNode_SetAddress_Call return _c } +func (_c *MockQueryNode_SetAddress_Call) RunAndReturn(run func(string)) *MockQueryNode_SetAddress_Call { + _c.Call.Return(run) + return _c +} + // SetEtcdClient provides a mock function with given fields: etcdClient func (_m *MockQueryNode) SetEtcdClient(etcdClient *clientv3.Client) { _m.Called(etcdClient) @@ -879,7 +1129,7 @@ type MockQueryNode_SetEtcdClient_Call struct { } // SetEtcdClient is a helper method to define mock.On call -// - etcdClient *clientv3.Client +// - etcdClient *clientv3.Client func (_e *MockQueryNode_Expecter) SetEtcdClient(etcdClient interface{}) *MockQueryNode_SetEtcdClient_Call { return &MockQueryNode_SetEtcdClient_Call{Call: _e.mock.On("SetEtcdClient", etcdClient)} } @@ -896,11 +1146,20 @@ func (_c *MockQueryNode_SetEtcdClient_Call) Return() *MockQueryNode_SetEtcdClien return _c } +func (_c *MockQueryNode_SetEtcdClient_Call) RunAndReturn(run func(*clientv3.Client)) *MockQueryNode_SetEtcdClient_Call { + _c.Call.Return(run) + return _c +} + // ShowConfigurations provides a mock function with given fields: ctx, req func (_m *MockQueryNode) ShowConfigurations(ctx context.Context, req *internalpb.ShowConfigurationsRequest) (*internalpb.ShowConfigurationsResponse, error) { ret := _m.Called(ctx, req) var r0 *internalpb.ShowConfigurationsResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *internalpb.ShowConfigurationsRequest) (*internalpb.ShowConfigurationsResponse, error)); ok { + return rf(ctx, req) + } if rf, ok := ret.Get(0).(func(context.Context, *internalpb.ShowConfigurationsRequest) *internalpb.ShowConfigurationsResponse); ok { r0 = rf(ctx, req) } else { @@ -909,7 +1168,6 @@ func (_m *MockQueryNode) ShowConfigurations(ctx context.Context, req *internalpb } } - var r1 error if rf, ok := ret.Get(1).(func(context.Context, *internalpb.ShowConfigurationsRequest) error); ok { r1 = rf(ctx, req) } else { @@ -925,8 +1183,8 @@ type MockQueryNode_ShowConfigurations_Call struct { } // ShowConfigurations is a helper method to define mock.On call -// - ctx context.Context -// - req *internalpb.ShowConfigurationsRequest +// - ctx context.Context +// - req *internalpb.ShowConfigurationsRequest func (_e *MockQueryNode_Expecter) ShowConfigurations(ctx interface{}, req interface{}) *MockQueryNode_ShowConfigurations_Call { return &MockQueryNode_ShowConfigurations_Call{Call: _e.mock.On("ShowConfigurations", ctx, req)} } @@ -943,6 +1201,11 @@ func (_c *MockQueryNode_ShowConfigurations_Call) Return(_a0 *internalpb.ShowConf return _c } +func (_c *MockQueryNode_ShowConfigurations_Call) RunAndReturn(run func(context.Context, *internalpb.ShowConfigurationsRequest) (*internalpb.ShowConfigurationsResponse, error)) *MockQueryNode_ShowConfigurations_Call { + _c.Call.Return(run) + return _c +} + // Start provides a mock function with given fields: func (_m *MockQueryNode) Start() error { ret := _m.Called() @@ -979,6 +1242,11 @@ func (_c *MockQueryNode_Start_Call) Return(_a0 error) *MockQueryNode_Start_Call return _c } +func (_c *MockQueryNode_Start_Call) RunAndReturn(run func() error) *MockQueryNode_Start_Call { + _c.Call.Return(run) + return _c +} + // Stop provides a mock function with given fields: func (_m *MockQueryNode) Stop() error { ret := _m.Called() @@ -1015,11 +1283,20 @@ func (_c *MockQueryNode_Stop_Call) Return(_a0 error) *MockQueryNode_Stop_Call { return _c } +func (_c *MockQueryNode_Stop_Call) RunAndReturn(run func() error) *MockQueryNode_Stop_Call { + _c.Call.Return(run) + return _c +} + // SyncDistribution provides a mock function with given fields: _a0, _a1 func (_m *MockQueryNode) SyncDistribution(_a0 context.Context, _a1 *querypb.SyncDistributionRequest) (*commonpb.Status, error) { ret := _m.Called(_a0, _a1) var r0 *commonpb.Status + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *querypb.SyncDistributionRequest) (*commonpb.Status, error)); ok { + return rf(_a0, _a1) + } if rf, ok := ret.Get(0).(func(context.Context, *querypb.SyncDistributionRequest) *commonpb.Status); ok { r0 = rf(_a0, _a1) } else { @@ -1028,7 +1305,6 @@ func (_m *MockQueryNode) SyncDistribution(_a0 context.Context, _a1 *querypb.Sync } } - var r1 error if rf, ok := ret.Get(1).(func(context.Context, *querypb.SyncDistributionRequest) error); ok { r1 = rf(_a0, _a1) } else { @@ -1044,8 +1320,8 @@ type MockQueryNode_SyncDistribution_Call struct { } // SyncDistribution is a helper method to define mock.On call -// - _a0 context.Context -// - _a1 *querypb.SyncDistributionRequest +// - _a0 context.Context +// - _a1 *querypb.SyncDistributionRequest func (_e *MockQueryNode_Expecter) SyncDistribution(_a0 interface{}, _a1 interface{}) *MockQueryNode_SyncDistribution_Call { return &MockQueryNode_SyncDistribution_Call{Call: _e.mock.On("SyncDistribution", _a0, _a1)} } @@ -1062,11 +1338,20 @@ func (_c *MockQueryNode_SyncDistribution_Call) Return(_a0 *commonpb.Status, _a1 return _c } +func (_c *MockQueryNode_SyncDistribution_Call) RunAndReturn(run func(context.Context, *querypb.SyncDistributionRequest) (*commonpb.Status, error)) *MockQueryNode_SyncDistribution_Call { + _c.Call.Return(run) + return _c +} + // SyncReplicaSegments provides a mock function with given fields: ctx, req func (_m *MockQueryNode) SyncReplicaSegments(ctx context.Context, req *querypb.SyncReplicaSegmentsRequest) (*commonpb.Status, error) { ret := _m.Called(ctx, req) var r0 *commonpb.Status + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *querypb.SyncReplicaSegmentsRequest) (*commonpb.Status, error)); ok { + return rf(ctx, req) + } if rf, ok := ret.Get(0).(func(context.Context, *querypb.SyncReplicaSegmentsRequest) *commonpb.Status); ok { r0 = rf(ctx, req) } else { @@ -1075,7 +1360,6 @@ func (_m *MockQueryNode) SyncReplicaSegments(ctx context.Context, req *querypb.S } } - var r1 error if rf, ok := ret.Get(1).(func(context.Context, *querypb.SyncReplicaSegmentsRequest) error); ok { r1 = rf(ctx, req) } else { @@ -1091,8 +1375,8 @@ type MockQueryNode_SyncReplicaSegments_Call struct { } // SyncReplicaSegments is a helper method to define mock.On call -// - ctx context.Context -// - req *querypb.SyncReplicaSegmentsRequest +// - ctx context.Context +// - req *querypb.SyncReplicaSegmentsRequest func (_e *MockQueryNode_Expecter) SyncReplicaSegments(ctx interface{}, req interface{}) *MockQueryNode_SyncReplicaSegments_Call { return &MockQueryNode_SyncReplicaSegments_Call{Call: _e.mock.On("SyncReplicaSegments", ctx, req)} } @@ -1109,11 +1393,20 @@ func (_c *MockQueryNode_SyncReplicaSegments_Call) Return(_a0 *commonpb.Status, _ return _c } +func (_c *MockQueryNode_SyncReplicaSegments_Call) RunAndReturn(run func(context.Context, *querypb.SyncReplicaSegmentsRequest) (*commonpb.Status, error)) *MockQueryNode_SyncReplicaSegments_Call { + _c.Call.Return(run) + return _c +} + // UnsubDmChannel provides a mock function with given fields: ctx, req func (_m *MockQueryNode) UnsubDmChannel(ctx context.Context, req *querypb.UnsubDmChannelRequest) (*commonpb.Status, error) { ret := _m.Called(ctx, req) var r0 *commonpb.Status + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *querypb.UnsubDmChannelRequest) (*commonpb.Status, error)); ok { + return rf(ctx, req) + } if rf, ok := ret.Get(0).(func(context.Context, *querypb.UnsubDmChannelRequest) *commonpb.Status); ok { r0 = rf(ctx, req) } else { @@ -1122,7 +1415,6 @@ func (_m *MockQueryNode) UnsubDmChannel(ctx context.Context, req *querypb.UnsubD } } - var r1 error if rf, ok := ret.Get(1).(func(context.Context, *querypb.UnsubDmChannelRequest) error); ok { r1 = rf(ctx, req) } else { @@ -1138,8 +1430,8 @@ type MockQueryNode_UnsubDmChannel_Call struct { } // UnsubDmChannel is a helper method to define mock.On call -// - ctx context.Context -// - req *querypb.UnsubDmChannelRequest +// - ctx context.Context +// - req *querypb.UnsubDmChannelRequest func (_e *MockQueryNode_Expecter) UnsubDmChannel(ctx interface{}, req interface{}) *MockQueryNode_UnsubDmChannel_Call { return &MockQueryNode_UnsubDmChannel_Call{Call: _e.mock.On("UnsubDmChannel", ctx, req)} } @@ -1156,6 +1448,11 @@ func (_c *MockQueryNode_UnsubDmChannel_Call) Return(_a0 *commonpb.Status, _a1 er return _c } +func (_c *MockQueryNode_UnsubDmChannel_Call) RunAndReturn(run func(context.Context, *querypb.UnsubDmChannelRequest) (*commonpb.Status, error)) *MockQueryNode_UnsubDmChannel_Call { + _c.Call.Return(run) + return _c +} + // UpdateStateCode provides a mock function with given fields: stateCode func (_m *MockQueryNode) UpdateStateCode(stateCode commonpb.StateCode) { _m.Called(stateCode) @@ -1167,7 +1464,7 @@ type MockQueryNode_UpdateStateCode_Call struct { } // UpdateStateCode is a helper method to define mock.On call -// - stateCode commonpb.StateCode +// - stateCode commonpb.StateCode func (_e *MockQueryNode_Expecter) UpdateStateCode(stateCode interface{}) *MockQueryNode_UpdateStateCode_Call { return &MockQueryNode_UpdateStateCode_Call{Call: _e.mock.On("UpdateStateCode", stateCode)} } @@ -1184,11 +1481,20 @@ func (_c *MockQueryNode_UpdateStateCode_Call) Return() *MockQueryNode_UpdateStat return _c } +func (_c *MockQueryNode_UpdateStateCode_Call) RunAndReturn(run func(commonpb.StateCode)) *MockQueryNode_UpdateStateCode_Call { + _c.Call.Return(run) + return _c +} + // WatchDmChannels provides a mock function with given fields: ctx, req func (_m *MockQueryNode) WatchDmChannels(ctx context.Context, req *querypb.WatchDmChannelsRequest) (*commonpb.Status, error) { ret := _m.Called(ctx, req) var r0 *commonpb.Status + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *querypb.WatchDmChannelsRequest) (*commonpb.Status, error)); ok { + return rf(ctx, req) + } if rf, ok := ret.Get(0).(func(context.Context, *querypb.WatchDmChannelsRequest) *commonpb.Status); ok { r0 = rf(ctx, req) } else { @@ -1197,7 +1503,6 @@ func (_m *MockQueryNode) WatchDmChannels(ctx context.Context, req *querypb.Watch } } - var r1 error if rf, ok := ret.Get(1).(func(context.Context, *querypb.WatchDmChannelsRequest) error); ok { r1 = rf(ctx, req) } else { @@ -1213,8 +1518,8 @@ type MockQueryNode_WatchDmChannels_Call struct { } // WatchDmChannels is a helper method to define mock.On call -// - ctx context.Context -// - req *querypb.WatchDmChannelsRequest +// - ctx context.Context +// - req *querypb.WatchDmChannelsRequest func (_e *MockQueryNode_Expecter) WatchDmChannels(ctx interface{}, req interface{}) *MockQueryNode_WatchDmChannels_Call { return &MockQueryNode_WatchDmChannels_Call{Call: _e.mock.On("WatchDmChannels", ctx, req)} } @@ -1231,6 +1536,11 @@ func (_c *MockQueryNode_WatchDmChannels_Call) Return(_a0 *commonpb.Status, _a1 e return _c } +func (_c *MockQueryNode_WatchDmChannels_Call) RunAndReturn(run func(context.Context, *querypb.WatchDmChannelsRequest) (*commonpb.Status, error)) *MockQueryNode_WatchDmChannels_Call { + _c.Call.Return(run) + return _c +} + type mockConstructorTestingTNewMockQueryNode interface { mock.TestingT Cleanup(func()) diff --git a/internal/types/types.go b/internal/types/types.go index 452d5bf8ca..f1d3e18591 100644 --- a/internal/types/types.go +++ b/internal/types/types.go @@ -1377,7 +1377,9 @@ type QueryNode interface { GetStatistics(ctx context.Context, req *querypb.GetStatisticsRequest) (*internalpb.GetStatisticsResponse, error) Search(ctx context.Context, req *querypb.SearchRequest) (*internalpb.SearchResults, error) + SearchSegments(ctx context.Context, req *querypb.SearchRequest) (*internalpb.SearchResults, error) Query(ctx context.Context, req *querypb.QueryRequest) (*internalpb.RetrieveResults, error) + QuerySegments(ctx context.Context, req *querypb.QueryRequest) (*internalpb.RetrieveResults, error) SyncReplicaSegments(ctx context.Context, req *querypb.SyncReplicaSegmentsRequest) (*commonpb.Status, error) ShowConfigurations(ctx context.Context, req *internalpb.ShowConfigurationsRequest) (*internalpb.ShowConfigurationsResponse, error) diff --git a/internal/util/mock/grpc_querynode_client.go b/internal/util/mock/grpc_querynode_client.go index 2b15d0e8ec..9164993874 100644 --- a/internal/util/mock/grpc_querynode_client.go +++ b/internal/util/mock/grpc_querynode_client.go @@ -81,10 +81,18 @@ func (m *GrpcQueryNodeClient) Search(ctx context.Context, in *querypb.SearchRequ return &internalpb.SearchResults{}, m.Err } +func (m *GrpcQueryNodeClient) SearchSegments(ctx context.Context, in *querypb.SearchRequest, opts ...grpc.CallOption) (*internalpb.SearchResults, error) { + return &internalpb.SearchResults{}, m.Err +} + func (m *GrpcQueryNodeClient) Query(ctx context.Context, in *querypb.QueryRequest, opts ...grpc.CallOption) (*internalpb.RetrieveResults, error) { return &internalpb.RetrieveResults{}, m.Err } +func (m *GrpcQueryNodeClient) QuerySegments(ctx context.Context, in *querypb.QueryRequest, opts ...grpc.CallOption) (*internalpb.RetrieveResults, error) { + return &internalpb.RetrieveResults{}, m.Err +} + func (m *GrpcQueryNodeClient) SyncReplicaSegments(ctx context.Context, in *querypb.SyncReplicaSegmentsRequest, opts ...grpc.CallOption) (*commonpb.Status, error) { return &commonpb.Status{}, m.Err } diff --git a/internal/util/mock/querynode_client.go b/internal/util/mock/querynode_client.go index 40af6ccbee..e281a97a76 100644 --- a/internal/util/mock/querynode_client.go +++ b/internal/util/mock/querynode_client.go @@ -97,10 +97,18 @@ func (q QueryNodeClient) Search(ctx context.Context, req *querypb.SearchRequest) return q.grpcClient.Search(ctx, req) } +func (q QueryNodeClient) SearchSegments(ctx context.Context, req *querypb.SearchRequest) (*internalpb.SearchResults, error) { + return q.grpcClient.Search(ctx, req) +} + func (q QueryNodeClient) Query(ctx context.Context, req *querypb.QueryRequest) (*internalpb.RetrieveResults, error) { return q.grpcClient.Query(ctx, req) } +func (q QueryNodeClient) QuerySegments(ctx context.Context, req *querypb.QueryRequest) (*internalpb.RetrieveResults, error) { + return q.grpcClient.Query(ctx, req) +} + func (q QueryNodeClient) SyncReplicaSegments(ctx context.Context, req *querypb.SyncReplicaSegmentsRequest) (*commonpb.Status, error) { return q.grpcClient.SyncReplicaSegments(ctx, req) }