diff --git a/internal/coordinator/mix_coord.go b/internal/coordinator/mix_coord.go index 74d798513c..0b49f4c21d 100644 --- a/internal/coordinator/mix_coord.go +++ b/internal/coordinator/mix_coord.go @@ -463,6 +463,18 @@ func (s *mixCoordImpl) AlterCollectionField(ctx context.Context, req *milvuspb.A return s.rootcoordServer.AlterCollectionField(ctx, req) } +func (s *mixCoordImpl) AddCollectionFunction(ctx context.Context, req *milvuspb.AddCollectionFunctionRequest) (*commonpb.Status, error) { + return s.rootcoordServer.AddCollectionFunction(ctx, req) +} + +func (s *mixCoordImpl) AlterCollectionFunction(ctx context.Context, req *milvuspb.AlterCollectionFunctionRequest) (*commonpb.Status, error) { + return s.rootcoordServer.AlterCollectionFunction(ctx, req) +} + +func (s *mixCoordImpl) DropCollectionFunction(ctx context.Context, req *milvuspb.DropCollectionFunctionRequest) (*commonpb.Status, error) { + return s.rootcoordServer.DropCollectionFunction(ctx, req) +} + func (s *mixCoordImpl) CreatePartition(ctx context.Context, req *milvuspb.CreatePartitionRequest) (*commonpb.Status, error) { return s.rootcoordServer.CreatePartition(ctx, req) } diff --git a/internal/datacoord/mock_handler.go b/internal/datacoord/mock_handler.go index 5d4d3cd571..865cdb96a4 100644 --- a/internal/datacoord/mock_handler.go +++ b/internal/datacoord/mock_handler.go @@ -413,8 +413,7 @@ func (_c *NMockHandler_ListLoadedSegments_Call) RunAndReturn(run func(context.Co func NewNMockHandler(t interface { mock.TestingT Cleanup(func()) -}, -) *NMockHandler { +}) *NMockHandler { mock := &NMockHandler{} mock.Mock.Test(t) diff --git a/internal/datacoord/mock_test.go b/internal/datacoord/mock_test.go index 3aece80c91..8eb6fb04a7 100644 --- a/internal/datacoord/mock_test.go +++ b/internal/datacoord/mock_test.go @@ -323,6 +323,18 @@ func (m *mockMixCoord) AlterCollectionField(ctx context.Context, request *milvus panic("not implemented") // TODO: Implement } +func (m *mockMixCoord) AddCollectionFunction(ctx context.Context, request *milvuspb.AddCollectionFunctionRequest) (*commonpb.Status, error) { + panic("not implemented") // TODO: Implement +} + +func (m *mockMixCoord) AlterCollectionFunction(ctx context.Context, request *milvuspb.AlterCollectionFunctionRequest) (*commonpb.Status, error) { + panic("not implemented") // TODO: Implement +} + +func (m *mockMixCoord) DropCollectionFunction(ctx context.Context, request *milvuspb.DropCollectionFunctionRequest) (*commonpb.Status, error) { + panic("not implemented") // TODO: Implement +} + func (m *mockMixCoord) CreatePartition(ctx context.Context, req *milvuspb.CreatePartitionRequest) (*commonpb.Status, error) { panic("not implemented") // TODO: Implement } diff --git a/internal/distributed/mixcoord/client/client.go b/internal/distributed/mixcoord/client/client.go index 09e7fb349d..b49442ab2d 100644 --- a/internal/distributed/mixcoord/client/client.go +++ b/internal/distributed/mixcoord/client/client.go @@ -338,6 +338,39 @@ func (c *Client) AlterCollectionField(ctx context.Context, request *milvuspb.Alt }) } +func (c *Client) AddCollectionFunction(ctx context.Context, request *milvuspb.AddCollectionFunctionRequest, opts ...grpc.CallOption) (*commonpb.Status, error) { + request = typeutil.Clone(request) + commonpbutil.UpdateMsgBase( + request.GetBase(), + commonpbutil.FillMsgBaseFromClient(paramtable.GetNodeID(), commonpbutil.WithTargetID(c.grpcClient.GetNodeID())), + ) + return wrapGrpcCall(ctx, c, func(client MixCoordClient) (*commonpb.Status, error) { + return client.AddCollectionFunction(ctx, request) + }) +} + +func (c *Client) AlterCollectionFunction(ctx context.Context, request *milvuspb.AlterCollectionFunctionRequest, opts ...grpc.CallOption) (*commonpb.Status, error) { + request = typeutil.Clone(request) + commonpbutil.UpdateMsgBase( + request.GetBase(), + commonpbutil.FillMsgBaseFromClient(paramtable.GetNodeID(), commonpbutil.WithTargetID(c.grpcClient.GetNodeID())), + ) + return wrapGrpcCall(ctx, c, func(client MixCoordClient) (*commonpb.Status, error) { + return client.AlterCollectionFunction(ctx, request) + }) +} + +func (c *Client) DropCollectionFunction(ctx context.Context, request *milvuspb.DropCollectionFunctionRequest, opts ...grpc.CallOption) (*commonpb.Status, error) { + request = typeutil.Clone(request) + commonpbutil.UpdateMsgBase( + request.GetBase(), + commonpbutil.FillMsgBaseFromClient(paramtable.GetNodeID(), commonpbutil.WithTargetID(c.grpcClient.GetNodeID())), + ) + return wrapGrpcCall(ctx, c, func(client MixCoordClient) (*commonpb.Status, error) { + return client.DropCollectionFunction(ctx, request) + }) +} + // CreatePartition create partition func (c *Client) CreatePartition(ctx context.Context, in *milvuspb.CreatePartitionRequest, opts ...grpc.CallOption) (*commonpb.Status, error) { in = typeutil.Clone(in) diff --git a/internal/distributed/mixcoord/client/client_test.go b/internal/distributed/mixcoord/client/client_test.go index 1ba5e7a7b0..63a3bd62ff 100644 --- a/internal/distributed/mixcoord/client/client_test.go +++ b/internal/distributed/mixcoord/client/client_test.go @@ -257,6 +257,18 @@ func Test_NewClient(t *testing.T) { r, err := client.AlterCollection(ctx, nil) retCheck(retNotNil, r, err) } + { + r, err := client.AddCollectionFunction(ctx, nil) + retCheck(retNotNil, r, err) + } + { + r, err := client.AlterCollectionFunction(ctx, nil) + retCheck(retNotNil, r, err) + } + { + r, err := client.DropCollectionFunction(ctx, nil) + retCheck(retNotNil, r, err) + } { r, err := client.AlterDatabase(ctx, nil) retCheck(retNotNil, r, err) diff --git a/internal/distributed/mixcoord/service.go b/internal/distributed/mixcoord/service.go index ea82f95e5e..b31c7cab01 100644 --- a/internal/distributed/mixcoord/service.go +++ b/internal/distributed/mixcoord/service.go @@ -531,6 +531,18 @@ func (s *Server) AlterCollectionField(ctx context.Context, request *milvuspb.Alt return s.mixCoord.AlterCollectionField(ctx, request) } +func (s *Server) AddCollectionFunction(ctx context.Context, request *milvuspb.AddCollectionFunctionRequest) (*commonpb.Status, error) { + return s.mixCoord.AddCollectionFunction(ctx, request) +} + +func (s *Server) AlterCollectionFunction(ctx context.Context, request *milvuspb.AlterCollectionFunctionRequest) (*commonpb.Status, error) { + return s.mixCoord.AlterCollectionFunction(ctx, request) +} + +func (s *Server) DropCollectionFunction(ctx context.Context, request *milvuspb.DropCollectionFunctionRequest) (*commonpb.Status, error) { + return s.mixCoord.DropCollectionFunction(ctx, request) +} + func (s *Server) RenameCollection(ctx context.Context, request *milvuspb.RenameCollectionRequest) (*commonpb.Status, error) { return s.mixCoord.RenameCollection(ctx, request) } diff --git a/internal/distributed/proxy/httpserver/constant.go b/internal/distributed/proxy/httpserver/constant.go index c6754cd4ca..89d14f707a 100644 --- a/internal/distributed/proxy/httpserver/constant.go +++ b/internal/distributed/proxy/httpserver/constant.go @@ -69,6 +69,9 @@ const ( RevokePrivilegeActionV2 = "revoke_privilege_v2" AlterAction = "alter" AlterPropertiesAction = "alter_properties" + AddFunctionAction = "add_function" + AlterFunctionAction = "alter_function" + DropFunctionAction = "drop_function" AddAction = `add` DropPropertiesAction = "drop_properties" CompactAction = "compact" diff --git a/internal/distributed/proxy/httpserver/handler_v2.go b/internal/distributed/proxy/httpserver/handler_v2.go index 06a0f95366..c462a06762 100644 --- a/internal/distributed/proxy/httpserver/handler_v2.go +++ b/internal/distributed/proxy/httpserver/handler_v2.go @@ -81,6 +81,9 @@ func (h *HandlersV2) RegisterRoutesToV2(router gin.IRouter) { router.POST(CollectionCategory+RefreshLoadAction, timeoutMiddleware(wrapperPost(func() any { return &CollectionNameReq{} }, wrapperTraceLog(h.refreshLoadCollection)))) router.POST(CollectionCategory+ReleaseAction, timeoutMiddleware(wrapperPost(func() any { return &CollectionNameReq{} }, wrapperTraceLog(h.releaseCollection)))) router.POST(CollectionCategory+AlterPropertiesAction, timeoutMiddleware(wrapperPost(func() any { return &CollectionReqWithProperties{} }, wrapperTraceLog(h.alterCollectionProperties)))) + router.POST(CollectionCategory+AddFunctionAction, timeoutMiddleware(wrapperPost(func() any { return &CollectionAddFunction{} }, wrapperTraceLog(h.addCollectionFunction)))) + router.POST(CollectionCategory+AlterFunctionAction, timeoutMiddleware(wrapperPost(func() any { return &CollectionAlterFunction{} }, wrapperTraceLog(h.alterCollectionFunction)))) + router.POST(CollectionCategory+DropFunctionAction, timeoutMiddleware(wrapperPost(func() any { return &CollectionDropFunction{} }, wrapperTraceLog(h.dropCollectionFunction)))) router.POST(CollectionCategory+DropPropertiesAction, timeoutMiddleware(wrapperPost(func() any { return &DropCollectionPropertiesReq{} }, wrapperTraceLog(h.dropCollectionProperties)))) router.POST(CollectionCategory+CompactAction, timeoutMiddleware(wrapperPost(func() any { return &CompactReq{} }, wrapperTraceLog(h.compact)))) router.POST(CollectionCategory+CompactionStateAction, timeoutMiddleware(wrapperPost(func() any { return &GetCompactionStateReq{} }, wrapperTraceLog(h.getcompactionState)))) @@ -685,6 +688,74 @@ func (h *HandlersV2) alterCollectionProperties(ctx context.Context, c *gin.Conte return resp, err } +func (h *HandlersV2) addCollectionFunction(ctx context.Context, c *gin.Context, anyReq any, dbName string) (interface{}, error) { + httpReq := anyReq.(*CollectionAddFunction) + req := &milvuspb.AddCollectionFunctionRequest{ + DbName: dbName, + CollectionName: httpReq.CollectionName, + } + fSchema, err := genFunctionSchema(ctx, &httpReq.Function) + if err != nil { + HTTPAbortReturn(c, http.StatusOK, gin.H{ + HTTPReturnCode: merr.Code(merr.ErrParameterInvalid), + HTTPReturnMessage: err.Error(), + }) + } + + req.FunctionSchema = fSchema + c.Set(ContextRequest, req) + resp, err := wrapperProxyWithLimit(ctx, c, req, h.checkAuth, false, "/milvus.proto.milvus.MilvusService/AddCollectionFunction", true, h.proxy, func(reqCtx context.Context, req any) (interface{}, error) { + return h.proxy.AddCollectionFunction(reqCtx, req.(*milvuspb.AddCollectionFunctionRequest)) + }) + if err == nil { + HTTPReturn(c, http.StatusOK, wrapperReturnDefault()) + } + return resp, err +} + +func (h *HandlersV2) alterCollectionFunction(ctx context.Context, c *gin.Context, anyReq any, dbName string) (interface{}, error) { + httpReq := anyReq.(*CollectionAlterFunction) + req := &milvuspb.AlterCollectionFunctionRequest{ + DbName: dbName, + CollectionName: httpReq.CollectionName, + FunctionName: httpReq.FunctionName, + } + fSchema, err := genFunctionSchema(ctx, &httpReq.Function) + if err != nil { + HTTPAbortReturn(c, http.StatusOK, gin.H{ + HTTPReturnCode: merr.Code(merr.ErrParameterInvalid), + HTTPReturnMessage: err.Error(), + }) + } + + req.FunctionSchema = fSchema + c.Set(ContextRequest, req) + resp, err := wrapperProxyWithLimit(ctx, c, req, h.checkAuth, false, "/milvus.proto.milvus.MilvusService/AlterCollectionFunction", true, h.proxy, func(reqCtx context.Context, req any) (interface{}, error) { + return h.proxy.AlterCollectionFunction(reqCtx, req.(*milvuspb.AlterCollectionFunctionRequest)) + }) + if err == nil { + HTTPReturn(c, http.StatusOK, wrapperReturnDefault()) + } + return resp, err +} + +func (h *HandlersV2) dropCollectionFunction(ctx context.Context, c *gin.Context, anyReq any, dbName string) (interface{}, error) { + httpReq := anyReq.(*CollectionDropFunction) + req := &milvuspb.DropCollectionFunctionRequest{ + DbName: dbName, + CollectionName: httpReq.CollectionName, + FunctionName: httpReq.FunctionName, + } + c.Set(ContextRequest, req) + resp, err := wrapperProxyWithLimit(ctx, c, req, h.checkAuth, false, "/milvus.proto.milvus.MilvusService/DropCollectionFunction", true, h.proxy, func(reqCtx context.Context, req any) (interface{}, error) { + return h.proxy.DropCollectionFunction(reqCtx, req.(*milvuspb.DropCollectionFunctionRequest)) + }) + if err == nil { + HTTPReturn(c, http.StatusOK, wrapperReturnDefault()) + } + return resp, err +} + func (h *HandlersV2) dropCollectionProperties(ctx context.Context, c *gin.Context, anyReq any, dbName string) (interface{}, error) { httpReq := anyReq.(*DropCollectionPropertiesReq) req := &milvuspb.AlterCollectionRequest{ diff --git a/internal/distributed/proxy/httpserver/handler_v2_test.go b/internal/distributed/proxy/httpserver/handler_v2_test.go index 6a852334a9..eacc0319ef 100644 --- a/internal/distributed/proxy/httpserver/handler_v2_test.go +++ b/internal/distributed/proxy/httpserver/handler_v2_test.go @@ -2872,3 +2872,112 @@ func (s *AddCollectionFieldSuite) TestAddCollectionFieldFail() { func TestAddCollectionFieldSuite(t *testing.T) { suite.Run(t, new(AddCollectionFieldSuite)) } + +func TestCollectionFunctionSuite(t *testing.T) { + suite.Run(t, new(CollectionFunctionSuite)) +} + +type CollectionFunctionSuite struct { + suite.Suite + testEngine *gin.Engine + mp *mocks.MockProxy +} + +func (s *CollectionFunctionSuite) SetupSuite() { + paramtable.Init() + // disable rate limit + paramtable.Get().Save(paramtable.Get().QuotaConfig.QuotaAndLimitsEnabled.Key, "false") +} + +func (s *CollectionFunctionSuite) TearDownSuite() { + defer paramtable.Get().Reset(paramtable.Get().QuotaConfig.QuotaAndLimitsEnabled.Key) +} + +func (s *CollectionFunctionSuite) SetupTest() { + s.mp = mocks.NewMockProxy(s.T()) + s.testEngine = initHTTPServerV2(s.mp, false) +} + +func (s *CollectionFunctionSuite) TestAddCollectionFunctionNormal() { + s.Run("success", func() { + addFunctionTestCases := []requestBodyTestCase{ + { + path: versionalV2(CollectionCategory, AddFunctionAction), + requestBody: []byte(`{"dbName": "db", "collectionName": "coll", "function": {"name": "test_function", "type": "TextEmbedding", "inputFieldNames": [], "OutputFieldNames": []}}`), + errCode: 0, + errMsg: "", + }, + } + s.mp.EXPECT().AddCollectionFunction(mock.Anything, mock.Anything).Return(&commonpb.Status{ErrorCode: commonpb.ErrorCode_Success}, nil).Maybe() + + validateRequestBodyTestCases(s.T(), s.testEngine, addFunctionTestCases, false) + }) + + s.Run("bad_request", func() { + addFunctionTestCases := []requestBodyTestCase{ + { + path: versionalV2(CollectionCategory, AddFunctionAction), + requestBody: []byte(`{"dbName": "db", "collectionName": "", "function": {"name": "test_function", "type": "BM25", "inputFieldNames": [], "OutputFieldNames": []}}`), + errCode: 1802, + errMsg: "missing required parameters, error: Key: 'CollectionAddFunction.CollectionName' Error:Field validation for 'CollectionName' failed on the 'required' tag", + }, + { + path: versionalV2(CollectionCategory, AddFunctionAction), + requestBody: []byte(`invalid json`), + errCode: 1801, + errMsg: "can only accept json format request, error: invalid character 'i' looking for beginning of value", + }, + } + validateRequestBodyTestCases(s.T(), s.testEngine, addFunctionTestCases, false) + }) +} + +func (s *CollectionFunctionSuite) TestAlterCollectionFunctionNormal() { + s.Run("success", func() { + alterFunctionTestCases := []requestBodyTestCase{ + { + path: versionalV2(CollectionCategory, AlterFunctionAction), + requestBody: []byte(`{"dbName": "db", "collectionName": "coll", "functionName": "test_function", "function": {"name": "test_function", "type": "TextEmbedding", "inputFieldNames": [], "OutputFieldNames": []}}`), + errCode: 0, + errMsg: "", + }, + } + s.mp.EXPECT().AlterCollectionFunction(mock.Anything, mock.Anything).Return(&commonpb.Status{ErrorCode: commonpb.ErrorCode_Success}, nil).Maybe() + + validateRequestBodyTestCases(s.T(), s.testEngine, alterFunctionTestCases, false) + }) + + s.Run("bad_request", func() { + alterFunctionTestCases := []requestBodyTestCase{ + { + path: versionalV2(CollectionCategory, AlterFunctionAction), + requestBody: []byte(`{"dbName": "db", "collectionName": "", "functionName": "test_function", "function": {"name": "test_function", "type": "BM25", "inputFieldNames": [], "OutputFieldNames": []}}`), + errCode: 1802, + errMsg: "missing required parameters, error: Key: 'CollectionAlterFunction.CollectionName' Error:Field validation for 'CollectionName' failed on the 'required' tag", + }, + { + path: versionalV2(CollectionCategory, AlterFunctionAction), + requestBody: []byte(`invalid json`), + errCode: 1801, + errMsg: "can only accept json format request, error: invalid character 'i' looking for beginning of value", + }, + } + validateRequestBodyTestCases(s.T(), s.testEngine, alterFunctionTestCases, false) + }) +} + +func (s *CollectionFunctionSuite) TestDropCollectionFunctionNormal() { + s.Run("success", func() { + addFunctionTestCases := []requestBodyTestCase{ + { + path: versionalV2(CollectionCategory, DropFunctionAction), + requestBody: []byte(`{"dbName": "db", "collectionName": "coll", "functionName": "test"}`), + errCode: 0, + errMsg: "", + }, + } + s.mp.EXPECT().DropCollectionFunction(mock.Anything, mock.Anything).Return(&commonpb.Status{ErrorCode: commonpb.ErrorCode_Success}, nil).Maybe() + + validateRequestBodyTestCases(s.T(), s.testEngine, addFunctionTestCases, false) + }) +} diff --git a/internal/distributed/proxy/httpserver/request_v2.go b/internal/distributed/proxy/httpserver/request_v2.go index 130f5d39e2..a7d22a86c1 100644 --- a/internal/distributed/proxy/httpserver/request_v2.go +++ b/internal/distributed/proxy/httpserver/request_v2.go @@ -89,6 +89,59 @@ func (req *CollectionReqWithProperties) GetCollectionName() string { return req.CollectionName } +type CollectionDropFunction struct { + DbName string `json:"dbName"` + CollectionName string `json:"collectionName" binding:"required"` + FunctionName string `json:"FunctionName" binding:"required"` +} + +func (req *CollectionDropFunction) GetDbName() string { return req.DbName } + +func (req *CollectionDropFunction) GetCollectionName() string { + return req.CollectionName +} + +func (req *CollectionDropFunction) GetFunctionName() string { + return req.FunctionName +} + +type CollectionAddFunction struct { + DbName string `json:"dbName"` + CollectionName string `json:"collectionName" binding:"required"` + Function FunctionSchema `json:"function" binding:"required"` +} + +func (req *CollectionAddFunction) GetDbName() string { return req.DbName } + +func (req *CollectionAddFunction) GetCollectionName() string { + return req.CollectionName +} + +func (req *CollectionAddFunction) GetFunction() *FunctionSchema { + return &req.Function +} + +type CollectionAlterFunction struct { + DbName string `json:"dbName"` + CollectionName string `json:"collectionName" binding:"required"` + FunctionName string `json:"functionName" binding:"required"` + Function FunctionSchema `json:"function" binding:"required"` +} + +func (req *CollectionAlterFunction) GetDbName() string { return req.DbName } + +func (req *CollectionAlterFunction) GetCollectionName() string { + return req.CollectionName +} + +func (req *CollectionAlterFunction) GetFunctionName() string { + return req.FunctionName +} + +func (req *CollectionAlterFunction) GetFunction() *FunctionSchema { + return &req.Function +} + type OptionalCollectionNameReq struct { DbName string `json:"dbName"` CollectionName string `json:"collectionName"` diff --git a/internal/distributed/proxy/service.go b/internal/distributed/proxy/service.go index 41691bac29..a0a904c58e 100644 --- a/internal/distributed/proxy/service.go +++ b/internal/distributed/proxy/service.go @@ -671,6 +671,18 @@ func (s *Server) AlterCollectionField(ctx context.Context, request *milvuspb.Alt return s.proxy.AlterCollectionField(ctx, request) } +func (s *Server) AddCollectionFunction(ctx context.Context, request *milvuspb.AddCollectionFunctionRequest) (*commonpb.Status, error) { + return s.proxy.AddCollectionFunction(ctx, request) +} + +func (s *Server) AlterCollectionFunction(ctx context.Context, request *milvuspb.AlterCollectionFunctionRequest) (*commonpb.Status, error) { + return s.proxy.AlterCollectionFunction(ctx, request) +} + +func (s *Server) DropCollectionFunction(ctx context.Context, request *milvuspb.DropCollectionFunctionRequest) (*commonpb.Status, error) { + return s.proxy.DropCollectionFunction(ctx, request) +} + // CreatePartition notifies Proxy to create a partition func (s *Server) CreatePartition(ctx context.Context, request *milvuspb.CreatePartitionRequest) (*commonpb.Status, error) { return s.proxy.CreatePartition(ctx, request) diff --git a/internal/metastore/kv/rootcoord/kv_catalog.go b/internal/metastore/kv/rootcoord/kv_catalog.go index 8ba174abc0..ff981905a8 100644 --- a/internal/metastore/kv/rootcoord/kv_catalog.go +++ b/internal/metastore/kv/rootcoord/kv_catalog.go @@ -725,6 +725,15 @@ func (kc *Catalog) alterModifyCollection(ctx context.Context, oldColl *model.Col } saves[k] = string(v) } + for _, function := range newColl.Functions { + k := BuildFunctionKey(newColl.CollectionID, function.ID) + functionInfo := model.MarshalFunctionModel(function) + v, err := proto.Marshal(functionInfo) + if err != nil { + return err + } + saves[k] = string(v) + } } maxTxnNum := paramtable.Get().MetaStoreCfg.MaxEtcdTxnNum.GetAsInt() diff --git a/internal/metastore/kv/rootcoord/kv_catalog_test.go b/internal/metastore/kv/rootcoord/kv_catalog_test.go index fb8471b88a..0a71164331 100644 --- a/internal/metastore/kv/rootcoord/kv_catalog_test.go +++ b/internal/metastore/kv/rootcoord/kv_catalog_test.go @@ -1117,6 +1117,29 @@ func TestCatalog_AlterCollection(t *testing.T) { err := kc.AlterCollection(ctx, oldC, newC, metastore.MODIFY, 0, true) assert.NoError(t, err) }) + + t.Run("modify function", func(t *testing.T) { + var collectionID int64 = 1 + snapshot := kv.NewMockSnapshotKV() + snapshot.MultiSaveFunc = func(ctx context.Context, saves map[string]string, ts typeutil.Timestamp) error { + assert.LessOrEqual(t, len(saves), 64) + return nil + } + + kc := NewCatalog(nil, snapshot).(*Catalog) + ctx := context.Background() + + functions := []*model.Function{ + { + Name: "test_function", + }, + } + + oldC := &model.Collection{DBID: 0, CollectionID: collectionID, State: pb.CollectionState_CollectionCreated} + newC := &model.Collection{DBID: 0, CollectionID: collectionID, State: pb.CollectionState_CollectionCreated, Functions: functions} + err := kc.AlterCollection(ctx, oldC, newC, metastore.MODIFY, 0, true) + assert.NoError(t, err) + }) } func TestCatalog_AlterCollectionDB(t *testing.T) { diff --git a/internal/metastore/mocks/mock_rootcoord_catalog.go b/internal/metastore/mocks/mock_rootcoord_catalog.go index 1aacb1eeb3..ce4ea3fd31 100644 --- a/internal/metastore/mocks/mock_rootcoord_catalog.go +++ b/internal/metastore/mocks/mock_rootcoord_catalog.go @@ -655,53 +655,6 @@ func (_c *RootCoordCatalog_CreateCollection_Call) RunAndReturn(run func(context. return _c } -// CreateCredential provides a mock function with given fields: ctx, credential -func (_m *RootCoordCatalog) CreateCredential(ctx context.Context, credential *model.Credential) error { - ret := _m.Called(ctx, credential) - - if len(ret) == 0 { - panic("no return value specified for CreateCredential") - } - - var r0 error - if rf, ok := ret.Get(0).(func(context.Context, *model.Credential) error); ok { - r0 = rf(ctx, credential) - } else { - r0 = ret.Error(0) - } - - return r0 -} - -// RootCoordCatalog_CreateCredential_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateCredential' -type RootCoordCatalog_CreateCredential_Call struct { - *mock.Call -} - -// CreateCredential is a helper method to define mock.On call -// - ctx context.Context -// - credential *model.Credential -func (_e *RootCoordCatalog_Expecter) CreateCredential(ctx interface{}, credential interface{}) *RootCoordCatalog_CreateCredential_Call { - return &RootCoordCatalog_CreateCredential_Call{Call: _e.mock.On("CreateCredential", ctx, credential)} -} - -func (_c *RootCoordCatalog_CreateCredential_Call) Run(run func(ctx context.Context, credential *model.Credential)) *RootCoordCatalog_CreateCredential_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(*model.Credential)) - }) - return _c -} - -func (_c *RootCoordCatalog_CreateCredential_Call) Return(_a0 error) *RootCoordCatalog_CreateCredential_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *RootCoordCatalog_CreateCredential_Call) RunAndReturn(run func(context.Context, *model.Credential) error) *RootCoordCatalog_CreateCredential_Call { - _c.Call.Return(run) - return _c -} - // CreateDatabase provides a mock function with given fields: ctx, db, ts func (_m *RootCoordCatalog) CreateDatabase(ctx context.Context, db *model.Database, ts uint64) error { ret := _m.Called(ctx, db, ts) diff --git a/internal/mocks/mock_mixcoord.go b/internal/mocks/mock_mixcoord.go index 9bb8b289e0..16640666a1 100644 --- a/internal/mocks/mock_mixcoord.go +++ b/internal/mocks/mock_mixcoord.go @@ -162,6 +162,65 @@ func (_c *MixCoord_AddCollectionField_Call) RunAndReturn(run func(context.Contex return _c } +// AddCollectionFunction provides a mock function with given fields: _a0, _a1 +func (_m *MixCoord) AddCollectionFunction(_a0 context.Context, _a1 *milvuspb.AddCollectionFunctionRequest) (*commonpb.Status, error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for AddCollectionFunction") + } + + var r0 *commonpb.Status + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.AddCollectionFunctionRequest) (*commonpb.Status, error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.AddCollectionFunctionRequest) *commonpb.Status); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*commonpb.Status) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.AddCollectionFunctionRequest) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MixCoord_AddCollectionFunction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddCollectionFunction' +type MixCoord_AddCollectionFunction_Call struct { + *mock.Call +} + +// AddCollectionFunction is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *milvuspb.AddCollectionFunctionRequest +func (_e *MixCoord_Expecter) AddCollectionFunction(_a0 interface{}, _a1 interface{}) *MixCoord_AddCollectionFunction_Call { + return &MixCoord_AddCollectionFunction_Call{Call: _e.mock.On("AddCollectionFunction", _a0, _a1)} +} + +func (_c *MixCoord_AddCollectionFunction_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.AddCollectionFunctionRequest)) *MixCoord_AddCollectionFunction_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*milvuspb.AddCollectionFunctionRequest)) + }) + return _c +} + +func (_c *MixCoord_AddCollectionFunction_Call) Return(_a0 *commonpb.Status, _a1 error) *MixCoord_AddCollectionFunction_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MixCoord_AddCollectionFunction_Call) RunAndReturn(run func(context.Context, *milvuspb.AddCollectionFunctionRequest) (*commonpb.Status, error)) *MixCoord_AddCollectionFunction_Call { + _c.Call.Return(run) + return _c +} + // AddFileResource provides a mock function with given fields: _a0, _a1 func (_m *MixCoord) AddFileResource(_a0 context.Context, _a1 *milvuspb.AddFileResourceRequest) (*commonpb.Status, error) { ret := _m.Called(_a0, _a1) @@ -575,6 +634,65 @@ func (_c *MixCoord_AlterCollectionField_Call) RunAndReturn(run func(context.Cont return _c } +// AlterCollectionFunction provides a mock function with given fields: _a0, _a1 +func (_m *MixCoord) AlterCollectionFunction(_a0 context.Context, _a1 *milvuspb.AlterCollectionFunctionRequest) (*commonpb.Status, error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for AlterCollectionFunction") + } + + var r0 *commonpb.Status + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.AlterCollectionFunctionRequest) (*commonpb.Status, error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.AlterCollectionFunctionRequest) *commonpb.Status); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*commonpb.Status) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.AlterCollectionFunctionRequest) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MixCoord_AlterCollectionFunction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AlterCollectionFunction' +type MixCoord_AlterCollectionFunction_Call struct { + *mock.Call +} + +// AlterCollectionFunction is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *milvuspb.AlterCollectionFunctionRequest +func (_e *MixCoord_Expecter) AlterCollectionFunction(_a0 interface{}, _a1 interface{}) *MixCoord_AlterCollectionFunction_Call { + return &MixCoord_AlterCollectionFunction_Call{Call: _e.mock.On("AlterCollectionFunction", _a0, _a1)} +} + +func (_c *MixCoord_AlterCollectionFunction_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.AlterCollectionFunctionRequest)) *MixCoord_AlterCollectionFunction_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*milvuspb.AlterCollectionFunctionRequest)) + }) + return _c +} + +func (_c *MixCoord_AlterCollectionFunction_Call) Return(_a0 *commonpb.Status, _a1 error) *MixCoord_AlterCollectionFunction_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MixCoord_AlterCollectionFunction_Call) RunAndReturn(run func(context.Context, *milvuspb.AlterCollectionFunctionRequest) (*commonpb.Status, error)) *MixCoord_AlterCollectionFunction_Call { + _c.Call.Return(run) + return _c +} + // AlterDatabase provides a mock function with given fields: _a0, _a1 func (_m *MixCoord) AlterDatabase(_a0 context.Context, _a1 *rootcoordpb.AlterDatabaseRequest) (*commonpb.Status, error) { ret := _m.Called(_a0, _a1) @@ -2168,6 +2286,65 @@ func (_c *MixCoord_DropCollection_Call) RunAndReturn(run func(context.Context, * return _c } +// DropCollectionFunction provides a mock function with given fields: _a0, _a1 +func (_m *MixCoord) DropCollectionFunction(_a0 context.Context, _a1 *milvuspb.DropCollectionFunctionRequest) (*commonpb.Status, error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for DropCollectionFunction") + } + + var r0 *commonpb.Status + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.DropCollectionFunctionRequest) (*commonpb.Status, error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.DropCollectionFunctionRequest) *commonpb.Status); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*commonpb.Status) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.DropCollectionFunctionRequest) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MixCoord_DropCollectionFunction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DropCollectionFunction' +type MixCoord_DropCollectionFunction_Call struct { + *mock.Call +} + +// DropCollectionFunction is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *milvuspb.DropCollectionFunctionRequest +func (_e *MixCoord_Expecter) DropCollectionFunction(_a0 interface{}, _a1 interface{}) *MixCoord_DropCollectionFunction_Call { + return &MixCoord_DropCollectionFunction_Call{Call: _e.mock.On("DropCollectionFunction", _a0, _a1)} +} + +func (_c *MixCoord_DropCollectionFunction_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.DropCollectionFunctionRequest)) *MixCoord_DropCollectionFunction_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*milvuspb.DropCollectionFunctionRequest)) + }) + return _c +} + +func (_c *MixCoord_DropCollectionFunction_Call) Return(_a0 *commonpb.Status, _a1 error) *MixCoord_DropCollectionFunction_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MixCoord_DropCollectionFunction_Call) RunAndReturn(run func(context.Context, *milvuspb.DropCollectionFunctionRequest) (*commonpb.Status, error)) *MixCoord_DropCollectionFunction_Call { + _c.Call.Return(run) + return _c +} + // DropDatabase provides a mock function with given fields: _a0, _a1 func (_m *MixCoord) DropDatabase(_a0 context.Context, _a1 *milvuspb.DropDatabaseRequest) (*commonpb.Status, error) { ret := _m.Called(_a0, _a1) diff --git a/internal/mocks/mock_mixcoord_client.go b/internal/mocks/mock_mixcoord_client.go index 9713911bd4..39a964cb43 100644 --- a/internal/mocks/mock_mixcoord_client.go +++ b/internal/mocks/mock_mixcoord_client.go @@ -187,6 +187,80 @@ func (_c *MockMixCoordClient_AddCollectionField_Call) RunAndReturn(run func(cont return _c } +// AddCollectionFunction provides a mock function with given fields: ctx, in, opts +func (_m *MockMixCoordClient) AddCollectionFunction(ctx context.Context, in *milvuspb.AddCollectionFunctionRequest, opts ...grpc.CallOption) (*commonpb.Status, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, in) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for AddCollectionFunction") + } + + var r0 *commonpb.Status + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.AddCollectionFunctionRequest, ...grpc.CallOption) (*commonpb.Status, error)); ok { + return rf(ctx, in, opts...) + } + if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.AddCollectionFunctionRequest, ...grpc.CallOption) *commonpb.Status); ok { + r0 = rf(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*commonpb.Status) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.AddCollectionFunctionRequest, ...grpc.CallOption) error); ok { + r1 = rf(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockMixCoordClient_AddCollectionFunction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddCollectionFunction' +type MockMixCoordClient_AddCollectionFunction_Call struct { + *mock.Call +} + +// AddCollectionFunction is a helper method to define mock.On call +// - ctx context.Context +// - in *milvuspb.AddCollectionFunctionRequest +// - opts ...grpc.CallOption +func (_e *MockMixCoordClient_Expecter) AddCollectionFunction(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_AddCollectionFunction_Call { + return &MockMixCoordClient_AddCollectionFunction_Call{Call: _e.mock.On("AddCollectionFunction", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockMixCoordClient_AddCollectionFunction_Call) Run(run func(ctx context.Context, in *milvuspb.AddCollectionFunctionRequest, opts ...grpc.CallOption)) *MockMixCoordClient_AddCollectionFunction_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]grpc.CallOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(grpc.CallOption) + } + } + run(args[0].(context.Context), args[1].(*milvuspb.AddCollectionFunctionRequest), variadicArgs...) + }) + return _c +} + +func (_c *MockMixCoordClient_AddCollectionFunction_Call) Return(_a0 *commonpb.Status, _a1 error) *MockMixCoordClient_AddCollectionFunction_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockMixCoordClient_AddCollectionFunction_Call) RunAndReturn(run func(context.Context, *milvuspb.AddCollectionFunctionRequest, ...grpc.CallOption) (*commonpb.Status, error)) *MockMixCoordClient_AddCollectionFunction_Call { + _c.Call.Return(run) + return _c +} + // AddFileResource provides a mock function with given fields: ctx, in, opts func (_m *MockMixCoordClient) AddFileResource(ctx context.Context, in *milvuspb.AddFileResourceRequest, opts ...grpc.CallOption) (*commonpb.Status, error) { _va := make([]interface{}, len(opts)) @@ -705,6 +779,80 @@ func (_c *MockMixCoordClient_AlterCollectionField_Call) RunAndReturn(run func(co return _c } +// AlterCollectionFunction provides a mock function with given fields: ctx, in, opts +func (_m *MockMixCoordClient) AlterCollectionFunction(ctx context.Context, in *milvuspb.AlterCollectionFunctionRequest, opts ...grpc.CallOption) (*commonpb.Status, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, in) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for AlterCollectionFunction") + } + + var r0 *commonpb.Status + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.AlterCollectionFunctionRequest, ...grpc.CallOption) (*commonpb.Status, error)); ok { + return rf(ctx, in, opts...) + } + if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.AlterCollectionFunctionRequest, ...grpc.CallOption) *commonpb.Status); ok { + r0 = rf(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*commonpb.Status) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.AlterCollectionFunctionRequest, ...grpc.CallOption) error); ok { + r1 = rf(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockMixCoordClient_AlterCollectionFunction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AlterCollectionFunction' +type MockMixCoordClient_AlterCollectionFunction_Call struct { + *mock.Call +} + +// AlterCollectionFunction is a helper method to define mock.On call +// - ctx context.Context +// - in *milvuspb.AlterCollectionFunctionRequest +// - opts ...grpc.CallOption +func (_e *MockMixCoordClient_Expecter) AlterCollectionFunction(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_AlterCollectionFunction_Call { + return &MockMixCoordClient_AlterCollectionFunction_Call{Call: _e.mock.On("AlterCollectionFunction", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockMixCoordClient_AlterCollectionFunction_Call) Run(run func(ctx context.Context, in *milvuspb.AlterCollectionFunctionRequest, opts ...grpc.CallOption)) *MockMixCoordClient_AlterCollectionFunction_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]grpc.CallOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(grpc.CallOption) + } + } + run(args[0].(context.Context), args[1].(*milvuspb.AlterCollectionFunctionRequest), variadicArgs...) + }) + return _c +} + +func (_c *MockMixCoordClient_AlterCollectionFunction_Call) Return(_a0 *commonpb.Status, _a1 error) *MockMixCoordClient_AlterCollectionFunction_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockMixCoordClient_AlterCollectionFunction_Call) RunAndReturn(run func(context.Context, *milvuspb.AlterCollectionFunctionRequest, ...grpc.CallOption) (*commonpb.Status, error)) *MockMixCoordClient_AlterCollectionFunction_Call { + _c.Call.Return(run) + return _c +} + // AlterDatabase provides a mock function with given fields: ctx, in, opts func (_m *MockMixCoordClient) AlterDatabase(ctx context.Context, in *rootcoordpb.AlterDatabaseRequest, opts ...grpc.CallOption) (*commonpb.Status, error) { _va := make([]interface{}, len(opts)) @@ -2748,6 +2896,80 @@ func (_c *MockMixCoordClient_DropCollection_Call) RunAndReturn(run func(context. return _c } +// DropCollectionFunction provides a mock function with given fields: ctx, in, opts +func (_m *MockMixCoordClient) DropCollectionFunction(ctx context.Context, in *milvuspb.DropCollectionFunctionRequest, opts ...grpc.CallOption) (*commonpb.Status, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, in) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for DropCollectionFunction") + } + + var r0 *commonpb.Status + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.DropCollectionFunctionRequest, ...grpc.CallOption) (*commonpb.Status, error)); ok { + return rf(ctx, in, opts...) + } + if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.DropCollectionFunctionRequest, ...grpc.CallOption) *commonpb.Status); ok { + r0 = rf(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*commonpb.Status) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.DropCollectionFunctionRequest, ...grpc.CallOption) error); ok { + r1 = rf(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockMixCoordClient_DropCollectionFunction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DropCollectionFunction' +type MockMixCoordClient_DropCollectionFunction_Call struct { + *mock.Call +} + +// DropCollectionFunction is a helper method to define mock.On call +// - ctx context.Context +// - in *milvuspb.DropCollectionFunctionRequest +// - opts ...grpc.CallOption +func (_e *MockMixCoordClient_Expecter) DropCollectionFunction(ctx interface{}, in interface{}, opts ...interface{}) *MockMixCoordClient_DropCollectionFunction_Call { + return &MockMixCoordClient_DropCollectionFunction_Call{Call: _e.mock.On("DropCollectionFunction", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockMixCoordClient_DropCollectionFunction_Call) Run(run func(ctx context.Context, in *milvuspb.DropCollectionFunctionRequest, opts ...grpc.CallOption)) *MockMixCoordClient_DropCollectionFunction_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]grpc.CallOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(grpc.CallOption) + } + } + run(args[0].(context.Context), args[1].(*milvuspb.DropCollectionFunctionRequest), variadicArgs...) + }) + return _c +} + +func (_c *MockMixCoordClient_DropCollectionFunction_Call) Return(_a0 *commonpb.Status, _a1 error) *MockMixCoordClient_DropCollectionFunction_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockMixCoordClient_DropCollectionFunction_Call) RunAndReturn(run func(context.Context, *milvuspb.DropCollectionFunctionRequest, ...grpc.CallOption) (*commonpb.Status, error)) *MockMixCoordClient_DropCollectionFunction_Call { + _c.Call.Return(run) + return _c +} + // DropDatabase provides a mock function with given fields: ctx, in, opts func (_m *MockMixCoordClient) DropDatabase(ctx context.Context, in *milvuspb.DropDatabaseRequest, opts ...grpc.CallOption) (*commonpb.Status, error) { _va := make([]interface{}, len(opts)) diff --git a/internal/mocks/mock_rootcoord.go b/internal/mocks/mock_rootcoord.go index 24f914b882..823982f3e3 100644 --- a/internal/mocks/mock_rootcoord.go +++ b/internal/mocks/mock_rootcoord.go @@ -95,6 +95,65 @@ func (_c *MockRootCoord_AddCollectionField_Call) RunAndReturn(run func(context.C return _c } +// AddCollectionFunction provides a mock function with given fields: _a0, _a1 +func (_m *MockRootCoord) AddCollectionFunction(_a0 context.Context, _a1 *milvuspb.AddCollectionFunctionRequest) (*commonpb.Status, error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for AddCollectionFunction") + } + + var r0 *commonpb.Status + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.AddCollectionFunctionRequest) (*commonpb.Status, error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.AddCollectionFunctionRequest) *commonpb.Status); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*commonpb.Status) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.AddCollectionFunctionRequest) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockRootCoord_AddCollectionFunction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddCollectionFunction' +type MockRootCoord_AddCollectionFunction_Call struct { + *mock.Call +} + +// AddCollectionFunction is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *milvuspb.AddCollectionFunctionRequest +func (_e *MockRootCoord_Expecter) AddCollectionFunction(_a0 interface{}, _a1 interface{}) *MockRootCoord_AddCollectionFunction_Call { + return &MockRootCoord_AddCollectionFunction_Call{Call: _e.mock.On("AddCollectionFunction", _a0, _a1)} +} + +func (_c *MockRootCoord_AddCollectionFunction_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.AddCollectionFunctionRequest)) *MockRootCoord_AddCollectionFunction_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*milvuspb.AddCollectionFunctionRequest)) + }) + return _c +} + +func (_c *MockRootCoord_AddCollectionFunction_Call) Return(_a0 *commonpb.Status, _a1 error) *MockRootCoord_AddCollectionFunction_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockRootCoord_AddCollectionFunction_Call) RunAndReturn(run func(context.Context, *milvuspb.AddCollectionFunctionRequest) (*commonpb.Status, error)) *MockRootCoord_AddCollectionFunction_Call { + _c.Call.Return(run) + return _c +} + // AllocID provides a mock function with given fields: _a0, _a1 func (_m *MockRootCoord) AllocID(_a0 context.Context, _a1 *rootcoordpb.AllocIDRequest) (*rootcoordpb.AllocIDResponse, error) { ret := _m.Called(_a0, _a1) @@ -390,6 +449,65 @@ func (_c *MockRootCoord_AlterCollectionField_Call) RunAndReturn(run func(context return _c } +// AlterCollectionFunction provides a mock function with given fields: _a0, _a1 +func (_m *MockRootCoord) AlterCollectionFunction(_a0 context.Context, _a1 *milvuspb.AlterCollectionFunctionRequest) (*commonpb.Status, error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for AlterCollectionFunction") + } + + var r0 *commonpb.Status + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.AlterCollectionFunctionRequest) (*commonpb.Status, error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.AlterCollectionFunctionRequest) *commonpb.Status); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*commonpb.Status) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.AlterCollectionFunctionRequest) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockRootCoord_AlterCollectionFunction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AlterCollectionFunction' +type MockRootCoord_AlterCollectionFunction_Call struct { + *mock.Call +} + +// AlterCollectionFunction is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *milvuspb.AlterCollectionFunctionRequest +func (_e *MockRootCoord_Expecter) AlterCollectionFunction(_a0 interface{}, _a1 interface{}) *MockRootCoord_AlterCollectionFunction_Call { + return &MockRootCoord_AlterCollectionFunction_Call{Call: _e.mock.On("AlterCollectionFunction", _a0, _a1)} +} + +func (_c *MockRootCoord_AlterCollectionFunction_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.AlterCollectionFunctionRequest)) *MockRootCoord_AlterCollectionFunction_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*milvuspb.AlterCollectionFunctionRequest)) + }) + return _c +} + +func (_c *MockRootCoord_AlterCollectionFunction_Call) Return(_a0 *commonpb.Status, _a1 error) *MockRootCoord_AlterCollectionFunction_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockRootCoord_AlterCollectionFunction_Call) RunAndReturn(run func(context.Context, *milvuspb.AlterCollectionFunctionRequest) (*commonpb.Status, error)) *MockRootCoord_AlterCollectionFunction_Call { + _c.Call.Return(run) + return _c +} + // AlterDatabase provides a mock function with given fields: _a0, _a1 func (_m *MockRootCoord) AlterDatabase(_a0 context.Context, _a1 *rootcoordpb.AlterDatabaseRequest) (*commonpb.Status, error) { ret := _m.Called(_a0, _a1) @@ -1393,6 +1511,65 @@ func (_c *MockRootCoord_DropCollection_Call) RunAndReturn(run func(context.Conte return _c } +// DropCollectionFunction provides a mock function with given fields: _a0, _a1 +func (_m *MockRootCoord) DropCollectionFunction(_a0 context.Context, _a1 *milvuspb.DropCollectionFunctionRequest) (*commonpb.Status, error) { + ret := _m.Called(_a0, _a1) + + if len(ret) == 0 { + panic("no return value specified for DropCollectionFunction") + } + + var r0 *commonpb.Status + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.DropCollectionFunctionRequest) (*commonpb.Status, error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.DropCollectionFunctionRequest) *commonpb.Status); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*commonpb.Status) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.DropCollectionFunctionRequest) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockRootCoord_DropCollectionFunction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DropCollectionFunction' +type MockRootCoord_DropCollectionFunction_Call struct { + *mock.Call +} + +// DropCollectionFunction is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *milvuspb.DropCollectionFunctionRequest +func (_e *MockRootCoord_Expecter) DropCollectionFunction(_a0 interface{}, _a1 interface{}) *MockRootCoord_DropCollectionFunction_Call { + return &MockRootCoord_DropCollectionFunction_Call{Call: _e.mock.On("DropCollectionFunction", _a0, _a1)} +} + +func (_c *MockRootCoord_DropCollectionFunction_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.DropCollectionFunctionRequest)) *MockRootCoord_DropCollectionFunction_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*milvuspb.DropCollectionFunctionRequest)) + }) + return _c +} + +func (_c *MockRootCoord_DropCollectionFunction_Call) Return(_a0 *commonpb.Status, _a1 error) *MockRootCoord_DropCollectionFunction_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockRootCoord_DropCollectionFunction_Call) RunAndReturn(run func(context.Context, *milvuspb.DropCollectionFunctionRequest) (*commonpb.Status, error)) *MockRootCoord_DropCollectionFunction_Call { + _c.Call.Return(run) + return _c +} + // DropDatabase provides a mock function with given fields: _a0, _a1 func (_m *MockRootCoord) DropDatabase(_a0 context.Context, _a1 *milvuspb.DropDatabaseRequest) (*commonpb.Status, error) { ret := _m.Called(_a0, _a1) diff --git a/internal/mocks/mock_rootcoord_client.go b/internal/mocks/mock_rootcoord_client.go index d277fedbeb..58ad609c40 100644 --- a/internal/mocks/mock_rootcoord_client.go +++ b/internal/mocks/mock_rootcoord_client.go @@ -107,6 +107,80 @@ func (_c *MockRootCoordClient_AddCollectionField_Call) RunAndReturn(run func(con return _c } +// AddCollectionFunction provides a mock function with given fields: ctx, in, opts +func (_m *MockRootCoordClient) AddCollectionFunction(ctx context.Context, in *milvuspb.AddCollectionFunctionRequest, opts ...grpc.CallOption) (*commonpb.Status, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, in) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for AddCollectionFunction") + } + + var r0 *commonpb.Status + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.AddCollectionFunctionRequest, ...grpc.CallOption) (*commonpb.Status, error)); ok { + return rf(ctx, in, opts...) + } + if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.AddCollectionFunctionRequest, ...grpc.CallOption) *commonpb.Status); ok { + r0 = rf(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*commonpb.Status) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.AddCollectionFunctionRequest, ...grpc.CallOption) error); ok { + r1 = rf(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockRootCoordClient_AddCollectionFunction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddCollectionFunction' +type MockRootCoordClient_AddCollectionFunction_Call struct { + *mock.Call +} + +// AddCollectionFunction is a helper method to define mock.On call +// - ctx context.Context +// - in *milvuspb.AddCollectionFunctionRequest +// - opts ...grpc.CallOption +func (_e *MockRootCoordClient_Expecter) AddCollectionFunction(ctx interface{}, in interface{}, opts ...interface{}) *MockRootCoordClient_AddCollectionFunction_Call { + return &MockRootCoordClient_AddCollectionFunction_Call{Call: _e.mock.On("AddCollectionFunction", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockRootCoordClient_AddCollectionFunction_Call) Run(run func(ctx context.Context, in *milvuspb.AddCollectionFunctionRequest, opts ...grpc.CallOption)) *MockRootCoordClient_AddCollectionFunction_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]grpc.CallOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(grpc.CallOption) + } + } + run(args[0].(context.Context), args[1].(*milvuspb.AddCollectionFunctionRequest), variadicArgs...) + }) + return _c +} + +func (_c *MockRootCoordClient_AddCollectionFunction_Call) Return(_a0 *commonpb.Status, _a1 error) *MockRootCoordClient_AddCollectionFunction_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockRootCoordClient_AddCollectionFunction_Call) RunAndReturn(run func(context.Context, *milvuspb.AddCollectionFunctionRequest, ...grpc.CallOption) (*commonpb.Status, error)) *MockRootCoordClient_AddCollectionFunction_Call { + _c.Call.Return(run) + return _c +} + // AllocID provides a mock function with given fields: ctx, in, opts func (_m *MockRootCoordClient) AllocID(ctx context.Context, in *rootcoordpb.AllocIDRequest, opts ...grpc.CallOption) (*rootcoordpb.AllocIDResponse, error) { _va := make([]interface{}, len(opts)) @@ -477,6 +551,80 @@ func (_c *MockRootCoordClient_AlterCollectionField_Call) RunAndReturn(run func(c return _c } +// AlterCollectionFunction provides a mock function with given fields: ctx, in, opts +func (_m *MockRootCoordClient) AlterCollectionFunction(ctx context.Context, in *milvuspb.AlterCollectionFunctionRequest, opts ...grpc.CallOption) (*commonpb.Status, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, in) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for AlterCollectionFunction") + } + + var r0 *commonpb.Status + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.AlterCollectionFunctionRequest, ...grpc.CallOption) (*commonpb.Status, error)); ok { + return rf(ctx, in, opts...) + } + if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.AlterCollectionFunctionRequest, ...grpc.CallOption) *commonpb.Status); ok { + r0 = rf(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*commonpb.Status) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.AlterCollectionFunctionRequest, ...grpc.CallOption) error); ok { + r1 = rf(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockRootCoordClient_AlterCollectionFunction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AlterCollectionFunction' +type MockRootCoordClient_AlterCollectionFunction_Call struct { + *mock.Call +} + +// AlterCollectionFunction is a helper method to define mock.On call +// - ctx context.Context +// - in *milvuspb.AlterCollectionFunctionRequest +// - opts ...grpc.CallOption +func (_e *MockRootCoordClient_Expecter) AlterCollectionFunction(ctx interface{}, in interface{}, opts ...interface{}) *MockRootCoordClient_AlterCollectionFunction_Call { + return &MockRootCoordClient_AlterCollectionFunction_Call{Call: _e.mock.On("AlterCollectionFunction", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockRootCoordClient_AlterCollectionFunction_Call) Run(run func(ctx context.Context, in *milvuspb.AlterCollectionFunctionRequest, opts ...grpc.CallOption)) *MockRootCoordClient_AlterCollectionFunction_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]grpc.CallOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(grpc.CallOption) + } + } + run(args[0].(context.Context), args[1].(*milvuspb.AlterCollectionFunctionRequest), variadicArgs...) + }) + return _c +} + +func (_c *MockRootCoordClient_AlterCollectionFunction_Call) Return(_a0 *commonpb.Status, _a1 error) *MockRootCoordClient_AlterCollectionFunction_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockRootCoordClient_AlterCollectionFunction_Call) RunAndReturn(run func(context.Context, *milvuspb.AlterCollectionFunctionRequest, ...grpc.CallOption) (*commonpb.Status, error)) *MockRootCoordClient_AlterCollectionFunction_Call { + _c.Call.Return(run) + return _c +} + // AlterDatabase provides a mock function with given fields: ctx, in, opts func (_m *MockRootCoordClient) AlterDatabase(ctx context.Context, in *rootcoordpb.AlterDatabaseRequest, opts ...grpc.CallOption) (*commonpb.Status, error) { _va := make([]interface{}, len(opts)) @@ -1780,6 +1928,80 @@ func (_c *MockRootCoordClient_DropCollection_Call) RunAndReturn(run func(context return _c } +// DropCollectionFunction provides a mock function with given fields: ctx, in, opts +func (_m *MockRootCoordClient) DropCollectionFunction(ctx context.Context, in *milvuspb.DropCollectionFunctionRequest, opts ...grpc.CallOption) (*commonpb.Status, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, in) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for DropCollectionFunction") + } + + var r0 *commonpb.Status + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.DropCollectionFunctionRequest, ...grpc.CallOption) (*commonpb.Status, error)); ok { + return rf(ctx, in, opts...) + } + if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.DropCollectionFunctionRequest, ...grpc.CallOption) *commonpb.Status); ok { + r0 = rf(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*commonpb.Status) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.DropCollectionFunctionRequest, ...grpc.CallOption) error); ok { + r1 = rf(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockRootCoordClient_DropCollectionFunction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DropCollectionFunction' +type MockRootCoordClient_DropCollectionFunction_Call struct { + *mock.Call +} + +// DropCollectionFunction is a helper method to define mock.On call +// - ctx context.Context +// - in *milvuspb.DropCollectionFunctionRequest +// - opts ...grpc.CallOption +func (_e *MockRootCoordClient_Expecter) DropCollectionFunction(ctx interface{}, in interface{}, opts ...interface{}) *MockRootCoordClient_DropCollectionFunction_Call { + return &MockRootCoordClient_DropCollectionFunction_Call{Call: _e.mock.On("DropCollectionFunction", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockRootCoordClient_DropCollectionFunction_Call) Run(run func(ctx context.Context, in *milvuspb.DropCollectionFunctionRequest, opts ...grpc.CallOption)) *MockRootCoordClient_DropCollectionFunction_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]grpc.CallOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(grpc.CallOption) + } + } + run(args[0].(context.Context), args[1].(*milvuspb.DropCollectionFunctionRequest), variadicArgs...) + }) + return _c +} + +func (_c *MockRootCoordClient_DropCollectionFunction_Call) Return(_a0 *commonpb.Status, _a1 error) *MockRootCoordClient_DropCollectionFunction_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockRootCoordClient_DropCollectionFunction_Call) RunAndReturn(run func(context.Context, *milvuspb.DropCollectionFunctionRequest, ...grpc.CallOption) (*commonpb.Status, error)) *MockRootCoordClient_DropCollectionFunction_Call { + _c.Call.Return(run) + return _c +} + // DropDatabase provides a mock function with given fields: ctx, in, opts func (_m *MockRootCoordClient) DropDatabase(ctx context.Context, in *milvuspb.DropDatabaseRequest, opts ...grpc.CallOption) (*commonpb.Status, error) { _va := make([]interface{}, len(opts)) diff --git a/internal/proxy/function_task.go b/internal/proxy/function_task.go new file mode 100644 index 0000000000..75c03043dc --- /dev/null +++ b/internal/proxy/function_task.go @@ -0,0 +1,331 @@ +// 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" + "fmt" + + "go.uber.org/zap" + "google.golang.org/protobuf/proto" + + "github.com/milvus-io/milvus-proto/go-api/v2/commonpb" + "github.com/milvus-io/milvus-proto/go-api/v2/milvuspb" + "github.com/milvus-io/milvus-proto/go-api/v2/schemapb" + "github.com/milvus-io/milvus/internal/types" + "github.com/milvus-io/milvus/pkg/v2/log" + "github.com/milvus-io/milvus/pkg/v2/util/commonpbutil" + "github.com/milvus-io/milvus/pkg/v2/util/merr" + "github.com/milvus-io/milvus/pkg/v2/util/paramtable" +) + +type addCollectionFunctionTask struct { + baseTask + Condition + *milvuspb.AddCollectionFunctionRequest + ctx context.Context + mixCoord types.MixCoordClient + result *commonpb.Status +} + +func (t *addCollectionFunctionTask) TraceCtx() context.Context { + return t.ctx +} + +func (t *addCollectionFunctionTask) ID() UniqueID { + return t.Base.MsgID +} + +func (t *addCollectionFunctionTask) SetID(uid UniqueID) { + t.Base.MsgID = uid +} + +func (t *addCollectionFunctionTask) Type() commonpb.MsgType { + return t.Base.MsgType +} + +func (t *addCollectionFunctionTask) BeginTs() Timestamp { + return t.Base.Timestamp +} + +func (t *addCollectionFunctionTask) EndTs() Timestamp { + return t.Base.Timestamp +} + +func (t *addCollectionFunctionTask) SetTs(ts Timestamp) { + t.Base.Timestamp = ts +} + +func (t *addCollectionFunctionTask) OnEnqueue() error { + if t.Base == nil { + t.Base = commonpbutil.NewMsgBase() + } + t.Base.MsgType = commonpb.MsgType_AddCollectionFunction + t.Base.SourceID = paramtable.GetNodeID() + return nil +} + +func (t *addCollectionFunctionTask) Name() string { + return AddCollectionFunctionTask +} + +func (t *addCollectionFunctionTask) PreExecute(ctx context.Context) error { + if t.FunctionSchema == nil { + return fmt.Errorf("Function Schema is empty") + } + + if t.FunctionSchema.Type == schemapb.FunctionType_BM25 { + return fmt.Errorf("Currently does not support adding BM25 function") + } + coll, err := getCollectionInfo(ctx, t.GetDbName(), t.GetCollectionName()) + if err != nil { + log.Ctx(t.ctx).Error("AddCollectionTask, get collection info failed", + zap.String("dbName", t.GetDbName()), + zap.String("collectionName", t.GetCollectionName()), + zap.Error(err)) + return err + } + newColl := proto.Clone(coll.schema.CollectionSchema).(*schemapb.CollectionSchema) + newColl.Functions = append(coll.schema.CollectionSchema.Functions, t.FunctionSchema) + if err := validateFunction(newColl); err != nil { + return err + } + return nil +} + +func (t *addCollectionFunctionTask) Execute(ctx context.Context) error { + var err error + t.result, err = t.mixCoord.AddCollectionFunction(ctx, t.AddCollectionFunctionRequest) + if err = merr.CheckRPCCall(t.result, err); err != nil { + return err + } + return nil +} + +func (t *addCollectionFunctionTask) PostExecute(ctx context.Context) error { + return nil +} + +type alterCollectionFunctionTask struct { + baseTask + Condition + *milvuspb.AlterCollectionFunctionRequest + ctx context.Context + mixCoord types.MixCoordClient + result *commonpb.Status +} + +func (t *alterCollectionFunctionTask) TraceCtx() context.Context { + return t.ctx +} + +func (t *alterCollectionFunctionTask) ID() UniqueID { + return t.Base.MsgID +} + +func (t *alterCollectionFunctionTask) SetID(uid UniqueID) { + t.Base.MsgID = uid +} + +func (t *alterCollectionFunctionTask) Type() commonpb.MsgType { + return t.Base.MsgType +} + +func (t *alterCollectionFunctionTask) BeginTs() Timestamp { + return t.Base.Timestamp +} + +func (t *alterCollectionFunctionTask) EndTs() Timestamp { + return t.Base.Timestamp +} + +func (t *alterCollectionFunctionTask) SetTs(ts Timestamp) { + t.Base.Timestamp = ts +} + +func (t *alterCollectionFunctionTask) OnEnqueue() error { + if t.Base == nil { + t.Base = commonpbutil.NewMsgBase() + } + t.Base.MsgType = commonpb.MsgType_AlterCollectionFunction + t.Base.SourceID = paramtable.GetNodeID() + return nil +} + +func (t *alterCollectionFunctionTask) Name() string { + return AlterCollectionFunctionTask +} + +func (t *alterCollectionFunctionTask) PreExecute(ctx context.Context) error { + if t.FunctionSchema == nil { + return fmt.Errorf("Function Schema is empty") + } + if t.FunctionSchema.Type == schemapb.FunctionType_BM25 { + return fmt.Errorf("Currently does not support alter BM25 function") + } + if t.FunctionName != t.FunctionSchema.Name { + return fmt.Errorf("Invalid function config, name not match") + } + coll, err := getCollectionInfo(ctx, t.GetDbName(), t.GetCollectionName()) + if err != nil { + log.Ctx(t.ctx).Error("AddCollectionTask, get collection info failed", + zap.String("dbName", t.GetDbName()), + zap.String("collectionName", t.GetCollectionName()), + zap.Error(err)) + return err + } + funcExist := false + newFunctions := []*schemapb.FunctionSchema{} + for _, fSchema := range coll.schema.Functions { + if t.FunctionName == fSchema.Name { + if fSchema.Type == schemapb.FunctionType_BM25 { + return fmt.Errorf("Currently does not support alter BM25 function") + } + newFunctions = append(newFunctions, t.FunctionSchema) + funcExist = true + } else { + newFunctions = append(newFunctions, fSchema) + } + } + if !funcExist { + return fmt.Errorf("Function %s not found", t.FunctionName) + } + + newColl := proto.Clone(coll.schema.CollectionSchema).(*schemapb.CollectionSchema) + newColl.Functions = newFunctions + if err := validateFunction(newColl); err != nil { + return err + } + return nil +} + +func (t *alterCollectionFunctionTask) Execute(ctx context.Context) error { + var err error + t.result, err = t.mixCoord.AlterCollectionFunction(ctx, t.AlterCollectionFunctionRequest) + if err = merr.CheckRPCCall(t.result, err); err != nil { + return err + } + return nil +} + +func (t *alterCollectionFunctionTask) PostExecute(ctx context.Context) error { + return nil +} + +type dropCollectionFunctionTask struct { + baseTask + Condition + *milvuspb.DropCollectionFunctionRequest + ctx context.Context + mixCoord types.MixCoordClient + + result *commonpb.Status + fSchema *schemapb.FunctionSchema +} + +func (t *dropCollectionFunctionTask) TraceCtx() context.Context { + return t.ctx +} + +func (t *dropCollectionFunctionTask) ID() UniqueID { + return t.Base.MsgID +} + +func (t *dropCollectionFunctionTask) SetID(uid UniqueID) { + t.Base.MsgID = uid +} + +func (t *dropCollectionFunctionTask) Type() commonpb.MsgType { + return t.Base.MsgType +} + +func (t *dropCollectionFunctionTask) BeginTs() Timestamp { + return t.Base.Timestamp +} + +func (t *dropCollectionFunctionTask) EndTs() Timestamp { + return t.Base.Timestamp +} + +func (t *dropCollectionFunctionTask) SetTs(ts Timestamp) { + t.Base.Timestamp = ts +} + +func (t *dropCollectionFunctionTask) OnEnqueue() error { + if t.Base == nil { + t.Base = commonpbutil.NewMsgBase() + } + t.Base.MsgType = commonpb.MsgType_DropCollectionFunction + t.Base.SourceID = paramtable.GetNodeID() + return nil +} + +func (t *dropCollectionFunctionTask) Name() string { + return DropCollectionFunctionTask +} + +func (t *dropCollectionFunctionTask) PreExecute(ctx context.Context) error { + coll, err := getCollectionInfo(ctx, t.GetDbName(), t.GetCollectionName()) + if err != nil { + log.Ctx(t.ctx).Error("DropFunctionTask, get collection info failed", + zap.String("dbName", t.GetDbName()), + zap.String("collectionName", t.GetCollectionName()), + zap.Error(err)) + return err + } + + for _, f := range coll.schema.Functions { + if f.Name == t.FunctionName { + t.fSchema = f + break + } + } + return nil +} + +func (t *dropCollectionFunctionTask) Execute(ctx context.Context) error { + if t.fSchema == nil { + return nil + } + + if t.fSchema.Type == schemapb.FunctionType_BM25 { + return fmt.Errorf("Currently does not support droping BM25 function") + } + + var err error + t.result, err = t.mixCoord.DropCollectionFunction(ctx, t.DropCollectionFunctionRequest) + if err = merr.CheckRPCCall(t.result, err); err != nil { + return err + } + return nil +} + +func (t *dropCollectionFunctionTask) PostExecute(ctx context.Context) error { + return nil +} + +func getCollectionInfo(ctx context.Context, dbName string, collectionName string) (*collectionInfo, error) { + collID, err := globalMetaCache.GetCollectionID(ctx, dbName, collectionName) + if err != nil { + return nil, err + } + coll, err := globalMetaCache.GetCollectionInfo(ctx, dbName, collectionName, collID) + if err != nil { + return nil, err + } + return coll, nil +} diff --git a/internal/proxy/function_task_test.go b/internal/proxy/function_task_test.go new file mode 100644 index 0000000000..f1fd6c0e5e --- /dev/null +++ b/internal/proxy/function_task_test.go @@ -0,0 +1,750 @@ +// 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" + "fmt" + "testing" + + "github.com/bytedance/mockey" + "github.com/stretchr/testify/mock" + "github.com/stretchr/testify/suite" + + "github.com/milvus-io/milvus-proto/go-api/v2/commonpb" + "github.com/milvus-io/milvus-proto/go-api/v2/milvuspb" + "github.com/milvus-io/milvus-proto/go-api/v2/schemapb" + "github.com/milvus-io/milvus/internal/mocks" +) + +type FunctionTaskSuite struct { + suite.Suite +} + +func TestFunctionTask(t *testing.T) { + suite.Run(t, new(FunctionTaskSuite)) +} + +func (f *FunctionTaskSuite) TestFunctionOnType() { + { + task := &addCollectionFunctionTask{ + AddCollectionFunctionRequest: &milvuspb.AddCollectionFunctionRequest{}, + } + err := task.OnEnqueue() + f.NoError(err) + f.Equal(commonpb.MsgType_AddCollectionFunction, task.Type()) + f.Equal(task.TraceCtx(), task.ctx) + task.SetID(1) + f.Equal(task.ID(), int64(1)) + task.SetTs(2) + f.Equal(task.EndTs(), uint64(2)) + f.Equal(task.Name(), AddCollectionFunctionTask) + } + { + task := &dropCollectionFunctionTask{ + DropCollectionFunctionRequest: &milvuspb.DropCollectionFunctionRequest{}, + } + err := task.OnEnqueue() + f.NoError(err) + f.Equal(commonpb.MsgType_DropCollectionFunction, task.Type()) + f.Equal(task.TraceCtx(), task.ctx) + task.SetID(1) + f.Equal(task.ID(), int64(1)) + task.SetTs(2) + f.Equal(task.EndTs(), uint64(2)) + f.Equal(task.Name(), DropCollectionFunctionTask) + } + { + task := &alterCollectionFunctionTask{ + AlterCollectionFunctionRequest: &milvuspb.AlterCollectionFunctionRequest{}, + } + err := task.OnEnqueue() + f.NoError(err) + f.Equal(commonpb.MsgType_AlterCollectionFunction, task.Type()) + f.Equal(task.TraceCtx(), task.ctx) + task.SetID(1) + f.Equal(task.ID(), int64(1)) + task.SetTs(2) + f.Equal(task.EndTs(), uint64(2)) + f.Equal(task.Name(), AlterCollectionFunctionTask) + } +} + +func (f *FunctionTaskSuite) TestAddCollectionFunctionTaskPreExecute() { + ctx := context.Background() + { + mixc := mocks.NewMockMixCoordClient(f.T()) + req := &milvuspb.AddCollectionFunctionRequest{ + Base: &commonpb.MsgBase{ + MsgType: commonpb.MsgType_AddCollectionFunction, + }, + DbName: "db", + CollectionName: "NotExist", + CollectionID: 1, + FunctionSchema: &schemapb.FunctionSchema{}, + } + + task := &addCollectionFunctionTask{ + Condition: NewTaskCondition(ctx), + AddCollectionFunctionRequest: req, + mixCoord: mixc, + } + cache := NewMockCache(f.T()) + cache.EXPECT().GetCollectionID(ctx, req.DbName, req.CollectionName).Return(0, fmt.Errorf("Mock Error")).Maybe() + globalMetaCache = cache + + err := task.PreExecute(ctx) + f.ErrorContains(err, "Mock Error") + } + { + // Test with invalid function schema + mixc := mocks.NewMockMixCoordClient(f.T()) + req := &milvuspb.AddCollectionFunctionRequest{ + Base: &commonpb.MsgBase{ + MsgType: commonpb.MsgType_AddCollectionFunction, + }, + CollectionName: "test_collection", + CollectionID: 1, + FunctionSchema: &schemapb.FunctionSchema{}, + } + + task := &addCollectionFunctionTask{ + Condition: NewTaskCondition(ctx), + AddCollectionFunctionRequest: req, + mixCoord: mixc, + } + + cache := NewMockCache(f.T()) + cache.EXPECT().GetCollectionID(ctx, req.DbName, req.CollectionName).Return(int64(1), nil).Maybe() + cache.EXPECT().GetCollectionInfo(ctx, req.DbName, req.CollectionName, int64(1)).Return(nil, fmt.Errorf("Mock info error")).Maybe() + globalMetaCache = cache + + err := task.PreExecute(ctx) + f.ErrorContains(err, "Mock info error") + } + + { + // Test with valid request + functionSchema := &schemapb.FunctionSchema{ + Name: "test_function", + Type: schemapb.FunctionType_BM25, + InputFieldNames: []string{"text_field"}, + OutputFieldNames: []string{"sparse_field"}, + Params: []*commonpb.KeyValuePair{}, + } + + req := &milvuspb.AddCollectionFunctionRequest{ + Base: &commonpb.MsgBase{ + MsgType: commonpb.MsgType_AddCollectionFunction, + }, + CollectionName: "test_collection", + CollectionID: 1, + FunctionSchema: functionSchema, + } + + task := &addCollectionFunctionTask{ + Condition: NewTaskCondition(ctx), + AddCollectionFunctionRequest: req, + } + cache := NewMockCache(f.T()) + cache.EXPECT().GetCollectionID(ctx, req.DbName, req.CollectionName).Return(int64(1), nil).Maybe() + cache.EXPECT().GetCollectionInfo(ctx, req.DbName, req.CollectionName, int64(1)).Return(nil, nil).Maybe() + globalMetaCache = cache + err := task.PreExecute(ctx) + f.ErrorContains(err, "not support adding BM25") + } + { + functionSchema := &schemapb.FunctionSchema{ + Name: "test_function", + Type: schemapb.FunctionType_TextEmbedding, + InputFieldNames: []string{"text"}, + OutputFieldNames: []string{"vec"}, + Params: []*commonpb.KeyValuePair{}, + } + + req := &milvuspb.AddCollectionFunctionRequest{ + Base: &commonpb.MsgBase{ + MsgType: commonpb.MsgType_AddCollectionFunction, + }, + CollectionName: "test_collection", + CollectionID: 1, + FunctionSchema: functionSchema, + } + + task := &addCollectionFunctionTask{ + Condition: NewTaskCondition(ctx), + AddCollectionFunctionRequest: req, + } + coll := &collectionInfo{ + schema: &schemaInfo{ + CollectionSchema: &schemapb.CollectionSchema{ + Functions: []*schemapb.FunctionSchema{}, + }, + }, + } + cache := NewMockCache(f.T()) + cache.EXPECT().GetCollectionID(ctx, req.DbName, req.CollectionName).Return(int64(1), nil).Maybe() + cache.EXPECT().GetCollectionInfo(ctx, req.DbName, req.CollectionName, int64(1)).Return(coll, nil).Maybe() + m := mockey.Mock(validateFunction).Return(nil).Build() + defer m.UnPatch() + globalMetaCache = cache + err := task.PreExecute(ctx) + f.NoError(err) + } +} + +func (f *FunctionTaskSuite) TestAlterCollectionFunctionTaskPreExecute() { + ctx := context.Background() + + { + mixc := mocks.NewMockMixCoordClient(f.T()) + req := &milvuspb.AlterCollectionFunctionRequest{ + Base: &commonpb.MsgBase{ + MsgType: commonpb.MsgType_AlterCollectionFunction, + }, + DbName: "db", + CollectionName: "NotExist", + FunctionName: "test", + CollectionID: 1, + FunctionSchema: &schemapb.FunctionSchema{Name: "test"}, + } + + task := &alterCollectionFunctionTask{ + Condition: NewTaskCondition(ctx), + AlterCollectionFunctionRequest: req, + mixCoord: mixc, + } + cache := NewMockCache(f.T()) + cache.EXPECT().GetCollectionID(ctx, req.DbName, req.CollectionName).Return(0, fmt.Errorf("Mock Error")).Maybe() + globalMetaCache = cache + + err := task.PreExecute(ctx) + f.ErrorContains(err, "Mock Error") + } + { + // Test with invalid function schema + mixc := mocks.NewMockMixCoordClient(f.T()) + req := &milvuspb.AlterCollectionFunctionRequest{ + Base: &commonpb.MsgBase{ + MsgType: commonpb.MsgType_AlterCollectionFunction, + }, + CollectionName: "test_collection", + CollectionID: 1, + FunctionName: "test", + FunctionSchema: &schemapb.FunctionSchema{Name: "test"}, + } + + task := &alterCollectionFunctionTask{ + Condition: NewTaskCondition(ctx), + AlterCollectionFunctionRequest: req, + mixCoord: mixc, + } + + cache := NewMockCache(f.T()) + cache.EXPECT().GetCollectionID(ctx, req.DbName, req.CollectionName).Return(int64(1), nil).Maybe() + cache.EXPECT().GetCollectionInfo(ctx, req.DbName, req.CollectionName, int64(1)).Return(nil, fmt.Errorf("Mock info error")).Maybe() + globalMetaCache = cache + + err := task.PreExecute(ctx) + f.ErrorContains(err, "Mock info error") + } + { + functionSchema := &schemapb.FunctionSchema{ + Name: "test_function", + Type: schemapb.FunctionType_BM25, + InputFieldNames: []string{"text_field"}, + OutputFieldNames: []string{"sparse_field"}, + Params: []*commonpb.KeyValuePair{}, + } + + req := &milvuspb.AlterCollectionFunctionRequest{ + Base: &commonpb.MsgBase{ + MsgType: commonpb.MsgType_AlterCollectionFunction, + }, + CollectionName: "test_collection", + CollectionID: 1, + FunctionName: "test_function", + FunctionSchema: functionSchema, + } + + task := &alterCollectionFunctionTask{ + Condition: NewTaskCondition(ctx), + AlterCollectionFunctionRequest: req, + } + cache := NewMockCache(f.T()) + cache.EXPECT().GetCollectionID(ctx, req.DbName, req.CollectionName).Return(int64(1), nil).Maybe() + cache.EXPECT().GetCollectionInfo(ctx, req.DbName, req.CollectionName, int64(1)).Return(nil, nil).Maybe() + globalMetaCache = cache + err := task.PreExecute(ctx) + f.ErrorContains(err, "not support alter BM25") + } + { + functionSchema := &schemapb.FunctionSchema{ + Name: "test_function", + Type: schemapb.FunctionType_TextEmbedding, + InputFieldNames: []string{"text_field"}, + OutputFieldNames: []string{"vector_field"}, + Params: []*commonpb.KeyValuePair{}, + } + + req := &milvuspb.AlterCollectionFunctionRequest{ + Base: &commonpb.MsgBase{ + MsgType: commonpb.MsgType_AlterCollectionFunction, + }, + CollectionName: "test_collection", + CollectionID: 1, + FunctionName: "test_function", + FunctionSchema: functionSchema, + } + + task := &alterCollectionFunctionTask{ + Condition: NewTaskCondition(ctx), + AlterCollectionFunctionRequest: req, + } + cache := NewMockCache(f.T()) + cache.EXPECT().GetCollectionID(ctx, req.DbName, req.CollectionName).Return(int64(1), nil).Maybe() + coll := &collectionInfo{ + schema: &schemaInfo{ + CollectionSchema: &schemapb.CollectionSchema{ + Functions: []*schemapb.FunctionSchema{ + {Name: req.FunctionName, Type: schemapb.FunctionType_BM25}, + }, + }, + }, + } + + cache.EXPECT().GetCollectionInfo(ctx, req.DbName, req.CollectionName, int64(1)).Return(coll, nil).Maybe() + globalMetaCache = cache + err := task.PreExecute(ctx) + f.ErrorContains(err, "not support alter BM25") + } + { + functionSchema := &schemapb.FunctionSchema{ + Name: "test_function", + Type: schemapb.FunctionType_TextEmbedding, + InputFieldNames: []string{"text_field"}, + OutputFieldNames: []string{"dense_field"}, + Params: []*commonpb.KeyValuePair{}, + } + + req := &milvuspb.AlterCollectionFunctionRequest{ + Base: &commonpb.MsgBase{ + MsgType: commonpb.MsgType_AlterCollectionFunction, + }, + CollectionName: "test_collection", + CollectionID: 1, + FunctionName: "NotEqual", + FunctionSchema: functionSchema, + } + + task := &alterCollectionFunctionTask{ + Condition: NewTaskCondition(ctx), + AlterCollectionFunctionRequest: req, + } + cache := NewMockCache(f.T()) + cache.EXPECT().GetCollectionID(ctx, req.DbName, req.CollectionName).Return(int64(1), nil).Maybe() + cache.EXPECT().GetCollectionInfo(ctx, req.DbName, req.CollectionName, int64(1)).Return(nil, nil).Maybe() + globalMetaCache = cache + err := task.PreExecute(ctx) + f.ErrorContains(err, "Invalid function config, name not match") + } + { + functionSchema := &schemapb.FunctionSchema{ + Name: "test_function", + Type: schemapb.FunctionType_TextEmbedding, + InputFieldNames: []string{"text"}, + OutputFieldNames: []string{"vec"}, + Params: []*commonpb.KeyValuePair{}, + } + + req := &milvuspb.AlterCollectionFunctionRequest{ + Base: &commonpb.MsgBase{ + MsgType: commonpb.MsgType_AddCollectionFunction, + }, + CollectionName: "test_collection", + CollectionID: 1, + FunctionName: "test_function", + FunctionSchema: functionSchema, + } + + task := &alterCollectionFunctionTask{ + Condition: NewTaskCondition(ctx), + AlterCollectionFunctionRequest: req, + } + coll := &collectionInfo{ + schema: &schemaInfo{ + CollectionSchema: &schemapb.CollectionSchema{ + Functions: []*schemapb.FunctionSchema{ + {Name: "test_function", Type: schemapb.FunctionType_TextEmbedding}, + {Name: "f2", Type: schemapb.FunctionType_TextEmbedding}, + }, + }, + }, + } + cache := NewMockCache(f.T()) + cache.EXPECT().GetCollectionID(ctx, req.DbName, req.CollectionName).Return(int64(1), nil).Maybe() + cache.EXPECT().GetCollectionInfo(ctx, req.DbName, req.CollectionName, int64(1)).Return(coll, nil).Maybe() + m := mockey.Mock(validateFunction).Return(nil).Build() + defer m.UnPatch() + globalMetaCache = cache + err := task.PreExecute(ctx) + f.NoError(err) + } +} + +func (f *FunctionTaskSuite) TestDropCollectionFunctionTaskPreExecute() { + ctx := context.Background() + { + // Test with valid request + req := &milvuspb.DropCollectionFunctionRequest{ + Base: &commonpb.MsgBase{ + MsgType: commonpb.MsgType_DropCollectionFunction, + }, + CollectionName: "test_collection", + FunctionName: "test_function", + } + + task := &dropCollectionFunctionTask{ + Condition: NewTaskCondition(ctx), + DropCollectionFunctionRequest: req, + } + + cache := NewMockCache(f.T()) + cache.EXPECT().GetCollectionID(ctx, req.DbName, req.CollectionName).Return(int64(1), nil).Maybe() + cache.EXPECT().GetCollectionInfo(ctx, req.DbName, req.CollectionName, int64(1)).Return(nil, fmt.Errorf("mock error")).Maybe() + globalMetaCache = cache + + err := task.PreExecute(ctx) + f.ErrorContains(err, "mock error") + } + { + req := &milvuspb.DropCollectionFunctionRequest{ + Base: &commonpb.MsgBase{ + MsgType: commonpb.MsgType_DropCollectionFunction, + }, + CollectionName: "test_collection", + FunctionName: "test_function", + } + + task := &dropCollectionFunctionTask{ + Condition: NewTaskCondition(ctx), + DropCollectionFunctionRequest: req, + } + + coll := &collectionInfo{ + schema: &schemaInfo{ + CollectionSchema: &schemapb.CollectionSchema{ + Functions: []*schemapb.FunctionSchema{}, + }, + }, + } + + cache := NewMockCache(f.T()) + cache.EXPECT().GetCollectionID(ctx, req.DbName, req.CollectionName).Return(int64(1), nil).Maybe() + cache.EXPECT().GetCollectionInfo(ctx, req.DbName, req.CollectionName, int64(1)).Return(coll, nil).Maybe() + globalMetaCache = cache + + err := task.PreExecute(ctx) + f.NoError(err) + } + { + req := &milvuspb.DropCollectionFunctionRequest{ + Base: &commonpb.MsgBase{ + MsgType: commonpb.MsgType_DropCollectionFunction, + }, + CollectionName: "test_collection", + FunctionName: "test_function", + } + + task := &dropCollectionFunctionTask{ + Condition: NewTaskCondition(ctx), + DropCollectionFunctionRequest: req, + } + + coll := &collectionInfo{ + schema: &schemaInfo{ + CollectionSchema: &schemapb.CollectionSchema{ + Functions: []*schemapb.FunctionSchema{ + {Name: req.FunctionName}, + }, + }, + }, + } + + cache := NewMockCache(f.T()) + cache.EXPECT().GetCollectionID(ctx, req.DbName, req.CollectionName).Return(int64(1), nil).Maybe() + cache.EXPECT().GetCollectionInfo(ctx, req.DbName, req.CollectionName, int64(1)).Return(coll, nil).Maybe() + globalMetaCache = cache + + err := task.PreExecute(ctx) + f.NoError(err) + } +} + +func (f *FunctionTaskSuite) TestGetCollectionInfo() { + ctx := context.Background() + { + cache := NewMockCache(f.T()) + cache.EXPECT().GetCollectionID(ctx, "db", "collection").Return(0, fmt.Errorf("Mock Error")).Maybe() + globalMetaCache = cache + + _, err := getCollectionInfo(ctx, "db", "collection") + f.ErrorContains(err, "Mock Error") + } + { + cache := NewMockCache(f.T()) + cache.EXPECT().GetCollectionID(ctx, "db", "collection").Return(int64(1), nil).Maybe() + cache.EXPECT().GetCollectionInfo(ctx, "db", "collection", int64(1)).Return(nil, fmt.Errorf("Mock info error")).Maybe() + globalMetaCache = cache + + _, err := getCollectionInfo(ctx, "db", "collection") + f.ErrorContains(err, "Mock info error") + } +} + +func (f *FunctionTaskSuite) TestAlterCollectionFunctionTaskExecute() { + ctx := context.Background() + { + mockRootCoord := mocks.NewMockMixCoordClient(f.T()) + + functionSchema := &schemapb.FunctionSchema{ + Name: "test_function", + Type: schemapb.FunctionType_BM25, + InputFieldNames: []string{"text_field"}, + OutputFieldNames: []string{"sparse_field"}, + Params: []*commonpb.KeyValuePair{}, + } + + req := &milvuspb.AlterCollectionFunctionRequest{ + Base: &commonpb.MsgBase{ + MsgType: commonpb.MsgType_AlterCollectionFunction, + }, + CollectionName: "test_collection", + CollectionID: 1, + FunctionName: "test_function", + FunctionSchema: functionSchema, + } + + mockRootCoord.EXPECT().AlterCollectionFunction(mock.Anything, req).Return(&commonpb.Status{ + ErrorCode: commonpb.ErrorCode_Success, + }, nil) + + task := &alterCollectionFunctionTask{ + Condition: NewTaskCondition(ctx), + AlterCollectionFunctionRequest: req, + mixCoord: mockRootCoord, + } + + err := task.Execute(ctx) + f.NoError(err) + } + + { + mockRootCoord := mocks.NewMockMixCoordClient(f.T()) + + functionSchema := &schemapb.FunctionSchema{ + Name: "test_function", + Type: schemapb.FunctionType_BM25, + InputFieldNames: []string{"text_field"}, + OutputFieldNames: []string{"sparse_field"}, + Params: []*commonpb.KeyValuePair{}, + } + + req := &milvuspb.AlterCollectionFunctionRequest{ + Base: &commonpb.MsgBase{ + MsgType: commonpb.MsgType_AlterCollectionFunction, + }, + CollectionName: "test_collection", + CollectionID: 1, + FunctionName: "test_function", + FunctionSchema: functionSchema, + } + + mockRootCoord.EXPECT().AlterCollectionFunction(mock.Anything, req).Return(&commonpb.Status{ + ErrorCode: commonpb.ErrorCode_UnexpectedError, + Reason: "test error", + }, nil) + + task := &alterCollectionFunctionTask{ + Condition: NewTaskCondition(ctx), + AlterCollectionFunctionRequest: req, + mixCoord: mockRootCoord, + } + err := task.Execute(ctx) + f.Error(err) + } +} + +func (f *FunctionTaskSuite) TestAddCollectionFunctionTaskExecute() { + ctx := context.Background() + + { + mockRootCoord := mocks.NewMockMixCoordClient(f.T()) + + functionSchema := &schemapb.FunctionSchema{ + Name: "test_function", + Type: schemapb.FunctionType_BM25, + InputFieldNames: []string{"text_field"}, + OutputFieldNames: []string{"sparse_field"}, + Params: []*commonpb.KeyValuePair{}, + } + + req := &milvuspb.AddCollectionFunctionRequest{ + Base: &commonpb.MsgBase{ + MsgType: commonpb.MsgType_AddCollectionFunction, + }, + CollectionName: "test_collection", + CollectionID: 1, + FunctionSchema: functionSchema, + } + + mockRootCoord.EXPECT().AddCollectionFunction(mock.Anything, req).Return(&commonpb.Status{ + ErrorCode: commonpb.ErrorCode_Success, + }, nil) + + task := &addCollectionFunctionTask{ + Condition: NewTaskCondition(ctx), + AddCollectionFunctionRequest: req, + mixCoord: mockRootCoord, + } + + err := task.Execute(ctx) + f.NoError(err) + } + + { + mockRootCoord := mocks.NewMockMixCoordClient(f.T()) + + functionSchema := &schemapb.FunctionSchema{ + Name: "test_function", + Type: schemapb.FunctionType_BM25, + InputFieldNames: []string{"text_field"}, + OutputFieldNames: []string{"sparse_field"}, + Params: []*commonpb.KeyValuePair{}, + } + + req := &milvuspb.AddCollectionFunctionRequest{ + Base: &commonpb.MsgBase{ + MsgType: commonpb.MsgType_AddCollectionFunction, + }, + CollectionName: "test_collection", + CollectionID: 1, + FunctionSchema: functionSchema, + } + + mockRootCoord.EXPECT().AddCollectionFunction(mock.Anything, req).Return(&commonpb.Status{ + ErrorCode: commonpb.ErrorCode_UnexpectedError, + Reason: "test error", + }, nil) + + task := &addCollectionFunctionTask{ + Condition: NewTaskCondition(ctx), + AddCollectionFunctionRequest: req, + mixCoord: mockRootCoord, + } + err := task.Execute(ctx) + f.Error(err) + } +} + +func (f *FunctionTaskSuite) TestDropCollectionFunctionTaskExecute() { + ctx := context.Background() + + { + mockRootCoord := mocks.NewMockMixCoordClient(f.T()) + + req := &milvuspb.DropCollectionFunctionRequest{ + Base: &commonpb.MsgBase{ + MsgType: commonpb.MsgType_DropCollectionFunction, + }, + CollectionName: "test_collection", + CollectionID: 1, + FunctionName: "test_function", + } + + mockRootCoord.EXPECT().DropCollectionFunction(mock.Anything, req).Return(&commonpb.Status{ + ErrorCode: commonpb.ErrorCode_Success, + }, nil) + + task := &dropCollectionFunctionTask{ + Condition: NewTaskCondition(ctx), + DropCollectionFunctionRequest: req, + mixCoord: mockRootCoord, + fSchema: &schemapb.FunctionSchema{ + Type: schemapb.FunctionType_TextEmbedding, + }, + } + + err := task.Execute(ctx) + f.NoError(err) + } + + { + mockRootCoord := mocks.NewMockMixCoordClient(f.T()) + + req := &milvuspb.DropCollectionFunctionRequest{ + Base: &commonpb.MsgBase{ + MsgType: commonpb.MsgType_DropCollectionFunction, + }, + CollectionName: "test_collection", + CollectionID: 1, + FunctionName: "test_function", + } + + mockRootCoord.EXPECT().DropCollectionFunction(mock.Anything, req).Return(&commonpb.Status{ + ErrorCode: commonpb.ErrorCode_UnexpectedError, + Reason: "test error", + }, nil) + + task := &dropCollectionFunctionTask{ + Condition: NewTaskCondition(ctx), + DropCollectionFunctionRequest: req, + mixCoord: mockRootCoord, + fSchema: &schemapb.FunctionSchema{ + Type: schemapb.FunctionType_TextEmbedding, + }, + } + + err := task.Execute(ctx) + f.Error(err) + } + + { + mockRootCoord := mocks.NewMockMixCoordClient(f.T()) + + req := &milvuspb.DropCollectionFunctionRequest{ + Base: &commonpb.MsgBase{ + MsgType: commonpb.MsgType_DropCollectionFunction, + }, + CollectionName: "test_collection", + CollectionID: 1, + FunctionName: "test_function", + } + + task := &dropCollectionFunctionTask{ + Condition: NewTaskCondition(ctx), + DropCollectionFunctionRequest: req, + mixCoord: mockRootCoord, + fSchema: &schemapb.FunctionSchema{ + Type: schemapb.FunctionType_BM25, + }, + } + + err := task.Execute(ctx) + f.ErrorContains(err, "Currently does not support droping BM25 function") + } +} diff --git a/internal/proxy/impl.go b/internal/proxy/impl.go index 722aa6cb7f..e065030c19 100644 --- a/internal/proxy/impl.go +++ b/internal/proxy/impl.go @@ -1168,6 +1168,169 @@ func (node *Proxy) AlterCollection(ctx context.Context, request *milvuspb.AlterC return act.result, nil } +func (node *Proxy) AddCollectionFunction(ctx context.Context, request *milvuspb.AddCollectionFunctionRequest) (*commonpb.Status, error) { + if err := merr.CheckHealthy(node.GetStateCode()); err != nil { + return merr.Status(err), nil + } + + ctx, sp := otel.Tracer(typeutil.ProxyRole).Start(ctx, "Proxy-AddCollectionFunction") + defer sp.End() + method := "AddCollectionFunction" + tr := timerecord.NewTimeRecorder(method) + task := &addCollectionFunctionTask{ + ctx: ctx, + Condition: NewTaskCondition(ctx), + AddCollectionFunctionRequest: request, + mixCoord: node.mixCoord, + } + log := log.Ctx(ctx).With( + zap.String("role", typeutil.ProxyRole), + zap.String("db", request.DbName), + zap.String("collection", request.CollectionName)) + + log.Info(rpcReceived(method)) + + if err := node.sched.ddQueue.Enqueue(task); err != nil { + log.Warn( + rpcFailedToEnqueue(method), + zap.Error(err)) + return merr.Status(err), nil + } + + log.Debug( + rpcEnqueued(method), + zap.Uint64("BeginTs", task.BeginTs()), + zap.Uint64("EndTs", task.EndTs()), + zap.Uint64("timestamp", request.Base.Timestamp)) + + if err := task.WaitToFinish(); err != nil { + log.Warn( + rpcFailedToWaitToFinish(method), + zap.Error(err), + zap.Uint64("BeginTs", task.BeginTs()), + zap.Uint64("EndTs", task.EndTs())) + + return merr.Status(err), nil + } + + log.Info( + rpcDone(method), + zap.Uint64("BeginTs", task.BeginTs()), + zap.Uint64("EndTs", task.EndTs())) + + metrics.ProxyReqLatency.WithLabelValues(strconv.FormatInt(paramtable.GetNodeID(), 10), method).Observe(float64(tr.ElapseSpan().Milliseconds())) + return task.result, nil +} + +func (node *Proxy) AlterCollectionFunction(ctx context.Context, request *milvuspb.AlterCollectionFunctionRequest) (*commonpb.Status, error) { + if err := merr.CheckHealthy(node.GetStateCode()); err != nil { + return merr.Status(err), nil + } + + ctx, sp := otel.Tracer(typeutil.ProxyRole).Start(ctx, "Proxy-AlterCollectionFunction") + defer sp.End() + method := "AlterCollectionFunction" + tr := timerecord.NewTimeRecorder(method) + task := &alterCollectionFunctionTask{ + ctx: ctx, + Condition: NewTaskCondition(ctx), + AlterCollectionFunctionRequest: request, + mixCoord: node.mixCoord, + } + log := log.Ctx(ctx).With( + zap.String("role", typeutil.ProxyRole), + zap.String("db", request.DbName), + zap.String("collection", request.CollectionName), + zap.String("collection", request.FunctionName)) + + log.Info(rpcReceived(method)) + + if err := node.sched.ddQueue.Enqueue(task); err != nil { + log.Warn( + rpcFailedToEnqueue(method), + zap.Error(err)) + return merr.Status(err), nil + } + + log.Debug( + rpcEnqueued(method), + zap.Uint64("BeginTs", task.BeginTs()), + zap.Uint64("EndTs", task.EndTs()), + zap.Uint64("timestamp", request.Base.Timestamp)) + + if err := task.WaitToFinish(); err != nil { + log.Warn( + rpcFailedToWaitToFinish(method), + zap.Error(err), + zap.Uint64("BeginTs", task.BeginTs()), + zap.Uint64("EndTs", task.EndTs())) + + return merr.Status(err), nil + } + + log.Info( + rpcDone(method), + zap.Uint64("BeginTs", task.BeginTs()), + zap.Uint64("EndTs", task.EndTs())) + + metrics.ProxyReqLatency.WithLabelValues(strconv.FormatInt(paramtable.GetNodeID(), 10), method).Observe(float64(tr.ElapseSpan().Milliseconds())) + return task.result, nil +} + +func (node *Proxy) DropCollectionFunction(ctx context.Context, request *milvuspb.DropCollectionFunctionRequest) (*commonpb.Status, error) { + if err := merr.CheckHealthy(node.GetStateCode()); err != nil { + return merr.Status(err), nil + } + + ctx, sp := otel.Tracer(typeutil.ProxyRole).Start(ctx, "Proxy-DropCollectionFunction") + defer sp.End() + method := "DropCollectionFunction" + tr := timerecord.NewTimeRecorder(method) + task := &dropCollectionFunctionTask{ + ctx: ctx, + Condition: NewTaskCondition(ctx), + DropCollectionFunctionRequest: request, + mixCoord: node.mixCoord, + } + log := log.Ctx(ctx).With( + zap.String("role", typeutil.ProxyRole), + zap.String("db", request.DbName), + zap.String("collection", request.CollectionName)) + + log.Info(rpcReceived(method)) + + if err := node.sched.ddQueue.Enqueue(task); err != nil { + log.Warn( + rpcFailedToEnqueue(method), + zap.Error(err)) + return merr.Status(err), nil + } + + log.Debug( + rpcEnqueued(method), + zap.Uint64("BeginTs", task.BeginTs()), + zap.Uint64("EndTs", task.EndTs()), + zap.Uint64("timestamp", request.Base.Timestamp)) + + if err := task.WaitToFinish(); err != nil { + log.Warn( + rpcFailedToWaitToFinish(method), + zap.Error(err), + zap.Uint64("BeginTs", task.BeginTs()), + zap.Uint64("EndTs", task.EndTs())) + + return merr.Status(err), nil + } + + log.Info( + rpcDone(method), + zap.Uint64("BeginTs", task.BeginTs()), + zap.Uint64("EndTs", task.EndTs())) + + metrics.ProxyReqLatency.WithLabelValues(strconv.FormatInt(paramtable.GetNodeID(), 10), method).Observe(float64(tr.ElapseSpan().Milliseconds())) + return task.result, nil +} + func (node *Proxy) AlterCollectionField(ctx context.Context, request *milvuspb.AlterCollectionFieldRequest) (*commonpb.Status, error) { if err := merr.CheckHealthy(node.GetStateCode()); err != nil { return merr.Status(err), nil diff --git a/internal/proxy/impl_test.go b/internal/proxy/impl_test.go index 7418921625..af0f7e4d5e 100644 --- a/internal/proxy/impl_test.go +++ b/internal/proxy/impl_test.go @@ -226,6 +226,84 @@ func TestProxyRenameCollection(t *testing.T) { }) } +func TestProxyFunctionEdit(t *testing.T) { + mockey.PatchConvey("TestProxy_AddFunction", t, func() { + m1 := mockey.Mock((*ddTaskQueue).Enqueue).To(func(t task) error { + return nil + }).Build() + m2 := mockey.Mock((*TaskCondition).WaitToFinish).Return(nil).Build() + defer m1.UnPatch() + defer m2.UnPatch() + node := createTestProxy() + defer node.sched.Close() + + _, err := node.AddCollectionFunction(context.Background(), &milvuspb.AddCollectionFunctionRequest{ + Base: &commonpb.MsgBase{ + MsgType: commonpb.MsgType_AddCollectionFunction, + }, + CollectionName: "test_collection", + CollectionID: 1, + FunctionSchema: &schemapb.FunctionSchema{ + Name: "test_function", + Type: schemapb.FunctionType_TextEmbedding, + InputFieldNames: []string{}, + OutputFieldNames: []string{}, + Params: []*commonpb.KeyValuePair{}, + }, + }) + assert.NoError(t, err) + }) + + mockey.PatchConvey("TestProxy_DropFunction", t, func() { + m1 := mockey.Mock((*ddTaskQueue).Enqueue).To(func(t task) error { + return nil + }).Build() + m2 := mockey.Mock((*TaskCondition).WaitToFinish).Return(nil).Build() + defer m1.UnPatch() + defer m2.UnPatch() + node := createTestProxy() + defer node.sched.Close() + + _, err := node.DropCollectionFunction(context.Background(), &milvuspb.DropCollectionFunctionRequest{ + Base: &commonpb.MsgBase{ + MsgType: commonpb.MsgType_AddCollectionFunction, + }, + CollectionName: "test_collection", + CollectionID: 1, + FunctionName: "test", + }) + assert.NoError(t, err) + }) + + mockey.PatchConvey("TestProxy_AlterFunction", t, func() { + m1 := mockey.Mock((*ddTaskQueue).Enqueue).To(func(t task) error { + return nil + }).Build() + m2 := mockey.Mock((*TaskCondition).WaitToFinish).Return(nil).Build() + defer m1.UnPatch() + defer m2.UnPatch() + node := createTestProxy() + defer node.sched.Close() + + _, err := node.AlterCollectionFunction(context.Background(), &milvuspb.AlterCollectionFunctionRequest{ + Base: &commonpb.MsgBase{ + MsgType: commonpb.MsgType_AddCollectionFunction, + }, + CollectionName: "test_collection", + CollectionID: 1, + FunctionName: "test", + FunctionSchema: &schemapb.FunctionSchema{ + Name: "test_function", + Type: schemapb.FunctionType_TextEmbedding, + InputFieldNames: []string{}, + OutputFieldNames: []string{}, + Params: []*commonpb.KeyValuePair{}, + }, + }) + assert.NoError(t, err) + }) +} + func TestProxy_ResourceGroup(t *testing.T) { factory := dependency.NewDefaultFactory(true) ctx := context.Background() diff --git a/internal/proxy/rootcoord_mock_test.go b/internal/proxy/rootcoord_mock_test.go index 11f6422b1d..19fba6357e 100644 --- a/internal/proxy/rootcoord_mock_test.go +++ b/internal/proxy/rootcoord_mock_test.go @@ -1168,6 +1168,18 @@ func (coord *MixCoordMock) AlterCollectionField(ctx context.Context, request *mi return &commonpb.Status{}, nil } +func (coord *MixCoordMock) AddCollectionFunction(ctx context.Context, request *milvuspb.AddCollectionFunctionRequest, opts ...grpc.CallOption) (*commonpb.Status, error) { + return &commonpb.Status{}, nil +} + +func (coord *MixCoordMock) AlterCollectionFunction(ctx context.Context, request *milvuspb.AlterCollectionFunctionRequest, opts ...grpc.CallOption) (*commonpb.Status, error) { + return &commonpb.Status{}, nil +} + +func (coord *MixCoordMock) DropCollectionFunction(ctx context.Context, request *milvuspb.DropCollectionFunctionRequest, opts ...grpc.CallOption) (*commonpb.Status, error) { + return &commonpb.Status{}, nil +} + func (coord *MixCoordMock) CreateDatabase(ctx context.Context, in *milvuspb.CreateDatabaseRequest, opts ...grpc.CallOption) (*commonpb.Status, error) { return &commonpb.Status{}, nil } diff --git a/internal/proxy/task.go b/internal/proxy/task.go index c155d3e1d5..847ec12a75 100644 --- a/internal/proxy/task.go +++ b/internal/proxy/task.go @@ -104,6 +104,9 @@ const ( ListAliasesTaskName = "ListAliasesTask" AlterCollectionTaskName = "AlterCollectionTask" AlterCollectionFieldTaskName = "AlterCollectionFieldTask" + AddCollectionFunctionTask = "AddCollectionFunctionTask" + AlterCollectionFunctionTask = "AlterCollectionFunctionTask" + DropCollectionFunctionTask = "DropCollectionFunctionTask" UpsertTaskName = "UpsertTask" CreateResourceGroupTaskName = "CreateResourceGroupTask" UpdateResourceGroupsTaskName = "UpdateResourceGroupsTask" diff --git a/internal/rootcoord/ddl_callbacks_collection_function.go b/internal/rootcoord/ddl_callbacks_collection_function.go new file mode 100644 index 0000000000..397c622fa9 --- /dev/null +++ b/internal/rootcoord/ddl_callbacks_collection_function.go @@ -0,0 +1,275 @@ +// 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 rootcoord + +import ( + "context" + "fmt" + + "go.uber.org/zap" + "google.golang.org/protobuf/types/known/fieldmaskpb" + + "github.com/milvus-io/milvus-proto/go-api/v2/milvuspb" + "github.com/milvus-io/milvus-proto/go-api/v2/schemapb" + "github.com/milvus-io/milvus/internal/distributed/streaming" + "github.com/milvus-io/milvus/internal/metastore/model" + "github.com/milvus-io/milvus/internal/streamingcoord/server/broadcaster" + "github.com/milvus-io/milvus/pkg/v2/log" + "github.com/milvus-io/milvus/pkg/v2/proto/messagespb" + "github.com/milvus-io/milvus/pkg/v2/streaming/util/message" + "github.com/milvus-io/milvus/pkg/v2/util/merr" + "github.com/milvus-io/milvus/pkg/v2/util/typeutil" +) + +func callAlterCollection(ctx context.Context, c *Core, broadcaster broadcaster.BroadcastAPI, coll *model.Collection, dbName string, collectionName string) error { + // build new collection schema. + schema := &schemapb.CollectionSchema{ + Name: coll.Name, + Description: coll.Description, + AutoID: coll.AutoID, + Fields: model.MarshalFieldModels(coll.Fields), + StructArrayFields: model.MarshalStructArrayFieldModels(coll.StructArrayFields), + Functions: model.MarshalFunctionModels(coll.Functions), + EnableDynamicField: coll.EnableDynamicField, + Properties: coll.Properties, + Version: coll.SchemaVersion + 1, + } + + cacheExpirations, err := c.getCacheExpireForCollection(ctx, dbName, collectionName) + if err != nil { + return err + } + + header := &messagespb.AlterCollectionMessageHeader{ + DbId: coll.DBID, + CollectionId: coll.CollectionID, + UpdateMask: &fieldmaskpb.FieldMask{ + Paths: []string{message.FieldMaskCollectionSchema}, + }, + CacheExpirations: cacheExpirations, + } + body := &messagespb.AlterCollectionMessageBody{ + Updates: &messagespb.AlterCollectionMessageUpdates{ + Schema: schema, + }, + } + + channels := make([]string, 0, len(coll.VirtualChannelNames)+1) + channels = append(channels, streaming.WAL().ControlChannel()) + channels = append(channels, coll.VirtualChannelNames...) + msg := message.NewAlterCollectionMessageBuilderV2(). + WithHeader(header). + WithBody(body). + WithBroadcast(channels). + MustBuildBroadcast() + if _, err := broadcaster.Broadcast(ctx, msg); err != nil { + return err + } + return nil +} + +func alterFunctionGenNewCollection(ctx context.Context, fSchema *schemapb.FunctionSchema, collection *model.Collection) error { + if fSchema == nil { + return fmt.Errorf("Function schema is empty") + } + var oldFuncSchema *model.Function + newFuncs := []*model.Function{} + for _, f := range collection.Functions { + if f.Name == fSchema.Name { + oldFuncSchema = f + } else { + newFuncs = append(newFuncs, f) + } + } + if oldFuncSchema == nil { + err := fmt.Errorf("Function %s not exists", fSchema.Name) + log.Ctx(ctx).Error("Alter function failed:", zap.Error(err)) + return err + } + + fSchema.Id = oldFuncSchema.ID + + fieldMapping := map[string]*model.Field{} + for _, field := range collection.Fields { + fieldMapping[field.Name] = field + } + + // reset output field info + for _, name := range oldFuncSchema.OutputFieldNames { + field, exists := fieldMapping[name] + if !exists { + return fmt.Errorf("Old version function's output field %s not exists", name) + } + field.IsFunctionOutput = false + } + + for _, name := range fSchema.InputFieldNames { + field, exists := fieldMapping[name] + if !exists { + err := fmt.Errorf("function's input field %s not exists", name) + log.Ctx(ctx).Error("Incorrect function configuration:", zap.Error(err)) + return err + } + fSchema.InputFieldIds = append(fSchema.InputFieldIds, field.FieldID) + } + for _, name := range fSchema.OutputFieldNames { + field, exists := fieldMapping[name] + if !exists { + err := fmt.Errorf("function's output field %s not exists", name) + log.Ctx(ctx).Error("Incorrect function configuration:", zap.Error(err)) + return err + } + if field.IsFunctionOutput { + err := fmt.Errorf("function's output field %s is already of other functions", name) + log.Ctx(ctx).Error("Incorrect function configuration: ", zap.Error(err)) + return err + } + fSchema.OutputFieldIds = append(fSchema.OutputFieldIds, field.FieldID) + field.IsFunctionOutput = true + } + newFunc := model.UnmarshalFunctionModel(fSchema) + newFuncs = append(newFuncs, newFunc) + collection.Functions = newFuncs + return nil +} + +func (c *Core) broadcastAlterCollectionForAlterFunction(ctx context.Context, req *milvuspb.AlterCollectionFunctionRequest) error { + broadcaster, err := c.startBroadcastWithAliasOrCollectionLock(ctx, req.GetDbName(), req.GetCollectionName()) + if err != nil { + return err + } + defer broadcaster.Close() + + oldColl, err := c.meta.GetCollectionByName(ctx, req.GetDbName(), req.GetCollectionName(), typeutil.MaxTimestamp) + if err != nil { + return err + } + + newColl := oldColl.Clone() + if err := alterFunctionGenNewCollection(ctx, req.FunctionSchema, newColl); err != nil { + return err + } + + return callAlterCollection(ctx, c, broadcaster, newColl, req.GetDbName(), req.GetCollectionName()) +} + +func (c *Core) broadcastAlterCollectionForDropFunction(ctx context.Context, req *milvuspb.DropCollectionFunctionRequest) error { + broadcaster, err := c.startBroadcastWithAliasOrCollectionLock(ctx, req.GetDbName(), req.GetCollectionName()) + if err != nil { + return err + } + defer broadcaster.Close() + + oldColl, err := c.meta.GetCollectionByName(ctx, req.GetDbName(), req.GetCollectionName(), typeutil.MaxTimestamp) + if err != nil { + return err + } + + var needDelFunc *model.Function + for _, f := range oldColl.Functions { + if f.Name == req.FunctionName { + needDelFunc = f + break + } + } + if needDelFunc == nil { + return nil + } + + newColl := oldColl.Clone() + + newFuncs := []*model.Function{} + for _, f := range newColl.Functions { + if f.Name != needDelFunc.Name { + newFuncs = append(newFuncs, f) + } + } + newColl.Functions = newFuncs + + fieldMapping := map[int64]*model.Field{} + for _, field := range newColl.Fields { + fieldMapping[field.FieldID] = field + } + for _, id := range needDelFunc.OutputFieldIDs { + field, exists := fieldMapping[id] + if !exists { + return fmt.Errorf("function's output field %d not exists", id) + } + field.IsFunctionOutput = false + } + return callAlterCollection(ctx, c, broadcaster, newColl, req.GetDbName(), req.GetCollectionName()) +} + +func (c *Core) broadcastAlterCollectionForAddFunction(ctx context.Context, req *milvuspb.AddCollectionFunctionRequest) error { + broadcaster, err := c.startBroadcastWithAliasOrCollectionLock(ctx, req.GetDbName(), req.GetCollectionName()) + if err != nil { + return err + } + defer broadcaster.Close() + + oldColl, err := c.meta.GetCollectionByName(ctx, req.GetDbName(), req.GetCollectionName(), typeutil.MaxTimestamp) + if err != nil { + return err + } + + newColl := oldColl.Clone() + fSchema := req.FunctionSchema + if fSchema == nil { + return merr.WrapErrParameterInvalidMsg("Function schema is empty") + } + + nextFunctionID := int64(StartOfUserFunctionID) + for _, f := range newColl.Functions { + if f.Name == fSchema.Name { + return merr.WrapErrParameterInvalidMsg("function name already exists: %s", f.Name) + } + nextFunctionID = max(nextFunctionID, f.ID+1) + } + fSchema.Id = nextFunctionID + + fieldMapping := map[string]*model.Field{} + for _, field := range newColl.Fields { + fieldMapping[field.Name] = field + } + for _, name := range fSchema.InputFieldNames { + field, exists := fieldMapping[name] + if !exists { + err := fmt.Errorf("function's input field %s not exists", name) + log.Ctx(ctx).Error("Incorrect function configuration:", zap.Error(err)) + return err + } + fSchema.InputFieldIds = append(fSchema.InputFieldIds, field.FieldID) + } + for _, name := range fSchema.OutputFieldNames { + field, exists := fieldMapping[name] + if !exists { + err := fmt.Errorf("function's output field %s not exists", name) + log.Ctx(ctx).Error("Incorrect function configuration:", zap.Error(err)) + return err + } + if field.IsFunctionOutput { + err := fmt.Errorf("function's output field %s is already of other functions", name) + log.Ctx(ctx).Error("Incorrect function configuration: ", zap.Error(err)) + return err + } + fSchema.OutputFieldIds = append(fSchema.OutputFieldIds, field.FieldID) + field.IsFunctionOutput = true + } + newFunc := model.UnmarshalFunctionModel(fSchema) + newColl.Functions = append(newColl.Functions, newFunc) + return callAlterCollection(ctx, c, broadcaster, newColl, req.GetDbName(), req.GetCollectionName()) +} diff --git a/internal/rootcoord/ddl_callbacks_collection_function_test.go b/internal/rootcoord/ddl_callbacks_collection_function_test.go new file mode 100644 index 0000000000..92c04454f8 --- /dev/null +++ b/internal/rootcoord/ddl_callbacks_collection_function_test.go @@ -0,0 +1,596 @@ +// 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 rootcoord + +import ( + "context" + "testing" + + "github.com/bytedance/mockey" + "github.com/cockroachdb/errors" + "github.com/stretchr/testify/mock" + "github.com/stretchr/testify/suite" + + "github.com/milvus-io/milvus-proto/go-api/v2/commonpb" + "github.com/milvus-io/milvus-proto/go-api/v2/milvuspb" + "github.com/milvus-io/milvus-proto/go-api/v2/schemapb" + "github.com/milvus-io/milvus/internal/metastore/model" + "github.com/milvus-io/milvus/internal/mocks/streamingcoord/server/mock_broadcaster" + mockrootcoord "github.com/milvus-io/milvus/internal/rootcoord/mocks" + "github.com/milvus-io/milvus/pkg/v2/streaming/util/message" + "github.com/milvus-io/milvus/pkg/v2/streaming/util/types" + "github.com/milvus-io/milvus/pkg/v2/util/typeutil" +) + +type DDLCallbacksCollectionFunctionTestSuite struct { + suite.Suite + core *Core + mockBroadcaster *mock_broadcaster.MockBroadcastAPI +} + +func (suite *DDLCallbacksCollectionFunctionTestSuite) SetupTest() { + suite.core = initStreamingSystemAndCore(suite.T()) + suite.mockBroadcaster = mock_broadcaster.NewMockBroadcastAPI(suite.T()) +} + +func (suite *DDLCallbacksCollectionFunctionTestSuite) TearDownTest() { + suite.mockBroadcaster = nil + suite.core.Stop() + suite.core = nil +} + +// Helper function to create a test collection +func (suite *DDLCallbacksCollectionFunctionTestSuite) createTestCollection() *model.Collection { + return &model.Collection{ + DBID: 1, + CollectionID: 100, + Name: "test_collection", + Description: "test collection", + AutoID: true, + Fields: []*model.Field{ + { + FieldID: 101, + Name: "id", + IsPrimaryKey: true, + AutoID: true, + DataType: schemapb.DataType_Int64, + IsFunctionOutput: false, + }, + { + FieldID: 102, + Name: "vector", + DataType: schemapb.DataType_FloatVector, + IsFunctionOutput: false, + }, + { + FieldID: 103, + Name: "text_field", + DataType: schemapb.DataType_VarChar, + IsFunctionOutput: false, + }, + { + FieldID: 104, + Name: "output_field", + DataType: schemapb.DataType_FloatVector, + IsFunctionOutput: true, + }, + }, + Functions: []*model.Function{ + { + ID: 1001, + Name: "test_function", + Type: schemapb.FunctionType_TextEmbedding, + Description: "test function", + InputFieldIDs: []int64{103}, + InputFieldNames: []string{"text_field"}, + OutputFieldIDs: []int64{104}, + OutputFieldNames: []string{"output_field"}, + Params: []*commonpb.KeyValuePair{ + {Key: "param1", Value: "value1"}, + }, + }, + }, + VirtualChannelNames: []string{"test_channel"}, + EnableDynamicField: false, + Properties: []*commonpb.KeyValuePair{{Key: "key1", Value: "value1"}}, + SchemaVersion: 1, + } +} + +// Helper function to create a test function schema +func (suite *DDLCallbacksCollectionFunctionTestSuite) createTestFunctionSchema() *schemapb.FunctionSchema { + return &schemapb.FunctionSchema{ + Name: "new_function", + Type: schemapb.FunctionType_TextEmbedding, + Description: "new test function", + InputFieldNames: []string{"text_field"}, + OutputFieldNames: []string{"vector"}, + Params: []*commonpb.KeyValuePair{ + {Key: "param1", Value: "value1"}, + }, + } +} + +func TestDDLCallbacksCollectionFunctionTestSuite(t *testing.T) { + suite.Run(t, new(DDLCallbacksCollectionFunctionTestSuite)) +} + +// Test callAlterCollection function +func (suite *DDLCallbacksCollectionFunctionTestSuite) TestCallAlterCollection_Success() { + ctx := context.Background() + coll := suite.createTestCollection() + dbName := "test_db" + collectionName := "test_collection" + + // Create a test core with proper meta setup + core := newTestCore(withHealthyCode()) + mockMeta := mockrootcoord.NewIMetaTable(suite.T()) + core.meta = mockMeta + + // Mock meta calls for getCacheExpireForCollection + mockMeta.EXPECT().GetCollectionByName(mock.Anything, dbName, collectionName, typeutil.MaxTimestamp).Return(coll, nil) + mockMeta.EXPECT().ListAliases(mock.Anything, dbName, collectionName, typeutil.MaxTimestamp).Return([]string{}, nil) + + // Mock broadcaster + suite.mockBroadcaster.EXPECT().Broadcast(mock.Anything, mock.MatchedBy(func(msg message.BroadcastMutableMessage) bool { + // Verify the message structure + return msg != nil + })).Return(&types.BroadcastAppendResult{}, nil) + + err := callAlterCollection(ctx, core, suite.mockBroadcaster, coll, dbName, collectionName) + suite.NoError(err) +} + +func (suite *DDLCallbacksCollectionFunctionTestSuite) TestCallAlterCollection_GetCacheExpireFailed() { + ctx := context.Background() + coll := suite.createTestCollection() + dbName := "test_db" + collectionName := "test_collection" + + // Create a test core with proper meta setup + core := newTestCore(withHealthyCode()) + mockMeta := mockrootcoord.NewIMetaTable(suite.T()) + core.meta = mockMeta + + // Mock meta calls to return error + mockMeta.EXPECT().GetCollectionByName(mock.Anything, dbName, collectionName, typeutil.MaxTimestamp).Return(nil, errors.New("cache expire error")) + + err := callAlterCollection(ctx, core, suite.mockBroadcaster, coll, dbName, collectionName) + suite.Error(err) + suite.Contains(err.Error(), "cache expire error") +} + +func (suite *DDLCallbacksCollectionFunctionTestSuite) TestCallAlterCollection_BroadcastFailed() { + ctx := context.Background() + coll := suite.createTestCollection() + dbName := "test_db" + collectionName := "test_collection" + + // Create a test core with proper meta setup + core := newTestCore(withHealthyCode()) + mockMeta := mockrootcoord.NewIMetaTable(suite.T()) + core.meta = mockMeta + + // Mock meta calls for getCacheExpireForCollection + mockMeta.EXPECT().GetCollectionByName(mock.Anything, dbName, collectionName, typeutil.MaxTimestamp).Return(coll, nil) + mockMeta.EXPECT().ListAliases(mock.Anything, dbName, collectionName, typeutil.MaxTimestamp).Return([]string{}, nil) + + // Mock broadcaster to return error + suite.mockBroadcaster.EXPECT().Broadcast(mock.Anything, mock.Anything).Return(nil, errors.New("broadcast error")) + + err := callAlterCollection(ctx, core, suite.mockBroadcaster, coll, dbName, collectionName) + suite.Error(err) + suite.Contains(err.Error(), "broadcast error") +} + +// Test alterFunctionGenNewCollection function +func (suite *DDLCallbacksCollectionFunctionTestSuite) TestAlterFunctionGenNewCollection_Success() { + ctx := context.Background() + coll := suite.createTestCollection() + + // Create a function schema to alter existing function + fSchema := &schemapb.FunctionSchema{ + Name: "test_function", // Same name as existing function + Type: schemapb.FunctionType_TextEmbedding, + Description: "updated test function", + InputFieldNames: []string{"text_field"}, + OutputFieldNames: []string{"vector"}, // Different output field + } + + err := alterFunctionGenNewCollection(ctx, fSchema, coll) + suite.NoError(err) + + // Verify function ID is preserved + suite.Equal(int64(1001), fSchema.Id) + + // Verify input field IDs are set + suite.Equal([]int64{103}, fSchema.InputFieldIds) + + // Verify output field IDs are set + suite.Equal([]int64{102}, fSchema.OutputFieldIds) + + // Verify old output field is no longer marked as function output + oldOutputField := coll.Fields[3] // output_field + suite.False(oldOutputField.IsFunctionOutput) + + // Verify new output field is marked as function output + newOutputField := coll.Fields[1] // vector + suite.True(newOutputField.IsFunctionOutput) + + // Verify function is added to collection + suite.Len(coll.Functions, 1) // Original + new +} + +func (suite *DDLCallbacksCollectionFunctionTestSuite) TestAlterFunctionGenNewCollection_FunctionNotExists() { + ctx := context.Background() + coll := suite.createTestCollection() + + fSchema := &schemapb.FunctionSchema{ + Name: "non_existent_function", + } + + err := alterFunctionGenNewCollection(ctx, fSchema, coll) + suite.Error(err) + suite.Contains(err.Error(), "Function non_existent_function not exists") +} + +func (suite *DDLCallbacksCollectionFunctionTestSuite) TestAlterFunctionGenNewCollection_InputFieldNotExists() { + ctx := context.Background() + coll := suite.createTestCollection() + + fSchema := &schemapb.FunctionSchema{ + Name: "test_function", + InputFieldNames: []string{"non_existent_field"}, + } + + err := alterFunctionGenNewCollection(ctx, fSchema, coll) + suite.Error(err) + suite.Contains(err.Error(), "function's input field non_existent_field not exists") +} + +func (suite *DDLCallbacksCollectionFunctionTestSuite) TestAlterFunctionGenNewCollection_OutputFieldNotExists() { + ctx := context.Background() + coll := suite.createTestCollection() + + fSchema := &schemapb.FunctionSchema{ + Name: "test_function", + InputFieldNames: []string{"text_field"}, + OutputFieldNames: []string{"non_existent_field"}, + } + + err := alterFunctionGenNewCollection(ctx, fSchema, coll) + suite.Error(err) + suite.Contains(err.Error(), "function's output field non_existent_field not exists") +} + +func (suite *DDLCallbacksCollectionFunctionTestSuite) TestBroadcastAlterCollectionForAddFunction_FunctionNameExists() { + coll := suite.createTestCollection() + + // Create request with existing function name + req := &milvuspb.AddCollectionFunctionRequest{ + DbName: "test_db", + CollectionName: "test_collection", + FunctionSchema: &schemapb.FunctionSchema{ + Name: "test_function", // Same as existing function + }, + } + + newColl := coll.Clone() + fSchema := req.FunctionSchema + + // Check for function name conflict + for _, f := range newColl.Functions { + if f.Name == fSchema.Name { + err := errors.New("function name already exists") + suite.Error(err) + return + } + } +} + +// Test broadcastAlterCollectionForDropFunction +func (suite *DDLCallbacksCollectionFunctionTestSuite) TestBroadcastAlterCollectionForDropFunction_Success() { + coll := suite.createTestCollection() + req := &milvuspb.DropCollectionFunctionRequest{ + DbName: "test_db", + CollectionName: "test_collection", + FunctionName: "test_function", + } + + // Find function to delete + var needDelFunc *model.Function + for _, f := range coll.Functions { + if f.Name == req.FunctionName { + needDelFunc = f + break + } + } + suite.NotNil(needDelFunc, "Function should exist") + + newColl := coll.Clone() + + // Remove function from collection + newFuncs := []*model.Function{} + for _, f := range newColl.Functions { + if f.Name != needDelFunc.Name { + newFuncs = append(newFuncs, f) + } + } + newColl.Functions = newFuncs + + // Reset output field flags + fieldMapping := map[int64]*model.Field{} + for _, field := range newColl.Fields { + fieldMapping[field.FieldID] = field + } + for _, id := range needDelFunc.OutputFieldIDs { + field, exists := fieldMapping[id] + suite.True(exists, "Output field should exist") + field.IsFunctionOutput = false + } + + // Verify function was removed + suite.Len(newColl.Functions, 0) + + // Verify output field is no longer marked as function output + outputField := fieldMapping[104] // output_field + suite.False(outputField.IsFunctionOutput) +} + +func (suite *DDLCallbacksCollectionFunctionTestSuite) TestBroadcastAlterCollectionForDropFunction_FunctionNotExists() { + coll := suite.createTestCollection() + req := &milvuspb.DropCollectionFunctionRequest{ + DbName: "test_db", + CollectionName: "test_collection", + FunctionName: "non_existent_function", + } + + // Find function to delete + var needDelFunc *model.Function + for _, f := range coll.Functions { + if f.Name == req.FunctionName { + needDelFunc = f + break + } + } + suite.Nil(needDelFunc, "Function should not exist") + // This should return nil (no error) as per the original implementation +} + +func (suite *DDLCallbacksCollectionFunctionTestSuite) TestBroadcastAlterCollectionForDropFunction_OutputFieldNotExists() { + coll := suite.createTestCollection() + + // Create a function with non-existent output field ID + needDelFunc := &model.Function{ + ID: 1001, + Name: "test_function", + OutputFieldIDs: []int64{999}, // Non-existent field ID + } + + newColl := coll.Clone() + fieldMapping := map[int64]*model.Field{} + for _, field := range newColl.Fields { + fieldMapping[field.FieldID] = field + } + + for _, id := range needDelFunc.OutputFieldIDs { + _, exists := fieldMapping[id] + if !exists { + err := errors.New("function's output field not exists") + suite.Error(err) + return + } + } +} + +// Test edge cases and error conditions +func (suite *DDLCallbacksCollectionFunctionTestSuite) TestAlterFunctionGenNewCollection_OldOutputFieldNotExists() { + coll := suite.createTestCollection() + + // Modify the existing function to have a non-existent output field + coll.Functions[0].OutputFieldNames = []string{"non_existent_output"} + + fSchema := &schemapb.FunctionSchema{ + Name: "test_function", + InputFieldNames: []string{"text_field"}, + OutputFieldNames: []string{"vector"}, + } + + err := alterFunctionGenNewCollection(context.Background(), fSchema, coll) + suite.Error(err) + suite.Contains(err.Error(), "Old version function's output field non_existent_output not exists") +} + +// Test with empty collections and functions +func (suite *DDLCallbacksCollectionFunctionTestSuite) TestAlterFunctionGenNewCollection_EmptyCollection() { + // Create collection with no functions + coll := &model.Collection{ + Fields: []*model.Field{}, + Functions: []*model.Function{}, + } + + fSchema := &schemapb.FunctionSchema{ + Name: "test_function", + } + + err := alterFunctionGenNewCollection(context.Background(), fSchema, coll) + suite.Error(err) + suite.Contains(err.Error(), "Function test_function not exists") +} + +// Test max function ID calculation +func (suite *DDLCallbacksCollectionFunctionTestSuite) TestAddFunction_NextFunctionIDCalculation() { + coll := suite.createTestCollection() + + // Add more functions to test max ID calculation + coll.Functions = append(coll.Functions, &model.Function{ + ID: 2000, + Name: "function2", + }) + coll.Functions = append(coll.Functions, &model.Function{ + ID: 1500, + Name: "function3", + }) + + nextFunctionID := int64(StartOfUserFunctionID) + for _, f := range coll.Functions { + nextFunctionID = max(nextFunctionID, f.ID+1) + } + + suite.Equal(int64(2001), nextFunctionID) +} + +// Test broadcastAlterCollectionForAlterFunction +func (suite *DDLCallbacksCollectionFunctionTestSuite) TestBroadcastAlterCollectionForAlterFunction() { + suite.Run("success", func() { + coll := suite.createTestCollection() + + mockMeta := mockrootcoord.NewIMetaTable(suite.T()) + mockMeta.EXPECT().GetCollectionByName(mock.Anything, "test_db", "test_collection", typeutil.MaxTimestamp).Return(coll, nil) + suite.core.meta = mockMeta + + req := &milvuspb.AlterCollectionFunctionRequest{ + DbName: "test_db", + CollectionName: "test_collection", + FunctionSchema: &schemapb.FunctionSchema{ + Name: "test_function", + Type: schemapb.FunctionType_BM25, + InputFieldNames: []string{"text_field"}, + OutputFieldNames: []string{"vector"}, + }, + } + mocker := mockey.Mock(callAlterCollection).Return(nil).Build() + defer mocker.UnPatch() + + err := suite.core.broadcastAlterCollectionForAlterFunction(context.Background(), req) + suite.NoError(err) + }) +} + +func (suite *DDLCallbacksCollectionFunctionTestSuite) TestBroadcastAlterCollectionForDropFunction() { + suite.Run("success", func() { + coll := suite.createTestCollection() + + mockMeta := mockrootcoord.NewIMetaTable(suite.T()) + mockMeta.EXPECT().GetCollectionByName(mock.Anything, "test_db", "test_collection", typeutil.MaxTimestamp).Return(coll, nil) + suite.core.meta = mockMeta + + req := &milvuspb.DropCollectionFunctionRequest{ + DbName: "test_db", + CollectionName: "test_collection", + FunctionName: "test_function", + } + + mocker := mockey.Mock(callAlterCollection).Return(nil).Build() + defer mocker.UnPatch() + + err := suite.core.broadcastAlterCollectionForDropFunction(context.Background(), req) + suite.NoError(err) + }) + + suite.Run("function not exists", func() { + req := &milvuspb.DropCollectionFunctionRequest{ + DbName: "test_db", + CollectionName: "test_collection", + FunctionName: "non_existent_function", + } + + mocker := mockey.Mock(callAlterCollection).Return(nil).Build() + defer mocker.UnPatch() + + err := suite.core.broadcastAlterCollectionForDropFunction(context.Background(), req) + suite.NoError(err) + }) +} + +func (suite *DDLCallbacksCollectionFunctionTestSuite) TestBroadcastAlterCollectionForAddFunction() { + suite.Run("function name already exists", func() { + coll := suite.createTestCollection() + + mockMeta := mockrootcoord.NewIMetaTable(suite.T()) + mockMeta.EXPECT().GetCollectionByName(mock.Anything, "test_db", "test_collection", typeutil.MaxTimestamp).Return(coll, nil) + suite.core.meta = mockMeta + + req := &milvuspb.AddCollectionFunctionRequest{ + DbName: "test_db", + CollectionName: "test_collection", + FunctionSchema: &schemapb.FunctionSchema{ + Name: "test_function", + Type: schemapb.FunctionType_TextEmbedding, + InputFieldNames: []string{"text_field"}, + OutputFieldNames: []string{"vector"}, + }, + } + + mocker := mockey.Mock(callAlterCollection).Return(nil).Build() + defer mocker.UnPatch() + + err := suite.core.broadcastAlterCollectionForAddFunction(context.Background(), req) + suite.Error(err) + }) + + suite.Run("function input field not exists", func() { + coll := suite.createTestCollection() + mockMeta := mockrootcoord.NewIMetaTable(suite.T()) + mockMeta.EXPECT().GetCollectionByName(mock.Anything, "test_db", "test_collection", typeutil.MaxTimestamp).Return(coll, nil) + suite.core.meta = mockMeta + + req := &milvuspb.AddCollectionFunctionRequest{ + DbName: "test_db", + CollectionName: "test_collection", + FunctionSchema: &schemapb.FunctionSchema{ + Name: "new_function", + Type: schemapb.FunctionType_TextEmbedding, + InputFieldNames: []string{"non_existent_field"}, + OutputFieldNames: []string{"vector"}, + }, + } + + mocker := mockey.Mock(callAlterCollection).Return(nil).Build() + defer mocker.UnPatch() + + err := suite.core.broadcastAlterCollectionForAddFunction(context.Background(), req) + suite.Error(err) + suite.Contains(err.Error(), "function's input field non_existent_field not exists") + }) + + suite.Run("function output field not exists", func() { + coll := suite.createTestCollection() + + mockMeta := mockrootcoord.NewIMetaTable(suite.T()) + mockMeta.EXPECT().GetCollectionByName(mock.Anything, "test_db", "test_collection", typeutil.MaxTimestamp).Return(coll, nil) + suite.core.meta = mockMeta + + req := &milvuspb.AddCollectionFunctionRequest{ + DbName: "test_db", + CollectionName: "test_collection", + FunctionSchema: &schemapb.FunctionSchema{ + Name: "new_function2", + Type: schemapb.FunctionType_TextEmbedding, + InputFieldNames: []string{"text_field"}, + OutputFieldNames: []string{"non_existent_field"}, + }, + } + + mocker := mockey.Mock(callAlterCollection).Return(nil).Build() + defer mocker.UnPatch() + + err := suite.core.broadcastAlterCollectionForAddFunction(context.Background(), req) + suite.Error(err) + suite.Contains(err.Error(), "function's output field non_existent_field not exists") + }) +} diff --git a/internal/rootcoord/meta_table_test.go b/internal/rootcoord/meta_table_test.go index da8d5f27ad..489455e4dc 100644 --- a/internal/rootcoord/meta_table_test.go +++ b/internal/rootcoord/meta_table_test.go @@ -797,13 +797,14 @@ func TestMetaTable_AlterCollection(t *testing.T) { mock.Anything, mock.Anything, mock.Anything, + mock.Anything, ).Return(errors.New("error")) meta := &MetaTable{ catalog: catalog, collID2Meta: map[typeutil.UniqueID]*model.Collection{}, } ctx := context.Background() - err := meta.AlterCollection(ctx, nil, nil, 0, false) + err := meta.AlterCollection(ctx, nil, nil, 0, false, false) assert.Error(t, err) }) @@ -839,6 +840,7 @@ func TestMetaTable_AlterCollection(t *testing.T) { mock.Anything, mock.Anything, mock.Anything, + mock.Anything, ).Return(nil) meta := &MetaTable{ catalog: catalog, @@ -848,7 +850,7 @@ func TestMetaTable_AlterCollection(t *testing.T) { oldColl := &model.Collection{CollectionID: 1} newColl := &model.Collection{CollectionID: 1} - err := meta.AlterCollection(ctx, oldColl, newColl, 0, false) + err := meta.AlterCollection(ctx, oldColl, newColl, 0, false, false) assert.NoError(t, err) assert.Equal(t, meta.collID2Meta[1], newColl) }) @@ -1682,6 +1684,7 @@ func TestMetaTable_RenameCollection(t *testing.T) { mock.Anything, mock.Anything, mock.Anything, + mock.Anything, ).Return(errors.New("fail")) meta := &MetaTable{ @@ -1735,6 +1738,7 @@ func TestMetaTable_RenameCollection(t *testing.T) { mock.Anything, mock.Anything, mock.Anything, + mock.Anything, ).Return(nil) catalog.On("GetCollectionByName", mock.Anything, @@ -1779,6 +1783,7 @@ func TestMetaTable_RenameCollection(t *testing.T) { mock.Anything, mock.Anything, mock.Anything, + mock.Anything, ).Return(nil) catalog.On("GetCollectionByName", mock.Anything, diff --git a/internal/rootcoord/root_coord.go b/internal/rootcoord/root_coord.go index 14db9cbf48..6e72d470b2 100644 --- a/internal/rootcoord/root_coord.go +++ b/internal/rootcoord/root_coord.go @@ -1339,6 +1339,100 @@ func (c *Core) AlterCollection(ctx context.Context, in *milvuspb.AlterCollection return merr.Success(), nil } +func (c *Core) AddCollectionFunction(ctx context.Context, in *milvuspb.AddCollectionFunctionRequest) (*commonpb.Status, error) { + if err := merr.CheckHealthy(c.GetStateCode()); err != nil { + return merr.Status(err), nil + } + + metrics.RootCoordDDLReqCounter.WithLabelValues("AddCollectionFunction", metrics.TotalLabel).Inc() + tr := timerecord.NewTimeRecorder("AddCollectionFunction") + + log := log.Ctx(ctx).With(zap.String("role", typeutil.RootCoordRole), + zap.String("dbName", in.GetDbName()), + zap.String("collectionName", in.GetCollectionName()), + ) + log.Info("received request to Add collection function") + + if err := c.broadcastAlterCollectionForAddFunction(ctx, in); err != nil { + if errors.Is(err, errIgnoredAlterCollection) { + log.Info("add collection function make no changes, ignore it") + metrics.RootCoordDDLReqCounter.WithLabelValues("AddCollectionFunction", metrics.SuccessLabel).Inc() + return merr.Success(), nil + } + log.Warn("failed to alter collection function", zap.Error(err)) + metrics.RootCoordDDLReqCounter.WithLabelValues("AddCollectionFunction", metrics.FailLabel).Inc() + return merr.Status(err), nil + } + + metrics.RootCoordDDLReqCounter.WithLabelValues("AddCollectionFunction", metrics.SuccessLabel).Inc() + metrics.RootCoordDDLReqLatency.WithLabelValues("AddCollectionFunction").Observe(float64(tr.ElapseSpan().Milliseconds())) + log.Info("done to add collection function") + return merr.Success(), nil +} + +func (c *Core) AlterCollectionFunction(ctx context.Context, in *milvuspb.AlterCollectionFunctionRequest) (*commonpb.Status, error) { + if err := merr.CheckHealthy(c.GetStateCode()); err != nil { + return merr.Status(err), nil + } + + metrics.RootCoordDDLReqCounter.WithLabelValues("AlterCollectionFunction", metrics.TotalLabel).Inc() + tr := timerecord.NewTimeRecorder("AlterCollectionFunction") + + log := log.Ctx(ctx).With(zap.String("role", typeutil.RootCoordRole), + zap.String("dbName", in.GetDbName()), + zap.String("collectionName", in.GetCollectionName()), + ) + log.Info("received request to alter collection function") + + if err := c.broadcastAlterCollectionForAlterFunction(ctx, in); err != nil { + if errors.Is(err, errIgnoredAlterCollection) { + log.Info("alter collection function make no changes, ignore it") + metrics.RootCoordDDLReqCounter.WithLabelValues("AlterCollectionFunction", metrics.SuccessLabel).Inc() + return merr.Success(), nil + } + log.Warn("failed to alter collection function", zap.Error(err)) + metrics.RootCoordDDLReqCounter.WithLabelValues("AlterCollectionFunction", metrics.FailLabel).Inc() + return merr.Status(err), nil + } + + metrics.RootCoordDDLReqCounter.WithLabelValues("AlterCollectionFunction", metrics.SuccessLabel).Inc() + metrics.RootCoordDDLReqLatency.WithLabelValues("AlterCollectionFunction").Observe(float64(tr.ElapseSpan().Milliseconds())) + log.Info("done to alter collection function") + return merr.Success(), nil +} + +func (c *Core) DropCollectionFunction(ctx context.Context, in *milvuspb.DropCollectionFunctionRequest) (*commonpb.Status, error) { + if err := merr.CheckHealthy(c.GetStateCode()); err != nil { + return merr.Status(err), nil + } + + metrics.RootCoordDDLReqCounter.WithLabelValues("DropCollectionFunction", metrics.TotalLabel).Inc() + tr := timerecord.NewTimeRecorder("DropCollectionFunction") + + log := log.Ctx(ctx).With(zap.String("role", typeutil.RootCoordRole), + zap.String("dbName", in.GetDbName()), + zap.String("collectionName", in.GetCollectionName()), + zap.String("functionName", in.GetFunctionName()), + ) + log.Info("received request to drop collection function") + + if err := c.broadcastAlterCollectionForDropFunction(ctx, in); err != nil { + if errors.Is(err, errIgnoredAlterCollection) { + log.Info("Drop collection function make no changes, ignore it") + metrics.RootCoordDDLReqCounter.WithLabelValues("DropCollectionFunction", metrics.SuccessLabel).Inc() + return merr.Success(), nil + } + log.Warn("failed to drop collection function", zap.Error(err)) + metrics.RootCoordDDLReqCounter.WithLabelValues("DropCollectionFunction", metrics.FailLabel).Inc() + return merr.Status(err), nil + } + + metrics.RootCoordDDLReqCounter.WithLabelValues("DropCollectionFunction", metrics.SuccessLabel).Inc() + metrics.RootCoordDDLReqLatency.WithLabelValues("DropCollectionFunction").Observe(float64(tr.ElapseSpan().Milliseconds())) + log.Info("done to drop collection function") + return merr.Success(), nil +} + func (c *Core) AlterCollectionField(ctx context.Context, in *milvuspb.AlterCollectionFieldRequest) (*commonpb.Status, error) { if err := merr.CheckHealthy(c.GetStateCode()); err != nil { return merr.Status(err), nil diff --git a/internal/rootcoord/root_coord_test.go b/internal/rootcoord/root_coord_test.go index a79c71564e..b83f000229 100644 --- a/internal/rootcoord/root_coord_test.go +++ b/internal/rootcoord/root_coord_test.go @@ -24,6 +24,7 @@ import ( "testing" "time" + "github.com/bytedance/mockey" "github.com/cockroachdb/errors" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/mock" @@ -1266,6 +1267,102 @@ func TestRootCoord_AlterCollection(t *testing.T) { }) } +func TestRootCoord_AddCollectionFunction(t *testing.T) { + t.Run("not healthy", func(t *testing.T) { + ctx := context.Background() + c := newTestCore(withAbnormalCode()) + resp, err := c.AddCollectionFunction(ctx, &milvuspb.AddCollectionFunctionRequest{}) + assert.NoError(t, err) + assert.NotEqual(t, commonpb.ErrorCode_Success, resp.GetErrorCode()) + }) + + t.Run("run ok", func(t *testing.T) { + ctx := context.Background() + c := initStreamingSystemAndCore(t) + defer c.Stop() + mocker := mockey.Mock((*Core).broadcastAlterCollectionForAddFunction).Return(nil).Build() + defer mocker.UnPatch() + resp, err := c.AddCollectionFunction(ctx, &milvuspb.AddCollectionFunctionRequest{}) + assert.NoError(t, err) + assert.Equal(t, commonpb.ErrorCode_Success, resp.GetErrorCode()) + }) + + t.Run("run failed", func(t *testing.T) { + ctx := context.Background() + c := initStreamingSystemAndCore(t) + defer c.Stop() + mocker := mockey.Mock((*Core).broadcastAlterCollectionForAddFunction).Return(fmt.Errorf("")).Build() + defer mocker.UnPatch() + resp, err := c.AddCollectionFunction(ctx, &milvuspb.AddCollectionFunctionRequest{}) + assert.NoError(t, err) + assert.Equal(t, commonpb.ErrorCode_UnexpectedError, resp.GetErrorCode()) + }) +} + +func TestRootCoord_DropCollectionFunction(t *testing.T) { + t.Run("not healthy", func(t *testing.T) { + ctx := context.Background() + c := newTestCore(withAbnormalCode()) + resp, err := c.DropCollectionFunction(ctx, &milvuspb.DropCollectionFunctionRequest{}) + assert.NoError(t, err) + assert.NotEqual(t, commonpb.ErrorCode_Success, resp.GetErrorCode()) + }) + + t.Run("run ok", func(t *testing.T) { + ctx := context.Background() + c := initStreamingSystemAndCore(t) + defer c.Stop() + mocker := mockey.Mock((*Core).broadcastAlterCollectionForDropFunction).Return(nil).Build() + defer mocker.UnPatch() + resp, err := c.DropCollectionFunction(ctx, &milvuspb.DropCollectionFunctionRequest{}) + assert.NoError(t, err) + assert.Equal(t, commonpb.ErrorCode_Success, resp.GetErrorCode()) + }) + + t.Run("run failed", func(t *testing.T) { + ctx := context.Background() + c := initStreamingSystemAndCore(t) + defer c.Stop() + mocker := mockey.Mock((*Core).broadcastAlterCollectionForDropFunction).Return(fmt.Errorf("")).Build() + defer mocker.UnPatch() + resp, err := c.DropCollectionFunction(ctx, &milvuspb.DropCollectionFunctionRequest{}) + assert.NoError(t, err) + assert.Equal(t, commonpb.ErrorCode_UnexpectedError, resp.GetErrorCode()) + }) +} + +func TestRootCoord_AlterCollectionFunction(t *testing.T) { + t.Run("not healthy", func(t *testing.T) { + ctx := context.Background() + c := newTestCore(withAbnormalCode()) + resp, err := c.AlterCollectionFunction(ctx, &milvuspb.AlterCollectionFunctionRequest{}) + assert.NoError(t, err) + assert.NotEqual(t, commonpb.ErrorCode_Success, resp.GetErrorCode()) + }) + + t.Run("run ok", func(t *testing.T) { + ctx := context.Background() + c := initStreamingSystemAndCore(t) + defer c.Stop() + mocker := mockey.Mock((*Core).broadcastAlterCollectionForAlterFunction).Return(nil).Build() + defer mocker.UnPatch() + resp, err := c.AlterCollectionFunction(ctx, &milvuspb.AlterCollectionFunctionRequest{}) + assert.NoError(t, err) + assert.Equal(t, commonpb.ErrorCode_Success, resp.GetErrorCode()) + }) + + t.Run("run failed", func(t *testing.T) { + ctx := context.Background() + c := initStreamingSystemAndCore(t) + defer c.Stop() + mocker := mockey.Mock((*Core).broadcastAlterCollectionForAlterFunction).Return(fmt.Errorf("")).Build() + defer mocker.UnPatch() + resp, err := c.AlterCollectionFunction(ctx, &milvuspb.AlterCollectionFunctionRequest{}) + assert.NoError(t, err) + assert.Equal(t, commonpb.ErrorCode_UnexpectedError, resp.GetErrorCode()) + }) +} + func TestRootCoord_CheckHealth(t *testing.T) { // getQueryCoordMetricsFunc := func(tt typeutil.Timestamp) (*milvuspb.GetMetricsResponse, error) { // clusterTopology := metricsinfo.QueryClusterTopology{ diff --git a/internal/util/function/embedding/text_embedding_function.go b/internal/util/function/embedding/text_embedding_function.go index ac9930605c..88d365b229 100644 --- a/internal/util/function/embedding/text_embedding_function.go +++ b/internal/util/function/embedding/text_embedding_function.go @@ -108,7 +108,6 @@ func NewTextEmbeddingFunction(coll *schemapb.CollectionSchema, functionSchema *s if err := TextEmbeddingOutputsCheck(base.outputFields); err != nil { return nil, err } - var embP textEmbeddingProvider var newProviderErr error conf := paramtable.Get().FunctionCfg.GetTextEmbeddingProviderConfig(base.provider) diff --git a/internal/util/mock/grpc_rootcoord_client.go b/internal/util/mock/grpc_rootcoord_client.go index bf2f2314cc..4b978afc96 100644 --- a/internal/util/mock/grpc_rootcoord_client.go +++ b/internal/util/mock/grpc_rootcoord_client.go @@ -274,6 +274,18 @@ func (m *GrpcRootCoordClient) AlterCollectionField(ctx context.Context, in *milv return &commonpb.Status{}, m.Err } +func (m *GrpcRootCoordClient) AddCollectionFunction(ctx context.Context, in *milvuspb.AddCollectionFunctionRequest, opts ...grpc.CallOption) (*commonpb.Status, error) { + return &commonpb.Status{}, m.Err +} + +func (m *GrpcRootCoordClient) AlterCollectionFunction(ctx context.Context, in *milvuspb.AlterCollectionFunctionRequest, opts ...grpc.CallOption) (*commonpb.Status, error) { + return &commonpb.Status{}, m.Err +} + +func (m *GrpcRootCoordClient) DropCollectionFunction(ctx context.Context, in *milvuspb.DropCollectionFunctionRequest, opts ...grpc.CallOption) (*commonpb.Status, error) { + return &commonpb.Status{}, m.Err +} + func (m *GrpcRootCoordClient) AlterDatabase(ctx context.Context, in *rootcoordpb.AlterDatabaseRequest, opts ...grpc.CallOption) (*commonpb.Status, error) { return &commonpb.Status{}, m.Err } diff --git a/pkg/proto/root_coord.proto b/pkg/proto/root_coord.proto index 765cdad52f..a63775d677 100644 --- a/pkg/proto/root_coord.proto +++ b/pkg/proto/root_coord.proto @@ -77,6 +77,12 @@ service RootCoord { rpc AlterCollection(milvus.AlterCollectionRequest) returns (common.Status) {} rpc AlterCollectionField(milvus.AlterCollectionFieldRequest) returns (common.Status) {} + + rpc AddCollectionFunction(milvus.AddCollectionFunctionRequest) returns (common.Status) {} + + rpc AlterCollectionFunction(milvus.AlterCollectionFunctionRequest) returns (common.Status) {} + + rpc DropCollectionFunction(milvus.DropCollectionFunctionRequest) returns (common.Status) {} /** * @brief This method is used to create partition * diff --git a/pkg/proto/rootcoordpb/root_coord.pb.go b/pkg/proto/rootcoordpb/root_coord.pb.go index 279af51f27..60ff12ea3b 100644 --- a/pkg/proto/rootcoordpb/root_coord.pb.go +++ b/pkg/proto/rootcoordpb/root_coord.pb.go @@ -1466,7 +1466,7 @@ var file_root_coord_proto_rawDesc = []byte{ 0x03, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x6f, 0x6f, 0x74, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x2e, 0x44, 0x42, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x0d, 0x64, 0x62, 0x43, 0x6f, - 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x32, 0xc1, 0x2e, 0x0a, 0x09, 0x52, 0x6f, + 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x32, 0x88, 0x31, 0x0a, 0x09, 0x52, 0x6f, 0x6f, 0x74, 0x43, 0x6f, 0x6f, 0x72, 0x64, 0x12, 0x6c, 0x0a, 0x12, 0x47, 0x65, 0x74, 0x43, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x65, 0x73, 0x12, 0x2e, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, @@ -1584,265 +1584,286 @@ var file_root_coord_proto_rawDesc = []byte{ 0x72, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, - 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x5d, 0x0a, 0x0f, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, - 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x2b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, - 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, - 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, - 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, - 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x59, 0x0a, 0x0d, 0x44, 0x72, 0x6f, 0x70, 0x50, 0x61, 0x72, - 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x29, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, - 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x44, 0x72, 0x6f, - 0x70, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, - 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, - 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, - 0x12, 0x5d, 0x0a, 0x0c, 0x48, 0x61, 0x73, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, - 0x12, 0x28, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, - 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x48, 0x61, 0x73, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, - 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x21, 0x2e, 0x6d, 0x69, 0x6c, - 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, - 0x2e, 0x42, 0x6f, 0x6f, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, - 0x6b, 0x0a, 0x0e, 0x53, 0x68, 0x6f, 0x77, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, - 0x73, 0x12, 0x2a, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, - 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x53, 0x68, 0x6f, 0x77, 0x50, 0x61, 0x72, 0x74, - 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2b, 0x2e, - 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, - 0x76, 0x75, 0x73, 0x2e, 0x53, 0x68, 0x6f, 0x77, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, - 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x73, 0x0a, 0x16, - 0x53, 0x68, 0x6f, 0x77, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x49, 0x6e, - 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x12, 0x2a, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, - 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x53, 0x68, 0x6f, - 0x77, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, - 0x73, 0x74, 0x1a, 0x2b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, - 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x53, 0x68, 0x6f, 0x77, 0x50, 0x61, 0x72, - 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, - 0x00, 0x12, 0x65, 0x0a, 0x0c, 0x53, 0x68, 0x6f, 0x77, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, - 0x73, 0x12, 0x28, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, - 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x53, 0x68, 0x6f, 0x77, 0x53, 0x65, 0x67, 0x6d, - 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x29, 0x2e, 0x6d, 0x69, - 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, - 0x73, 0x2e, 0x53, 0x68, 0x6f, 0x77, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, - 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x74, 0x0a, 0x0f, 0x47, 0x65, 0x74, 0x50, - 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x2e, 0x2e, 0x6d, 0x69, - 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x6f, 0x6f, 0x74, 0x63, - 0x6f, 0x6f, 0x72, 0x64, 0x2e, 0x47, 0x65, 0x74, 0x50, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, - 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2f, 0x2e, 0x6d, 0x69, - 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x6f, 0x6f, 0x74, 0x63, - 0x6f, 0x6f, 0x72, 0x64, 0x2e, 0x47, 0x65, 0x74, 0x50, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, - 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x71, - 0x0a, 0x0e, 0x41, 0x6c, 0x6c, 0x6f, 0x63, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, - 0x12, 0x2d, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, - 0x72, 0x6f, 0x6f, 0x74, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x2e, 0x41, 0x6c, 0x6c, 0x6f, 0x63, 0x54, - 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, - 0x2e, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, - 0x6f, 0x6f, 0x74, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x2e, 0x41, 0x6c, 0x6c, 0x6f, 0x63, 0x54, 0x69, - 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, - 0x00, 0x12, 0x5c, 0x0a, 0x07, 0x41, 0x6c, 0x6c, 0x6f, 0x63, 0x49, 0x44, 0x12, 0x26, 0x2e, 0x6d, - 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x6f, 0x6f, 0x74, - 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x2e, 0x41, 0x6c, 0x6c, 0x6f, 0x63, 0x49, 0x44, 0x52, 0x65, 0x71, - 0x75, 0x65, 0x73, 0x74, 0x1a, 0x27, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, - 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x6f, 0x6f, 0x74, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x2e, 0x41, 0x6c, - 0x6c, 0x6f, 0x63, 0x49, 0x44, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, - 0x61, 0x0a, 0x15, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, - 0x54, 0x69, 0x6d, 0x65, 0x54, 0x69, 0x63, 0x6b, 0x12, 0x29, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, - 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, - 0x2e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x54, 0x69, 0x6d, 0x65, 0x54, 0x69, 0x63, 0x6b, - 0x4d, 0x73, 0x67, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, - 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, - 0x22, 0x00, 0x12, 0x72, 0x0a, 0x1d, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, - 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x65, 0x74, 0x61, 0x43, 0x61, - 0x63, 0x68, 0x65, 0x12, 0x32, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, - 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x78, 0x79, 0x2e, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, - 0x61, 0x74, 0x65, 0x43, 0x6f, 0x6c, 0x6c, 0x4d, 0x65, 0x74, 0x61, 0x43, 0x61, 0x63, 0x68, 0x65, - 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, - 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, - 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x7b, 0x0a, 0x12, 0x53, 0x68, 0x6f, 0x77, 0x43, 0x6f, - 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x30, 0x2e, 0x6d, - 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x74, 0x65, - 0x72, 0x6e, 0x61, 0x6c, 0x2e, 0x53, 0x68, 0x6f, 0x77, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, - 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x31, - 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, - 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2e, 0x53, 0x68, 0x6f, 0x77, 0x43, 0x6f, 0x6e, 0x66, 0x69, - 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, - 0x65, 0x22, 0x00, 0x12, 0x5f, 0x0a, 0x0a, 0x47, 0x65, 0x74, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, - 0x73, 0x12, 0x26, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, - 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x47, 0x65, 0x74, 0x4d, 0x65, 0x74, 0x72, 0x69, - 0x63, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x27, 0x2e, 0x6d, 0x69, 0x6c, 0x76, - 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, - 0x47, 0x65, 0x74, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, - 0x73, 0x65, 0x22, 0x00, 0x12, 0x58, 0x0a, 0x10, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x43, 0x72, - 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x12, 0x25, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, - 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, - 0x2e, 0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x49, 0x6e, 0x66, 0x6f, 0x1a, - 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, - 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x58, - 0x0a, 0x10, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, - 0x61, 0x6c, 0x12, 0x25, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, - 0x6f, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2e, 0x43, 0x72, 0x65, 0x64, 0x65, - 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x49, 0x6e, 0x66, 0x6f, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, - 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, - 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x5f, 0x0a, 0x10, 0x44, 0x65, 0x6c, 0x65, - 0x74, 0x65, 0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x12, 0x2c, 0x2e, 0x6d, - 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, - 0x75, 0x73, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, - 0x69, 0x61, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, - 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, - 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x68, 0x0a, 0x0d, 0x4c, 0x69, 0x73, - 0x74, 0x43, 0x72, 0x65, 0x64, 0x55, 0x73, 0x65, 0x72, 0x73, 0x12, 0x29, 0x2e, 0x6d, 0x69, 0x6c, - 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, - 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x43, 0x72, 0x65, 0x64, 0x55, 0x73, 0x65, 0x72, 0x73, 0x52, 0x65, - 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2a, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, - 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x4c, 0x69, 0x73, 0x74, - 0x43, 0x72, 0x65, 0x64, 0x55, 0x73, 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, - 0x65, 0x22, 0x00, 0x12, 0x6e, 0x0a, 0x0d, 0x47, 0x65, 0x74, 0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, - 0x74, 0x69, 0x61, 0x6c, 0x12, 0x2c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, - 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x6f, 0x6f, 0x74, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x2e, 0x47, 0x65, - 0x74, 0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, - 0x73, 0x74, 0x1a, 0x2d, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, - 0x6f, 0x2e, 0x72, 0x6f, 0x6f, 0x74, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x2e, 0x47, 0x65, 0x74, 0x43, - 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, - 0x65, 0x22, 0x00, 0x12, 0x53, 0x0a, 0x0a, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, 0x6f, 0x6c, - 0x65, 0x12, 0x26, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, - 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, 0x6f, - 0x6c, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, - 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, - 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x4f, 0x0a, 0x08, 0x44, 0x72, 0x6f, 0x70, - 0x52, 0x6f, 0x6c, 0x65, 0x12, 0x24, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, - 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x44, 0x72, 0x6f, 0x70, 0x52, - 0x6f, 0x6c, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, - 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, - 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x5d, 0x0a, 0x0f, 0x4f, 0x70, 0x65, - 0x72, 0x61, 0x74, 0x65, 0x55, 0x73, 0x65, 0x72, 0x52, 0x6f, 0x6c, 0x65, 0x12, 0x2b, 0x2e, 0x6d, - 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, - 0x75, 0x73, 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x65, 0x55, 0x73, 0x65, 0x72, 0x52, 0x6f, - 0x6c, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, - 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, - 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x5f, 0x0a, 0x0a, 0x53, 0x65, 0x6c, 0x65, - 0x63, 0x74, 0x52, 0x6f, 0x6c, 0x65, 0x12, 0x26, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, - 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x53, 0x65, 0x6c, - 0x65, 0x63, 0x74, 0x52, 0x6f, 0x6c, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x27, - 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, - 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x52, 0x6f, 0x6c, 0x65, 0x52, - 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x5f, 0x0a, 0x0a, 0x53, 0x65, 0x6c, - 0x65, 0x63, 0x74, 0x55, 0x73, 0x65, 0x72, 0x12, 0x26, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, - 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x53, 0x65, - 0x6c, 0x65, 0x63, 0x74, 0x55, 0x73, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, - 0x27, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, - 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x55, 0x73, 0x65, 0x72, - 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x5f, 0x0a, 0x10, 0x4f, 0x70, - 0x65, 0x72, 0x61, 0x74, 0x65, 0x50, 0x72, 0x69, 0x76, 0x69, 0x6c, 0x65, 0x67, 0x65, 0x12, 0x2c, - 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, - 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x65, 0x50, 0x72, 0x69, 0x76, - 0x69, 0x6c, 0x65, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, - 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, - 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x62, 0x0a, 0x0b, 0x53, - 0x65, 0x6c, 0x65, 0x63, 0x74, 0x47, 0x72, 0x61, 0x6e, 0x74, 0x12, 0x27, 0x2e, 0x6d, 0x69, 0x6c, - 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, - 0x2e, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x47, 0x72, 0x61, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75, - 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, - 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, - 0x47, 0x72, 0x61, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, - 0x63, 0x0a, 0x0a, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x12, 0x28, 0x2e, - 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x74, - 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, - 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x29, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, - 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2e, - 0x4c, 0x69, 0x73, 0x74, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, - 0x73, 0x65, 0x22, 0x00, 0x12, 0x67, 0x0a, 0x0a, 0x42, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x52, 0x42, - 0x41, 0x43, 0x12, 0x2a, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, - 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x42, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x52, - 0x42, 0x41, 0x43, 0x4d, 0x65, 0x74, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2b, - 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, - 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x42, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x52, 0x42, 0x41, 0x43, 0x4d, - 0x65, 0x74, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x59, 0x0a, - 0x0b, 0x52, 0x65, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x52, 0x42, 0x41, 0x43, 0x12, 0x2b, 0x2e, 0x6d, - 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, - 0x75, 0x73, 0x2e, 0x52, 0x65, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x52, 0x42, 0x41, 0x43, 0x4d, 0x65, - 0x74, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, - 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, - 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x67, 0x0a, 0x14, 0x43, 0x72, 0x65, 0x61, - 0x74, 0x65, 0x50, 0x72, 0x69, 0x76, 0x69, 0x6c, 0x65, 0x67, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, - 0x12, 0x30, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, - 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x50, 0x72, 0x69, - 0x76, 0x69, 0x6c, 0x65, 0x67, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x69, 0x0a, 0x15, 0x41, 0x64, 0x64, 0x43, 0x6f, 0x6c, + 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x46, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, + 0x31, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, + 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x41, 0x64, 0x64, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x46, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, - 0x00, 0x12, 0x63, 0x0a, 0x12, 0x44, 0x72, 0x6f, 0x70, 0x50, 0x72, 0x69, 0x76, 0x69, 0x6c, 0x65, - 0x67, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x12, 0x2e, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, - 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x44, 0x72, - 0x6f, 0x70, 0x50, 0x72, 0x69, 0x76, 0x69, 0x6c, 0x65, 0x67, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, - 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, - 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, - 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x7a, 0x0a, 0x13, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x72, - 0x69, 0x76, 0x69, 0x6c, 0x65, 0x67, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x73, 0x12, 0x2f, 0x2e, - 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, - 0x76, 0x75, 0x73, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x72, 0x69, 0x76, 0x69, 0x6c, 0x65, 0x67, - 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x30, - 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, - 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x72, 0x69, 0x76, 0x69, 0x6c, 0x65, - 0x67, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, - 0x22, 0x00, 0x12, 0x69, 0x0a, 0x15, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x65, 0x50, 0x72, 0x69, - 0x76, 0x69, 0x6c, 0x65, 0x67, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x12, 0x31, 0x2e, 0x6d, 0x69, - 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, - 0x73, 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x65, 0x50, 0x72, 0x69, 0x76, 0x69, 0x6c, 0x65, - 0x67, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, - 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, - 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x62, 0x0a, - 0x0b, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x12, 0x27, 0x2e, 0x6d, + 0x00, 0x12, 0x6d, 0x0a, 0x17, 0x41, 0x6c, 0x74, 0x65, 0x72, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, + 0x74, 0x69, 0x6f, 0x6e, 0x46, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x33, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, - 0x75, 0x73, 0x2e, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x52, 0x65, - 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, - 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x43, 0x68, 0x65, 0x63, - 0x6b, 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, - 0x00, 0x12, 0x5f, 0x0a, 0x10, 0x52, 0x65, 0x6e, 0x61, 0x6d, 0x65, 0x43, 0x6f, 0x6c, 0x6c, 0x65, - 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x2c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, - 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x52, 0x65, 0x6e, 0x61, - 0x6d, 0x65, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, - 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, - 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, - 0x22, 0x00, 0x12, 0x5b, 0x0a, 0x0e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x44, 0x61, 0x74, 0x61, - 0x62, 0x61, 0x73, 0x65, 0x12, 0x2a, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, - 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, - 0x65, 0x44, 0x61, 0x74, 0x61, 0x62, 0x61, 0x73, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x75, 0x73, 0x2e, 0x41, 0x6c, 0x74, 0x65, 0x72, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, + 0x6f, 0x6e, 0x46, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, + 0x12, 0x6b, 0x0a, 0x16, 0x44, 0x72, 0x6f, 0x70, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, + 0x6f, 0x6e, 0x46, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x32, 0x2e, 0x6d, 0x69, 0x6c, + 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, + 0x2e, 0x44, 0x72, 0x6f, 0x70, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x46, + 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, + 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, + 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x5d, 0x0a, + 0x0f, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, + 0x12, 0x2b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, + 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x50, 0x61, 0x72, + 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, + 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, + 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x59, 0x0a, 0x0d, + 0x44, 0x72, 0x6f, 0x70, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x29, 0x2e, + 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, + 0x76, 0x75, 0x73, 0x2e, 0x44, 0x72, 0x6f, 0x70, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, + 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, + 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, + 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x5d, 0x0a, 0x0c, 0x48, 0x61, 0x73, 0x50, 0x61, + 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x28, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x48, 0x61, + 0x73, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x1a, 0x21, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x42, 0x6f, 0x6f, 0x6c, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x6b, 0x0a, 0x0e, 0x53, 0x68, 0x6f, 0x77, 0x50, 0x61, + 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x2a, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, + 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x53, + 0x68, 0x6f, 0x77, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x53, 0x68, 0x6f, 0x77, 0x50, + 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x22, 0x00, 0x12, 0x73, 0x0a, 0x16, 0x53, 0x68, 0x6f, 0x77, 0x50, 0x61, 0x72, 0x74, 0x69, + 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x12, 0x2a, 0x2e, + 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, + 0x76, 0x75, 0x73, 0x2e, 0x53, 0x68, 0x6f, 0x77, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, + 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, + 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, + 0x53, 0x68, 0x6f, 0x77, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x65, 0x0a, 0x0c, 0x53, 0x68, 0x6f, 0x77, + 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x28, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, + 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x53, + 0x68, 0x6f, 0x77, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x1a, 0x29, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x53, 0x68, 0x6f, 0x77, 0x53, 0x65, 0x67, + 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, + 0x74, 0x0a, 0x0f, 0x47, 0x65, 0x74, 0x50, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x49, 0x6e, + 0x66, 0x6f, 0x12, 0x2e, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x2e, 0x72, 0x6f, 0x6f, 0x74, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x2e, 0x47, 0x65, 0x74, 0x50, + 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x1a, 0x2f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x2e, 0x72, 0x6f, 0x6f, 0x74, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x2e, 0x47, 0x65, 0x74, 0x50, + 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x71, 0x0a, 0x0e, 0x41, 0x6c, 0x6c, 0x6f, 0x63, 0x54, 0x69, + 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x12, 0x2d, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x6f, 0x6f, 0x74, 0x63, 0x6f, 0x6f, 0x72, 0x64, + 0x2e, 0x41, 0x6c, 0x6c, 0x6f, 0x63, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2e, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x6f, 0x6f, 0x74, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x2e, + 0x41, 0x6c, 0x6c, 0x6f, 0x63, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x5c, 0x0a, 0x07, 0x41, 0x6c, 0x6c, 0x6f, + 0x63, 0x49, 0x44, 0x12, 0x26, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x2e, 0x72, 0x6f, 0x6f, 0x74, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x2e, 0x41, 0x6c, 0x6c, + 0x6f, 0x63, 0x49, 0x44, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x27, 0x2e, 0x6d, 0x69, + 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x6f, 0x6f, 0x74, 0x63, + 0x6f, 0x6f, 0x72, 0x64, 0x2e, 0x41, 0x6c, 0x6c, 0x6f, 0x63, 0x49, 0x44, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x61, 0x0a, 0x15, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, + 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x54, 0x69, 0x6d, 0x65, 0x54, 0x69, 0x63, 0x6b, 0x12, + 0x29, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, + 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x54, + 0x69, 0x6d, 0x65, 0x54, 0x69, 0x63, 0x6b, 0x4d, 0x73, 0x67, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, + 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, + 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x72, 0x0a, 0x1d, 0x49, 0x6e, 0x76, + 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, + 0x6e, 0x4d, 0x65, 0x74, 0x61, 0x43, 0x61, 0x63, 0x68, 0x65, 0x12, 0x32, 0x2e, 0x6d, 0x69, 0x6c, + 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x78, 0x79, 0x2e, + 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x43, 0x6f, 0x6c, 0x6c, 0x4d, 0x65, + 0x74, 0x61, 0x43, 0x61, 0x63, 0x68, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, + 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, + 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x7b, 0x0a, + 0x12, 0x53, 0x68, 0x6f, 0x77, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x73, 0x12, 0x30, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2e, 0x53, 0x68, 0x6f, 0x77, + 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x31, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2e, 0x53, 0x68, + 0x6f, 0x77, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x5f, 0x0a, 0x0a, 0x47, 0x65, + 0x74, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x12, 0x26, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, + 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x47, + 0x65, 0x74, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x1a, 0x27, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, + 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x47, 0x65, 0x74, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, + 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x58, 0x0a, 0x10, 0x43, + 0x72, 0x65, 0x61, 0x74, 0x65, 0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x12, + 0x25, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, + 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2e, 0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, + 0x61, 0x6c, 0x49, 0x6e, 0x66, 0x6f, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, + 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x58, 0x0a, 0x10, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x43, + 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x12, 0x25, 0x2e, 0x6d, 0x69, 0x6c, 0x76, + 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, + 0x6c, 0x2e, 0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x49, 0x6e, 0x66, 0x6f, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, - 0x57, 0x0a, 0x0c, 0x44, 0x72, 0x6f, 0x70, 0x44, 0x61, 0x74, 0x61, 0x62, 0x61, 0x73, 0x65, 0x12, - 0x28, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, - 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x44, 0x72, 0x6f, 0x70, 0x44, 0x61, 0x74, 0x61, 0x62, 0x61, - 0x73, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, - 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, - 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x68, 0x0a, 0x0d, 0x4c, 0x69, 0x73, 0x74, - 0x44, 0x61, 0x74, 0x61, 0x62, 0x61, 0x73, 0x65, 0x73, 0x12, 0x29, 0x2e, 0x6d, 0x69, 0x6c, 0x76, + 0x5f, 0x0a, 0x10, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, + 0x69, 0x61, 0x6c, 0x12, 0x2c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, + 0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, + 0x12, 0x68, 0x0a, 0x0d, 0x4c, 0x69, 0x73, 0x74, 0x43, 0x72, 0x65, 0x64, 0x55, 0x73, 0x65, 0x72, + 0x73, 0x12, 0x29, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x43, 0x72, 0x65, 0x64, + 0x55, 0x73, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2a, 0x2e, 0x6d, + 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, + 0x75, 0x73, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x43, 0x72, 0x65, 0x64, 0x55, 0x73, 0x65, 0x72, 0x73, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x6e, 0x0a, 0x0d, 0x47, 0x65, + 0x74, 0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x12, 0x2c, 0x2e, 0x6d, 0x69, + 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x6f, 0x6f, 0x74, 0x63, + 0x6f, 0x6f, 0x72, 0x64, 0x2e, 0x47, 0x65, 0x74, 0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, + 0x61, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2d, 0x2e, 0x6d, 0x69, 0x6c, 0x76, + 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x6f, 0x6f, 0x74, 0x63, 0x6f, 0x6f, + 0x72, 0x64, 0x2e, 0x47, 0x65, 0x74, 0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x53, 0x0a, 0x0a, 0x43, 0x72, + 0x65, 0x61, 0x74, 0x65, 0x52, 0x6f, 0x6c, 0x65, 0x12, 0x26, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, + 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x43, + 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, 0x6f, 0x6c, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, + 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, + 0x4f, 0x0a, 0x08, 0x44, 0x72, 0x6f, 0x70, 0x52, 0x6f, 0x6c, 0x65, 0x12, 0x24, 0x2e, 0x6d, 0x69, + 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, + 0x73, 0x2e, 0x44, 0x72, 0x6f, 0x70, 0x52, 0x6f, 0x6c, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, + 0x12, 0x5d, 0x0a, 0x0f, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x65, 0x55, 0x73, 0x65, 0x72, 0x52, + 0x6f, 0x6c, 0x65, 0x12, 0x2b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, + 0x65, 0x55, 0x73, 0x65, 0x72, 0x52, 0x6f, 0x6c, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, + 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, + 0x5f, 0x0a, 0x0a, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x52, 0x6f, 0x6c, 0x65, 0x12, 0x26, 0x2e, + 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, + 0x76, 0x75, 0x73, 0x2e, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x52, 0x6f, 0x6c, 0x65, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x27, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x53, 0x65, 0x6c, 0x65, + 0x63, 0x74, 0x52, 0x6f, 0x6c, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, + 0x12, 0x5f, 0x0a, 0x0a, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x55, 0x73, 0x65, 0x72, 0x12, 0x26, + 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, + 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x55, 0x73, 0x65, 0x72, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x27, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x53, 0x65, 0x6c, + 0x65, 0x63, 0x74, 0x55, 0x73, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, + 0x00, 0x12, 0x5f, 0x0a, 0x10, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x65, 0x50, 0x72, 0x69, 0x76, + 0x69, 0x6c, 0x65, 0x67, 0x65, 0x12, 0x2c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x4f, 0x70, 0x65, 0x72, + 0x61, 0x74, 0x65, 0x50, 0x72, 0x69, 0x76, 0x69, 0x6c, 0x65, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, + 0x22, 0x00, 0x12, 0x62, 0x0a, 0x0b, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x47, 0x72, 0x61, 0x6e, + 0x74, 0x12, 0x27, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x47, 0x72, + 0x61, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x6d, 0x69, 0x6c, + 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, + 0x2e, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x47, 0x72, 0x61, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x63, 0x0a, 0x0a, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x6f, + 0x6c, 0x69, 0x63, 0x79, 0x12, 0x28, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2e, 0x4c, 0x69, 0x73, + 0x74, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x29, + 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, + 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x6f, 0x6c, 0x69, 0x63, + 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x67, 0x0a, 0x0a, 0x42, + 0x61, 0x63, 0x6b, 0x75, 0x70, 0x52, 0x42, 0x41, 0x43, 0x12, 0x2a, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, - 0x4c, 0x69, 0x73, 0x74, 0x44, 0x61, 0x74, 0x61, 0x62, 0x61, 0x73, 0x65, 0x73, 0x52, 0x65, 0x71, - 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2a, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, - 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x44, - 0x61, 0x74, 0x61, 0x62, 0x61, 0x73, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, - 0x22, 0x00, 0x12, 0x77, 0x0a, 0x10, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x44, 0x61, - 0x74, 0x61, 0x62, 0x61, 0x73, 0x65, 0x12, 0x2f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, - 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x6f, 0x6f, 0x74, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x2e, - 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x44, 0x61, 0x74, 0x61, 0x62, 0x61, 0x73, 0x65, - 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x30, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, - 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x6f, 0x6f, 0x74, 0x63, 0x6f, 0x6f, 0x72, 0x64, - 0x2e, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x44, 0x61, 0x74, 0x61, 0x62, 0x61, 0x73, - 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x5c, 0x0a, 0x0d, 0x41, - 0x6c, 0x74, 0x65, 0x72, 0x44, 0x61, 0x74, 0x61, 0x62, 0x61, 0x73, 0x65, 0x12, 0x2c, 0x2e, 0x6d, - 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x6f, 0x6f, 0x74, - 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x2e, 0x41, 0x6c, 0x74, 0x65, 0x72, 0x44, 0x61, 0x74, 0x61, 0x62, - 0x61, 0x73, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, + 0x42, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x52, 0x42, 0x41, 0x43, 0x4d, 0x65, 0x74, 0x61, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x42, 0x61, 0x63, 0x6b, + 0x75, 0x70, 0x52, 0x42, 0x41, 0x43, 0x4d, 0x65, 0x74, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x22, 0x00, 0x12, 0x59, 0x0a, 0x0b, 0x52, 0x65, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x52, + 0x42, 0x41, 0x43, 0x12, 0x2b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x52, 0x65, 0x73, 0x74, 0x6f, 0x72, + 0x65, 0x52, 0x42, 0x41, 0x43, 0x4d, 0x65, 0x74, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, + 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, + 0x67, 0x0a, 0x14, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x50, 0x72, 0x69, 0x76, 0x69, 0x6c, 0x65, + 0x67, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x12, 0x30, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x43, 0x72, + 0x65, 0x61, 0x74, 0x65, 0x50, 0x72, 0x69, 0x76, 0x69, 0x6c, 0x65, 0x67, 0x65, 0x47, 0x72, 0x6f, + 0x75, 0x70, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, + 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, + 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x63, 0x0a, 0x12, 0x44, 0x72, 0x6f, 0x70, + 0x50, 0x72, 0x69, 0x76, 0x69, 0x6c, 0x65, 0x67, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x12, 0x2e, + 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, + 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x44, 0x72, 0x6f, 0x70, 0x50, 0x72, 0x69, 0x76, 0x69, 0x6c, 0x65, + 0x67, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, + 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, + 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x7a, 0x0a, + 0x13, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x72, 0x69, 0x76, 0x69, 0x6c, 0x65, 0x67, 0x65, 0x47, 0x72, + 0x6f, 0x75, 0x70, 0x73, 0x12, 0x2f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x50, + 0x72, 0x69, 0x76, 0x69, 0x6c, 0x65, 0x67, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x73, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x30, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x4c, 0x69, 0x73, 0x74, + 0x50, 0x72, 0x69, 0x76, 0x69, 0x6c, 0x65, 0x67, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x73, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x69, 0x0a, 0x15, 0x4f, 0x70, 0x65, + 0x72, 0x61, 0x74, 0x65, 0x50, 0x72, 0x69, 0x76, 0x69, 0x6c, 0x65, 0x67, 0x65, 0x47, 0x72, 0x6f, + 0x75, 0x70, 0x12, 0x31, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x65, + 0x50, 0x72, 0x69, 0x76, 0x69, 0x6c, 0x65, 0x67, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, + 0x75, 0x73, 0x22, 0x00, 0x12, 0x62, 0x0a, 0x0b, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x48, 0x65, 0x61, + 0x6c, 0x74, 0x68, 0x12, 0x27, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x48, + 0x65, 0x61, 0x6c, 0x74, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x6d, + 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, + 0x75, 0x73, 0x2e, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x5f, 0x0a, 0x10, 0x52, 0x65, 0x6e, 0x61, + 0x6d, 0x65, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x2c, 0x2e, 0x6d, + 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, + 0x75, 0x73, 0x2e, 0x52, 0x65, 0x6e, 0x61, 0x6d, 0x65, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, - 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x72, 0x0a, 0x0f, 0x47, 0x65, 0x74, - 0x51, 0x75, 0x6f, 0x74, 0x61, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x12, 0x2d, 0x2e, 0x6d, - 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x74, 0x65, - 0x72, 0x6e, 0x61, 0x6c, 0x2e, 0x47, 0x65, 0x74, 0x51, 0x75, 0x6f, 0x74, 0x61, 0x4d, 0x65, 0x74, - 0x72, 0x69, 0x63, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2e, 0x2e, 0x6d, 0x69, - 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, - 0x6e, 0x61, 0x6c, 0x2e, 0x47, 0x65, 0x74, 0x51, 0x75, 0x6f, 0x74, 0x61, 0x4d, 0x65, 0x74, 0x72, - 0x69, 0x63, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x42, 0x36, 0x5a, - 0x34, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x6d, 0x69, 0x6c, 0x76, - 0x75, 0x73, 0x2d, 0x69, 0x6f, 0x2f, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2f, 0x70, 0x6b, 0x67, - 0x2f, 0x76, 0x32, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x72, 0x6f, 0x6f, 0x74, 0x63, 0x6f, - 0x6f, 0x72, 0x64, 0x70, 0x62, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, + 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x5b, 0x0a, 0x0e, 0x43, 0x72, 0x65, + 0x61, 0x74, 0x65, 0x44, 0x61, 0x74, 0x61, 0x62, 0x61, 0x73, 0x65, 0x12, 0x2a, 0x2e, 0x6d, 0x69, + 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, + 0x73, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x44, 0x61, 0x74, 0x61, 0x62, 0x61, 0x73, 0x65, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, + 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x57, 0x0a, 0x0c, 0x44, 0x72, 0x6f, 0x70, 0x44, 0x61, + 0x74, 0x61, 0x62, 0x61, 0x73, 0x65, 0x12, 0x28, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x44, 0x72, 0x6f, + 0x70, 0x44, 0x61, 0x74, 0x61, 0x62, 0x61, 0x73, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, + 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, + 0x68, 0x0a, 0x0d, 0x4c, 0x69, 0x73, 0x74, 0x44, 0x61, 0x74, 0x61, 0x62, 0x61, 0x73, 0x65, 0x73, + 0x12, 0x29, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, + 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x44, 0x61, 0x74, 0x61, 0x62, + 0x61, 0x73, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2a, 0x2e, 0x6d, 0x69, + 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, + 0x73, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x44, 0x61, 0x74, 0x61, 0x62, 0x61, 0x73, 0x65, 0x73, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x77, 0x0a, 0x10, 0x44, 0x65, 0x73, + 0x63, 0x72, 0x69, 0x62, 0x65, 0x44, 0x61, 0x74, 0x61, 0x62, 0x61, 0x73, 0x65, 0x12, 0x2f, 0x2e, + 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x6f, 0x6f, + 0x74, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x2e, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x44, + 0x61, 0x74, 0x61, 0x62, 0x61, 0x73, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x30, + 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x6f, + 0x6f, 0x74, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x2e, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, + 0x44, 0x61, 0x74, 0x61, 0x62, 0x61, 0x73, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x22, 0x00, 0x12, 0x5c, 0x0a, 0x0d, 0x41, 0x6c, 0x74, 0x65, 0x72, 0x44, 0x61, 0x74, 0x61, 0x62, + 0x61, 0x73, 0x65, 0x12, 0x2c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x2e, 0x72, 0x6f, 0x6f, 0x74, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x2e, 0x41, 0x6c, 0x74, + 0x65, 0x72, 0x44, 0x61, 0x74, 0x61, 0x62, 0x61, 0x73, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, + 0x12, 0x72, 0x0a, 0x0f, 0x47, 0x65, 0x74, 0x51, 0x75, 0x6f, 0x74, 0x61, 0x4d, 0x65, 0x74, 0x72, + 0x69, 0x63, 0x73, 0x12, 0x2d, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2e, 0x47, 0x65, 0x74, 0x51, + 0x75, 0x6f, 0x74, 0x61, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x1a, 0x2e, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2e, 0x47, 0x65, 0x74, 0x51, 0x75, + 0x6f, 0x74, 0x61, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x22, 0x00, 0x42, 0x36, 0x5a, 0x34, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, + 0x6f, 0x6d, 0x2f, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2d, 0x69, 0x6f, 0x2f, 0x6d, 0x69, 0x6c, + 0x76, 0x75, 0x73, 0x2f, 0x70, 0x6b, 0x67, 0x2f, 0x76, 0x32, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x2f, 0x72, 0x6f, 0x6f, 0x74, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x70, 0x62, 0x62, 0x06, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x33, } var ( @@ -1859,103 +1880,106 @@ func file_root_coord_proto_rawDescGZIP() []byte { var file_root_coord_proto_msgTypes = make([]protoimpl.MessageInfo, 22) var file_root_coord_proto_goTypes = []interface{}{ - (*AllocTimestampRequest)(nil), // 0: milvus.proto.rootcoord.AllocTimestampRequest - (*AllocTimestampResponse)(nil), // 1: milvus.proto.rootcoord.AllocTimestampResponse - (*AllocIDRequest)(nil), // 2: milvus.proto.rootcoord.AllocIDRequest - (*AllocIDResponse)(nil), // 3: milvus.proto.rootcoord.AllocIDResponse - (*DescribeSegmentsRequest)(nil), // 4: milvus.proto.rootcoord.DescribeSegmentsRequest - (*SegmentBaseInfo)(nil), // 5: milvus.proto.rootcoord.SegmentBaseInfo - (*SegmentInfos)(nil), // 6: milvus.proto.rootcoord.SegmentInfos - (*DescribeSegmentsResponse)(nil), // 7: milvus.proto.rootcoord.DescribeSegmentsResponse - (*GetCredentialRequest)(nil), // 8: milvus.proto.rootcoord.GetCredentialRequest - (*GetCredentialResponse)(nil), // 9: milvus.proto.rootcoord.GetCredentialResponse - (*DescribeDatabaseRequest)(nil), // 10: milvus.proto.rootcoord.DescribeDatabaseRequest - (*DescribeDatabaseResponse)(nil), // 11: milvus.proto.rootcoord.DescribeDatabaseResponse - (*AlterDatabaseRequest)(nil), // 12: milvus.proto.rootcoord.AlterDatabaseRequest - (*GetPChannelInfoRequest)(nil), // 13: milvus.proto.rootcoord.GetPChannelInfoRequest - (*GetPChannelInfoResponse)(nil), // 14: milvus.proto.rootcoord.GetPChannelInfoResponse - (*CollectionInfoOnPChannel)(nil), // 15: milvus.proto.rootcoord.CollectionInfoOnPChannel - (*PartitionInfoOnPChannel)(nil), // 16: milvus.proto.rootcoord.PartitionInfoOnPChannel - (*ShowCollectionIDsRequest)(nil), // 17: milvus.proto.rootcoord.ShowCollectionIDsRequest - (*DBCollections)(nil), // 18: milvus.proto.rootcoord.DBCollections - (*ShowCollectionIDsResponse)(nil), // 19: milvus.proto.rootcoord.ShowCollectionIDsResponse - nil, // 20: milvus.proto.rootcoord.SegmentInfos.ExtraIndexInfosEntry - nil, // 21: milvus.proto.rootcoord.DescribeSegmentsResponse.SegmentInfosEntry - (*commonpb.MsgBase)(nil), // 22: milvus.proto.common.MsgBase - (*commonpb.Status)(nil), // 23: milvus.proto.common.Status - (*etcdpb.SegmentIndexInfo)(nil), // 24: milvus.proto.etcd.SegmentIndexInfo - (*commonpb.KeyValuePair)(nil), // 25: milvus.proto.common.KeyValuePair - (etcdpb.CollectionState)(0), // 26: milvus.proto.etcd.CollectionState - (*etcdpb.IndexInfo)(nil), // 27: milvus.proto.etcd.IndexInfo - (*milvuspb.GetComponentStatesRequest)(nil), // 28: milvus.proto.milvus.GetComponentStatesRequest - (*internalpb.GetTimeTickChannelRequest)(nil), // 29: milvus.proto.internal.GetTimeTickChannelRequest - (*internalpb.GetStatisticsChannelRequest)(nil), // 30: milvus.proto.internal.GetStatisticsChannelRequest - (*milvuspb.CreateCollectionRequest)(nil), // 31: milvus.proto.milvus.CreateCollectionRequest - (*milvuspb.DropCollectionRequest)(nil), // 32: milvus.proto.milvus.DropCollectionRequest - (*milvuspb.AddCollectionFieldRequest)(nil), // 33: milvus.proto.milvus.AddCollectionFieldRequest - (*milvuspb.HasCollectionRequest)(nil), // 34: milvus.proto.milvus.HasCollectionRequest - (*milvuspb.DescribeCollectionRequest)(nil), // 35: milvus.proto.milvus.DescribeCollectionRequest - (*milvuspb.CreateAliasRequest)(nil), // 36: milvus.proto.milvus.CreateAliasRequest - (*milvuspb.DropAliasRequest)(nil), // 37: milvus.proto.milvus.DropAliasRequest - (*milvuspb.AlterAliasRequest)(nil), // 38: milvus.proto.milvus.AlterAliasRequest - (*milvuspb.DescribeAliasRequest)(nil), // 39: milvus.proto.milvus.DescribeAliasRequest - (*milvuspb.ListAliasesRequest)(nil), // 40: milvus.proto.milvus.ListAliasesRequest - (*milvuspb.ShowCollectionsRequest)(nil), // 41: milvus.proto.milvus.ShowCollectionsRequest - (*milvuspb.AlterCollectionRequest)(nil), // 42: milvus.proto.milvus.AlterCollectionRequest - (*milvuspb.AlterCollectionFieldRequest)(nil), // 43: milvus.proto.milvus.AlterCollectionFieldRequest - (*milvuspb.CreatePartitionRequest)(nil), // 44: milvus.proto.milvus.CreatePartitionRequest - (*milvuspb.DropPartitionRequest)(nil), // 45: milvus.proto.milvus.DropPartitionRequest - (*milvuspb.HasPartitionRequest)(nil), // 46: milvus.proto.milvus.HasPartitionRequest - (*milvuspb.ShowPartitionsRequest)(nil), // 47: milvus.proto.milvus.ShowPartitionsRequest - (*milvuspb.ShowSegmentsRequest)(nil), // 48: milvus.proto.milvus.ShowSegmentsRequest - (*internalpb.ChannelTimeTickMsg)(nil), // 49: milvus.proto.internal.ChannelTimeTickMsg - (*proxypb.InvalidateCollMetaCacheRequest)(nil), // 50: milvus.proto.proxy.InvalidateCollMetaCacheRequest - (*internalpb.ShowConfigurationsRequest)(nil), // 51: milvus.proto.internal.ShowConfigurationsRequest - (*milvuspb.GetMetricsRequest)(nil), // 52: milvus.proto.milvus.GetMetricsRequest - (*internalpb.CredentialInfo)(nil), // 53: milvus.proto.internal.CredentialInfo - (*milvuspb.DeleteCredentialRequest)(nil), // 54: milvus.proto.milvus.DeleteCredentialRequest - (*milvuspb.ListCredUsersRequest)(nil), // 55: milvus.proto.milvus.ListCredUsersRequest - (*milvuspb.CreateRoleRequest)(nil), // 56: milvus.proto.milvus.CreateRoleRequest - (*milvuspb.DropRoleRequest)(nil), // 57: milvus.proto.milvus.DropRoleRequest - (*milvuspb.OperateUserRoleRequest)(nil), // 58: milvus.proto.milvus.OperateUserRoleRequest - (*milvuspb.SelectRoleRequest)(nil), // 59: milvus.proto.milvus.SelectRoleRequest - (*milvuspb.SelectUserRequest)(nil), // 60: milvus.proto.milvus.SelectUserRequest - (*milvuspb.OperatePrivilegeRequest)(nil), // 61: milvus.proto.milvus.OperatePrivilegeRequest - (*milvuspb.SelectGrantRequest)(nil), // 62: milvus.proto.milvus.SelectGrantRequest - (*internalpb.ListPolicyRequest)(nil), // 63: milvus.proto.internal.ListPolicyRequest - (*milvuspb.BackupRBACMetaRequest)(nil), // 64: milvus.proto.milvus.BackupRBACMetaRequest - (*milvuspb.RestoreRBACMetaRequest)(nil), // 65: milvus.proto.milvus.RestoreRBACMetaRequest - (*milvuspb.CreatePrivilegeGroupRequest)(nil), // 66: milvus.proto.milvus.CreatePrivilegeGroupRequest - (*milvuspb.DropPrivilegeGroupRequest)(nil), // 67: milvus.proto.milvus.DropPrivilegeGroupRequest - (*milvuspb.ListPrivilegeGroupsRequest)(nil), // 68: milvus.proto.milvus.ListPrivilegeGroupsRequest - (*milvuspb.OperatePrivilegeGroupRequest)(nil), // 69: milvus.proto.milvus.OperatePrivilegeGroupRequest - (*milvuspb.CheckHealthRequest)(nil), // 70: milvus.proto.milvus.CheckHealthRequest - (*milvuspb.RenameCollectionRequest)(nil), // 71: milvus.proto.milvus.RenameCollectionRequest - (*milvuspb.CreateDatabaseRequest)(nil), // 72: milvus.proto.milvus.CreateDatabaseRequest - (*milvuspb.DropDatabaseRequest)(nil), // 73: milvus.proto.milvus.DropDatabaseRequest - (*milvuspb.ListDatabasesRequest)(nil), // 74: milvus.proto.milvus.ListDatabasesRequest - (*internalpb.GetQuotaMetricsRequest)(nil), // 75: milvus.proto.internal.GetQuotaMetricsRequest - (*milvuspb.ComponentStates)(nil), // 76: milvus.proto.milvus.ComponentStates - (*milvuspb.StringResponse)(nil), // 77: milvus.proto.milvus.StringResponse - (*milvuspb.BoolResponse)(nil), // 78: milvus.proto.milvus.BoolResponse - (*milvuspb.DescribeCollectionResponse)(nil), // 79: milvus.proto.milvus.DescribeCollectionResponse - (*milvuspb.DescribeAliasResponse)(nil), // 80: milvus.proto.milvus.DescribeAliasResponse - (*milvuspb.ListAliasesResponse)(nil), // 81: milvus.proto.milvus.ListAliasesResponse - (*milvuspb.ShowCollectionsResponse)(nil), // 82: milvus.proto.milvus.ShowCollectionsResponse - (*milvuspb.ShowPartitionsResponse)(nil), // 83: milvus.proto.milvus.ShowPartitionsResponse - (*milvuspb.ShowSegmentsResponse)(nil), // 84: milvus.proto.milvus.ShowSegmentsResponse - (*internalpb.ShowConfigurationsResponse)(nil), // 85: milvus.proto.internal.ShowConfigurationsResponse - (*milvuspb.GetMetricsResponse)(nil), // 86: milvus.proto.milvus.GetMetricsResponse - (*milvuspb.ListCredUsersResponse)(nil), // 87: milvus.proto.milvus.ListCredUsersResponse - (*milvuspb.SelectRoleResponse)(nil), // 88: milvus.proto.milvus.SelectRoleResponse - (*milvuspb.SelectUserResponse)(nil), // 89: milvus.proto.milvus.SelectUserResponse - (*milvuspb.SelectGrantResponse)(nil), // 90: milvus.proto.milvus.SelectGrantResponse - (*internalpb.ListPolicyResponse)(nil), // 91: milvus.proto.internal.ListPolicyResponse - (*milvuspb.BackupRBACMetaResponse)(nil), // 92: milvus.proto.milvus.BackupRBACMetaResponse - (*milvuspb.ListPrivilegeGroupsResponse)(nil), // 93: milvus.proto.milvus.ListPrivilegeGroupsResponse - (*milvuspb.CheckHealthResponse)(nil), // 94: milvus.proto.milvus.CheckHealthResponse - (*milvuspb.ListDatabasesResponse)(nil), // 95: milvus.proto.milvus.ListDatabasesResponse - (*internalpb.GetQuotaMetricsResponse)(nil), // 96: milvus.proto.internal.GetQuotaMetricsResponse + (*AllocTimestampRequest)(nil), // 0: milvus.proto.rootcoord.AllocTimestampRequest + (*AllocTimestampResponse)(nil), // 1: milvus.proto.rootcoord.AllocTimestampResponse + (*AllocIDRequest)(nil), // 2: milvus.proto.rootcoord.AllocIDRequest + (*AllocIDResponse)(nil), // 3: milvus.proto.rootcoord.AllocIDResponse + (*DescribeSegmentsRequest)(nil), // 4: milvus.proto.rootcoord.DescribeSegmentsRequest + (*SegmentBaseInfo)(nil), // 5: milvus.proto.rootcoord.SegmentBaseInfo + (*SegmentInfos)(nil), // 6: milvus.proto.rootcoord.SegmentInfos + (*DescribeSegmentsResponse)(nil), // 7: milvus.proto.rootcoord.DescribeSegmentsResponse + (*GetCredentialRequest)(nil), // 8: milvus.proto.rootcoord.GetCredentialRequest + (*GetCredentialResponse)(nil), // 9: milvus.proto.rootcoord.GetCredentialResponse + (*DescribeDatabaseRequest)(nil), // 10: milvus.proto.rootcoord.DescribeDatabaseRequest + (*DescribeDatabaseResponse)(nil), // 11: milvus.proto.rootcoord.DescribeDatabaseResponse + (*AlterDatabaseRequest)(nil), // 12: milvus.proto.rootcoord.AlterDatabaseRequest + (*GetPChannelInfoRequest)(nil), // 13: milvus.proto.rootcoord.GetPChannelInfoRequest + (*GetPChannelInfoResponse)(nil), // 14: milvus.proto.rootcoord.GetPChannelInfoResponse + (*CollectionInfoOnPChannel)(nil), // 15: milvus.proto.rootcoord.CollectionInfoOnPChannel + (*PartitionInfoOnPChannel)(nil), // 16: milvus.proto.rootcoord.PartitionInfoOnPChannel + (*ShowCollectionIDsRequest)(nil), // 17: milvus.proto.rootcoord.ShowCollectionIDsRequest + (*DBCollections)(nil), // 18: milvus.proto.rootcoord.DBCollections + (*ShowCollectionIDsResponse)(nil), // 19: milvus.proto.rootcoord.ShowCollectionIDsResponse + nil, // 20: milvus.proto.rootcoord.SegmentInfos.ExtraIndexInfosEntry + nil, // 21: milvus.proto.rootcoord.DescribeSegmentsResponse.SegmentInfosEntry + (*commonpb.MsgBase)(nil), // 22: milvus.proto.common.MsgBase + (*commonpb.Status)(nil), // 23: milvus.proto.common.Status + (*etcdpb.SegmentIndexInfo)(nil), // 24: milvus.proto.etcd.SegmentIndexInfo + (*commonpb.KeyValuePair)(nil), // 25: milvus.proto.common.KeyValuePair + (etcdpb.CollectionState)(0), // 26: milvus.proto.etcd.CollectionState + (*etcdpb.IndexInfo)(nil), // 27: milvus.proto.etcd.IndexInfo + (*milvuspb.GetComponentStatesRequest)(nil), // 28: milvus.proto.milvus.GetComponentStatesRequest + (*internalpb.GetTimeTickChannelRequest)(nil), // 29: milvus.proto.internal.GetTimeTickChannelRequest + (*internalpb.GetStatisticsChannelRequest)(nil), // 30: milvus.proto.internal.GetStatisticsChannelRequest + (*milvuspb.CreateCollectionRequest)(nil), // 31: milvus.proto.milvus.CreateCollectionRequest + (*milvuspb.DropCollectionRequest)(nil), // 32: milvus.proto.milvus.DropCollectionRequest + (*milvuspb.AddCollectionFieldRequest)(nil), // 33: milvus.proto.milvus.AddCollectionFieldRequest + (*milvuspb.HasCollectionRequest)(nil), // 34: milvus.proto.milvus.HasCollectionRequest + (*milvuspb.DescribeCollectionRequest)(nil), // 35: milvus.proto.milvus.DescribeCollectionRequest + (*milvuspb.CreateAliasRequest)(nil), // 36: milvus.proto.milvus.CreateAliasRequest + (*milvuspb.DropAliasRequest)(nil), // 37: milvus.proto.milvus.DropAliasRequest + (*milvuspb.AlterAliasRequest)(nil), // 38: milvus.proto.milvus.AlterAliasRequest + (*milvuspb.DescribeAliasRequest)(nil), // 39: milvus.proto.milvus.DescribeAliasRequest + (*milvuspb.ListAliasesRequest)(nil), // 40: milvus.proto.milvus.ListAliasesRequest + (*milvuspb.ShowCollectionsRequest)(nil), // 41: milvus.proto.milvus.ShowCollectionsRequest + (*milvuspb.AlterCollectionRequest)(nil), // 42: milvus.proto.milvus.AlterCollectionRequest + (*milvuspb.AlterCollectionFieldRequest)(nil), // 43: milvus.proto.milvus.AlterCollectionFieldRequest + (*milvuspb.AddCollectionFunctionRequest)(nil), // 44: milvus.proto.milvus.AddCollectionFunctionRequest + (*milvuspb.AlterCollectionFunctionRequest)(nil), // 45: milvus.proto.milvus.AlterCollectionFunctionRequest + (*milvuspb.DropCollectionFunctionRequest)(nil), // 46: milvus.proto.milvus.DropCollectionFunctionRequest + (*milvuspb.CreatePartitionRequest)(nil), // 47: milvus.proto.milvus.CreatePartitionRequest + (*milvuspb.DropPartitionRequest)(nil), // 48: milvus.proto.milvus.DropPartitionRequest + (*milvuspb.HasPartitionRequest)(nil), // 49: milvus.proto.milvus.HasPartitionRequest + (*milvuspb.ShowPartitionsRequest)(nil), // 50: milvus.proto.milvus.ShowPartitionsRequest + (*milvuspb.ShowSegmentsRequest)(nil), // 51: milvus.proto.milvus.ShowSegmentsRequest + (*internalpb.ChannelTimeTickMsg)(nil), // 52: milvus.proto.internal.ChannelTimeTickMsg + (*proxypb.InvalidateCollMetaCacheRequest)(nil), // 53: milvus.proto.proxy.InvalidateCollMetaCacheRequest + (*internalpb.ShowConfigurationsRequest)(nil), // 54: milvus.proto.internal.ShowConfigurationsRequest + (*milvuspb.GetMetricsRequest)(nil), // 55: milvus.proto.milvus.GetMetricsRequest + (*internalpb.CredentialInfo)(nil), // 56: milvus.proto.internal.CredentialInfo + (*milvuspb.DeleteCredentialRequest)(nil), // 57: milvus.proto.milvus.DeleteCredentialRequest + (*milvuspb.ListCredUsersRequest)(nil), // 58: milvus.proto.milvus.ListCredUsersRequest + (*milvuspb.CreateRoleRequest)(nil), // 59: milvus.proto.milvus.CreateRoleRequest + (*milvuspb.DropRoleRequest)(nil), // 60: milvus.proto.milvus.DropRoleRequest + (*milvuspb.OperateUserRoleRequest)(nil), // 61: milvus.proto.milvus.OperateUserRoleRequest + (*milvuspb.SelectRoleRequest)(nil), // 62: milvus.proto.milvus.SelectRoleRequest + (*milvuspb.SelectUserRequest)(nil), // 63: milvus.proto.milvus.SelectUserRequest + (*milvuspb.OperatePrivilegeRequest)(nil), // 64: milvus.proto.milvus.OperatePrivilegeRequest + (*milvuspb.SelectGrantRequest)(nil), // 65: milvus.proto.milvus.SelectGrantRequest + (*internalpb.ListPolicyRequest)(nil), // 66: milvus.proto.internal.ListPolicyRequest + (*milvuspb.BackupRBACMetaRequest)(nil), // 67: milvus.proto.milvus.BackupRBACMetaRequest + (*milvuspb.RestoreRBACMetaRequest)(nil), // 68: milvus.proto.milvus.RestoreRBACMetaRequest + (*milvuspb.CreatePrivilegeGroupRequest)(nil), // 69: milvus.proto.milvus.CreatePrivilegeGroupRequest + (*milvuspb.DropPrivilegeGroupRequest)(nil), // 70: milvus.proto.milvus.DropPrivilegeGroupRequest + (*milvuspb.ListPrivilegeGroupsRequest)(nil), // 71: milvus.proto.milvus.ListPrivilegeGroupsRequest + (*milvuspb.OperatePrivilegeGroupRequest)(nil), // 72: milvus.proto.milvus.OperatePrivilegeGroupRequest + (*milvuspb.CheckHealthRequest)(nil), // 73: milvus.proto.milvus.CheckHealthRequest + (*milvuspb.RenameCollectionRequest)(nil), // 74: milvus.proto.milvus.RenameCollectionRequest + (*milvuspb.CreateDatabaseRequest)(nil), // 75: milvus.proto.milvus.CreateDatabaseRequest + (*milvuspb.DropDatabaseRequest)(nil), // 76: milvus.proto.milvus.DropDatabaseRequest + (*milvuspb.ListDatabasesRequest)(nil), // 77: milvus.proto.milvus.ListDatabasesRequest + (*internalpb.GetQuotaMetricsRequest)(nil), // 78: milvus.proto.internal.GetQuotaMetricsRequest + (*milvuspb.ComponentStates)(nil), // 79: milvus.proto.milvus.ComponentStates + (*milvuspb.StringResponse)(nil), // 80: milvus.proto.milvus.StringResponse + (*milvuspb.BoolResponse)(nil), // 81: milvus.proto.milvus.BoolResponse + (*milvuspb.DescribeCollectionResponse)(nil), // 82: milvus.proto.milvus.DescribeCollectionResponse + (*milvuspb.DescribeAliasResponse)(nil), // 83: milvus.proto.milvus.DescribeAliasResponse + (*milvuspb.ListAliasesResponse)(nil), // 84: milvus.proto.milvus.ListAliasesResponse + (*milvuspb.ShowCollectionsResponse)(nil), // 85: milvus.proto.milvus.ShowCollectionsResponse + (*milvuspb.ShowPartitionsResponse)(nil), // 86: milvus.proto.milvus.ShowPartitionsResponse + (*milvuspb.ShowSegmentsResponse)(nil), // 87: milvus.proto.milvus.ShowSegmentsResponse + (*internalpb.ShowConfigurationsResponse)(nil), // 88: milvus.proto.internal.ShowConfigurationsResponse + (*milvuspb.GetMetricsResponse)(nil), // 89: milvus.proto.milvus.GetMetricsResponse + (*milvuspb.ListCredUsersResponse)(nil), // 90: milvus.proto.milvus.ListCredUsersResponse + (*milvuspb.SelectRoleResponse)(nil), // 91: milvus.proto.milvus.SelectRoleResponse + (*milvuspb.SelectUserResponse)(nil), // 92: milvus.proto.milvus.SelectUserResponse + (*milvuspb.SelectGrantResponse)(nil), // 93: milvus.proto.milvus.SelectGrantResponse + (*internalpb.ListPolicyResponse)(nil), // 94: milvus.proto.internal.ListPolicyResponse + (*milvuspb.BackupRBACMetaResponse)(nil), // 95: milvus.proto.milvus.BackupRBACMetaResponse + (*milvuspb.ListPrivilegeGroupsResponse)(nil), // 96: milvus.proto.milvus.ListPrivilegeGroupsResponse + (*milvuspb.CheckHealthResponse)(nil), // 97: milvus.proto.milvus.CheckHealthResponse + (*milvuspb.ListDatabasesResponse)(nil), // 98: milvus.proto.milvus.ListDatabasesResponse + (*internalpb.GetQuotaMetricsResponse)(nil), // 99: milvus.proto.internal.GetQuotaMetricsResponse } var file_root_coord_proto_depIdxs = []int32{ 22, // 0: milvus.proto.rootcoord.AllocTimestampRequest.base:type_name -> milvus.proto.common.MsgBase @@ -2003,106 +2027,112 @@ var file_root_coord_proto_depIdxs = []int32{ 17, // 42: milvus.proto.rootcoord.RootCoord.ShowCollectionIDs:input_type -> milvus.proto.rootcoord.ShowCollectionIDsRequest 42, // 43: milvus.proto.rootcoord.RootCoord.AlterCollection:input_type -> milvus.proto.milvus.AlterCollectionRequest 43, // 44: milvus.proto.rootcoord.RootCoord.AlterCollectionField:input_type -> milvus.proto.milvus.AlterCollectionFieldRequest - 44, // 45: milvus.proto.rootcoord.RootCoord.CreatePartition:input_type -> milvus.proto.milvus.CreatePartitionRequest - 45, // 46: milvus.proto.rootcoord.RootCoord.DropPartition:input_type -> milvus.proto.milvus.DropPartitionRequest - 46, // 47: milvus.proto.rootcoord.RootCoord.HasPartition:input_type -> milvus.proto.milvus.HasPartitionRequest - 47, // 48: milvus.proto.rootcoord.RootCoord.ShowPartitions:input_type -> milvus.proto.milvus.ShowPartitionsRequest - 47, // 49: milvus.proto.rootcoord.RootCoord.ShowPartitionsInternal:input_type -> milvus.proto.milvus.ShowPartitionsRequest - 48, // 50: milvus.proto.rootcoord.RootCoord.ShowSegments:input_type -> milvus.proto.milvus.ShowSegmentsRequest - 13, // 51: milvus.proto.rootcoord.RootCoord.GetPChannelInfo:input_type -> milvus.proto.rootcoord.GetPChannelInfoRequest - 0, // 52: milvus.proto.rootcoord.RootCoord.AllocTimestamp:input_type -> milvus.proto.rootcoord.AllocTimestampRequest - 2, // 53: milvus.proto.rootcoord.RootCoord.AllocID:input_type -> milvus.proto.rootcoord.AllocIDRequest - 49, // 54: milvus.proto.rootcoord.RootCoord.UpdateChannelTimeTick:input_type -> milvus.proto.internal.ChannelTimeTickMsg - 50, // 55: milvus.proto.rootcoord.RootCoord.InvalidateCollectionMetaCache:input_type -> milvus.proto.proxy.InvalidateCollMetaCacheRequest - 51, // 56: milvus.proto.rootcoord.RootCoord.ShowConfigurations:input_type -> milvus.proto.internal.ShowConfigurationsRequest - 52, // 57: milvus.proto.rootcoord.RootCoord.GetMetrics:input_type -> milvus.proto.milvus.GetMetricsRequest - 53, // 58: milvus.proto.rootcoord.RootCoord.CreateCredential:input_type -> milvus.proto.internal.CredentialInfo - 53, // 59: milvus.proto.rootcoord.RootCoord.UpdateCredential:input_type -> milvus.proto.internal.CredentialInfo - 54, // 60: milvus.proto.rootcoord.RootCoord.DeleteCredential:input_type -> milvus.proto.milvus.DeleteCredentialRequest - 55, // 61: milvus.proto.rootcoord.RootCoord.ListCredUsers:input_type -> milvus.proto.milvus.ListCredUsersRequest - 8, // 62: milvus.proto.rootcoord.RootCoord.GetCredential:input_type -> milvus.proto.rootcoord.GetCredentialRequest - 56, // 63: milvus.proto.rootcoord.RootCoord.CreateRole:input_type -> milvus.proto.milvus.CreateRoleRequest - 57, // 64: milvus.proto.rootcoord.RootCoord.DropRole:input_type -> milvus.proto.milvus.DropRoleRequest - 58, // 65: milvus.proto.rootcoord.RootCoord.OperateUserRole:input_type -> milvus.proto.milvus.OperateUserRoleRequest - 59, // 66: milvus.proto.rootcoord.RootCoord.SelectRole:input_type -> milvus.proto.milvus.SelectRoleRequest - 60, // 67: milvus.proto.rootcoord.RootCoord.SelectUser:input_type -> milvus.proto.milvus.SelectUserRequest - 61, // 68: milvus.proto.rootcoord.RootCoord.OperatePrivilege:input_type -> milvus.proto.milvus.OperatePrivilegeRequest - 62, // 69: milvus.proto.rootcoord.RootCoord.SelectGrant:input_type -> milvus.proto.milvus.SelectGrantRequest - 63, // 70: milvus.proto.rootcoord.RootCoord.ListPolicy:input_type -> milvus.proto.internal.ListPolicyRequest - 64, // 71: milvus.proto.rootcoord.RootCoord.BackupRBAC:input_type -> milvus.proto.milvus.BackupRBACMetaRequest - 65, // 72: milvus.proto.rootcoord.RootCoord.RestoreRBAC:input_type -> milvus.proto.milvus.RestoreRBACMetaRequest - 66, // 73: milvus.proto.rootcoord.RootCoord.CreatePrivilegeGroup:input_type -> milvus.proto.milvus.CreatePrivilegeGroupRequest - 67, // 74: milvus.proto.rootcoord.RootCoord.DropPrivilegeGroup:input_type -> milvus.proto.milvus.DropPrivilegeGroupRequest - 68, // 75: milvus.proto.rootcoord.RootCoord.ListPrivilegeGroups:input_type -> milvus.proto.milvus.ListPrivilegeGroupsRequest - 69, // 76: milvus.proto.rootcoord.RootCoord.OperatePrivilegeGroup:input_type -> milvus.proto.milvus.OperatePrivilegeGroupRequest - 70, // 77: milvus.proto.rootcoord.RootCoord.CheckHealth:input_type -> milvus.proto.milvus.CheckHealthRequest - 71, // 78: milvus.proto.rootcoord.RootCoord.RenameCollection:input_type -> milvus.proto.milvus.RenameCollectionRequest - 72, // 79: milvus.proto.rootcoord.RootCoord.CreateDatabase:input_type -> milvus.proto.milvus.CreateDatabaseRequest - 73, // 80: milvus.proto.rootcoord.RootCoord.DropDatabase:input_type -> milvus.proto.milvus.DropDatabaseRequest - 74, // 81: milvus.proto.rootcoord.RootCoord.ListDatabases:input_type -> milvus.proto.milvus.ListDatabasesRequest - 10, // 82: milvus.proto.rootcoord.RootCoord.DescribeDatabase:input_type -> milvus.proto.rootcoord.DescribeDatabaseRequest - 12, // 83: milvus.proto.rootcoord.RootCoord.AlterDatabase:input_type -> milvus.proto.rootcoord.AlterDatabaseRequest - 75, // 84: milvus.proto.rootcoord.RootCoord.GetQuotaMetrics:input_type -> milvus.proto.internal.GetQuotaMetricsRequest - 76, // 85: milvus.proto.rootcoord.RootCoord.GetComponentStates:output_type -> milvus.proto.milvus.ComponentStates - 77, // 86: milvus.proto.rootcoord.RootCoord.GetTimeTickChannel:output_type -> milvus.proto.milvus.StringResponse - 77, // 87: milvus.proto.rootcoord.RootCoord.GetStatisticsChannel:output_type -> milvus.proto.milvus.StringResponse - 23, // 88: milvus.proto.rootcoord.RootCoord.CreateCollection:output_type -> milvus.proto.common.Status - 23, // 89: milvus.proto.rootcoord.RootCoord.DropCollection:output_type -> milvus.proto.common.Status - 23, // 90: milvus.proto.rootcoord.RootCoord.AddCollectionField:output_type -> milvus.proto.common.Status - 78, // 91: milvus.proto.rootcoord.RootCoord.HasCollection:output_type -> milvus.proto.milvus.BoolResponse - 79, // 92: milvus.proto.rootcoord.RootCoord.DescribeCollection:output_type -> milvus.proto.milvus.DescribeCollectionResponse - 79, // 93: milvus.proto.rootcoord.RootCoord.DescribeCollectionInternal:output_type -> milvus.proto.milvus.DescribeCollectionResponse - 23, // 94: milvus.proto.rootcoord.RootCoord.CreateAlias:output_type -> milvus.proto.common.Status - 23, // 95: milvus.proto.rootcoord.RootCoord.DropAlias:output_type -> milvus.proto.common.Status - 23, // 96: milvus.proto.rootcoord.RootCoord.AlterAlias:output_type -> milvus.proto.common.Status - 80, // 97: milvus.proto.rootcoord.RootCoord.DescribeAlias:output_type -> milvus.proto.milvus.DescribeAliasResponse - 81, // 98: milvus.proto.rootcoord.RootCoord.ListAliases:output_type -> milvus.proto.milvus.ListAliasesResponse - 82, // 99: milvus.proto.rootcoord.RootCoord.ShowCollections:output_type -> milvus.proto.milvus.ShowCollectionsResponse - 19, // 100: milvus.proto.rootcoord.RootCoord.ShowCollectionIDs:output_type -> milvus.proto.rootcoord.ShowCollectionIDsResponse - 23, // 101: milvus.proto.rootcoord.RootCoord.AlterCollection:output_type -> milvus.proto.common.Status - 23, // 102: milvus.proto.rootcoord.RootCoord.AlterCollectionField:output_type -> milvus.proto.common.Status - 23, // 103: milvus.proto.rootcoord.RootCoord.CreatePartition:output_type -> milvus.proto.common.Status - 23, // 104: milvus.proto.rootcoord.RootCoord.DropPartition:output_type -> milvus.proto.common.Status - 78, // 105: milvus.proto.rootcoord.RootCoord.HasPartition:output_type -> milvus.proto.milvus.BoolResponse - 83, // 106: milvus.proto.rootcoord.RootCoord.ShowPartitions:output_type -> milvus.proto.milvus.ShowPartitionsResponse - 83, // 107: milvus.proto.rootcoord.RootCoord.ShowPartitionsInternal:output_type -> milvus.proto.milvus.ShowPartitionsResponse - 84, // 108: milvus.proto.rootcoord.RootCoord.ShowSegments:output_type -> milvus.proto.milvus.ShowSegmentsResponse - 14, // 109: milvus.proto.rootcoord.RootCoord.GetPChannelInfo:output_type -> milvus.proto.rootcoord.GetPChannelInfoResponse - 1, // 110: milvus.proto.rootcoord.RootCoord.AllocTimestamp:output_type -> milvus.proto.rootcoord.AllocTimestampResponse - 3, // 111: milvus.proto.rootcoord.RootCoord.AllocID:output_type -> milvus.proto.rootcoord.AllocIDResponse - 23, // 112: milvus.proto.rootcoord.RootCoord.UpdateChannelTimeTick:output_type -> milvus.proto.common.Status - 23, // 113: milvus.proto.rootcoord.RootCoord.InvalidateCollectionMetaCache:output_type -> milvus.proto.common.Status - 85, // 114: milvus.proto.rootcoord.RootCoord.ShowConfigurations:output_type -> milvus.proto.internal.ShowConfigurationsResponse - 86, // 115: milvus.proto.rootcoord.RootCoord.GetMetrics:output_type -> milvus.proto.milvus.GetMetricsResponse - 23, // 116: milvus.proto.rootcoord.RootCoord.CreateCredential:output_type -> milvus.proto.common.Status - 23, // 117: milvus.proto.rootcoord.RootCoord.UpdateCredential:output_type -> milvus.proto.common.Status - 23, // 118: milvus.proto.rootcoord.RootCoord.DeleteCredential:output_type -> milvus.proto.common.Status - 87, // 119: milvus.proto.rootcoord.RootCoord.ListCredUsers:output_type -> milvus.proto.milvus.ListCredUsersResponse - 9, // 120: milvus.proto.rootcoord.RootCoord.GetCredential:output_type -> milvus.proto.rootcoord.GetCredentialResponse - 23, // 121: milvus.proto.rootcoord.RootCoord.CreateRole:output_type -> milvus.proto.common.Status - 23, // 122: milvus.proto.rootcoord.RootCoord.DropRole:output_type -> milvus.proto.common.Status - 23, // 123: milvus.proto.rootcoord.RootCoord.OperateUserRole:output_type -> milvus.proto.common.Status - 88, // 124: milvus.proto.rootcoord.RootCoord.SelectRole:output_type -> milvus.proto.milvus.SelectRoleResponse - 89, // 125: milvus.proto.rootcoord.RootCoord.SelectUser:output_type -> milvus.proto.milvus.SelectUserResponse - 23, // 126: milvus.proto.rootcoord.RootCoord.OperatePrivilege:output_type -> milvus.proto.common.Status - 90, // 127: milvus.proto.rootcoord.RootCoord.SelectGrant:output_type -> milvus.proto.milvus.SelectGrantResponse - 91, // 128: milvus.proto.rootcoord.RootCoord.ListPolicy:output_type -> milvus.proto.internal.ListPolicyResponse - 92, // 129: milvus.proto.rootcoord.RootCoord.BackupRBAC:output_type -> milvus.proto.milvus.BackupRBACMetaResponse - 23, // 130: milvus.proto.rootcoord.RootCoord.RestoreRBAC:output_type -> milvus.proto.common.Status - 23, // 131: milvus.proto.rootcoord.RootCoord.CreatePrivilegeGroup:output_type -> milvus.proto.common.Status - 23, // 132: milvus.proto.rootcoord.RootCoord.DropPrivilegeGroup:output_type -> milvus.proto.common.Status - 93, // 133: milvus.proto.rootcoord.RootCoord.ListPrivilegeGroups:output_type -> milvus.proto.milvus.ListPrivilegeGroupsResponse - 23, // 134: milvus.proto.rootcoord.RootCoord.OperatePrivilegeGroup:output_type -> milvus.proto.common.Status - 94, // 135: milvus.proto.rootcoord.RootCoord.CheckHealth:output_type -> milvus.proto.milvus.CheckHealthResponse - 23, // 136: milvus.proto.rootcoord.RootCoord.RenameCollection:output_type -> milvus.proto.common.Status - 23, // 137: milvus.proto.rootcoord.RootCoord.CreateDatabase:output_type -> milvus.proto.common.Status - 23, // 138: milvus.proto.rootcoord.RootCoord.DropDatabase:output_type -> milvus.proto.common.Status - 95, // 139: milvus.proto.rootcoord.RootCoord.ListDatabases:output_type -> milvus.proto.milvus.ListDatabasesResponse - 11, // 140: milvus.proto.rootcoord.RootCoord.DescribeDatabase:output_type -> milvus.proto.rootcoord.DescribeDatabaseResponse - 23, // 141: milvus.proto.rootcoord.RootCoord.AlterDatabase:output_type -> milvus.proto.common.Status - 96, // 142: milvus.proto.rootcoord.RootCoord.GetQuotaMetrics:output_type -> milvus.proto.internal.GetQuotaMetricsResponse - 85, // [85:143] is the sub-list for method output_type - 27, // [27:85] is the sub-list for method input_type + 44, // 45: milvus.proto.rootcoord.RootCoord.AddCollectionFunction:input_type -> milvus.proto.milvus.AddCollectionFunctionRequest + 45, // 46: milvus.proto.rootcoord.RootCoord.AlterCollectionFunction:input_type -> milvus.proto.milvus.AlterCollectionFunctionRequest + 46, // 47: milvus.proto.rootcoord.RootCoord.DropCollectionFunction:input_type -> milvus.proto.milvus.DropCollectionFunctionRequest + 47, // 48: milvus.proto.rootcoord.RootCoord.CreatePartition:input_type -> milvus.proto.milvus.CreatePartitionRequest + 48, // 49: milvus.proto.rootcoord.RootCoord.DropPartition:input_type -> milvus.proto.milvus.DropPartitionRequest + 49, // 50: milvus.proto.rootcoord.RootCoord.HasPartition:input_type -> milvus.proto.milvus.HasPartitionRequest + 50, // 51: milvus.proto.rootcoord.RootCoord.ShowPartitions:input_type -> milvus.proto.milvus.ShowPartitionsRequest + 50, // 52: milvus.proto.rootcoord.RootCoord.ShowPartitionsInternal:input_type -> milvus.proto.milvus.ShowPartitionsRequest + 51, // 53: milvus.proto.rootcoord.RootCoord.ShowSegments:input_type -> milvus.proto.milvus.ShowSegmentsRequest + 13, // 54: milvus.proto.rootcoord.RootCoord.GetPChannelInfo:input_type -> milvus.proto.rootcoord.GetPChannelInfoRequest + 0, // 55: milvus.proto.rootcoord.RootCoord.AllocTimestamp:input_type -> milvus.proto.rootcoord.AllocTimestampRequest + 2, // 56: milvus.proto.rootcoord.RootCoord.AllocID:input_type -> milvus.proto.rootcoord.AllocIDRequest + 52, // 57: milvus.proto.rootcoord.RootCoord.UpdateChannelTimeTick:input_type -> milvus.proto.internal.ChannelTimeTickMsg + 53, // 58: milvus.proto.rootcoord.RootCoord.InvalidateCollectionMetaCache:input_type -> milvus.proto.proxy.InvalidateCollMetaCacheRequest + 54, // 59: milvus.proto.rootcoord.RootCoord.ShowConfigurations:input_type -> milvus.proto.internal.ShowConfigurationsRequest + 55, // 60: milvus.proto.rootcoord.RootCoord.GetMetrics:input_type -> milvus.proto.milvus.GetMetricsRequest + 56, // 61: milvus.proto.rootcoord.RootCoord.CreateCredential:input_type -> milvus.proto.internal.CredentialInfo + 56, // 62: milvus.proto.rootcoord.RootCoord.UpdateCredential:input_type -> milvus.proto.internal.CredentialInfo + 57, // 63: milvus.proto.rootcoord.RootCoord.DeleteCredential:input_type -> milvus.proto.milvus.DeleteCredentialRequest + 58, // 64: milvus.proto.rootcoord.RootCoord.ListCredUsers:input_type -> milvus.proto.milvus.ListCredUsersRequest + 8, // 65: milvus.proto.rootcoord.RootCoord.GetCredential:input_type -> milvus.proto.rootcoord.GetCredentialRequest + 59, // 66: milvus.proto.rootcoord.RootCoord.CreateRole:input_type -> milvus.proto.milvus.CreateRoleRequest + 60, // 67: milvus.proto.rootcoord.RootCoord.DropRole:input_type -> milvus.proto.milvus.DropRoleRequest + 61, // 68: milvus.proto.rootcoord.RootCoord.OperateUserRole:input_type -> milvus.proto.milvus.OperateUserRoleRequest + 62, // 69: milvus.proto.rootcoord.RootCoord.SelectRole:input_type -> milvus.proto.milvus.SelectRoleRequest + 63, // 70: milvus.proto.rootcoord.RootCoord.SelectUser:input_type -> milvus.proto.milvus.SelectUserRequest + 64, // 71: milvus.proto.rootcoord.RootCoord.OperatePrivilege:input_type -> milvus.proto.milvus.OperatePrivilegeRequest + 65, // 72: milvus.proto.rootcoord.RootCoord.SelectGrant:input_type -> milvus.proto.milvus.SelectGrantRequest + 66, // 73: milvus.proto.rootcoord.RootCoord.ListPolicy:input_type -> milvus.proto.internal.ListPolicyRequest + 67, // 74: milvus.proto.rootcoord.RootCoord.BackupRBAC:input_type -> milvus.proto.milvus.BackupRBACMetaRequest + 68, // 75: milvus.proto.rootcoord.RootCoord.RestoreRBAC:input_type -> milvus.proto.milvus.RestoreRBACMetaRequest + 69, // 76: milvus.proto.rootcoord.RootCoord.CreatePrivilegeGroup:input_type -> milvus.proto.milvus.CreatePrivilegeGroupRequest + 70, // 77: milvus.proto.rootcoord.RootCoord.DropPrivilegeGroup:input_type -> milvus.proto.milvus.DropPrivilegeGroupRequest + 71, // 78: milvus.proto.rootcoord.RootCoord.ListPrivilegeGroups:input_type -> milvus.proto.milvus.ListPrivilegeGroupsRequest + 72, // 79: milvus.proto.rootcoord.RootCoord.OperatePrivilegeGroup:input_type -> milvus.proto.milvus.OperatePrivilegeGroupRequest + 73, // 80: milvus.proto.rootcoord.RootCoord.CheckHealth:input_type -> milvus.proto.milvus.CheckHealthRequest + 74, // 81: milvus.proto.rootcoord.RootCoord.RenameCollection:input_type -> milvus.proto.milvus.RenameCollectionRequest + 75, // 82: milvus.proto.rootcoord.RootCoord.CreateDatabase:input_type -> milvus.proto.milvus.CreateDatabaseRequest + 76, // 83: milvus.proto.rootcoord.RootCoord.DropDatabase:input_type -> milvus.proto.milvus.DropDatabaseRequest + 77, // 84: milvus.proto.rootcoord.RootCoord.ListDatabases:input_type -> milvus.proto.milvus.ListDatabasesRequest + 10, // 85: milvus.proto.rootcoord.RootCoord.DescribeDatabase:input_type -> milvus.proto.rootcoord.DescribeDatabaseRequest + 12, // 86: milvus.proto.rootcoord.RootCoord.AlterDatabase:input_type -> milvus.proto.rootcoord.AlterDatabaseRequest + 78, // 87: milvus.proto.rootcoord.RootCoord.GetQuotaMetrics:input_type -> milvus.proto.internal.GetQuotaMetricsRequest + 79, // 88: milvus.proto.rootcoord.RootCoord.GetComponentStates:output_type -> milvus.proto.milvus.ComponentStates + 80, // 89: milvus.proto.rootcoord.RootCoord.GetTimeTickChannel:output_type -> milvus.proto.milvus.StringResponse + 80, // 90: milvus.proto.rootcoord.RootCoord.GetStatisticsChannel:output_type -> milvus.proto.milvus.StringResponse + 23, // 91: milvus.proto.rootcoord.RootCoord.CreateCollection:output_type -> milvus.proto.common.Status + 23, // 92: milvus.proto.rootcoord.RootCoord.DropCollection:output_type -> milvus.proto.common.Status + 23, // 93: milvus.proto.rootcoord.RootCoord.AddCollectionField:output_type -> milvus.proto.common.Status + 81, // 94: milvus.proto.rootcoord.RootCoord.HasCollection:output_type -> milvus.proto.milvus.BoolResponse + 82, // 95: milvus.proto.rootcoord.RootCoord.DescribeCollection:output_type -> milvus.proto.milvus.DescribeCollectionResponse + 82, // 96: milvus.proto.rootcoord.RootCoord.DescribeCollectionInternal:output_type -> milvus.proto.milvus.DescribeCollectionResponse + 23, // 97: milvus.proto.rootcoord.RootCoord.CreateAlias:output_type -> milvus.proto.common.Status + 23, // 98: milvus.proto.rootcoord.RootCoord.DropAlias:output_type -> milvus.proto.common.Status + 23, // 99: milvus.proto.rootcoord.RootCoord.AlterAlias:output_type -> milvus.proto.common.Status + 83, // 100: milvus.proto.rootcoord.RootCoord.DescribeAlias:output_type -> milvus.proto.milvus.DescribeAliasResponse + 84, // 101: milvus.proto.rootcoord.RootCoord.ListAliases:output_type -> milvus.proto.milvus.ListAliasesResponse + 85, // 102: milvus.proto.rootcoord.RootCoord.ShowCollections:output_type -> milvus.proto.milvus.ShowCollectionsResponse + 19, // 103: milvus.proto.rootcoord.RootCoord.ShowCollectionIDs:output_type -> milvus.proto.rootcoord.ShowCollectionIDsResponse + 23, // 104: milvus.proto.rootcoord.RootCoord.AlterCollection:output_type -> milvus.proto.common.Status + 23, // 105: milvus.proto.rootcoord.RootCoord.AlterCollectionField:output_type -> milvus.proto.common.Status + 23, // 106: milvus.proto.rootcoord.RootCoord.AddCollectionFunction:output_type -> milvus.proto.common.Status + 23, // 107: milvus.proto.rootcoord.RootCoord.AlterCollectionFunction:output_type -> milvus.proto.common.Status + 23, // 108: milvus.proto.rootcoord.RootCoord.DropCollectionFunction:output_type -> milvus.proto.common.Status + 23, // 109: milvus.proto.rootcoord.RootCoord.CreatePartition:output_type -> milvus.proto.common.Status + 23, // 110: milvus.proto.rootcoord.RootCoord.DropPartition:output_type -> milvus.proto.common.Status + 81, // 111: milvus.proto.rootcoord.RootCoord.HasPartition:output_type -> milvus.proto.milvus.BoolResponse + 86, // 112: milvus.proto.rootcoord.RootCoord.ShowPartitions:output_type -> milvus.proto.milvus.ShowPartitionsResponse + 86, // 113: milvus.proto.rootcoord.RootCoord.ShowPartitionsInternal:output_type -> milvus.proto.milvus.ShowPartitionsResponse + 87, // 114: milvus.proto.rootcoord.RootCoord.ShowSegments:output_type -> milvus.proto.milvus.ShowSegmentsResponse + 14, // 115: milvus.proto.rootcoord.RootCoord.GetPChannelInfo:output_type -> milvus.proto.rootcoord.GetPChannelInfoResponse + 1, // 116: milvus.proto.rootcoord.RootCoord.AllocTimestamp:output_type -> milvus.proto.rootcoord.AllocTimestampResponse + 3, // 117: milvus.proto.rootcoord.RootCoord.AllocID:output_type -> milvus.proto.rootcoord.AllocIDResponse + 23, // 118: milvus.proto.rootcoord.RootCoord.UpdateChannelTimeTick:output_type -> milvus.proto.common.Status + 23, // 119: milvus.proto.rootcoord.RootCoord.InvalidateCollectionMetaCache:output_type -> milvus.proto.common.Status + 88, // 120: milvus.proto.rootcoord.RootCoord.ShowConfigurations:output_type -> milvus.proto.internal.ShowConfigurationsResponse + 89, // 121: milvus.proto.rootcoord.RootCoord.GetMetrics:output_type -> milvus.proto.milvus.GetMetricsResponse + 23, // 122: milvus.proto.rootcoord.RootCoord.CreateCredential:output_type -> milvus.proto.common.Status + 23, // 123: milvus.proto.rootcoord.RootCoord.UpdateCredential:output_type -> milvus.proto.common.Status + 23, // 124: milvus.proto.rootcoord.RootCoord.DeleteCredential:output_type -> milvus.proto.common.Status + 90, // 125: milvus.proto.rootcoord.RootCoord.ListCredUsers:output_type -> milvus.proto.milvus.ListCredUsersResponse + 9, // 126: milvus.proto.rootcoord.RootCoord.GetCredential:output_type -> milvus.proto.rootcoord.GetCredentialResponse + 23, // 127: milvus.proto.rootcoord.RootCoord.CreateRole:output_type -> milvus.proto.common.Status + 23, // 128: milvus.proto.rootcoord.RootCoord.DropRole:output_type -> milvus.proto.common.Status + 23, // 129: milvus.proto.rootcoord.RootCoord.OperateUserRole:output_type -> milvus.proto.common.Status + 91, // 130: milvus.proto.rootcoord.RootCoord.SelectRole:output_type -> milvus.proto.milvus.SelectRoleResponse + 92, // 131: milvus.proto.rootcoord.RootCoord.SelectUser:output_type -> milvus.proto.milvus.SelectUserResponse + 23, // 132: milvus.proto.rootcoord.RootCoord.OperatePrivilege:output_type -> milvus.proto.common.Status + 93, // 133: milvus.proto.rootcoord.RootCoord.SelectGrant:output_type -> milvus.proto.milvus.SelectGrantResponse + 94, // 134: milvus.proto.rootcoord.RootCoord.ListPolicy:output_type -> milvus.proto.internal.ListPolicyResponse + 95, // 135: milvus.proto.rootcoord.RootCoord.BackupRBAC:output_type -> milvus.proto.milvus.BackupRBACMetaResponse + 23, // 136: milvus.proto.rootcoord.RootCoord.RestoreRBAC:output_type -> milvus.proto.common.Status + 23, // 137: milvus.proto.rootcoord.RootCoord.CreatePrivilegeGroup:output_type -> milvus.proto.common.Status + 23, // 138: milvus.proto.rootcoord.RootCoord.DropPrivilegeGroup:output_type -> milvus.proto.common.Status + 96, // 139: milvus.proto.rootcoord.RootCoord.ListPrivilegeGroups:output_type -> milvus.proto.milvus.ListPrivilegeGroupsResponse + 23, // 140: milvus.proto.rootcoord.RootCoord.OperatePrivilegeGroup:output_type -> milvus.proto.common.Status + 97, // 141: milvus.proto.rootcoord.RootCoord.CheckHealth:output_type -> milvus.proto.milvus.CheckHealthResponse + 23, // 142: milvus.proto.rootcoord.RootCoord.RenameCollection:output_type -> milvus.proto.common.Status + 23, // 143: milvus.proto.rootcoord.RootCoord.CreateDatabase:output_type -> milvus.proto.common.Status + 23, // 144: milvus.proto.rootcoord.RootCoord.DropDatabase:output_type -> milvus.proto.common.Status + 98, // 145: milvus.proto.rootcoord.RootCoord.ListDatabases:output_type -> milvus.proto.milvus.ListDatabasesResponse + 11, // 146: milvus.proto.rootcoord.RootCoord.DescribeDatabase:output_type -> milvus.proto.rootcoord.DescribeDatabaseResponse + 23, // 147: milvus.proto.rootcoord.RootCoord.AlterDatabase:output_type -> milvus.proto.common.Status + 99, // 148: milvus.proto.rootcoord.RootCoord.GetQuotaMetrics:output_type -> milvus.proto.internal.GetQuotaMetricsResponse + 88, // [88:149] is the sub-list for method output_type + 27, // [27:88] is the sub-list for method input_type 27, // [27:27] is the sub-list for extension type_name 27, // [27:27] is the sub-list for extension extendee 0, // [0:27] is the sub-list for field type_name diff --git a/pkg/proto/rootcoordpb/root_coord_grpc.pb.go b/pkg/proto/rootcoordpb/root_coord_grpc.pb.go index 1142bcd381..4090738493 100644 --- a/pkg/proto/rootcoordpb/root_coord_grpc.pb.go +++ b/pkg/proto/rootcoordpb/root_coord_grpc.pb.go @@ -41,6 +41,9 @@ const ( RootCoord_ShowCollectionIDs_FullMethodName = "/milvus.proto.rootcoord.RootCoord/ShowCollectionIDs" RootCoord_AlterCollection_FullMethodName = "/milvus.proto.rootcoord.RootCoord/AlterCollection" RootCoord_AlterCollectionField_FullMethodName = "/milvus.proto.rootcoord.RootCoord/AlterCollectionField" + RootCoord_AddCollectionFunction_FullMethodName = "/milvus.proto.rootcoord.RootCoord/AddCollectionFunction" + RootCoord_AlterCollectionFunction_FullMethodName = "/milvus.proto.rootcoord.RootCoord/AlterCollectionFunction" + RootCoord_DropCollectionFunction_FullMethodName = "/milvus.proto.rootcoord.RootCoord/DropCollectionFunction" RootCoord_CreatePartition_FullMethodName = "/milvus.proto.rootcoord.RootCoord/CreatePartition" RootCoord_DropPartition_FullMethodName = "/milvus.proto.rootcoord.RootCoord/DropPartition" RootCoord_HasPartition_FullMethodName = "/milvus.proto.rootcoord.RootCoord/HasPartition" @@ -139,6 +142,9 @@ type RootCoordClient interface { ShowCollectionIDs(ctx context.Context, in *ShowCollectionIDsRequest, opts ...grpc.CallOption) (*ShowCollectionIDsResponse, error) AlterCollection(ctx context.Context, in *milvuspb.AlterCollectionRequest, opts ...grpc.CallOption) (*commonpb.Status, error) AlterCollectionField(ctx context.Context, in *milvuspb.AlterCollectionFieldRequest, opts ...grpc.CallOption) (*commonpb.Status, error) + AddCollectionFunction(ctx context.Context, in *milvuspb.AddCollectionFunctionRequest, opts ...grpc.CallOption) (*commonpb.Status, error) + AlterCollectionFunction(ctx context.Context, in *milvuspb.AlterCollectionFunctionRequest, opts ...grpc.CallOption) (*commonpb.Status, error) + DropCollectionFunction(ctx context.Context, in *milvuspb.DropCollectionFunctionRequest, opts ...grpc.CallOption) (*commonpb.Status, error) // * // @brief This method is used to create partition // @@ -373,6 +379,33 @@ func (c *rootCoordClient) AlterCollectionField(ctx context.Context, in *milvuspb return out, nil } +func (c *rootCoordClient) AddCollectionFunction(ctx context.Context, in *milvuspb.AddCollectionFunctionRequest, opts ...grpc.CallOption) (*commonpb.Status, error) { + out := new(commonpb.Status) + err := c.cc.Invoke(ctx, RootCoord_AddCollectionFunction_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *rootCoordClient) AlterCollectionFunction(ctx context.Context, in *milvuspb.AlterCollectionFunctionRequest, opts ...grpc.CallOption) (*commonpb.Status, error) { + out := new(commonpb.Status) + err := c.cc.Invoke(ctx, RootCoord_AlterCollectionFunction_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *rootCoordClient) DropCollectionFunction(ctx context.Context, in *milvuspb.DropCollectionFunctionRequest, opts ...grpc.CallOption) (*commonpb.Status, error) { + out := new(commonpb.Status) + err := c.cc.Invoke(ctx, RootCoord_DropCollectionFunction_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + func (c *rootCoordClient) CreatePartition(ctx context.Context, in *milvuspb.CreatePartitionRequest, opts ...grpc.CallOption) (*commonpb.Status, error) { out := new(commonpb.Status) err := c.cc.Invoke(ctx, RootCoord_CreatePartition_FullMethodName, in, out, opts...) @@ -789,6 +822,9 @@ type RootCoordServer interface { ShowCollectionIDs(context.Context, *ShowCollectionIDsRequest) (*ShowCollectionIDsResponse, error) AlterCollection(context.Context, *milvuspb.AlterCollectionRequest) (*commonpb.Status, error) AlterCollectionField(context.Context, *milvuspb.AlterCollectionFieldRequest) (*commonpb.Status, error) + AddCollectionFunction(context.Context, *milvuspb.AddCollectionFunctionRequest) (*commonpb.Status, error) + AlterCollectionFunction(context.Context, *milvuspb.AlterCollectionFunctionRequest) (*commonpb.Status, error) + DropCollectionFunction(context.Context, *milvuspb.DropCollectionFunctionRequest) (*commonpb.Status, error) // * // @brief This method is used to create partition // @@ -911,6 +947,15 @@ func (UnimplementedRootCoordServer) AlterCollection(context.Context, *milvuspb.A func (UnimplementedRootCoordServer) AlterCollectionField(context.Context, *milvuspb.AlterCollectionFieldRequest) (*commonpb.Status, error) { return nil, status.Errorf(codes.Unimplemented, "method AlterCollectionField not implemented") } +func (UnimplementedRootCoordServer) AddCollectionFunction(context.Context, *milvuspb.AddCollectionFunctionRequest) (*commonpb.Status, error) { + return nil, status.Errorf(codes.Unimplemented, "method AddCollectionFunction not implemented") +} +func (UnimplementedRootCoordServer) AlterCollectionFunction(context.Context, *milvuspb.AlterCollectionFunctionRequest) (*commonpb.Status, error) { + return nil, status.Errorf(codes.Unimplemented, "method AlterCollectionFunction not implemented") +} +func (UnimplementedRootCoordServer) DropCollectionFunction(context.Context, *milvuspb.DropCollectionFunctionRequest) (*commonpb.Status, error) { + return nil, status.Errorf(codes.Unimplemented, "method DropCollectionFunction not implemented") +} func (UnimplementedRootCoordServer) CreatePartition(context.Context, *milvuspb.CreatePartitionRequest) (*commonpb.Status, error) { return nil, status.Errorf(codes.Unimplemented, "method CreatePartition not implemented") } @@ -1367,6 +1412,60 @@ func _RootCoord_AlterCollectionField_Handler(srv interface{}, ctx context.Contex return interceptor(ctx, in, info, handler) } +func _RootCoord_AddCollectionFunction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(milvuspb.AddCollectionFunctionRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(RootCoordServer).AddCollectionFunction(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: RootCoord_AddCollectionFunction_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(RootCoordServer).AddCollectionFunction(ctx, req.(*milvuspb.AddCollectionFunctionRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _RootCoord_AlterCollectionFunction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(milvuspb.AlterCollectionFunctionRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(RootCoordServer).AlterCollectionFunction(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: RootCoord_AlterCollectionFunction_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(RootCoordServer).AlterCollectionFunction(ctx, req.(*milvuspb.AlterCollectionFunctionRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _RootCoord_DropCollectionFunction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(milvuspb.DropCollectionFunctionRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(RootCoordServer).DropCollectionFunction(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: RootCoord_DropCollectionFunction_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(RootCoordServer).DropCollectionFunction(ctx, req.(*milvuspb.DropCollectionFunctionRequest)) + } + return interceptor(ctx, in, info, handler) +} + func _RootCoord_CreatePartition_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(milvuspb.CreatePartitionRequest) if err := dec(in); err != nil { @@ -2166,6 +2265,18 @@ var RootCoord_ServiceDesc = grpc.ServiceDesc{ MethodName: "AlterCollectionField", Handler: _RootCoord_AlterCollectionField_Handler, }, + { + MethodName: "AddCollectionFunction", + Handler: _RootCoord_AddCollectionFunction_Handler, + }, + { + MethodName: "AlterCollectionFunction", + Handler: _RootCoord_AlterCollectionFunction_Handler, + }, + { + MethodName: "DropCollectionFunction", + Handler: _RootCoord_DropCollectionFunction_Handler, + }, { MethodName: "CreatePartition", Handler: _RootCoord_CreatePartition_Handler, diff --git a/pkg/streaming/util/message/codegen/reflect_info.json b/pkg/streaming/util/message/codegen/reflect_info.json index b2881a4b55..a3c3b0095f 100644 --- a/pkg/streaming/util/message/codegen/reflect_info.json +++ b/pkg/streaming/util/message/codegen/reflect_info.json @@ -436,4 +436,4 @@ } } ] -} \ No newline at end of file +}