test/milvus
1
0
Fork 0
mirror of https://gitee.com/milvus-io/milvus.git synced 2024-12-02 03:48:37 +08:00
Code Issues Actions 12 Packages Projects Releases Wiki Activity

feat: Implement DescribeAlias and ListAliases interfaces (#29641)

Browse Source 
#22882
/kind feature

Signed-off-by: wayblink <anyang.wang@zilliz.com>
This commit is contained in:
wayblink 2024-01-11 19:12:51 +08:00 committed by GitHub
parent 0b3b753ef6
commit 1df3f90696
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
29 changed files with 2328 additions and 629 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
internal/datacoord/mock_test.go
View File

@ -351,6 +351,14 @@ func (m *mockRootCoordClient) AlterAlias(ctx context.Context, req *milvuspb.Alte
panic("implement me")
}
func (m *mockRootCoordClient) DescribeAlias(ctx context.Context, req *milvuspb.DescribeAliasRequest, opts ...grpc.CallOption) (*milvuspb.DescribeAliasResponse, error) {
panic("implement me")
}
func (m *mockRootCoordClient) ListAliases(ctx context.Context, req *milvuspb.ListAliasesRequest, opts ...grpc.CallOption) (*milvuspb.ListAliasesResponse, error) {
panic("implement me")
}
func newMockRootCoordClient() *mockRootCoordClient {
return &mockRootCoordClient{state: commonpb.StateCode_Healthy}
}

8
internal/distributed/proxy/httpserver/handler_test.go
View File

@ -139,6 +139,14 @@ func (m *mockProxyComponent) AlterAlias(ctx context.Context, request *milvuspb.A
return testStatus, nil
}
func (m *mockProxyComponent) DescribeAlias(ctx context.Context, request *milvuspb.DescribeAliasRequest) (*milvuspb.DescribeAliasResponse, error) {
return &milvuspb.DescribeAliasResponse{Status: testStatus}, nil
}
func (m *mockProxyComponent) ListAliases(ctx context.Context, request *milvuspb.ListAliasesRequest) (*milvuspb.ListAliasesResponse, error) {
return &milvuspb.ListAliasesResponse{Status: testStatus}, nil
}
func (m *mockProxyComponent) CreateIndex(ctx context.Context, request *milvuspb.CreateIndexRequest) (*commonpb.Status, error) {
return testStatus, nil
}

10
internal/distributed/proxy/service.go
View File

@ -938,16 +938,14 @@ func (s *Server) AlterAlias(ctx context.Context, request *milvuspb.AlterAliasReq
return s.proxy.AlterAlias(ctx, request)
}
// DescribeAlias show the alias-collection relation for the specified alias.
func (s *Server) DescribeAlias(ctx context.Context, request *milvuspb.DescribeAliasRequest) (*milvuspb.DescribeAliasResponse, error) {
return &milvuspb.DescribeAliasResponse{
Status: merr.Status(merr.WrapErrServiceUnavailable("DescribeAlias unimplemented")),
}, nil
return s.proxy.DescribeAlias(ctx, request)
}
// ListAliases list all the alias for the specified db, collection.
func (s *Server) ListAliases(ctx context.Context, request *milvuspb.ListAliasesRequest) (*milvuspb.ListAliasesResponse, error) {
return &milvuspb.ListAliasesResponse{
Status: merr.Status(merr.WrapErrServiceUnavailable("ListAliases unimplemented")),
}, nil
return s.proxy.ListAliases(ctx, request)
}
// GetCompactionState gets the state of a compaction

13
internal/distributed/proxy/service_test.go
View File

@ -62,7 +62,6 @@ func TestMain(m *testing.M) {
}
// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
type WaitOption struct {
Duration time.Duration `json:"duration"`
Port int `json:"port"`
@ -466,6 +465,18 @@ func Test_NewServer(t *testing.T) {
assert.NoError(t, err)
})
t.Run("DescribeAlias", func(t *testing.T) {
mockProxy.EXPECT().DescribeAlias(mock.Anything, mock.Anything).Return(nil, nil)
_, err := server.DescribeAlias(ctx, nil)
assert.Nil(t, err)
})
t.Run("ListAliases", func(t *testing.T) {
mockProxy.EXPECT().ListAliases(mock.Anything, mock.Anything).Return(nil, nil)
_, err := server.ListAliases(ctx, nil)
assert.Nil(t, err)
})
t.Run("GetCompactionState", func(t *testing.T) {
mockProxy.EXPECT().GetCompactionState(mock.Anything, mock.Anything).Return(nil, nil)
_, err := server.GetCompactionState(ctx, nil)

24
internal/distributed/rootcoord/client/client.go
View File

@ -417,6 +417,30 @@ func (c *Client) AlterAlias(ctx context.Context, req *milvuspb.AlterAliasRequest
})
}
// DescribeAlias describe alias
func (c *Client) DescribeAlias(ctx context.Context, req *milvuspb.DescribeAliasRequest, opts ...grpc.CallOption) (*milvuspb.DescribeAliasResponse, error) {
req = typeutil.Clone(req)
commonpbutil.UpdateMsgBase(
req.GetBase(),
commonpbutil.FillMsgBaseFromClient(paramtable.GetNodeID(), commonpbutil.WithTargetID(c.grpcClient.GetNodeID())),
)
return wrapGrpcCall(ctx, c, func(client rootcoordpb.RootCoordClient) (*milvuspb.DescribeAliasResponse, error) {
return client.DescribeAlias(ctx, req)
})
}
// ListAliases list all aliases of db or collection
func (c *Client) ListAliases(ctx context.Context, req *milvuspb.ListAliasesRequest, opts ...grpc.CallOption) (*milvuspb.ListAliasesResponse, error) {
req = typeutil.Clone(req)
commonpbutil.UpdateMsgBase(
req.GetBase(),
commonpbutil.FillMsgBaseFromClient(paramtable.GetNodeID(), commonpbutil.WithTargetID(c.grpcClient.GetNodeID())),
)
return wrapGrpcCall(ctx, c, func(client rootcoordpb.RootCoordClient) (*milvuspb.ListAliasesResponse, error) {
return client.ListAliases(ctx, req)
})
}
// Import data files(json, numpy, etc.) on MinIO/S3 storage, read and parse them into sealed segments
func (c *Client) Import(ctx context.Context, req *milvuspb.ImportRequest, opts ...grpc.CallOption) (*milvuspb.ImportResponse, error) {
return wrapGrpcCall(ctx, c, func(client rootcoordpb.RootCoordClient) (*milvuspb.ImportResponse, error) {

16
internal/distributed/rootcoord/client/client_test.go
View File

@ -152,6 +152,14 @@ func Test_NewClient(t *testing.T) {
r, err := client.AlterAlias(ctx, nil)
retCheck(retNotNil, r, err)
}
{
r, err := client.DescribeAlias(ctx, nil)
retCheck(retNotNil, r, err)
}
{
r, err := client.ListAliases(ctx, nil)
retCheck(retNotNil, r, err)
}
{
r, err := client.Import(ctx, nil)
retCheck(retNotNil, r, err)
@ -366,6 +374,14 @@ func Test_NewClient(t *testing.T) {
rTimeout, err := client.AlterAlias(shortCtx, nil)
retCheck(rTimeout, err)
}
{
rTimeout, err := client.DescribeAlias(shortCtx, nil)
retCheck(rTimeout, err)
}
{
rTimeout, err := client.ListAliases(shortCtx, nil)
retCheck(rTimeout, err)
}
{
rTimeout, err := client.Import(shortCtx, nil)
retCheck(rTimeout, err)

10
internal/distributed/rootcoord/service.go
View File

@ -108,6 +108,16 @@ func (s *Server) AlterAlias(ctx context.Context, request *milvuspb.AlterAliasReq
return s.rootCoord.AlterAlias(ctx, request)
}
// DescribeAlias show the alias-collection relation for the specified alias.
func (s *Server) DescribeAlias(ctx context.Context, request *milvuspb.DescribeAliasRequest) (*milvuspb.DescribeAliasResponse, error) {
return s.rootCoord.DescribeAlias(ctx, request)
}
// ListAliases show all alias in db.
func (s *Server) ListAliases(ctx context.Context, request *milvuspb.ListAliasesRequest) (*milvuspb.ListAliasesResponse, error) {
return s.rootCoord.ListAliases(ctx, request)
}
// NewServer create a new RootCoord grpc server.
func NewServer(ctx context.Context, factory dependency.Factory) (*Server, error) {
ctx1, cancel := context.WithCancel(ctx)

602
internal/mocks/mock_rootcoord.go
View File

@ -1,4 +1,4 @@
// Code generated by mockery v2.32.4. DO NOT EDIT.
// Code generated by mockery v2.38.0. DO NOT EDIT.
package mocks
@ -6,7 +6,6 @@ import (
context "context"
commonpb "github.com/milvus-io/milvus-proto/go-api/v2/commonpb"
clientv3 "go.etcd.io/etcd/client/v3"
internalpb "github.com/milvus-io/milvus/internal/proto/internalpb"
@ -17,13 +16,9 @@ import (
proxypb "github.com/milvus-io/milvus/internal/proto/proxypb"
rootcoordpb "github.com/milvus-io/milvus/internal/proto/rootcoordpb"
txnkv "github.com/tikv/client-go/v2/txnkv"
types "github.com/milvus-io/milvus/internal/types"
)
// RootCoord is an autogenerated mock type for the RootCoordComponent type
// RootCoord is an autogenerated mock type for the RootCoord type
type RootCoord struct {
mock.Mock
}
@ -40,6 +35,10 @@ func (_m *RootCoord) EXPECT() *RootCoord_Expecter {
func (_m *RootCoord) AllocID(_a0 context.Context, _a1 *rootcoordpb.AllocIDRequest) (*rootcoordpb.AllocIDResponse, error) {
ret := _m.Called(_a0, _a1)
if len(ret) == 0 {
panic("no return value specified for AllocID")
}
var r0 *rootcoordpb.AllocIDResponse
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, *rootcoordpb.AllocIDRequest) (*rootcoordpb.AllocIDResponse, error)); ok {
@ -95,6 +94,10 @@ func (_c *RootCoord_AllocID_Call) RunAndReturn(run func(context.Context, *rootco
func (_m *RootCoord) AllocTimestamp(_a0 context.Context, _a1 *rootcoordpb.AllocTimestampRequest) (*rootcoordpb.AllocTimestampResponse, error) {
ret := _m.Called(_a0, _a1)
if len(ret) == 0 {
panic("no return value specified for AllocTimestamp")
}
var r0 *rootcoordpb.AllocTimestampResponse
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, *rootcoordpb.AllocTimestampRequest) (*rootcoordpb.AllocTimestampResponse, error)); ok {
@ -150,6 +153,10 @@ func (_c *RootCoord_AllocTimestamp_Call) RunAndReturn(run func(context.Context,
func (_m *RootCoord) AlterAlias(_a0 context.Context, _a1 *milvuspb.AlterAliasRequest) (*commonpb.Status, error) {
ret := _m.Called(_a0, _a1)
if len(ret) == 0 {
panic("no return value specified for AlterAlias")
}
var r0 *commonpb.Status
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.AlterAliasRequest) (*commonpb.Status, error)); ok {
@ -205,6 +212,10 @@ func (_c *RootCoord_AlterAlias_Call) RunAndReturn(run func(context.Context, *mil
func (_m *RootCoord) AlterCollection(_a0 context.Context, _a1 *milvuspb.AlterCollectionRequest) (*commonpb.Status, error) {
ret := _m.Called(_a0, _a1)
if len(ret) == 0 {
panic("no return value specified for AlterCollection")
}
var r0 *commonpb.Status
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.AlterCollectionRequest) (*commonpb.Status, error)); ok {
@ -260,6 +271,10 @@ func (_c *RootCoord_AlterCollection_Call) RunAndReturn(run func(context.Context,
func (_m *RootCoord) CheckHealth(_a0 context.Context, _a1 *milvuspb.CheckHealthRequest) (*milvuspb.CheckHealthResponse, error) {
ret := _m.Called(_a0, _a1)
if len(ret) == 0 {
panic("no return value specified for CheckHealth")
}
var r0 *milvuspb.CheckHealthResponse
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.CheckHealthRequest) (*milvuspb.CheckHealthResponse, error)); ok {
@ -315,6 +330,10 @@ func (_c *RootCoord_CheckHealth_Call) RunAndReturn(run func(context.Context, *mi
func (_m *RootCoord) CreateAlias(_a0 context.Context, _a1 *milvuspb.CreateAliasRequest) (*commonpb.Status, error) {
ret := _m.Called(_a0, _a1)
if len(ret) == 0 {
panic("no return value specified for CreateAlias")
}
var r0 *commonpb.Status
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.CreateAliasRequest) (*commonpb.Status, error)); ok {
@ -370,6 +389,10 @@ func (_c *RootCoord_CreateAlias_Call) RunAndReturn(run func(context.Context, *mi
func (_m *RootCoord) CreateCollection(_a0 context.Context, _a1 *milvuspb.CreateCollectionRequest) (*commonpb.Status, error) {
ret := _m.Called(_a0, _a1)
if len(ret) == 0 {
panic("no return value specified for CreateCollection")
}
var r0 *commonpb.Status
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.CreateCollectionRequest) (*commonpb.Status, error)); ok {
@ -425,6 +448,10 @@ func (_c *RootCoord_CreateCollection_Call) RunAndReturn(run func(context.Context
func (_m *RootCoord) CreateCredential(_a0 context.Context, _a1 *internalpb.CredentialInfo) (*commonpb.Status, error) {
ret := _m.Called(_a0, _a1)
if len(ret) == 0 {
panic("no return value specified for CreateCredential")
}
var r0 *commonpb.Status
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, *internalpb.CredentialInfo) (*commonpb.Status, error)); ok {
@ -480,6 +507,10 @@ func (_c *RootCoord_CreateCredential_Call) RunAndReturn(run func(context.Context
func (_m *RootCoord) CreateDatabase(_a0 context.Context, _a1 *milvuspb.CreateDatabaseRequest) (*commonpb.Status, error) {
ret := _m.Called(_a0, _a1)
if len(ret) == 0 {
panic("no return value specified for CreateDatabase")
}
var r0 *commonpb.Status
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.CreateDatabaseRequest) (*commonpb.Status, error)); ok {
@ -535,6 +566,10 @@ func (_c *RootCoord_CreateDatabase_Call) RunAndReturn(run func(context.Context,
func (_m *RootCoord) CreatePartition(_a0 context.Context, _a1 *milvuspb.CreatePartitionRequest) (*commonpb.Status, error) {
ret := _m.Called(_a0, _a1)
if len(ret) == 0 {
panic("no return value specified for CreatePartition")
}
var r0 *commonpb.Status
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.CreatePartitionRequest) (*commonpb.Status, error)); ok {
@ -590,6 +625,10 @@ func (_c *RootCoord_CreatePartition_Call) RunAndReturn(run func(context.Context,
func (_m *RootCoord) CreateRole(_a0 context.Context, _a1 *milvuspb.CreateRoleRequest) (*commonpb.Status, error) {
ret := _m.Called(_a0, _a1)
if len(ret) == 0 {
panic("no return value specified for CreateRole")
}
var r0 *commonpb.Status
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.CreateRoleRequest) (*commonpb.Status, error)); ok {
@ -645,6 +684,10 @@ func (_c *RootCoord_CreateRole_Call) RunAndReturn(run func(context.Context, *mil
func (_m *RootCoord) DeleteCredential(_a0 context.Context, _a1 *milvuspb.DeleteCredentialRequest) (*commonpb.Status, error) {
ret := _m.Called(_a0, _a1)
if len(ret) == 0 {
panic("no return value specified for DeleteCredential")
}
var r0 *commonpb.Status
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.DeleteCredentialRequest) (*commonpb.Status, error)); ok {
@ -696,10 +739,73 @@ func (_c *RootCoord_DeleteCredential_Call) RunAndReturn(run func(context.Context
return _c
}
// DescribeAlias provides a mock function with given fields: _a0, _a1
func (_m *RootCoord) DescribeAlias(_a0 context.Context, _a1 *milvuspb.DescribeAliasRequest) (*milvuspb.DescribeAliasResponse, error) {
ret := _m.Called(_a0, _a1)
if len(ret) == 0 {
panic("no return value specified for DescribeAlias")
}
var r0 *milvuspb.DescribeAliasResponse
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.DescribeAliasRequest) (*milvuspb.DescribeAliasResponse, error)); ok {
return rf(_a0, _a1)
}
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.DescribeAliasRequest) *milvuspb.DescribeAliasResponse); ok {
r0 = rf(_a0, _a1)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*milvuspb.DescribeAliasResponse)
}
}
if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.DescribeAliasRequest) error); ok {
r1 = rf(_a0, _a1)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// RootCoord_DescribeAlias_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeAlias'
type RootCoord_DescribeAlias_Call struct {
*mock.Call
}
// DescribeAlias is a helper method to define mock.On call
// - _a0 context.Context
// - _a1 *milvuspb.DescribeAliasRequest
func (_e *RootCoord_Expecter) DescribeAlias(_a0 interface{}, _a1 interface{}) *RootCoord_DescribeAlias_Call {
return &RootCoord_DescribeAlias_Call{Call: _e.mock.On("DescribeAlias", _a0, _a1)}
}
func (_c *RootCoord_DescribeAlias_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.DescribeAliasRequest)) *RootCoord_DescribeAlias_Call {
_c.Call.Run(func(args mock.Arguments) {
run(args[0].(context.Context), args[1].(*milvuspb.DescribeAliasRequest))
})
return _c
}
func (_c *RootCoord_DescribeAlias_Call) Return(_a0 *milvuspb.DescribeAliasResponse, _a1 error) *RootCoord_DescribeAlias_Call {
_c.Call.Return(_a0, _a1)
return _c
}
func (_c *RootCoord_DescribeAlias_Call) RunAndReturn(run func(context.Context, *milvuspb.DescribeAliasRequest) (*milvuspb.DescribeAliasResponse, error)) *RootCoord_DescribeAlias_Call {
_c.Call.Return(run)
return _c
}
// DescribeCollection provides a mock function with given fields: _a0, _a1
func (_m *RootCoord) DescribeCollection(_a0 context.Context, _a1 *milvuspb.DescribeCollectionRequest) (*milvuspb.DescribeCollectionResponse, error) {
ret := _m.Called(_a0, _a1)
if len(ret) == 0 {
panic("no return value specified for DescribeCollection")
}
var r0 *milvuspb.DescribeCollectionResponse
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.DescribeCollectionRequest) (*milvuspb.DescribeCollectionResponse, error)); ok {
@ -755,6 +861,10 @@ func (_c *RootCoord_DescribeCollection_Call) RunAndReturn(run func(context.Conte
func (_m *RootCoord) DescribeCollectionInternal(_a0 context.Context, _a1 *milvuspb.DescribeCollectionRequest) (*milvuspb.DescribeCollectionResponse, error) {
ret := _m.Called(_a0, _a1)
if len(ret) == 0 {
panic("no return value specified for DescribeCollectionInternal")
}
var r0 *milvuspb.DescribeCollectionResponse
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.DescribeCollectionRequest) (*milvuspb.DescribeCollectionResponse, error)); ok {
@ -810,6 +920,10 @@ func (_c *RootCoord_DescribeCollectionInternal_Call) RunAndReturn(run func(conte
func (_m *RootCoord) DropAlias(_a0 context.Context, _a1 *milvuspb.DropAliasRequest) (*commonpb.Status, error) {
ret := _m.Called(_a0, _a1)
if len(ret) == 0 {
panic("no return value specified for DropAlias")
}
var r0 *commonpb.Status
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.DropAliasRequest) (*commonpb.Status, error)); ok {
@ -865,6 +979,10 @@ func (_c *RootCoord_DropAlias_Call) RunAndReturn(run func(context.Context, *milv
func (_m *RootCoord) DropCollection(_a0 context.Context, _a1 *milvuspb.DropCollectionRequest) (*commonpb.Status, error) {
ret := _m.Called(_a0, _a1)
if len(ret) == 0 {
panic("no return value specified for DropCollection")
}
var r0 *commonpb.Status
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.DropCollectionRequest) (*commonpb.Status, error)); ok {
@ -920,6 +1038,10 @@ func (_c *RootCoord_DropCollection_Call) RunAndReturn(run func(context.Context,
func (_m *RootCoord) DropDatabase(_a0 context.Context, _a1 *milvuspb.DropDatabaseRequest) (*commonpb.Status, error) {
ret := _m.Called(_a0, _a1)
if len(ret) == 0 {
panic("no return value specified for DropDatabase")
}
var r0 *commonpb.Status
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.DropDatabaseRequest) (*commonpb.Status, error)); ok {
@ -975,6 +1097,10 @@ func (_c *RootCoord_DropDatabase_Call) RunAndReturn(run func(context.Context, *m
func (_m *RootCoord) DropPartition(_a0 context.Context, _a1 *milvuspb.DropPartitionRequest) (*commonpb.Status, error) {
ret := _m.Called(_a0, _a1)
if len(ret) == 0 {
panic("no return value specified for DropPartition")
}
var r0 *commonpb.Status
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.DropPartitionRequest) (*commonpb.Status, error)); ok {
@ -1030,6 +1156,10 @@ func (_c *RootCoord_DropPartition_Call) RunAndReturn(run func(context.Context, *
func (_m *RootCoord) DropRole(_a0 context.Context, _a1 *milvuspb.DropRoleRequest) (*commonpb.Status, error) {
ret := _m.Called(_a0, _a1)
if len(ret) == 0 {
panic("no return value specified for DropRole")
}
var r0 *commonpb.Status
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.DropRoleRequest) (*commonpb.Status, error)); ok {
@ -1085,6 +1215,10 @@ func (_c *RootCoord_DropRole_Call) RunAndReturn(run func(context.Context, *milvu
func (_m *RootCoord) GetComponentStates(_a0 context.Context, _a1 *milvuspb.GetComponentStatesRequest) (*milvuspb.ComponentStates, error) {
ret := _m.Called(_a0, _a1)
if len(ret) == 0 {
panic("no return value specified for GetComponentStates")
}
var r0 *milvuspb.ComponentStates
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.GetComponentStatesRequest) (*milvuspb.ComponentStates, error)); ok {
@ -1140,6 +1274,10 @@ func (_c *RootCoord_GetComponentStates_Call) RunAndReturn(run func(context.Conte
func (_m *RootCoord) GetCredential(_a0 context.Context, _a1 *rootcoordpb.GetCredentialRequest) (*rootcoordpb.GetCredentialResponse, error) {
ret := _m.Called(_a0, _a1)
if len(ret) == 0 {
panic("no return value specified for GetCredential")
}
var r0 *rootcoordpb.GetCredentialResponse
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, *rootcoordpb.GetCredentialRequest) (*rootcoordpb.GetCredentialResponse, error)); ok {
@ -1195,6 +1333,10 @@ func (_c *RootCoord_GetCredential_Call) RunAndReturn(run func(context.Context, *
func (_m *RootCoord) GetImportState(_a0 context.Context, _a1 *milvuspb.GetImportStateRequest) (*milvuspb.GetImportStateResponse, error) {
ret := _m.Called(_a0, _a1)
if len(ret) == 0 {
panic("no return value specified for GetImportState")
}
var r0 *milvuspb.GetImportStateResponse
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.GetImportStateRequest) (*milvuspb.GetImportStateResponse, error)); ok {
@ -1246,17 +1388,21 @@ func (_c *RootCoord_GetImportState_Call) RunAndReturn(run func(context.Context,
return _c
}
// GetMetrics provides a mock function with given fields: ctx, req
func (_m *RootCoord) GetMetrics(ctx context.Context, req *milvuspb.GetMetricsRequest) (*milvuspb.GetMetricsResponse, error) {
ret := _m.Called(ctx, req)
// GetMetrics provides a mock function with given fields: _a0, _a1
func (_m *RootCoord) GetMetrics(_a0 context.Context, _a1 *milvuspb.GetMetricsRequest) (*milvuspb.GetMetricsResponse, error) {
ret := _m.Called(_a0, _a1)
if len(ret) == 0 {
panic("no return value specified for GetMetrics")
}
var r0 *milvuspb.GetMetricsResponse
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.GetMetricsRequest) (*milvuspb.GetMetricsResponse, error)); ok {
return rf(ctx, req)
return rf(_a0, _a1)
}
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.GetMetricsRequest) *milvuspb.GetMetricsResponse); ok {
r0 = rf(ctx, req)
r0 = rf(_a0, _a1)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*milvuspb.GetMetricsResponse)
@ -1264,7 +1410,7 @@ func (_m *RootCoord) GetMetrics(ctx context.Context, req *milvuspb.GetMetricsReq
}
if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.GetMetricsRequest) error); ok {
r1 = rf(ctx, req)
r1 = rf(_a0, _a1)
} else {
r1 = ret.Error(1)
}
@ -1278,13 +1424,13 @@ type RootCoord_GetMetrics_Call struct {
}
// GetMetrics is a helper method to define mock.On call
// - ctx context.Context
// - req *milvuspb.GetMetricsRequest
func (_e *RootCoord_Expecter) GetMetrics(ctx interface{}, req interface{}) *RootCoord_GetMetrics_Call {
return &RootCoord_GetMetrics_Call{Call: _e.mock.On("GetMetrics", ctx, req)}
// - _a0 context.Context
// - _a1 *milvuspb.GetMetricsRequest
func (_e *RootCoord_Expecter) GetMetrics(_a0 interface{}, _a1 interface{}) *RootCoord_GetMetrics_Call {
return &RootCoord_GetMetrics_Call{Call: _e.mock.On("GetMetrics", _a0, _a1)}
}
func (_c *RootCoord_GetMetrics_Call) Run(run func(ctx context.Context, req *milvuspb.GetMetricsRequest)) *RootCoord_GetMetrics_Call {
func (_c *RootCoord_GetMetrics_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.GetMetricsRequest)) *RootCoord_GetMetrics_Call {
_c.Call.Run(func(args mock.Arguments) {
run(args[0].(context.Context), args[1].(*milvuspb.GetMetricsRequest))
})
@ -1305,6 +1451,10 @@ func (_c *RootCoord_GetMetrics_Call) RunAndReturn(run func(context.Context, *mil
func (_m *RootCoord) GetStatisticsChannel(_a0 context.Context, _a1 *internalpb.GetStatisticsChannelRequest) (*milvuspb.StringResponse, error) {
ret := _m.Called(_a0, _a1)
if len(ret) == 0 {
panic("no return value specified for GetStatisticsChannel")
}
var r0 *milvuspb.StringResponse
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, *internalpb.GetStatisticsChannelRequest) (*milvuspb.StringResponse, error)); ok {
@ -1360,6 +1510,10 @@ func (_c *RootCoord_GetStatisticsChannel_Call) RunAndReturn(run func(context.Con
func (_m *RootCoord) GetTimeTickChannel(_a0 context.Context, _a1 *internalpb.GetTimeTickChannelRequest) (*milvuspb.StringResponse, error) {
ret := _m.Called(_a0, _a1)
if len(ret) == 0 {
panic("no return value specified for GetTimeTickChannel")
}
var r0 *milvuspb.StringResponse
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, *internalpb.GetTimeTickChannelRequest) (*milvuspb.StringResponse, error)); ok {
@ -1415,6 +1569,10 @@ func (_c *RootCoord_GetTimeTickChannel_Call) RunAndReturn(run func(context.Conte
func (_m *RootCoord) HasCollection(_a0 context.Context, _a1 *milvuspb.HasCollectionRequest) (*milvuspb.BoolResponse, error) {
ret := _m.Called(_a0, _a1)
if len(ret) == 0 {
panic("no return value specified for HasCollection")
}
var r0 *milvuspb.BoolResponse
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.HasCollectionRequest) (*milvuspb.BoolResponse, error)); ok {
@ -1470,6 +1628,10 @@ func (_c *RootCoord_HasCollection_Call) RunAndReturn(run func(context.Context, *
func (_m *RootCoord) HasPartition(_a0 context.Context, _a1 *milvuspb.HasPartitionRequest) (*milvuspb.BoolResponse, error) {
ret := _m.Called(_a0, _a1)
if len(ret) == 0 {
panic("no return value specified for HasPartition")
}
var r0 *milvuspb.BoolResponse
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.HasPartitionRequest) (*milvuspb.BoolResponse, error)); ok {
@ -1525,6 +1687,10 @@ func (_c *RootCoord_HasPartition_Call) RunAndReturn(run func(context.Context, *m
func (_m *RootCoord) Import(_a0 context.Context, _a1 *milvuspb.ImportRequest) (*milvuspb.ImportResponse, error) {
ret := _m.Called(_a0, _a1)
if len(ret) == 0 {
panic("no return value specified for Import")
}
var r0 *milvuspb.ImportResponse
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.ImportRequest) (*milvuspb.ImportResponse, error)); ok {
@ -1580,6 +1746,10 @@ func (_c *RootCoord_Import_Call) RunAndReturn(run func(context.Context, *milvusp
func (_m *RootCoord) Init() error {
ret := _m.Called()
if len(ret) == 0 {
panic("no return value specified for Init")
}
var r0 error
if rf, ok := ret.Get(0).(func() error); ok {
r0 = rf()
@ -1621,6 +1791,10 @@ func (_c *RootCoord_Init_Call) RunAndReturn(run func() error) *RootCoord_Init_Ca
func (_m *RootCoord) InvalidateCollectionMetaCache(_a0 context.Context, _a1 *proxypb.InvalidateCollMetaCacheRequest) (*commonpb.Status, error) {
ret := _m.Called(_a0, _a1)
if len(ret) == 0 {
panic("no return value specified for InvalidateCollectionMetaCache")
}
var r0 *commonpb.Status
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, *proxypb.InvalidateCollMetaCacheRequest) (*commonpb.Status, error)); ok {
@ -1672,10 +1846,73 @@ func (_c *RootCoord_InvalidateCollectionMetaCache_Call) RunAndReturn(run func(co
return _c
}
// ListAliases provides a mock function with given fields: _a0, _a1
func (_m *RootCoord) ListAliases(_a0 context.Context, _a1 *milvuspb.ListAliasesRequest) (*milvuspb.ListAliasesResponse, error) {
ret := _m.Called(_a0, _a1)
if len(ret) == 0 {
panic("no return value specified for ListAliases")
}
var r0 *milvuspb.ListAliasesResponse
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.ListAliasesRequest) (*milvuspb.ListAliasesResponse, error)); ok {
return rf(_a0, _a1)
}
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.ListAliasesRequest) *milvuspb.ListAliasesResponse); ok {
r0 = rf(_a0, _a1)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*milvuspb.ListAliasesResponse)
}
}
if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.ListAliasesRequest) error); ok {
r1 = rf(_a0, _a1)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// RootCoord_ListAliases_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListAliases'
type RootCoord_ListAliases_Call struct {
*mock.Call
}
// ListAliases is a helper method to define mock.On call
// - _a0 context.Context
// - _a1 *milvuspb.ListAliasesRequest
func (_e *RootCoord_Expecter) ListAliases(_a0 interface{}, _a1 interface{}) *RootCoord_ListAliases_Call {
return &RootCoord_ListAliases_Call{Call: _e.mock.On("ListAliases", _a0, _a1)}
}
func (_c *RootCoord_ListAliases_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.ListAliasesRequest)) *RootCoord_ListAliases_Call {
_c.Call.Run(func(args mock.Arguments) {
run(args[0].(context.Context), args[1].(*milvuspb.ListAliasesRequest))
})
return _c
}
func (_c *RootCoord_ListAliases_Call) Return(_a0 *milvuspb.ListAliasesResponse, _a1 error) *RootCoord_ListAliases_Call {
_c.Call.Return(_a0, _a1)
return _c
}
func (_c *RootCoord_ListAliases_Call) RunAndReturn(run func(context.Context, *milvuspb.ListAliasesRequest) (*milvuspb.ListAliasesResponse, error)) *RootCoord_ListAliases_Call {
_c.Call.Return(run)
return _c
}
// ListCredUsers provides a mock function with given fields: _a0, _a1
func (_m *RootCoord) ListCredUsers(_a0 context.Context, _a1 *milvuspb.ListCredUsersRequest) (*milvuspb.ListCredUsersResponse, error) {
ret := _m.Called(_a0, _a1)
if len(ret) == 0 {
panic("no return value specified for ListCredUsers")
}
var r0 *milvuspb.ListCredUsersResponse
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.ListCredUsersRequest) (*milvuspb.ListCredUsersResponse, error)); ok {
@ -1731,6 +1968,10 @@ func (_c *RootCoord_ListCredUsers_Call) RunAndReturn(run func(context.Context, *
func (_m *RootCoord) ListDatabases(_a0 context.Context, _a1 *milvuspb.ListDatabasesRequest) (*milvuspb.ListDatabasesResponse, error) {
ret := _m.Called(_a0, _a1)
if len(ret) == 0 {
panic("no return value specified for ListDatabases")
}
var r0 *milvuspb.ListDatabasesResponse
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.ListDatabasesRequest) (*milvuspb.ListDatabasesResponse, error)); ok {
@ -1786,6 +2027,10 @@ func (_c *RootCoord_ListDatabases_Call) RunAndReturn(run func(context.Context, *
func (_m *RootCoord) ListImportTasks(_a0 context.Context, _a1 *milvuspb.ListImportTasksRequest) (*milvuspb.ListImportTasksResponse, error) {
ret := _m.Called(_a0, _a1)
if len(ret) == 0 {
panic("no return value specified for ListImportTasks")
}
var r0 *milvuspb.ListImportTasksResponse
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.ListImportTasksRequest) (*milvuspb.ListImportTasksResponse, error)); ok {
@ -1841,6 +2086,10 @@ func (_c *RootCoord_ListImportTasks_Call) RunAndReturn(run func(context.Context,
func (_m *RootCoord) ListPolicy(_a0 context.Context, _a1 *internalpb.ListPolicyRequest) (*internalpb.ListPolicyResponse, error) {
ret := _m.Called(_a0, _a1)
if len(ret) == 0 {
panic("no return value specified for ListPolicy")
}
var r0 *internalpb.ListPolicyResponse
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, *internalpb.ListPolicyRequest) (*internalpb.ListPolicyResponse, error)); ok {
@ -1896,6 +2145,10 @@ func (_c *RootCoord_ListPolicy_Call) RunAndReturn(run func(context.Context, *int
func (_m *RootCoord) OperatePrivilege(_a0 context.Context, _a1 *milvuspb.OperatePrivilegeRequest) (*commonpb.Status, error) {
ret := _m.Called(_a0, _a1)
if len(ret) == 0 {
panic("no return value specified for OperatePrivilege")
}
var r0 *commonpb.Status
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.OperatePrivilegeRequest) (*commonpb.Status, error)); ok {
@ -1951,6 +2204,10 @@ func (_c *RootCoord_OperatePrivilege_Call) RunAndReturn(run func(context.Context
func (_m *RootCoord) OperateUserRole(_a0 context.Context, _a1 *milvuspb.OperateUserRoleRequest) (*commonpb.Status, error) {
ret := _m.Called(_a0, _a1)
if len(ret) == 0 {
panic("no return value specified for OperateUserRole")
}
var r0 *commonpb.Status
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.OperateUserRoleRequest) (*commonpb.Status, error)); ok {
@ -2006,6 +2263,10 @@ func (_c *RootCoord_OperateUserRole_Call) RunAndReturn(run func(context.Context,
func (_m *RootCoord) Register() error {
ret := _m.Called()
if len(ret) == 0 {
panic("no return value specified for Register")
}
var r0 error
if rf, ok := ret.Get(0).(func() error); ok {
r0 = rf()
@ -2047,6 +2308,10 @@ func (_c *RootCoord_Register_Call) RunAndReturn(run func() error) *RootCoord_Reg
func (_m *RootCoord) RenameCollection(_a0 context.Context, _a1 *milvuspb.RenameCollectionRequest) (*commonpb.Status, error) {
ret := _m.Called(_a0, _a1)
if len(ret) == 0 {
panic("no return value specified for RenameCollection")
}
var r0 *commonpb.Status
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.RenameCollectionRequest) (*commonpb.Status, error)); ok {
@ -2102,6 +2367,10 @@ func (_c *RootCoord_RenameCollection_Call) RunAndReturn(run func(context.Context
func (_m *RootCoord) ReportImport(_a0 context.Context, _a1 *rootcoordpb.ImportResult) (*commonpb.Status, error) {
ret := _m.Called(_a0, _a1)
if len(ret) == 0 {
panic("no return value specified for ReportImport")
}
var r0 *commonpb.Status
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, *rootcoordpb.ImportResult) (*commonpb.Status, error)); ok {
@ -2157,6 +2426,10 @@ func (_c *RootCoord_ReportImport_Call) RunAndReturn(run func(context.Context, *r
func (_m *RootCoord) SelectGrant(_a0 context.Context, _a1 *milvuspb.SelectGrantRequest) (*milvuspb.SelectGrantResponse, error) {
ret := _m.Called(_a0, _a1)
if len(ret) == 0 {
panic("no return value specified for SelectGrant")
}
var r0 *milvuspb.SelectGrantResponse
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.SelectGrantRequest) (*milvuspb.SelectGrantResponse, error)); ok {
@ -2212,6 +2485,10 @@ func (_c *RootCoord_SelectGrant_Call) RunAndReturn(run func(context.Context, *mi
func (_m *RootCoord) SelectRole(_a0 context.Context, _a1 *milvuspb.SelectRoleRequest) (*milvuspb.SelectRoleResponse, error) {
ret := _m.Called(_a0, _a1)
if len(ret) == 0 {
panic("no return value specified for SelectRole")
}
var r0 *milvuspb.SelectRoleResponse
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.SelectRoleRequest) (*milvuspb.SelectRoleResponse, error)); ok {
@ -2267,6 +2544,10 @@ func (_c *RootCoord_SelectRole_Call) RunAndReturn(run func(context.Context, *mil
func (_m *RootCoord) SelectUser(_a0 context.Context, _a1 *milvuspb.SelectUserRequest) (*milvuspb.SelectUserResponse, error) {
ret := _m.Called(_a0, _a1)
if len(ret) == 0 {
panic("no return value specified for SelectUser")
}
var r0 *milvuspb.SelectUserResponse
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.SelectUserRequest) (*milvuspb.SelectUserResponse, error)); ok {
@ -2318,226 +2599,14 @@ func (_c *RootCoord_SelectUser_Call) RunAndReturn(run func(context.Context, *mil
return _c
}
// SetAddress provides a mock function with given fields: address
func (_m *RootCoord) SetAddress(address string) {
_m.Called(address)
}
// RootCoord_SetAddress_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetAddress'
type RootCoord_SetAddress_Call struct {
*mock.Call
}
// SetAddress is a helper method to define mock.On call
// - address string
func (_e *RootCoord_Expecter) SetAddress(address interface{}) *RootCoord_SetAddress_Call {
return &RootCoord_SetAddress_Call{Call: _e.mock.On("SetAddress", address)}
}
func (_c *RootCoord_SetAddress_Call) Run(run func(address string)) *RootCoord_SetAddress_Call {
_c.Call.Run(func(args mock.Arguments) {
run(args[0].(string))
})
return _c
}
func (_c *RootCoord_SetAddress_Call) Return() *RootCoord_SetAddress_Call {
_c.Call.Return()
return _c
}
func (_c *RootCoord_SetAddress_Call) RunAndReturn(run func(string)) *RootCoord_SetAddress_Call {
_c.Call.Return(run)
return _c
}
// SetDataCoordClient provides a mock function with given fields: dataCoord
func (_m *RootCoord) SetDataCoordClient(dataCoord types.DataCoordClient) error {
ret := _m.Called(dataCoord)
var r0 error
if rf, ok := ret.Get(0).(func(types.DataCoordClient) error); ok {
r0 = rf(dataCoord)
} else {
r0 = ret.Error(0)
}
return r0
}
// RootCoord_SetDataCoordClient_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetDataCoordClient'
type RootCoord_SetDataCoordClient_Call struct {
*mock.Call
}
// SetDataCoordClient is a helper method to define mock.On call
// - dataCoord types.DataCoordClient
func (_e *RootCoord_Expecter) SetDataCoordClient(dataCoord interface{}) *RootCoord_SetDataCoordClient_Call {
return &RootCoord_SetDataCoordClient_Call{Call: _e.mock.On("SetDataCoordClient", dataCoord)}
}
func (_c *RootCoord_SetDataCoordClient_Call) Run(run func(dataCoord types.DataCoordClient)) *RootCoord_SetDataCoordClient_Call {
_c.Call.Run(func(args mock.Arguments) {
run(args[0].(types.DataCoordClient))
})
return _c
}
func (_c *RootCoord_SetDataCoordClient_Call) Return(_a0 error) *RootCoord_SetDataCoordClient_Call {
_c.Call.Return(_a0)
return _c
}
func (_c *RootCoord_SetDataCoordClient_Call) RunAndReturn(run func(types.DataCoordClient) error) *RootCoord_SetDataCoordClient_Call {
_c.Call.Return(run)
return _c
}
// SetEtcdClient provides a mock function with given fields: etcdClient
func (_m *RootCoord) SetEtcdClient(etcdClient *clientv3.Client) {
_m.Called(etcdClient)
}
// RootCoord_SetEtcdClient_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetEtcdClient'
type RootCoord_SetEtcdClient_Call struct {
*mock.Call
}
// SetEtcdClient is a helper method to define mock.On call
// - etcdClient *clientv3.Client
func (_e *RootCoord_Expecter) SetEtcdClient(etcdClient interface{}) *RootCoord_SetEtcdClient_Call {
return &RootCoord_SetEtcdClient_Call{Call: _e.mock.On("SetEtcdClient", etcdClient)}
}
func (_c *RootCoord_SetEtcdClient_Call) Run(run func(etcdClient *clientv3.Client)) *RootCoord_SetEtcdClient_Call {
_c.Call.Run(func(args mock.Arguments) {
run(args[0].(*clientv3.Client))
})
return _c
}
func (_c *RootCoord_SetEtcdClient_Call) Return() *RootCoord_SetEtcdClient_Call {
_c.Call.Return()
return _c
}
func (_c *RootCoord_SetEtcdClient_Call) RunAndReturn(run func(*clientv3.Client)) *RootCoord_SetEtcdClient_Call {
_c.Call.Return(run)
return _c
}
// SetProxyCreator provides a mock function with given fields: _a0
func (_m *RootCoord) SetProxyCreator(_a0 func(context.Context, string, int64) (types.ProxyClient, error)) {
_m.Called(_a0)
}
// RootCoord_SetProxyCreator_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetProxyCreator'
type RootCoord_SetProxyCreator_Call struct {
*mock.Call
}
// SetProxyCreator is a helper method to define mock.On call
// - _a0 func(context.Context , string , int64)(types.ProxyClient , error)
func (_e *RootCoord_Expecter) SetProxyCreator(_a0 interface{}) *RootCoord_SetProxyCreator_Call {
return &RootCoord_SetProxyCreator_Call{Call: _e.mock.On("SetProxyCreator", _a0)}
}
func (_c *RootCoord_SetProxyCreator_Call) Run(run func(_a0 func(context.Context, string, int64) (types.ProxyClient, error))) *RootCoord_SetProxyCreator_Call {
_c.Call.Run(func(args mock.Arguments) {
run(args[0].(func(context.Context, string, int64) (types.ProxyClient, error)))
})
return _c
}
func (_c *RootCoord_SetProxyCreator_Call) Return() *RootCoord_SetProxyCreator_Call {
_c.Call.Return()
return _c
}
func (_c *RootCoord_SetProxyCreator_Call) RunAndReturn(run func(func(context.Context, string, int64) (types.ProxyClient, error))) *RootCoord_SetProxyCreator_Call {
_c.Call.Return(run)
return _c
}
// SetQueryCoordClient provides a mock function with given fields: queryCoord
func (_m *RootCoord) SetQueryCoordClient(queryCoord types.QueryCoordClient) error {
ret := _m.Called(queryCoord)
var r0 error
if rf, ok := ret.Get(0).(func(types.QueryCoordClient) error); ok {
r0 = rf(queryCoord)
} else {
r0 = ret.Error(0)
}
return r0
}
// RootCoord_SetQueryCoordClient_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetQueryCoordClient'
type RootCoord_SetQueryCoordClient_Call struct {
*mock.Call
}
// SetQueryCoordClient is a helper method to define mock.On call
// - queryCoord types.QueryCoordClient
func (_e *RootCoord_Expecter) SetQueryCoordClient(queryCoord interface{}) *RootCoord_SetQueryCoordClient_Call {
return &RootCoord_SetQueryCoordClient_Call{Call: _e.mock.On("SetQueryCoordClient", queryCoord)}
}
func (_c *RootCoord_SetQueryCoordClient_Call) Run(run func(queryCoord types.QueryCoordClient)) *RootCoord_SetQueryCoordClient_Call {
_c.Call.Run(func(args mock.Arguments) {
run(args[0].(types.QueryCoordClient))
})
return _c
}
func (_c *RootCoord_SetQueryCoordClient_Call) Return(_a0 error) *RootCoord_SetQueryCoordClient_Call {
_c.Call.Return(_a0)
return _c
}
func (_c *RootCoord_SetQueryCoordClient_Call) RunAndReturn(run func(types.QueryCoordClient) error) *RootCoord_SetQueryCoordClient_Call {
_c.Call.Return(run)
return _c
}
// SetTiKVClient provides a mock function with given fields: client
func (_m *RootCoord) SetTiKVClient(client *txnkv.Client) {
_m.Called(client)
}
// RootCoord_SetTiKVClient_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetTiKVClient'
type RootCoord_SetTiKVClient_Call struct {
*mock.Call
}
// SetTiKVClient is a helper method to define mock.On call
// - client *txnkv.Client
func (_e *RootCoord_Expecter) SetTiKVClient(client interface{}) *RootCoord_SetTiKVClient_Call {
return &RootCoord_SetTiKVClient_Call{Call: _e.mock.On("SetTiKVClient", client)}
}
func (_c *RootCoord_SetTiKVClient_Call) Run(run func(client *txnkv.Client)) *RootCoord_SetTiKVClient_Call {
_c.Call.Run(func(args mock.Arguments) {
run(args[0].(*txnkv.Client))
})
return _c
}
func (_c *RootCoord_SetTiKVClient_Call) Return() *RootCoord_SetTiKVClient_Call {
_c.Call.Return()
return _c
}
func (_c *RootCoord_SetTiKVClient_Call) RunAndReturn(run func(*txnkv.Client)) *RootCoord_SetTiKVClient_Call {
_c.Call.Return(run)
return _c
}
// ShowCollections provides a mock function with given fields: _a0, _a1
func (_m *RootCoord) ShowCollections(_a0 context.Context, _a1 *milvuspb.ShowCollectionsRequest) (*milvuspb.ShowCollectionsResponse, error) {
ret := _m.Called(_a0, _a1)
if len(ret) == 0 {
panic("no return value specified for ShowCollections")
}
var r0 *milvuspb.ShowCollectionsResponse
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.ShowCollectionsRequest) (*milvuspb.ShowCollectionsResponse, error)); ok {
@ -2593,6 +2662,10 @@ func (_c *RootCoord_ShowCollections_Call) RunAndReturn(run func(context.Context,
func (_m *RootCoord) ShowConfigurations(_a0 context.Context, _a1 *internalpb.ShowConfigurationsRequest) (*internalpb.ShowConfigurationsResponse, error) {
ret := _m.Called(_a0, _a1)
if len(ret) == 0 {
panic("no return value specified for ShowConfigurations")
}
var r0 *internalpb.ShowConfigurationsResponse
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, *internalpb.ShowConfigurationsRequest) (*internalpb.ShowConfigurationsResponse, error)); ok {
@ -2648,6 +2721,10 @@ func (_c *RootCoord_ShowConfigurations_Call) RunAndReturn(run func(context.Conte
func (_m *RootCoord) ShowPartitions(_a0 context.Context, _a1 *milvuspb.ShowPartitionsRequest) (*milvuspb.ShowPartitionsResponse, error) {
ret := _m.Called(_a0, _a1)
if len(ret) == 0 {
panic("no return value specified for ShowPartitions")
}
var r0 *milvuspb.ShowPartitionsResponse
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.ShowPartitionsRequest) (*milvuspb.ShowPartitionsResponse, error)); ok {
@ -2703,6 +2780,10 @@ func (_c *RootCoord_ShowPartitions_Call) RunAndReturn(run func(context.Context,
func (_m *RootCoord) ShowPartitionsInternal(_a0 context.Context, _a1 *milvuspb.ShowPartitionsRequest) (*milvuspb.ShowPartitionsResponse, error) {
ret := _m.Called(_a0, _a1)
if len(ret) == 0 {
panic("no return value specified for ShowPartitionsInternal")
}
var r0 *milvuspb.ShowPartitionsResponse
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.ShowPartitionsRequest) (*milvuspb.ShowPartitionsResponse, error)); ok {
@ -2758,6 +2839,10 @@ func (_c *RootCoord_ShowPartitionsInternal_Call) RunAndReturn(run func(context.C
func (_m *RootCoord) ShowSegments(_a0 context.Context, _a1 *milvuspb.ShowSegmentsRequest) (*milvuspb.ShowSegmentsResponse, error) {
ret := _m.Called(_a0, _a1)
if len(ret) == 0 {
panic("no return value specified for ShowSegments")
}
var r0 *milvuspb.ShowSegmentsResponse
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.ShowSegmentsRequest) (*milvuspb.ShowSegmentsResponse, error)); ok {
@ -2813,6 +2898,10 @@ func (_c *RootCoord_ShowSegments_Call) RunAndReturn(run func(context.Context, *m
func (_m *RootCoord) Start() error {
ret := _m.Called()
if len(ret) == 0 {
panic("no return value specified for Start")
}
var r0 error
if rf, ok := ret.Get(0).(func() error); ok {
r0 = rf()
@ -2854,6 +2943,10 @@ func (_c *RootCoord_Start_Call) RunAndReturn(run func() error) *RootCoord_Start_
func (_m *RootCoord) Stop() error {
ret := _m.Called()
if len(ret) == 0 {
panic("no return value specified for Stop")
}
var r0 error
if rf, ok := ret.Get(0).(func() error); ok {
r0 = rf()
@ -2895,6 +2988,10 @@ func (_c *RootCoord_Stop_Call) RunAndReturn(run func() error) *RootCoord_Stop_Ca
func (_m *RootCoord) UpdateChannelTimeTick(_a0 context.Context, _a1 *internalpb.ChannelTimeTickMsg) (*commonpb.Status, error) {
ret := _m.Called(_a0, _a1)
if len(ret) == 0 {
panic("no return value specified for UpdateChannelTimeTick")
}
var r0 *commonpb.Status
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, *internalpb.ChannelTimeTickMsg) (*commonpb.Status, error)); ok {
@ -2950,6 +3047,10 @@ func (_c *RootCoord_UpdateChannelTimeTick_Call) RunAndReturn(run func(context.Co
func (_m *RootCoord) UpdateCredential(_a0 context.Context, _a1 *internalpb.CredentialInfo) (*commonpb.Status, error) {
ret := _m.Called(_a0, _a1)
if len(ret) == 0 {
panic("no return value specified for UpdateCredential")
}
var r0 *commonpb.Status
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, *internalpb.CredentialInfo) (*commonpb.Status, error)); ok {
@ -3001,39 +3102,6 @@ func (_c *RootCoord_UpdateCredential_Call) RunAndReturn(run func(context.Context
return _c
}
// UpdateStateCode provides a mock function with given fields: _a0
func (_m *RootCoord) UpdateStateCode(_a0 commonpb.StateCode) {
_m.Called(_a0)
}
// RootCoord_UpdateStateCode_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateStateCode'
type RootCoord_UpdateStateCode_Call struct {
*mock.Call
}
// UpdateStateCode is a helper method to define mock.On call
// - _a0 commonpb.StateCode
func (_e *RootCoord_Expecter) UpdateStateCode(_a0 interface{}) *RootCoord_UpdateStateCode_Call {
return &RootCoord_UpdateStateCode_Call{Call: _e.mock.On("UpdateStateCode", _a0)}
}
func (_c *RootCoord_UpdateStateCode_Call) Run(run func(_a0 commonpb.StateCode)) *RootCoord_UpdateStateCode_Call {
_c.Call.Run(func(args mock.Arguments) {
run(args[0].(commonpb.StateCode))
})
return _c
}
func (_c *RootCoord_UpdateStateCode_Call) Return() *RootCoord_UpdateStateCode_Call {
_c.Call.Return()
return _c
}
func (_c *RootCoord_UpdateStateCode_Call) RunAndReturn(run func(commonpb.StateCode)) *RootCoord_UpdateStateCode_Call {
_c.Call.Return(run)
return _c
}
// NewRootCoord creates a new instance of RootCoord. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewRootCoord(t interface {

140
internal/mocks/mock_rootcoord_client.go
View File

@ -914,6 +914,76 @@ func (_c *MockRootCoordClient_DeleteCredential_Call) RunAndReturn(run func(conte
return _c
}
// DescribeAlias provides a mock function with given fields: ctx, in, opts
func (_m *MockRootCoordClient) DescribeAlias(ctx context.Context, in *milvuspb.DescribeAliasRequest, opts ...grpc.CallOption) (*milvuspb.DescribeAliasResponse, 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...)
var r0 *milvuspb.DescribeAliasResponse
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.DescribeAliasRequest, ...grpc.CallOption) (*milvuspb.DescribeAliasResponse, error)); ok {
return rf(ctx, in, opts...)
}
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.DescribeAliasRequest, ...grpc.CallOption) *milvuspb.DescribeAliasResponse); ok {
r0 = rf(ctx, in, opts...)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*milvuspb.DescribeAliasResponse)
}
}
if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.DescribeAliasRequest, ...grpc.CallOption) error); ok {
r1 = rf(ctx, in, opts...)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// MockRootCoordClient_DescribeAlias_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeAlias'
type MockRootCoordClient_DescribeAlias_Call struct {
*mock.Call
}
// DescribeAlias is a helper method to define mock.On call
// - ctx context.Context
// - in *milvuspb.DescribeAliasRequest
// - opts ...grpc.CallOption
func (_e *MockRootCoordClient_Expecter) DescribeAlias(ctx interface{}, in interface{}, opts ...interface{}) *MockRootCoordClient_DescribeAlias_Call {
return &MockRootCoordClient_DescribeAlias_Call{Call: _e.mock.On("DescribeAlias",
append([]interface{}{ctx, in}, opts...)...)}
}
func (_c *MockRootCoordClient_DescribeAlias_Call) Run(run func(ctx context.Context, in *milvuspb.DescribeAliasRequest, opts ...grpc.CallOption)) *MockRootCoordClient_DescribeAlias_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.DescribeAliasRequest), variadicArgs...)
})
return _c
}
func (_c *MockRootCoordClient_DescribeAlias_Call) Return(_a0 *milvuspb.DescribeAliasResponse, _a1 error) *MockRootCoordClient_DescribeAlias_Call {
_c.Call.Return(_a0, _a1)
return _c
}
func (_c *MockRootCoordClient_DescribeAlias_Call) RunAndReturn(run func(context.Context, *milvuspb.DescribeAliasRequest, ...grpc.CallOption) (*milvuspb.DescribeAliasResponse, error)) *MockRootCoordClient_DescribeAlias_Call {
_c.Call.Return(run)
return _c
}
// DescribeCollection provides a mock function with given fields: ctx, in, opts
func (_m *MockRootCoordClient) DescribeCollection(ctx context.Context, in *milvuspb.DescribeCollectionRequest, opts ...grpc.CallOption) (*milvuspb.DescribeCollectionResponse, error) {
_va := make([]interface{}, len(opts))
@ -2104,6 +2174,76 @@ func (_c *MockRootCoordClient_InvalidateCollectionMetaCache_Call) RunAndReturn(r
return _c
}
// ListAliases provides a mock function with given fields: ctx, in, opts
func (_m *MockRootCoordClient) ListAliases(ctx context.Context, in *milvuspb.ListAliasesRequest, opts ...grpc.CallOption) (*milvuspb.ListAliasesResponse, 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...)
var r0 *milvuspb.ListAliasesResponse
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.ListAliasesRequest, ...grpc.CallOption) (*milvuspb.ListAliasesResponse, error)); ok {
return rf(ctx, in, opts...)
}
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.ListAliasesRequest, ...grpc.CallOption) *milvuspb.ListAliasesResponse); ok {
r0 = rf(ctx, in, opts...)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*milvuspb.ListAliasesResponse)
}
}
if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.ListAliasesRequest, ...grpc.CallOption) error); ok {
r1 = rf(ctx, in, opts...)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// MockRootCoordClient_ListAliases_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListAliases'
type MockRootCoordClient_ListAliases_Call struct {
*mock.Call
}
// ListAliases is a helper method to define mock.On call
// - ctx context.Context
// - in *milvuspb.ListAliasesRequest
// - opts ...grpc.CallOption
func (_e *MockRootCoordClient_Expecter) ListAliases(ctx interface{}, in interface{}, opts ...interface{}) *MockRootCoordClient_ListAliases_Call {
return &MockRootCoordClient_ListAliases_Call{Call: _e.mock.On("ListAliases",
append([]interface{}{ctx, in}, opts...)...)}
}
func (_c *MockRootCoordClient_ListAliases_Call) Run(run func(ctx context.Context, in *milvuspb.ListAliasesRequest, opts ...grpc.CallOption)) *MockRootCoordClient_ListAliases_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.ListAliasesRequest), variadicArgs...)
})
return _c
}
func (_c *MockRootCoordClient_ListAliases_Call) Return(_a0 *milvuspb.ListAliasesResponse, _a1 error) *MockRootCoordClient_ListAliases_Call {
_c.Call.Return(_a0, _a1)
return _c
}
func (_c *MockRootCoordClient_ListAliases_Call) RunAndReturn(run func(context.Context, *milvuspb.ListAliasesRequest, ...grpc.CallOption) (*milvuspb.ListAliasesResponse, error)) *MockRootCoordClient_ListAliases_Call {
_c.Call.Return(run)
return _c
}
// ListCredUsers provides a mock function with given fields: ctx, in, opts
func (_m *MockRootCoordClient) ListCredUsers(ctx context.Context, in *milvuspb.ListCredUsersRequest, opts ...grpc.CallOption) (*milvuspb.ListCredUsersResponse, error) {
_va := make([]interface{}, len(opts))

2
internal/proto/root_coord.proto
View File

@ -54,6 +54,8 @@ service RootCoord {
rpc CreateAlias(milvus.CreateAliasRequest) returns (common.Status) {}
rpc DropAlias(milvus.DropAliasRequest) returns (common.Status) {}
rpc AlterAlias(milvus.AlterAliasRequest) returns (common.Status) {}
rpc DescribeAlias(milvus.DescribeAliasRequest) returns (milvus.DescribeAliasResponse) {}
rpc ListAliases(milvus.ListAliasesRequest) returns (milvus.ListAliasesResponse) {}
/**
* @brief This method is used to list all collections.

127
internal/proxy/impl.go
View File

@ -3194,16 +3194,131 @@ func (node *Proxy) CreateAlias(ctx context.Context, request *milvuspb.CreateAlia
return cat.result, nil
}
// DescribeAlias describe alias of collection.
func (node *Proxy) DescribeAlias(ctx context.Context, request *milvuspb.DescribeAliasRequest) (*milvuspb.DescribeAliasResponse, error) {
return &milvuspb.DescribeAliasResponse{
Status: merr.Status(merr.WrapErrServiceUnavailable("DescribeAlias unimplemented")),
}, nil
if err := merr.CheckHealthy(node.GetStateCode()); err != nil {
return &milvuspb.DescribeAliasResponse{
Status: merr.Status(err),
}, nil
}
ctx, sp := otel.Tracer(typeutil.ProxyRole).Start(ctx, "Proxy-DescribeAlias")
defer sp.End()
dat := &DescribeAliasTask{
ctx: ctx,
Condition: NewTaskCondition(ctx),
nodeID: node.session.ServerID,
DescribeAliasRequest: request,
rootCoord: node.rootCoord,
}
method := "DescribeAlias"
tr := timerecord.NewTimeRecorder(method)
metrics.ProxyFunctionCall.WithLabelValues(strconv.FormatInt(node.session.ServerID, 10), method, metrics.TotalLabel).Inc()
log := log.Ctx(ctx).With(
zap.String("role", typeutil.ProxyRole),
zap.String("db", request.DbName),
zap.String("alias", request.Alias))
log.Debug(rpcReceived(method))
if err := node.sched.ddQueue.Enqueue(dat); err != nil {
log.Warn(
rpcFailedToEnqueue(method),
zap.Error(err))
metrics.ProxyFunctionCall.WithLabelValues(strconv.FormatInt(node.session.ServerID, 10), method, metrics.AbandonLabel).Inc()
return &milvuspb.DescribeAliasResponse{
Status: merr.Status(err),
}, nil
}
log.Debug(
rpcEnqueued(method),
zap.Uint64("BeginTs", dat.BeginTs()),
zap.Uint64("EndTs", dat.EndTs()))
if err := dat.WaitToFinish(); err != nil {
log.Warn(rpcFailedToWaitToFinish(method), zap.Uint64("BeginTs", dat.BeginTs()), zap.Uint64("EndTs", dat.EndTs()), zap.Error(err))
metrics.ProxyFunctionCall.WithLabelValues(strconv.FormatInt(node.session.ServerID, 10), method, metrics.FailLabel).Inc()
return &milvuspb.DescribeAliasResponse{
Status: merr.Status(err),
}, nil
}
log.Debug(
rpcDone(method),
zap.Uint64("BeginTs", dat.BeginTs()),
zap.Uint64("EndTs", dat.EndTs()))
metrics.ProxyFunctionCall.WithLabelValues(strconv.FormatInt(node.session.ServerID, 10), method, metrics.SuccessLabel).Inc()
metrics.ProxyReqLatency.WithLabelValues(strconv.FormatInt(node.session.ServerID, 10), method).Observe(float64(tr.ElapseSpan().Milliseconds()))
return dat.result, nil
}
// ListAliases show all aliases of db.
func (node *Proxy) ListAliases(ctx context.Context, request *milvuspb.ListAliasesRequest) (*milvuspb.ListAliasesResponse, error) {
return &milvuspb.ListAliasesResponse{
Status: merr.Status(merr.WrapErrServiceUnavailable("ListAliases unimplemented")),
}, nil
if err := merr.CheckHealthy(node.GetStateCode()); err != nil {
return &milvuspb.ListAliasesResponse{
Status: merr.Status(err),
}, nil
}
ctx, sp := otel.Tracer(typeutil.ProxyRole).Start(ctx, "Proxy-ListAliases")
defer sp.End()
lat := &ListAliasesTask{
ctx: ctx,
Condition: NewTaskCondition(ctx),
nodeID: node.session.ServerID,
ListAliasesRequest: request,
rootCoord: node.rootCoord,
}
method := "ListAliases"
tr := timerecord.NewTimeRecorder(method)
metrics.ProxyFunctionCall.WithLabelValues(strconv.FormatInt(node.session.ServerID, 10), method, metrics.TotalLabel).Inc()
log := log.Ctx(ctx).With(
zap.String("role", typeutil.ProxyRole),
zap.String("db", request.DbName))
log.Debug(rpcReceived(method))
if err := node.sched.ddQueue.Enqueue(lat); err != nil {
log.Warn(
rpcFailedToEnqueue(method),
zap.Error(err))
metrics.ProxyFunctionCall.WithLabelValues(strconv.FormatInt(node.session.ServerID, 10), method, metrics.AbandonLabel).Inc()
return &milvuspb.ListAliasesResponse{
Status: merr.Status(err),
}, nil
}
log.Debug(
rpcEnqueued(method),
zap.Uint64("BeginTs", lat.BeginTs()),
zap.Uint64("EndTs", lat.EndTs()))
if err := lat.WaitToFinish(); err != nil {
log.Warn(rpcFailedToWaitToFinish(method), zap.Uint64("BeginTs", lat.BeginTs()), zap.Uint64("EndTs", lat.EndTs()), zap.Error(err))
metrics.ProxyFunctionCall.WithLabelValues(strconv.FormatInt(node.session.ServerID, 10), method, metrics.FailLabel).Inc()
return &milvuspb.ListAliasesResponse{
Status: merr.Status(err),
}, nil
}
log.Debug(
rpcDone(method),
zap.Uint64("BeginTs", lat.BeginTs()),
zap.Uint64("EndTs", lat.EndTs()))
metrics.ProxyFunctionCall.WithLabelValues(strconv.FormatInt(node.session.ServerID, 10), method, metrics.SuccessLabel).Inc()
metrics.ProxyReqLatency.WithLabelValues(strconv.FormatInt(node.session.ServerID, 10), method).Observe(float64(tr.ElapseSpan().Milliseconds()))
return lat.result, nil
}
// DropAlias alter the alias of collection.

72
internal/proxy/proxy_test.go
View File

@ -754,6 +754,30 @@ func TestProxy(t *testing.T) {
})
})
wg.Add(1)
t.Run("describe alias", func(t *testing.T) {
defer wg.Done()
describeAliasReq := &milvuspb.DescribeAliasRequest{
Base: nil,
DbName: dbName,
Alias: "alias",
}
resp, err := proxy.DescribeAlias(ctx, describeAliasReq)
assert.NoError(t, err)
assert.Equal(t, commonpb.ErrorCode_Success, resp.GetStatus().GetErrorCode())
})
wg.Add(1)
t.Run("list alias", func(t *testing.T) {
defer wg.Done()
listAliasReq := &milvuspb.ListAliasesRequest{
Base: nil,
}
resp, err := proxy.ListAliases(ctx, listAliasReq)
assert.NoError(t, err)
assert.Equal(t, commonpb.ErrorCode_Success, resp.GetStatus().GetErrorCode())
})
wg.Add(1)
t.Run("alter alias", func(t *testing.T) {
defer wg.Done()
@ -2884,6 +2908,22 @@ func TestProxy(t *testing.T) {
assert.NotEqual(t, commonpb.ErrorCode_Success, resp.ErrorCode)
})
wg.Add(1)
t.Run("ListAliases fail, unhealthy", func(t *testing.T) {
defer wg.Done()
resp, err := proxy.ListAliases(ctx, &milvuspb.ListAliasesRequest{})
assert.NoError(t, err)
assert.NotEqual(t, commonpb.ErrorCode_Success, resp.GetStatus().GetErrorCode())
})
wg.Add(1)
t.Run("DescribeAlias fail, unhealthy", func(t *testing.T) {
defer wg.Done()
resp, err := proxy.DescribeAlias(ctx, &milvuspb.DescribeAliasRequest{})
assert.NoError(t, err)
assert.NotEqual(t, commonpb.ErrorCode_Success, resp.GetStatus().GetErrorCode())
})
wg.Add(1)
t.Run("GetPersistentSegmentInfo fail, unhealthy", func(t *testing.T) {
defer wg.Done()
@ -3202,6 +3242,22 @@ func TestProxy(t *testing.T) {
assert.NotEqual(t, commonpb.ErrorCode_Success, resp.ErrorCode)
})
wg.Add(1)
t.Run("DescribeAlias fail, dd queue full", func(t *testing.T) {
defer wg.Done()
resp, err := proxy.DescribeAlias(ctx, &milvuspb.DescribeAliasRequest{})
assert.NoError(t, err)
assert.NotEqual(t, commonpb.ErrorCode_Success, resp.GetStatus().GetErrorCode())
})
wg.Add(1)
t.Run("ListAliases fail, dd queue full", func(t *testing.T) {
defer wg.Done()
resp, err := proxy.ListAliases(ctx, &milvuspb.ListAliasesRequest{})
assert.NoError(t, err)
assert.NotEqual(t, commonpb.ErrorCode_Success, resp.GetStatus().GetErrorCode())
})
proxy.sched.ddQueue.setMaxTaskNum(ddParallel)
dmParallelism := proxy.sched.dmQueue.getMaxTaskNum()
@ -3522,6 +3578,22 @@ func TestProxy(t *testing.T) {
assert.NotEqual(t, commonpb.ErrorCode_Success, resp.ErrorCode)
})
wg.Add(1)
t.Run("DescribeAlias fail, timeout", func(t *testing.T) {
defer wg.Done()
resp, err := proxy.DescribeAlias(shortCtx, &milvuspb.DescribeAliasRequest{})
assert.NoError(t, err)
assert.NotEqual(t, commonpb.ErrorCode_Success, resp.GetStatus().GetErrorCode())
})
wg.Add(1)
t.Run("ListAliases fail, timeout", func(t *testing.T) {
defer wg.Done()
resp, err := proxy.ListAliases(shortCtx, &milvuspb.ListAliasesRequest{})
assert.NoError(t, err)
assert.NotEqual(t, commonpb.ErrorCode_Success, resp.GetStatus().GetErrorCode())
})
wg.Add(1)
t.Run("CreateCredential fail, timeout", func(t *testing.T) {
defer wg.Done()

69
internal/proxy/rootcoord_mock_test.go
View File

@ -190,6 +190,75 @@ func (coord *RootCoordMock) AlterAlias(ctx context.Context, req *milvuspb.AlterA
return merr.Success(), nil
}
func (coord *RootCoordMock) DescribeAlias(ctx context.Context, req *milvuspb.DescribeAliasRequest, opts ...grpc.CallOption) (*milvuspb.DescribeAliasResponse, error) {
code := coord.state.Load().(commonpb.StateCode)
if code != commonpb.StateCode_Healthy {
return &milvuspb.DescribeAliasResponse{
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
Reason: fmt.Sprintf("state code = %s", commonpb.StateCode_name[int32(code)]),
},
}, nil
}
coord.collMtx.Lock()
defer coord.collMtx.Unlock()
collID, exist := coord.collAlias2ID[req.Alias]
if !exist {
return &milvuspb.DescribeAliasResponse{
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_CollectionNotExists,
Reason: fmt.Sprintf("alias does not exist, alias = %s", req.Alias),
},
}, nil
}
collMeta, exist := coord.collID2Meta[collID]
if !exist {
return &milvuspb.DescribeAliasResponse{
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_CollectionNotExists,
Reason: fmt.Sprintf("alias exist but not find related collection, alias = %s collID = %d", req.Alias, collID),
},
}, nil
}
return &milvuspb.DescribeAliasResponse{
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_Success,
Reason: "",
},
DbName: req.GetDbName(),
Alias: req.GetAlias(),
Collection: collMeta.name,
}, nil
}
func (coord *RootCoordMock) ListAliases(ctx context.Context, req *milvuspb.ListAliasesRequest, opts ...grpc.CallOption) (*milvuspb.ListAliasesResponse, error) {
code := coord.state.Load().(commonpb.StateCode)
if code != commonpb.StateCode_Healthy {
return &milvuspb.ListAliasesResponse{
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
Reason: fmt.Sprintf("state code = %s", commonpb.StateCode_name[int32(code)]),
},
}, nil
}
coord.collMtx.Lock()
defer coord.collMtx.Unlock()
var aliases []string
for alias := range coord.collAlias2ID {
aliases = append(aliases, alias)
}
return &milvuspb.ListAliasesResponse{
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_Success,
Reason: "",
},
DbName: req.GetDbName(),
Aliases: aliases,
}, nil
}
func (coord *RootCoordMock) updateState(state commonpb.StateCode) {
coord.state.Store(state)
}

237
internal/proxy/task.go
View File

@ -73,6 +73,8 @@ const (
CreateAliasTaskName = "CreateAliasTask"
DropAliasTaskName = "DropAliasTask"
AlterAliasTaskName = "AlterAliasTask"
DescribeAliasTaskName = "DescribeAliasTask"
ListAliasesTaskName = "ListAliasesTask"
AlterCollectionTaskName = "AlterCollectionTask"
UpsertTaskName = "UpsertTask"
CreateResourceGroupTaskName = "CreateResourceGroupTask"
@ -1905,241 +1907,6 @@ func (t *releasePartitionsTask) PostExecute(ctx context.Context) error {
return nil
}
// CreateAliasTask contains task information of CreateAlias
type CreateAliasTask struct {
Condition
*milvuspb.CreateAliasRequest
ctx context.Context
rootCoord types.RootCoordClient
result *commonpb.Status
}
// TraceCtx returns the trace context of the task.
func (t *CreateAliasTask) TraceCtx() context.Context {
return t.ctx
}
// ID return the id of the task
func (t *CreateAliasTask) ID() UniqueID {
return t.Base.MsgID
}
// SetID sets the id of the task
func (t *CreateAliasTask) SetID(uid UniqueID) {
t.Base.MsgID = uid
}
// Name returns the name of the task
func (t *CreateAliasTask) Name() string {
return CreateAliasTaskName
}
// Type returns the type of the task
func (t *CreateAliasTask) Type() commonpb.MsgType {
return t.Base.MsgType
}
// BeginTs returns the ts
func (t *CreateAliasTask) BeginTs() Timestamp {
return t.Base.Timestamp
}
// EndTs returns the ts
func (t *CreateAliasTask) EndTs() Timestamp {
return t.Base.Timestamp
}
// SetTs sets the ts
func (t *CreateAliasTask) SetTs(ts Timestamp) {
t.Base.Timestamp = ts
}
// OnEnqueue defines the behavior task enqueued
func (t *CreateAliasTask) OnEnqueue() error {
if t.Base == nil {
t.Base = commonpbutil.NewMsgBase()
}
return nil
}
// PreExecute defines the tion before task execution
func (t *CreateAliasTask) PreExecute(ctx context.Context) error {
t.Base.MsgType = commonpb.MsgType_CreateAlias
t.Base.SourceID = paramtable.GetNodeID()
collAlias := t.Alias
// collection alias uses the same format as collection name
if err := ValidateCollectionAlias(collAlias); err != nil {
return err
}
collName := t.CollectionName
if err := validateCollectionName(collName); err != nil {
return err
}
return nil
}
// Execute defines the tual execution of create alias
func (t *CreateAliasTask) Execute(ctx context.Context) error {
var err error
t.result, err = t.rootCoord.CreateAlias(ctx, t.CreateAliasRequest)
return err
}
// PostExecute defines the post execution, do nothing for create alias
func (t *CreateAliasTask) PostExecute(ctx context.Context) error {
return nil
}
// DropAliasTask is the task to drop alias
type DropAliasTask struct {
Condition
*milvuspb.DropAliasRequest
ctx context.Context
rootCoord types.RootCoordClient
result *commonpb.Status
}
// TraceCtx returns the context for trace
func (t *DropAliasTask) TraceCtx() context.Context {
return t.ctx
}
// ID returns the MsgID
func (t *DropAliasTask) ID() UniqueID {
return t.Base.MsgID
}
// SetID sets the MsgID
func (t *DropAliasTask) SetID(uid UniqueID) {
t.Base.MsgID = uid
}
// Name returns the name of the task
func (t *DropAliasTask) Name() string {
return DropAliasTaskName
}
func (t *DropAliasTask) Type() commonpb.MsgType {
return t.Base.MsgType
}
func (t *DropAliasTask) BeginTs() Timestamp {
return t.Base.Timestamp
}
func (t *DropAliasTask) EndTs() Timestamp {
return t.Base.Timestamp
}
func (t *DropAliasTask) SetTs(ts Timestamp) {
t.Base.Timestamp = ts
}
func (t *DropAliasTask) OnEnqueue() error {
if t.Base == nil {
t.Base = commonpbutil.NewMsgBase()
}
return nil
}
func (t *DropAliasTask) PreExecute(ctx context.Context) error {
t.Base.MsgType = commonpb.MsgType_DropAlias
t.Base.SourceID = paramtable.GetNodeID()
collAlias := t.Alias
if err := ValidateCollectionAlias(collAlias); err != nil {
return err
}
return nil
}
func (t *DropAliasTask) Execute(ctx context.Context) error {
var err error
t.result, err = t.rootCoord.DropAlias(ctx, t.DropAliasRequest)
return err
}
func (t *DropAliasTask) PostExecute(ctx context.Context) error {
return nil
}
// AlterAliasTask is the task to alter alias
type AlterAliasTask struct {
Condition
*milvuspb.AlterAliasRequest
ctx context.Context
rootCoord types.RootCoordClient
result *commonpb.Status
}
func (t *AlterAliasTask) TraceCtx() context.Context {
return t.ctx
}
func (t *AlterAliasTask) ID() UniqueID {
return t.Base.MsgID
}
func (t *AlterAliasTask) SetID(uid UniqueID) {
t.Base.MsgID = uid
}
func (t *AlterAliasTask) Name() string {
return AlterAliasTaskName
}
func (t *AlterAliasTask) Type() commonpb.MsgType {
return t.Base.MsgType
}
func (t *AlterAliasTask) BeginTs() Timestamp {
return t.Base.Timestamp
}
func (t *AlterAliasTask) EndTs() Timestamp {
return t.Base.Timestamp
}
func (t *AlterAliasTask) SetTs(ts Timestamp) {
t.Base.Timestamp = ts
}
func (t *AlterAliasTask) OnEnqueue() error {
if t.Base == nil {
t.Base = commonpbutil.NewMsgBase()
}
return nil
}
func (t *AlterAliasTask) PreExecute(ctx context.Context) error {
t.Base.MsgType = commonpb.MsgType_AlterAlias
t.Base.SourceID = paramtable.GetNodeID()
collAlias := t.Alias
// collection alias uses the same format as collection name
if err := ValidateCollectionAlias(collAlias); err != nil {
return err
}
collName := t.CollectionName
if err := validateCollectionName(collName); err != nil {
return err
}
return nil
}
func (t *AlterAliasTask) Execute(ctx context.Context) error {
var err error
t.result, err = t.rootCoord.AlterAlias(ctx, t.AlterAliasRequest)
return err
}
func (t *AlterAliasTask) PostExecute(ctx context.Context) error {
return nil
}
type CreateResourceGroupTask struct {
Condition
*milvuspb.CreateResourceGroupRequest

388
internal/proxy/task_alias.go Normal file
View File

@ -0,0 +1,388 @@
// 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"
"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/internal/types"
"github.com/milvus-io/milvus/pkg/util/commonpbutil"
"github.com/milvus-io/milvus/pkg/util/paramtable"
)
// CreateAliasTask contains task information of CreateAlias
type CreateAliasTask struct {
Condition
*milvuspb.CreateAliasRequest
ctx context.Context
rootCoord types.RootCoordClient
result *commonpb.Status
}
// TraceCtx returns the trace context of the task.
func (t *CreateAliasTask) TraceCtx() context.Context {
return t.ctx
}
// ID return the id of the task
func (t *CreateAliasTask) ID() UniqueID {
return t.Base.MsgID
}
// SetID sets the id of the task
func (t *CreateAliasTask) SetID(uid UniqueID) {
t.Base.MsgID = uid
}
// Name returns the name of the task
func (t *CreateAliasTask) Name() string {
return CreateAliasTaskName
}
// Type returns the type of the task
func (t *CreateAliasTask) Type() commonpb.MsgType {
return t.Base.MsgType
}
// BeginTs returns the ts
func (t *CreateAliasTask) BeginTs() Timestamp {
return t.Base.Timestamp
}
// EndTs returns the ts
func (t *CreateAliasTask) EndTs() Timestamp {
return t.Base.Timestamp
}
// SetTs sets the ts
func (t *CreateAliasTask) SetTs(ts Timestamp) {
t.Base.Timestamp = ts
}
// OnEnqueue defines the behavior task enqueued
func (t *CreateAliasTask) OnEnqueue() error {
if t.Base == nil {
t.Base = commonpbutil.NewMsgBase()
}
return nil
}
// PreExecute defines the tion before task execution
func (t *CreateAliasTask) PreExecute(ctx context.Context) error {
t.Base.MsgType = commonpb.MsgType_CreateAlias
t.Base.SourceID = paramtable.GetNodeID()
collAlias := t.Alias
// collection alias uses the same format as collection name
if err := ValidateCollectionAlias(collAlias); err != nil {
return err
}
collName := t.CollectionName
if err := validateCollectionName(collName); err != nil {
return err
}
return nil
}
// Execute defines the tual execution of create alias
func (t *CreateAliasTask) Execute(ctx context.Context) error {
var err error
t.result, err = t.rootCoord.CreateAlias(ctx, t.CreateAliasRequest)
return err
}
// PostExecute defines the post execution, do nothing for create alias
func (t *CreateAliasTask) PostExecute(ctx context.Context) error {
return nil
}
// DropAliasTask is the task to drop alias
type DropAliasTask struct {
Condition
*milvuspb.DropAliasRequest
ctx context.Context
rootCoord types.RootCoordClient
result *commonpb.Status
}
// TraceCtx returns the context for trace
func (t *DropAliasTask) TraceCtx() context.Context {
return t.ctx
}
// ID returns the MsgID
func (t *DropAliasTask) ID() UniqueID {
return t.Base.MsgID
}
// SetID sets the MsgID
func (t *DropAliasTask) SetID(uid UniqueID) {
t.Base.MsgID = uid
}
// Name returns the name of the task
func (t *DropAliasTask) Name() string {
return DropAliasTaskName
}
func (t *DropAliasTask) Type() commonpb.MsgType {
return t.Base.MsgType
}
func (t *DropAliasTask) BeginTs() Timestamp {
return t.Base.Timestamp
}
func (t *DropAliasTask) EndTs() Timestamp {
return t.Base.Timestamp
}
func (t *DropAliasTask) SetTs(ts Timestamp) {
t.Base.Timestamp = ts
}
func (t *DropAliasTask) OnEnqueue() error {
if t.Base == nil {
t.Base = commonpbutil.NewMsgBase()
}
return nil
}
func (t *DropAliasTask) PreExecute(ctx context.Context) error {
t.Base.MsgType = commonpb.MsgType_DropAlias
t.Base.SourceID = paramtable.GetNodeID()
collAlias := t.Alias
if err := ValidateCollectionAlias(collAlias); err != nil {
return err
}
return nil
}
func (t *DropAliasTask) Execute(ctx context.Context) error {
var err error
t.result, err = t.rootCoord.DropAlias(ctx, t.DropAliasRequest)
return err
}
func (t *DropAliasTask) PostExecute(ctx context.Context) error {
return nil
}
// AlterAliasTask is the task to alter alias
type AlterAliasTask struct {
Condition
*milvuspb.AlterAliasRequest
ctx context.Context
rootCoord types.RootCoordClient
result *commonpb.Status
}
func (t *AlterAliasTask) TraceCtx() context.Context {
return t.ctx
}
func (t *AlterAliasTask) ID() UniqueID {
return t.Base.MsgID
}
func (t *AlterAliasTask) SetID(uid UniqueID) {
t.Base.MsgID = uid
}
func (t *AlterAliasTask) Name() string {
return AlterAliasTaskName
}
func (t *AlterAliasTask) Type() commonpb.MsgType {
return t.Base.MsgType
}
func (t *AlterAliasTask) BeginTs() Timestamp {
return t.Base.Timestamp
}
func (t *AlterAliasTask) EndTs() Timestamp {
return t.Base.Timestamp
}
func (t *AlterAliasTask) SetTs(ts Timestamp) {
t.Base.Timestamp = ts
}
func (t *AlterAliasTask) OnEnqueue() error {
if t.Base == nil {
t.Base = commonpbutil.NewMsgBase()
}
return nil
}
func (t *AlterAliasTask) PreExecute(ctx context.Context) error {
t.Base.MsgType = commonpb.MsgType_AlterAlias
t.Base.SourceID = paramtable.GetNodeID()
collAlias := t.Alias
// collection alias uses the same format as collection name
if err := ValidateCollectionAlias(collAlias); err != nil {
return err
}
collName := t.CollectionName
if err := validateCollectionName(collName); err != nil {
return err
}
return nil
}
func (t *AlterAliasTask) Execute(ctx context.Context) error {
var err error
t.result, err = t.rootCoord.AlterAlias(ctx, t.AlterAliasRequest)
return err
}
func (t *AlterAliasTask) PostExecute(ctx context.Context) error {
return nil
}
// DescribeAliasTask is the task to describe alias
type DescribeAliasTask struct {
Condition
nodeID UniqueID
*milvuspb.DescribeAliasRequest
ctx context.Context
rootCoord types.RootCoordClient
result *milvuspb.DescribeAliasResponse
}
func (a *DescribeAliasTask) TraceCtx() context.Context {
return a.ctx
}
func (a *DescribeAliasTask) ID() UniqueID {
return a.Base.MsgID
}
func (a *DescribeAliasTask) SetID(uid UniqueID) {
a.Base.MsgID = uid
}
func (a *DescribeAliasTask) Name() string {
return DescribeAliasTaskName
}
func (a *DescribeAliasTask) Type() commonpb.MsgType {
return a.Base.MsgType
}
func (a *DescribeAliasTask) BeginTs() Timestamp {
return a.Base.Timestamp
}
func (a *DescribeAliasTask) EndTs() Timestamp {
return a.Base.Timestamp
}
func (a *DescribeAliasTask) SetTs(ts Timestamp) {
a.Base.Timestamp = ts
}
func (a *DescribeAliasTask) OnEnqueue() error {
a.Base = commonpbutil.NewMsgBase()
return nil
}
func (a *DescribeAliasTask) PreExecute(ctx context.Context) error {
a.Base.MsgType = commonpb.MsgType_DescribeAlias
a.Base.SourceID = a.nodeID
return nil
}
func (a *DescribeAliasTask) Execute(ctx context.Context) error {
var err error
a.result, err = a.rootCoord.DescribeAlias(ctx, a.DescribeAliasRequest)
return err
}
func (a *DescribeAliasTask) PostExecute(ctx context.Context) error {
return nil
}
// ListAliasesTask is the task to list aliases
type ListAliasesTask struct {
Condition
nodeID UniqueID
*milvuspb.ListAliasesRequest
ctx context.Context
rootCoord types.RootCoordClient
result *milvuspb.ListAliasesResponse
}
func (a *ListAliasesTask) TraceCtx() context.Context {
return a.ctx
}
func (a *ListAliasesTask) ID() UniqueID {
return a.Base.MsgID
}
func (a *ListAliasesTask) SetID(uid UniqueID) {
a.Base.MsgID = uid
}
func (a *ListAliasesTask) Name() string {
return ListAliasesTaskName
}
func (a *ListAliasesTask) Type() commonpb.MsgType {
return a.Base.MsgType
}
func (a *ListAliasesTask) BeginTs() Timestamp {
return a.Base.Timestamp
}
func (a *ListAliasesTask) EndTs() Timestamp {
return a.Base.Timestamp
}
func (a *ListAliasesTask) SetTs(ts Timestamp) {
a.Base.Timestamp = ts
}
func (a *ListAliasesTask) OnEnqueue() error {
a.Base = commonpbutil.NewMsgBase()
return nil
}
func (a *ListAliasesTask) PreExecute(ctx context.Context) error {
a.Base.MsgType = commonpb.MsgType_ListAliases
a.Base.SourceID = a.nodeID
return nil
}
func (a *ListAliasesTask) Execute(ctx context.Context) error {
var err error
a.result, err = a.rootCoord.ListAliases(ctx, a.ListAliasesRequest)
return err
}
func (a *ListAliasesTask) PostExecute(ctx context.Context) error {
return nil
}

237
internal/proxy/task_alias_test.go Normal file
View File

@ -0,0 +1,237 @@
// 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"
"testing"
"time"
"github.com/stretchr/testify/assert"
"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/pkg/util/funcutil"
"github.com/milvus-io/milvus/pkg/util/merr"
"github.com/milvus-io/milvus/pkg/util/uniquegenerator"
)
func TestCreateAlias_all(t *testing.T) {
rc := NewRootCoordMock()
defer rc.Close()
ctx := context.Background()
prefix := "TestCreateAlias_all"
collectionName := prefix + funcutil.GenRandomStr()
task := &CreateAliasTask{
Condition: NewTaskCondition(ctx),
CreateAliasRequest: &milvuspb.CreateAliasRequest{
Base: nil,
CollectionName: collectionName,
Alias: "alias1",
},
ctx: ctx,
result: merr.Success(),
rootCoord: rc,
}
assert.NoError(t, task.OnEnqueue())
assert.NotNil(t, task.TraceCtx())
id := UniqueID(uniquegenerator.GetUniqueIntGeneratorIns().GetInt())
task.SetID(id)
assert.Equal(t, id, task.ID())
task.Base.MsgType = commonpb.MsgType_CreateAlias
assert.Equal(t, commonpb.MsgType_CreateAlias, task.Type())
ts := Timestamp(time.Now().UnixNano())
task.SetTs(ts)
assert.Equal(t, ts, task.BeginTs())
assert.Equal(t, ts, task.EndTs())
task.CreateAliasRequest.Alias = "illgal-alias:!"
assert.Error(t, task.PreExecute(ctx))
task.CreateAliasRequest.Alias = "alias1"
task.CreateAliasRequest.CollectionName = "illgal-collection:!"
assert.Error(t, task.PreExecute(ctx))
task.CreateAliasRequest.CollectionName = collectionName
assert.NoError(t, task.PreExecute(ctx))
assert.NoError(t, task.Execute(ctx))
assert.NoError(t, task.PostExecute(ctx))
}
func TestDropAlias_all(t *testing.T) {
rc := NewRootCoordMock()
defer rc.Close()
ctx := context.Background()
task := &DropAliasTask{
Condition: NewTaskCondition(ctx),
DropAliasRequest: &milvuspb.DropAliasRequest{
Base: nil,
Alias: "alias1",
},
ctx: ctx,
result: merr.Success(),
rootCoord: rc,
}
assert.NoError(t, task.OnEnqueue())
assert.NotNil(t, task.TraceCtx())
id := UniqueID(uniquegenerator.GetUniqueIntGeneratorIns().GetInt())
task.SetID(id)
assert.Equal(t, id, task.ID())
task.Base.MsgType = commonpb.MsgType_DropAlias
assert.Equal(t, commonpb.MsgType_DropAlias, task.Type())
ts := Timestamp(time.Now().UnixNano())
task.SetTs(ts)
assert.Equal(t, ts, task.BeginTs())
assert.Equal(t, ts, task.EndTs())
assert.NoError(t, task.PreExecute(ctx))
assert.NoError(t, task.Execute(ctx))
assert.NoError(t, task.PostExecute(ctx))
}
func TestAlterAlias_all(t *testing.T) {
rc := NewRootCoordMock()
defer rc.Close()
ctx := context.Background()
prefix := "TestAlterAlias_all"
collectionName := prefix + funcutil.GenRandomStr()
task := &AlterAliasTask{
Condition: NewTaskCondition(ctx),
AlterAliasRequest: &milvuspb.AlterAliasRequest{
Base: nil,
CollectionName: collectionName,
Alias: "alias1",
},
ctx: ctx,
result: merr.Success(),
rootCoord: rc,
}
assert.NoError(t, task.OnEnqueue())
assert.NotNil(t, task.TraceCtx())
id := UniqueID(uniquegenerator.GetUniqueIntGeneratorIns().GetInt())
task.SetID(id)
assert.Equal(t, id, task.ID())
task.Base.MsgType = commonpb.MsgType_AlterAlias
assert.Equal(t, commonpb.MsgType_AlterAlias, task.Type())
ts := Timestamp(time.Now().UnixNano())
task.SetTs(ts)
assert.Equal(t, ts, task.BeginTs())
assert.Equal(t, ts, task.EndTs())
task.AlterAliasRequest.Alias = "illgal-alias:!"
assert.Error(t, task.PreExecute(ctx))
task.AlterAliasRequest.Alias = "alias1"
task.AlterAliasRequest.CollectionName = "illgal-collection:!"
assert.Error(t, task.PreExecute(ctx))
task.AlterAliasRequest.CollectionName = collectionName
assert.NoError(t, task.PreExecute(ctx))
assert.NoError(t, task.Execute(ctx))
assert.NoError(t, task.PostExecute(ctx))
}
func TestDescribeAlias_all(t *testing.T) {
rc := NewRootCoordMock()
defer rc.Close()
ctx := context.Background()
task := &DescribeAliasTask{
Condition: NewTaskCondition(ctx),
DescribeAliasRequest: &milvuspb.DescribeAliasRequest{
Base: nil,
Alias: "alias1",
},
ctx: ctx,
result: &milvuspb.DescribeAliasResponse{
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_Success,
},
},
rootCoord: rc,
}
assert.NoError(t, task.OnEnqueue())
assert.NotNil(t, task.TraceCtx())
id := UniqueID(uniquegenerator.GetUniqueIntGeneratorIns().GetInt())
task.SetID(id)
assert.Equal(t, id, task.ID())
task.Base.MsgType = commonpb.MsgType_DescribeAlias
assert.Equal(t, commonpb.MsgType_DescribeAlias, task.Type())
ts := Timestamp(time.Now().UnixNano())
task.SetTs(ts)
assert.Equal(t, ts, task.BeginTs())
assert.Equal(t, ts, task.EndTs())
assert.NoError(t, task.PreExecute(ctx))
assert.NoError(t, task.Execute(ctx))
assert.NoError(t, task.PostExecute(ctx))
}
func TestListAliases_all(t *testing.T) {
rc := NewRootCoordMock()
defer rc.Close()
ctx := context.Background()
task := &ListAliasesTask{
Condition: NewTaskCondition(ctx),
ListAliasesRequest: &milvuspb.ListAliasesRequest{
Base: nil,
},
ctx: ctx,
result: &milvuspb.ListAliasesResponse{
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_Success,
},
},
rootCoord: rc,
}
assert.NoError(t, task.OnEnqueue())
assert.NotNil(t, task.TraceCtx())
id := UniqueID(uniquegenerator.GetUniqueIntGeneratorIns().GetInt())
task.SetID(id)
assert.Equal(t, id, task.ID())
task.Base.MsgType = commonpb.MsgType_ListAliases
assert.Equal(t, commonpb.MsgType_ListAliases, task.Type())
ts := Timestamp(time.Now().UnixNano())
task.SetTs(ts)
assert.Equal(t, ts, task.BeginTs())
assert.Equal(t, ts, task.EndTs())
assert.NoError(t, task.PreExecute(ctx))
assert.NoError(t, task.Execute(ctx))
assert.NoError(t, task.PostExecute(ctx))
}

113
internal/proxy/task_test.go
View File

@ -2042,119 +2042,6 @@ func TestTask_VarCharPrimaryKey(t *testing.T) {
})
}
func TestCreateAlias_all(t *testing.T) {
rc := NewRootCoordMock()
defer rc.Close()
ctx := context.Background()
prefix := "TestCreateAlias_all"
collectionName := prefix + funcutil.GenRandomStr()
task := &CreateAliasTask{
Condition: NewTaskCondition(ctx),
CreateAliasRequest: &milvuspb.CreateAliasRequest{
Base: nil,
CollectionName: collectionName,
Alias: "alias1",
},
ctx: ctx,
result: merr.Success(),
rootCoord: rc,
}
assert.NoError(t, task.OnEnqueue())
assert.NotNil(t, task.TraceCtx())
id := UniqueID(uniquegenerator.GetUniqueIntGeneratorIns().GetInt())
task.SetID(id)
assert.Equal(t, id, task.ID())
task.Base.MsgType = commonpb.MsgType_CreateAlias
assert.Equal(t, commonpb.MsgType_CreateAlias, task.Type())
ts := Timestamp(time.Now().UnixNano())
task.SetTs(ts)
assert.Equal(t, ts, task.BeginTs())
assert.Equal(t, ts, task.EndTs())
assert.NoError(t, task.PreExecute(ctx))
assert.NoError(t, task.Execute(ctx))
assert.NoError(t, task.PostExecute(ctx))
}
func TestDropAlias_all(t *testing.T) {
rc := NewRootCoordMock()
defer rc.Close()
ctx := context.Background()
task := &DropAliasTask{
Condition: NewTaskCondition(ctx),
DropAliasRequest: &milvuspb.DropAliasRequest{
Base: nil,
Alias: "alias1",
},
ctx: ctx,
result: merr.Success(),
rootCoord: rc,
}
assert.NoError(t, task.OnEnqueue())
assert.NotNil(t, task.TraceCtx())
id := UniqueID(uniquegenerator.GetUniqueIntGeneratorIns().GetInt())
task.SetID(id)
assert.Equal(t, id, task.ID())
task.Base.MsgType = commonpb.MsgType_DropAlias
assert.Equal(t, commonpb.MsgType_DropAlias, task.Type())
ts := Timestamp(time.Now().UnixNano())
task.SetTs(ts)
assert.Equal(t, ts, task.BeginTs())
assert.Equal(t, ts, task.EndTs())
assert.NoError(t, task.PreExecute(ctx))
assert.NoError(t, task.Execute(ctx))
assert.NoError(t, task.PostExecute(ctx))
}
func TestAlterAlias_all(t *testing.T) {
rc := NewRootCoordMock()
defer rc.Close()
ctx := context.Background()
prefix := "TestAlterAlias_all"
collectionName := prefix + funcutil.GenRandomStr()
task := &AlterAliasTask{
Condition: NewTaskCondition(ctx),
AlterAliasRequest: &milvuspb.AlterAliasRequest{
Base: nil,
CollectionName: collectionName,
Alias: "alias1",
},
ctx: ctx,
result: merr.Success(),
rootCoord: rc,
}
assert.NoError(t, task.OnEnqueue())
assert.NotNil(t, task.TraceCtx())
id := UniqueID(uniquegenerator.GetUniqueIntGeneratorIns().GetInt())
task.SetID(id)
assert.Equal(t, id, task.ID())
task.Base.MsgType = commonpb.MsgType_AlterAlias
assert.Equal(t, commonpb.MsgType_AlterAlias, task.Type())
ts := Timestamp(time.Now().UnixNano())
task.SetTs(ts)
assert.Equal(t, ts, task.BeginTs())
assert.Equal(t, ts, task.EndTs())
assert.NoError(t, task.PreExecute(ctx))
assert.NoError(t, task.Execute(ctx))
assert.NoError(t, task.PostExecute(ctx))
}
func Test_createIndexTask_getIndexedField(t *testing.T) {
collectionName := "test"
fieldName := "test"

67
internal/rootcoord/meta_table.go
View File

@ -65,6 +65,8 @@ type IMetaTable interface {
CreateAlias(ctx context.Context, dbName string, alias string, collectionName string, ts Timestamp) error
DropAlias(ctx context.Context, dbName string, alias string, ts Timestamp) error
AlterAlias(ctx context.Context, dbName string, alias string, collectionName string, ts Timestamp) error
DescribeAlias(ctx context.Context, dbName string, alias string, ts Timestamp) (string, error)
ListAliases(ctx context.Context, dbName string, collectionName string, ts Timestamp) ([]string, error)
AlterCollection(ctx context.Context, oldColl *model.Collection, newColl *model.Collection, ts Timestamp) error
RenameCollection(ctx context.Context, dbName string, oldName string, newDBName string, newName string, ts Timestamp) error
@ -1054,6 +1056,71 @@ func (mt *MetaTable) AlterAlias(ctx context.Context, dbName string, alias string
return nil
}
func (mt *MetaTable) DescribeAlias(ctx context.Context, dbName string, alias string, ts Timestamp) (string, error) {
mt.ddLock.Lock()
defer mt.ddLock.Unlock()
if dbName == "" {
log.Warn("db name is empty", zap.String("alias", alias))
dbName = util.DefaultDBName
}
// check if database exists.
dbExist := mt.aliases.exist(dbName)
if !dbExist {
return "", merr.WrapErrDatabaseNotFound(dbName)
}
// check if alias exists.
collectionID, ok := mt.aliases.get(dbName, alias)
if !ok {
return "", merr.WrapErrAliasNotFound(dbName, alias)
}
collectionMeta, ok := mt.collID2Meta[collectionID]
if !ok {
return "", merr.WrapErrCollectionIDOfAliasNotFound(collectionID)
}
if collectionMeta.State == pb.CollectionState_CollectionCreated {
return collectionMeta.Name, nil
}
return "", merr.WrapErrAliasNotFound(dbName, alias)
}
func (mt *MetaTable) ListAliases(ctx context.Context, dbName string, collectionName string, ts Timestamp) ([]string, error) {
mt.ddLock.Lock()
defer mt.ddLock.Unlock()
if dbName == "" {
log.Warn("db name is empty", zap.String("collection", collectionName))
dbName = util.DefaultDBName
}
// check if database exists.
dbExist := mt.aliases.exist(dbName)
if !dbExist {
return nil, merr.WrapErrDatabaseNotFound(dbName)
}
var aliases []string
if collectionName == "" {
collections := mt.aliases.listCollections(dbName)
for name, collectionID := range collections {
if collectionMeta, ok := mt.collID2Meta[collectionID]; ok &&
collectionMeta.State == pb.CollectionState_CollectionCreated {
aliases = append(aliases, name)
}
}
} else {
collectionID, exist := mt.names.get(dbName, collectionName)
collectionMeta, exist2 := mt.collID2Meta[collectionID]
if exist && exist2 && collectionMeta.State == pb.CollectionState_CollectionCreated {
aliases = mt.listAliasesByID(collectionID)
} else {
return nil, merr.WrapErrCollectionNotFound(collectionName)
}
}
return aliases, nil
}
func (mt *MetaTable) IsAlias(db, name string) bool {
mt.ddLock.RLock()
defer mt.ddLock.RUnlock()

228
internal/rootcoord/meta_table_test.go
View File

@ -709,6 +709,234 @@ func TestMetaTable_AlterCollection(t *testing.T) {
})
}
func TestMetaTable_DescribeAlias(t *testing.T) {
t.Run("metatable describe alias ok", func(t *testing.T) {
var collectionID int64 = 100
collectionName := "test_metatable_describe_alias"
aliasName := "a_alias"
meta := &MetaTable{
collID2Meta: map[typeutil.UniqueID]*model.Collection{
collectionID: {
CollectionID: collectionID,
Name: collectionName,
},
},
names: newNameDb(),
aliases: newNameDb(),
}
meta.names.insert("", collectionName, collectionID)
meta.aliases.insert("", aliasName, collectionID)
ctx := context.Background()
descCollectionName, err := meta.DescribeAlias(ctx, "", aliasName, 0)
assert.NoError(t, err)
assert.Equal(t, collectionName, descCollectionName)
})
t.Run("metatable describe not exist alias", func(t *testing.T) {
var collectionID int64 = 100
aliasName1 := "a_alias"
aliasName2 := "a_alias2"
meta := &MetaTable{
names: newNameDb(),
aliases: newNameDb(),
}
meta.aliases.insert("", aliasName1, collectionID)
ctx := context.Background()
descCollectionName, err := meta.DescribeAlias(ctx, "", aliasName2, 0)
assert.Error(t, err)
assert.Equal(t, "", descCollectionName)
})
t.Run("metatable describe not exist database", func(t *testing.T) {
aliasName := "a_alias"
meta := &MetaTable{
names: newNameDb(),
aliases: newNameDb(),
}
ctx := context.Background()
descCollectionName, err := meta.DescribeAlias(ctx, "", aliasName, 0)
assert.Error(t, err)
assert.Equal(t, "", descCollectionName)
})
t.Run("metatable describe alias fail", func(t *testing.T) {
var collectionID int64 = 100
collectionName := "test_metatable_describe_alias"
aliasName := "a_alias"
meta := &MetaTable{
names: newNameDb(),
aliases: newNameDb(),
}
meta.names.insert("", collectionName, collectionID)
meta.aliases.insert("", aliasName, collectionID)
ctx := context.Background()
_, err := meta.DescribeAlias(ctx, "", aliasName, 0)
assert.Error(t, err)
})
t.Run("metatable describe alias dropped collection", func(t *testing.T) {
var collectionID int64 = 100
collectionName := "test_metatable_describe_alias"
aliasName := "a_alias"
meta := &MetaTable{
collID2Meta: map[typeutil.UniqueID]*model.Collection{
collectionID: {
CollectionID: collectionID,
Name: collectionName,
},
},
names: newNameDb(),
aliases: newNameDb(),
}
meta.names.insert("", collectionName, collectionID)
meta.aliases.insert("", aliasName, collectionID)
ctx := context.Background()
meta.collID2Meta[collectionID] = &model.Collection{State: pb.CollectionState_CollectionDropped}
alias, err := meta.DescribeAlias(ctx, "", aliasName, 0)
assert.Equal(t, "", alias)
assert.Error(t, err)
})
}
func TestMetaTable_ListAliases(t *testing.T) {
t.Run("metatable list alias ok", func(t *testing.T) {
var collectionID1 int64 = 101
collectionName1 := "test_metatable_list_alias1"
aliasName1 := "a_alias"
var collectionID2 int64 = 102
collectionName2 := "test_metatable_list_alias2"
aliasName2 := "a_alias2"
var collectionID3 int64 = 103
collectionName3 := "test_metatable_list_alias3"
aliasName3 := "a_alias3"
aliasName4 := "a_alias4"
meta := &MetaTable{
collID2Meta: map[typeutil.UniqueID]*model.Collection{
collectionID1: {
CollectionID: collectionID1,
Name: collectionName1,
},
collectionID1: {
CollectionID: collectionID2,
Name: collectionName2,
},
},
names: newNameDb(),
aliases: newNameDb(),
}
meta.names.insert("", collectionName1, collectionID1)
meta.names.insert("", collectionName2, collectionID2)
meta.names.insert("db2", collectionName3, collectionID3)
meta.aliases.insert("", aliasName1, collectionID1)
meta.aliases.insert("", aliasName2, collectionID2)
meta.aliases.insert("db2", aliasName3, collectionID3)
meta.aliases.insert("db2", aliasName4, collectionID3)
meta.collID2Meta[collectionID1] = &model.Collection{State: pb.CollectionState_CollectionCreated}
meta.collID2Meta[collectionID2] = &model.Collection{State: pb.CollectionState_CollectionCreated}
meta.collID2Meta[collectionID3] = &model.Collection{State: pb.CollectionState_CollectionCreated}
ctx := context.Background()
aliases, err := meta.ListAliases(ctx, "", "", 0)
assert.NoError(t, err)
assert.Equal(t, 2, len(aliases))
aliases2, err := meta.ListAliases(ctx, "", collectionName1, 0)
assert.NoError(t, err)
assert.Equal(t, 1, len(aliases2))
aliases3, err := meta.ListAliases(ctx, "db2", "", 0)
assert.NoError(t, err)
assert.Equal(t, 2, len(aliases3))
aliases4, err := meta.ListAliases(ctx, "db2", collectionName3, 0)
assert.NoError(t, err)
assert.Equal(t, 2, len(aliases4))
})
t.Run("metatable list alias in not exist database", func(t *testing.T) {
aliasName := "a_alias"
meta := &MetaTable{
names: newNameDb(),
aliases: newNameDb(),
}
ctx := context.Background()
aliases, err := meta.ListAliases(ctx, "", aliasName, 0)
assert.Error(t, err)
assert.Equal(t, 0, len(aliases))
})
t.Run("metatable list alias error", func(t *testing.T) {
var collectionID1 int64 = 101
collectionName1 := "test_metatable_list_alias1"
aliasName1 := "a_alias"
var collectionID2 int64 = 102
collectionName2 := "test_metatable_list_alias2"
aliasName2 := "a_alias2"
meta := &MetaTable{
collID2Meta: map[typeutil.UniqueID]*model.Collection{
collectionID1: {
CollectionID: collectionID1,
Name: collectionName1,
},
collectionID1: {
CollectionID: collectionID2,
Name: collectionName2,
},
},
names: newNameDb(),
aliases: newNameDb(),
}
meta.aliases.insert("", aliasName1, collectionID1)
meta.aliases.insert("", aliasName2, collectionID2)
ctx := context.Background()
_, err := meta.ListAliases(ctx, "", collectionName1, 0)
assert.Error(t, err)
})
t.Run("metatable list alias Dropping collection", func(t *testing.T) {
ctx := context.Background()
var collectionID1 int64 = 101
collectionName1 := "test_metatable_list_alias1"
aliasName1 := "a_alias"
var collectionID2 int64 = 102
collectionName2 := "test_metatable_list_alias2"
aliasName2 := "a_alias2"
meta := &MetaTable{
collID2Meta: map[typeutil.UniqueID]*model.Collection{
collectionID1: {
CollectionID: collectionID1,
Name: collectionName1,
},
collectionID1: {
CollectionID: collectionID2,
Name: collectionName2,
},
},
names: newNameDb(),
aliases: newNameDb(),
}
meta.names.insert("", collectionName1, collectionID1)
meta.names.insert("", collectionName2, collectionID2)
meta.aliases.insert("", aliasName1, collectionID1)
meta.aliases.insert("", aliasName2, collectionID2)
meta.collID2Meta[collectionID1] = &model.Collection{State: pb.CollectionState_CollectionCreated}
meta.collID2Meta[collectionID2] = &model.Collection{State: pb.CollectionState_CollectionDropped}
aliases, err := meta.ListAliases(ctx, "", "", 0)
assert.NoError(t, err)
assert.Equal(t, 1, len(aliases))
aliases2, err := meta.ListAliases(ctx, "", collectionName1, 0)
assert.NoError(t, err)
assert.Equal(t, 1, len(aliases2))
})
}
func Test_filterUnavailable(t *testing.T) {
coll := &model.Collection{}
nPartition := 10

16
internal/rootcoord/mock_test.go
View File

@ -72,6 +72,8 @@ type mockMetaTable struct {
AlterAliasFunc func(ctx context.Context, dbName string, alias string, collectionName string, ts Timestamp) error
DropAliasFunc func(ctx context.Context, dbName string, alias string, ts Timestamp) error
IsAliasFunc func(dbName, name string) bool
DescribeAliasFunc func(ctx context.Context, dbName, alias string, ts Timestamp) (string, error)
ListAliasesFunc func(ctx context.Context, dbName, collectionName string, ts Timestamp) ([]string, error)
ListAliasesByIDFunc func(collID UniqueID) []string
GetCollectionIDByNameFunc func(name string) (UniqueID, error)
GetPartitionByNameFunc func(collID UniqueID, partitionName string, ts Timestamp) (UniqueID, error)
@ -151,6 +153,14 @@ func (m mockMetaTable) IsAlias(dbName, name string) bool {
return m.IsAliasFunc(dbName, name)
}
func (m mockMetaTable) DescribeAlias(ctx context.Context, dbName, alias string, ts Timestamp) (string, error) {
return m.DescribeAliasFunc(ctx, dbName, alias, ts)
}
func (m mockMetaTable) ListAliases(ctx context.Context, dbName, collectionName string, ts Timestamp) ([]string, error) {
return m.ListAliasesFunc(ctx, dbName, collectionName, ts)
}
func (m mockMetaTable) ListAliasesByID(collID UniqueID) []string {
return m.ListAliasesByIDFunc(collID)
}
@ -510,6 +520,12 @@ func withInvalidMeta() Opt {
meta.ListUserRoleFunc = func(tenant string) ([]string, error) {
return nil, errors.New("error mock ListUserRole")
}
meta.DescribeAliasFunc = func(ctx context.Context, dbName, alias string, ts Timestamp) (string, error) {
return "", errors.New("error mock DescribeAlias")
}
meta.ListAliasesFunc = func(ctx context.Context, dbName, collectionName string, ts Timestamp) ([]string, error) {
return nil, errors.New("error mock ListAliases")
}
return withMeta(meta)
}

112
internal/rootcoord/mocks/meta_table.go
View File

@ -555,6 +555,61 @@ func (_c *IMetaTable_DeleteCredential_Call) RunAndReturn(run func(string) error)
return _c
}
// DescribeAlias provides a mock function with given fields: ctx, dbName, alias, ts
func (_m *IMetaTable) DescribeAlias(ctx context.Context, dbName string, alias string, ts uint64) (string, error) {
ret := _m.Called(ctx, dbName, alias, ts)
var r0 string
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, string, string, uint64) (string, error)); ok {
return rf(ctx, dbName, alias, ts)
}
if rf, ok := ret.Get(0).(func(context.Context, string, string, uint64) string); ok {
r0 = rf(ctx, dbName, alias, ts)
} else {
r0 = ret.Get(0).(string)
}
if rf, ok := ret.Get(1).(func(context.Context, string, string, uint64) error); ok {
r1 = rf(ctx, dbName, alias, ts)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// IMetaTable_DescribeAlias_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeAlias'
type IMetaTable_DescribeAlias_Call struct {
*mock.Call
}
// DescribeAlias is a helper method to define mock.On call
// - ctx context.Context
// - dbName string
// - alias string
// - ts uint64
func (_e *IMetaTable_Expecter) DescribeAlias(ctx interface{}, dbName interface{}, alias interface{}, ts interface{}) *IMetaTable_DescribeAlias_Call {
return &IMetaTable_DescribeAlias_Call{Call: _e.mock.On("DescribeAlias", ctx, dbName, alias, ts)}
}
func (_c *IMetaTable_DescribeAlias_Call) Run(run func(ctx context.Context, dbName string, alias string, ts uint64)) *IMetaTable_DescribeAlias_Call {
_c.Call.Run(func(args mock.Arguments) {
run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(uint64))
})
return _c
}
func (_c *IMetaTable_DescribeAlias_Call) Return(_a0 string, _a1 error) *IMetaTable_DescribeAlias_Call {
_c.Call.Return(_a0, _a1)
return _c
}
func (_c *IMetaTable_DescribeAlias_Call) RunAndReturn(run func(context.Context, string, string, uint64) (string, error)) *IMetaTable_DescribeAlias_Call {
_c.Call.Return(run)
return _c
}
// DropAlias provides a mock function with given fields: ctx, dbName, alias, ts
func (_m *IMetaTable) DropAlias(ctx context.Context, dbName string, alias string, ts uint64) error {
ret := _m.Called(ctx, dbName, alias, ts)
@ -1206,6 +1261,63 @@ func (_c *IMetaTable_IsAlias_Call) RunAndReturn(run func(string, string) bool) *
return _c
}
// ListAliases provides a mock function with given fields: ctx, dbName, collectionName, ts
func (_m *IMetaTable) ListAliases(ctx context.Context, dbName string, collectionName string, ts uint64) ([]string, error) {
ret := _m.Called(ctx, dbName, collectionName, ts)
var r0 []string
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, string, string, uint64) ([]string, error)); ok {
return rf(ctx, dbName, collectionName, ts)
}
if rf, ok := ret.Get(0).(func(context.Context, string, string, uint64) []string); ok {
r0 = rf(ctx, dbName, collectionName, ts)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).([]string)
}
}
if rf, ok := ret.Get(1).(func(context.Context, string, string, uint64) error); ok {
r1 = rf(ctx, dbName, collectionName, ts)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// IMetaTable_ListAliases_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListAliases'
type IMetaTable_ListAliases_Call struct {
*mock.Call
}
// ListAliases is a helper method to define mock.On call
// - ctx context.Context
// - dbName string
// - collectionName string
// - ts uint64
func (_e *IMetaTable_Expecter) ListAliases(ctx interface{}, dbName interface{}, collectionName interface{}, ts interface{}) *IMetaTable_ListAliases_Call {
return &IMetaTable_ListAliases_Call{Call: _e.mock.On("ListAliases", ctx, dbName, collectionName, ts)}
}
func (_c *IMetaTable_ListAliases_Call) Run(run func(ctx context.Context, dbName string, collectionName string, ts uint64)) *IMetaTable_ListAliases_Call {
_c.Call.Run(func(args mock.Arguments) {
run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(uint64))
})
return _c
}
func (_c *IMetaTable_ListAliases_Call) Return(_a0 []string, _a1 error) *IMetaTable_ListAliases_Call {
_c.Call.Return(_a0, _a1)
return _c
}
func (_c *IMetaTable_ListAliases_Call) RunAndReturn(run func(context.Context, string, string, uint64) ([]string, error)) *IMetaTable_ListAliases_Call {
_c.Call.Return(run)
return _c
}
// ListAliasesByID provides a mock function with given fields: collID
func (_m *IMetaTable) ListAliasesByID(collID int64) []string {
ret := _m.Called(collID)

28
internal/rootcoord/name_db.go
View File

@ -1,3 +1,19 @@
// 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 (
@ -5,6 +21,7 @@ import (
"golang.org/x/exp/maps"
"github.com/milvus-io/milvus/pkg/util"
"github.com/milvus-io/milvus/pkg/util/typeutil"
)
@ -35,6 +52,9 @@ func (n *nameDb) dropDb(dbName string) {
}
func (n *nameDb) insert(dbName string, collectionName string, collectionID UniqueID) {
if dbName == "" {
dbName = util.DefaultDBName
}
n.createDbIfNotExist(dbName)
n.db2Name2ID[dbName][collectionName] = collectionID
}
@ -55,6 +75,14 @@ func (n *nameDb) listDB() []string {
return dbs
}
func (n *nameDb) listCollections(dbName string) map[string]UniqueID {
res, ok := n.db2Name2ID[dbName]
if ok {
return res
}
return map[string]UniqueID{}
}
func (n *nameDb) listCollectionID(dbName string) ([]typeutil.UniqueID, error) {
name2ID, ok := n.db2Name2ID[dbName]
if !ok {

80
internal/rootcoord/root_coord.go
View File

@ -1853,6 +1853,86 @@ func (c *Core) AlterAlias(ctx context.Context, in *milvuspb.AlterAliasRequest) (
return merr.Success(), nil
}
// DescribeAlias describe collection alias
func (c *Core) DescribeAlias(ctx context.Context, in *milvuspb.DescribeAliasRequest) (*milvuspb.DescribeAliasResponse, error) {
if err := merr.CheckHealthy(c.GetStateCode()); err != nil {
return &milvuspb.DescribeAliasResponse{
Status: merr.Status(err),
}, nil
}
log := log.Ctx(ctx).With(
zap.String("role", typeutil.RootCoordRole),
zap.String("db", in.GetDbName()),
zap.String("alias", in.GetAlias()))
method := "DescribeAlias"
metrics.RootCoordDDLReqCounter.WithLabelValues(method, metrics.TotalLabel).Inc()
tr := timerecord.NewTimeRecorder("DescribeAlias")
log.Info("received request to describe alias")
if in.GetAlias() == "" {
return &milvuspb.DescribeAliasResponse{
Status: merr.Status(merr.WrapErrParameterMissing("alias", "no input alias")),
}, nil
}
collectionName, err := c.meta.DescribeAlias(ctx, in.GetDbName(), in.GetAlias(), 0)
if err != nil {
log.Warn("fail to DescribeAlias", zap.Error(err))
return &milvuspb.DescribeAliasResponse{
Status: merr.Status(err),
}, nil
}
metrics.RootCoordDDLReqCounter.WithLabelValues(method, metrics.SuccessLabel).Inc()
metrics.RootCoordDDLReqLatency.WithLabelValues(method).Observe(float64(tr.ElapseSpan().Milliseconds()))
log.Info("done to describe alias")
return &milvuspb.DescribeAliasResponse{
Status: merr.Status(nil),
DbName: in.GetDbName(),
Alias: in.GetAlias(),
Collection: collectionName,
}, nil
}
// ListAliases list aliases
func (c *Core) ListAliases(ctx context.Context, in *milvuspb.ListAliasesRequest) (*milvuspb.ListAliasesResponse, error) {
if err := merr.CheckHealthy(c.GetStateCode()); err != nil {
return &milvuspb.ListAliasesResponse{
Status: merr.Status(err),
}, nil
}
method := "ListAliases"
metrics.RootCoordDDLReqCounter.WithLabelValues(method, metrics.TotalLabel).Inc()
tr := timerecord.NewTimeRecorder(method)
log := log.Ctx(ctx).With(
zap.String("role", typeutil.RootCoordRole),
zap.String("db", in.GetDbName()),
zap.String("collectionName", in.GetCollectionName()))
log.Info("received request to list aliases")
aliases, err := c.meta.ListAliases(ctx, in.GetDbName(), in.GetCollectionName(), 0)
if err != nil {
log.Warn("fail to ListAliases", zap.Error(err))
return &milvuspb.ListAliasesResponse{
Status: merr.Status(err),
}, nil
}
metrics.RootCoordDDLReqCounter.WithLabelValues(method, metrics.SuccessLabel).Inc()
metrics.RootCoordDDLReqLatency.WithLabelValues(method).Observe(float64(tr.ElapseSpan().Milliseconds()))
log.Info("done to list aliases")
return &milvuspb.ListAliasesResponse{
Status: merr.Status(nil),
DbName: in.GetDbName(),
Aliases: aliases,
}, nil
}
// Import imports large files (json, numpy, etc.) on MinIO/S3 storage into Milvus storage.
func (c *Core) Import(ctx context.Context, req *milvuspb.ImportRequest) (*milvuspb.ImportResponse, error) {
if err := merr.CheckHealthy(c.GetStateCode()); err != nil {

103
internal/rootcoord/root_coord_test.go
View File

@ -462,6 +462,109 @@ func TestRootCoord_AlterAlias(t *testing.T) {
})
}
func TestRootCoord_DescribeAlias(t *testing.T) {
t.Run("not healthy", func(t *testing.T) {
c := newTestCore(withAbnormalCode())
ctx := context.Background()
resp, err := c.DescribeAlias(ctx, &milvuspb.DescribeAliasRequest{Alias: "test"})
assert.NoError(t, err)
assert.NotEqual(t, commonpb.ErrorCode_Success, resp.GetStatus().GetErrorCode())
})
t.Run("failed to add task", func(t *testing.T) {
c := newTestCore(withHealthyCode(),
withInvalidScheduler(),
withInvalidMeta())
ctx := context.Background()
resp, err := c.DescribeAlias(ctx, &milvuspb.DescribeAliasRequest{Alias: "test"})
assert.NoError(t, err)
assert.NotEqual(t, commonpb.ErrorCode_Success, resp.GetStatus().GetErrorCode())
})
t.Run("failed to execute", func(t *testing.T) {
c := newTestCore(withHealthyCode(),
withTaskFailScheduler(),
withInvalidMeta())
ctx := context.Background()
resp, err := c.DescribeAlias(ctx, &milvuspb.DescribeAliasRequest{Alias: "test"})
assert.NoError(t, err)
assert.NotEqual(t, commonpb.ErrorCode_Success, resp.GetStatus().GetErrorCode())
})
t.Run("input alias is empty", func(t *testing.T) {
c := newTestCore(withHealthyCode(),
withValidScheduler())
meta := newMockMetaTable()
meta.DescribeAliasFunc = func(ctx context.Context, dbName, alias string, ts Timestamp) (string, error) {
return "", nil
}
c.meta = meta
ctx := context.Background()
resp, err := c.DescribeAlias(ctx, &milvuspb.DescribeAliasRequest{})
assert.NoError(t, err)
assert.Equal(t, commonpb.ErrorCode_UnexpectedError, resp.GetStatus().GetErrorCode())
assert.Equal(t, int32(1101), resp.GetStatus().GetCode())
})
t.Run("normal case, everything is ok", func(t *testing.T) {
c := newTestCore(withHealthyCode(),
withValidScheduler())
meta := newMockMetaTable()
meta.DescribeAliasFunc = func(ctx context.Context, dbName, alias string, ts Timestamp) (string, error) {
return "", nil
}
c.meta = meta
ctx := context.Background()
resp, err := c.DescribeAlias(ctx, &milvuspb.DescribeAliasRequest{Alias: "test"})
assert.NoError(t, err)
assert.Equal(t, commonpb.ErrorCode_Success, resp.GetStatus().GetErrorCode())
})
}
func TestRootCoord_ListAliases(t *testing.T) {
t.Run("not healthy", func(t *testing.T) {
c := newTestCore(withAbnormalCode())
ctx := context.Background()
resp, err := c.ListAliases(ctx, &milvuspb.ListAliasesRequest{})
assert.NoError(t, err)
assert.NotEqual(t, commonpb.ErrorCode_Success, resp.GetStatus().GetErrorCode())
})
t.Run("failed to add task", func(t *testing.T) {
c := newTestCore(withHealthyCode(),
withInvalidScheduler(),
withInvalidMeta())
ctx := context.Background()
resp, err := c.ListAliases(ctx, &milvuspb.ListAliasesRequest{})
assert.NoError(t, err)
assert.NotEqual(t, commonpb.ErrorCode_Success, resp.GetStatus().GetErrorCode())
})
t.Run("failed to execute", func(t *testing.T) {
c := newTestCore(withHealthyCode(),
withTaskFailScheduler(),
withInvalidMeta())
ctx := context.Background()
resp, err := c.ListAliases(ctx, &milvuspb.ListAliasesRequest{})
assert.NoError(t, err)
assert.NotEqual(t, commonpb.ErrorCode_Success, resp.GetStatus().GetErrorCode())
})
t.Run("normal case, everything is ok", func(t *testing.T) {
c := newTestCore(withHealthyCode(),
withValidScheduler())
meta := newMockMetaTable()
meta.ListAliasesFunc = func(ctx context.Context, dbName, collectionName string, ts Timestamp) ([]string, error) {
return nil, nil
}
c.meta = meta
ctx := context.Background()
resp, err := c.ListAliases(ctx, &milvuspb.ListAliasesRequest{})
assert.NoError(t, err)
assert.Equal(t, commonpb.ErrorCode_Success, resp.GetStatus().GetErrorCode())
})
}
func TestRootCoord_DescribeCollection(t *testing.T) {
t.Run("not healthy", func(t *testing.T) {
c := newTestCore(withAbnormalCode())

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

@ -142,6 +142,14 @@ func (m *GrpcRootCoordClient) AlterAlias(ctx context.Context, in *milvuspb.Alter
return &commonpb.Status{}, m.Err
}
func (m *GrpcRootCoordClient) DescribeAlias(ctx context.Context, in *milvuspb.DescribeAliasRequest, opts ...grpc.CallOption) (*milvuspb.DescribeAliasResponse, error) {
return &milvuspb.DescribeAliasResponse{}, m.Err
}
func (m *GrpcRootCoordClient) ListAliases(ctx context.Context, in *milvuspb.ListAliasesRequest, opts ...grpc.CallOption) (*milvuspb.ListAliasesResponse, error) {
return &milvuspb.ListAliasesResponse{}, m.Err
}
func (m *GrpcRootCoordClient) ShowCollections(ctx context.Context, in *milvuspb.ShowCollectionsRequest, opts ...grpc.CallOption) (*milvuspb.ShowCollectionsResponse, error) {
return &milvuspb.ShowCollectionsResponse{}, m.Err
}

4
pkg/util/merr/errors.go
View File

@ -28,7 +28,7 @@ const (
// Define leaf errors here,
// WARN: take care to add new error,
// check whehter you can use the erorrs below before adding a new one.
// check whether you can use the errors below before adding a new one.
// Name: Err + related prefix + error name
var (
// Service related
@ -99,6 +99,7 @@ var (
// Parameter related
ErrParameterInvalid = newMilvusError("invalid parameter", 1100, false)
ErrParameterMissing = newMilvusError("missing parameter", 1101, false)
// Metrics related
ErrMetricNotFound = newMilvusError("metric not found", 1200, false)
@ -119,6 +120,7 @@ var (
ErrAliasNotFound = newMilvusError("alias not found", 1600, false)
ErrAliasCollectionNameConfilct = newMilvusError("alias and collection name conflict", 1601, false)
ErrAliasAlreadyExist = newMilvusError("alias already exist", 1602, false)
ErrCollectionIDOfAliasNotFound = newMilvusError("collection id of alias not found", 1603, false)
// field related
ErrFieldNotFound = newMilvusError("field not found", 1700, false)

5
pkg/util/merr/errors_test.go
View File

@ -128,6 +128,7 @@ func (s *ErrSuite) TestWrap() {
// Parameter related
s.ErrorIs(WrapErrParameterInvalid(8, 1, "failed to create"), ErrParameterInvalid)
s.ErrorIs(WrapErrParameterInvalidRange(1, 1<<16, 0, "topk should be in range"), ErrParameterInvalid)
s.ErrorIs(WrapErrParameterMissing("alias_name", "no alias parameter"), ErrParameterMissing)
// Metrics related
s.ErrorIs(WrapErrMetricNotFound("unknown", "failed to get metric"), ErrMetricNotFound)
@ -139,6 +140,10 @@ func (s *ErrSuite) TestWrap() {
// field related
s.ErrorIs(WrapErrFieldNotFound("meta", "failed to get field"), ErrFieldNotFound)
// alias related
s.ErrorIs(WrapErrAliasNotFound("alias", "failed to get collection id"), ErrAliasNotFound)
s.ErrorIs(WrapErrCollectionIDOfAliasNotFound(1000, "failed to get collection id"), ErrCollectionIDOfAliasNotFound)
}
func (s *ErrSuite) TestOldCode() {

18
pkg/util/merr/utils.go
View File

@ -448,6 +448,14 @@ func WrapErrCollectionNumLimitExceeded(limit int, msg ...string) error {
return err
}
func WrapErrCollectionIDOfAliasNotFound(collectionID int64, msg ...string) error {
err := wrapFields(ErrCollectionIDOfAliasNotFound, value("collectionID", collectionID))
if len(msg) > 0 {
err = errors.Wrap(err, strings.Join(msg, "; "))
}
return err
}
func WrapErrCollectionNotFullyLoaded(collection any, msg ...string) error {
err := wrapFields(ErrCollectionNotFullyLoaded, value("collection", collection))
if len(msg) > 0 {
@ -778,6 +786,16 @@ func WrapErrParameterInvalidMsg(fmt string, args ...any) error {
return errors.Wrapf(ErrParameterInvalid, fmt, args...)
}
func WrapErrParameterMissing[T any](param T, msg ...string) error {
err := wrapFields(ErrParameterMissing,
value("missing_param", param),
)
if len(msg) > 0 {
err = errors.Wrap(err, strings.Join(msg, "->"))
}
return err
}
// Metrics related
func WrapErrMetricNotFound(name string, msg ...string) error {
err := wrapFields(ErrMetricNotFound, value("metric", name))

212
tests/integration/alias/alias_test.go Normal file
View File

@ -0,0 +1,212 @@
// 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 alias
import (
"context"
"testing"
"github.com/golang/protobuf/proto"
"github.com/stretchr/testify/suite"
"go.uber.org/zap"
"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/pkg/log"
"github.com/milvus-io/milvus/pkg/util/funcutil"
"github.com/milvus-io/milvus/tests/integration"
)
type AliasSuite struct {
integration.MiniClusterSuite
}
func (s *AliasSuite) TestAliasOperations() {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
c := s.Cluster
// create 2 collection
const (
prefix = "TestAliasOperations"
dim = 128
dbName = ""
rowNum = 3000
)
collectionName := prefix + funcutil.GenRandomStr()
collectionName1 := collectionName + "1"
collectionName2 := collectionName + "2"
schema1 := integration.ConstructSchema(collectionName1, dim, true)
marshaledSchema1, err := proto.Marshal(schema1)
s.NoError(err)
createCollectionStatus, err := c.Proxy.CreateCollection(ctx, &milvuspb.CreateCollectionRequest{
DbName: dbName,
CollectionName: collectionName1,
Schema: marshaledSchema1,
})
s.NoError(err)
log.Info("CreateCollection 1 result", zap.Any("createCollectionStatus", createCollectionStatus))
schema2 := integration.ConstructSchema(collectionName2, dim, true)
marshaledSchema2, err := proto.Marshal(schema2)
s.NoError(err)
createCollectionStatus2, err := c.Proxy.CreateCollection(ctx, &milvuspb.CreateCollectionRequest{
DbName: dbName,
CollectionName: collectionName2,
Schema: marshaledSchema2,
})
s.NoError(err)
log.Info("CreateCollection 2 result", zap.Any("createCollectionStatus", createCollectionStatus2))
fVecColumn := integration.NewFloatVectorFieldData(integration.FloatVecField, rowNum, dim)
hashKeys := integration.GenerateHashKeys(rowNum)
insertResult, err := c.Proxy.Insert(ctx, &milvuspb.InsertRequest{
DbName: dbName,
CollectionName: collectionName1,
FieldsData: []*schemapb.FieldData{fVecColumn},
HashKeys: hashKeys,
NumRows: uint32(rowNum),
})
s.NoError(err)
s.Equal(insertResult.GetStatus().GetErrorCode(), commonpb.ErrorCode_Success)
insertResult2, err := c.Proxy.Insert(ctx, &milvuspb.InsertRequest{
DbName: dbName,
CollectionName: collectionName2,
FieldsData: []*schemapb.FieldData{fVecColumn},
HashKeys: hashKeys,
NumRows: uint32(rowNum),
})
s.NoError(err)
s.Equal(insertResult2.GetStatus().GetErrorCode(), commonpb.ErrorCode_Success)
// flush
flushResp, err := c.Proxy.Flush(ctx, &milvuspb.FlushRequest{
DbName: dbName,
CollectionNames: []string{collectionName1},
})
s.NoError(err)
segmentIDs, has := flushResp.GetCollSegIDs()[collectionName1]
ids := segmentIDs.GetData()
s.Require().NotEmpty(segmentIDs)
s.Require().True(has)
flushTs, has := flushResp.GetCollFlushTs()[collectionName1]
s.Require().True(has)
s.WaitForFlush(ctx, ids, flushTs, dbName, collectionName1)
flushResp2, err := c.Proxy.Flush(ctx, &milvuspb.FlushRequest{
DbName: dbName,
CollectionNames: []string{collectionName2},
})
s.NoError(err)
segmentIDs2, has2 := flushResp2.GetCollSegIDs()[collectionName2]
ids2 := segmentIDs2.GetData()
s.Require().NotEmpty(segmentIDs)
s.Require().True(has2)
flushTs2, has2 := flushResp2.GetCollFlushTs()[collectionName2]
s.Require().True(has2)
s.WaitForFlush(ctx, ids2, flushTs2, dbName, collectionName2)
// create alias
// alias11 -> collection1
// alias12 -> collection1
// alias21 -> collection2
createAliasResp1, err := c.Proxy.CreateAlias(ctx, &milvuspb.CreateAliasRequest{
CollectionName: collectionName1,
Alias: "alias11",
})
s.NoError(err)
s.Equal(createAliasResp1.GetErrorCode(), commonpb.ErrorCode_Success)
createAliasResp2, err := c.Proxy.CreateAlias(ctx, &milvuspb.CreateAliasRequest{
CollectionName: collectionName1,
Alias: "alias12",
})
s.NoError(err)
s.Equal(createAliasResp2.GetErrorCode(), commonpb.ErrorCode_Success)
createAliasResp3, err := c.Proxy.CreateAlias(ctx, &milvuspb.CreateAliasRequest{
CollectionName: collectionName2,
Alias: "alias21",
})
s.NoError(err)
s.Equal(createAliasResp3.GetErrorCode(), commonpb.ErrorCode_Success)
describeAliasResp1, err := c.Proxy.DescribeAlias(ctx, &milvuspb.DescribeAliasRequest{
Alias: "alias11",
})
s.NoError(err)
s.Equal(describeAliasResp1.GetStatus().GetErrorCode(), commonpb.ErrorCode_Success)
s.Equal(collectionName1, describeAliasResp1.GetCollection())
log.Info("describeAliasResp1",
zap.String("alias", describeAliasResp1.GetAlias()),
zap.String("collection", describeAliasResp1.GetCollection()))
describeAliasResp2, err := c.Proxy.DescribeAlias(ctx, &milvuspb.DescribeAliasRequest{
Alias: "alias12",
})
s.NoError(err)
s.Equal(describeAliasResp2.GetStatus().GetErrorCode(), commonpb.ErrorCode_Success)
s.Equal(collectionName1, describeAliasResp2.GetCollection())
log.Info("describeAliasResp2",
zap.String("alias", describeAliasResp2.GetAlias()),
zap.String("collection", describeAliasResp2.GetCollection()))
describeAliasResp3, err := c.Proxy.DescribeAlias(ctx, &milvuspb.DescribeAliasRequest{
Alias: "alias21",
})
s.NoError(err)
s.Equal(describeAliasResp3.GetStatus().GetErrorCode(), commonpb.ErrorCode_Success)
s.Equal(collectionName2, describeAliasResp3.GetCollection())
log.Info("describeAliasResp3",
zap.String("alias", describeAliasResp3.GetAlias()),
zap.String("collection", describeAliasResp3.GetCollection()))
listAliasesResp, err := c.Proxy.ListAliases(ctx, &milvuspb.ListAliasesRequest{})
s.NoError(err)
s.Equal(listAliasesResp.GetStatus().GetErrorCode(), commonpb.ErrorCode_Success)
s.Equal(3, len(listAliasesResp.Aliases))
log.Info("listAliasesResp", zap.Strings("aliases", listAliasesResp.Aliases))
dropAliasResp1, err := c.Proxy.DropAlias(ctx, &milvuspb.DropAliasRequest{
Alias: "alias11",
})
s.NoError(err)
s.Equal(dropAliasResp1.GetErrorCode(), commonpb.ErrorCode_Success)
dropAliasResp3, err := c.Proxy.DropAlias(ctx, &milvuspb.DropAliasRequest{
Alias: "alias21",
})
s.NoError(err)
s.Equal(dropAliasResp3.GetErrorCode(), commonpb.ErrorCode_Success)
listAliasesRespNew, err := c.Proxy.ListAliases(ctx, &milvuspb.ListAliasesRequest{})
s.NoError(err)
s.Equal(listAliasesRespNew.GetStatus().GetErrorCode(), commonpb.ErrorCode_Success)
s.Equal(1, len(listAliasesRespNew.Aliases))
log.Info("listAliasesResp after drop", zap.Strings("aliases", listAliasesResp.Aliases))
log.Info("======================")
log.Info("======================")
log.Info("TestAliasOperations succeed")
log.Info("======================")
log.Info("======================")
}
func TestAliasOperations(t *testing.T) {
suite.Run(t, new(AliasSuite))
}