milvus-io
/
milvus
mirror of https://github.com/milvus-io/milvus.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

simplify logic circle in search (#24110) 

Signed-off-by: Wei Liu <wei.liu@zilliz.com>
pull/24300/head
wei liu 2023-05-23 16:01:26 +08:00 committed by GitHub
parent 7819a5733f
commit ce03248b1a
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
24 changed files with 1477 additions and 781 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
internal/distributed/querynode/client/client.go
View File

@ -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)

6
internal/distributed/querynode/client/client_test.go
View File

@ -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]{

8
internal/distributed/querynode/service.go
View File

@ -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)

204
internal/distributed/querynode/service_test.go
View File

@ -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)
}

2
internal/proto/query_coord.proto
View File

@ -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

585
internal/proto/querypb/query_coord.pb.go
View File

@ -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,

141
internal/proxy/query_node_mock_test.go
View File

@ -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
}

4
internal/proxy/task_policies_test.go
View File

@ -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

21
internal/proxy/task_query_test.go
View File

@ -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{

28
internal/proxy/task_search_test.go
View File

@ -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))
}

312
internal/querycoordv2/mocks/mock_querynode.go → internal/querycoordv2/mocks/mock_querynode_server.go
View File

@ -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())

117
internal/querynodev2/cluster/mock_worker.go
View File

@ -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())

25
internal/querynodev2/cluster/worker.go
View File

@ -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) {

62
internal/querynodev2/cluster/worker_test.go
View File

@ -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)

14
internal/querynodev2/delegator/delegator.go
View File

@ -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))

32
internal/querynodev2/delegator/delegator_test.go
View File

@ -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())

60
internal/querynodev2/handlers.go
View File

@ -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

8
internal/querynodev2/local_worker.go
View File

@ -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) {

125
internal/querynodev2/services.go
View File

@ -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()),

42
internal/querynodev2/services_test.go
View File

@ -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{}

432
internal/types/mock_querynode.go
View File

@ -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())

2
internal/types/types.go
View File

@ -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)

8
internal/util/mock/grpc_querynode_client.go
View File

@ -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
}

8
internal/util/mock/querynode_client.go
View File

@ -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)
}