Merge branch 'master' of https://github.com/milvus-io/milvus into 231…

…2-import-restful
milvus-io · Feb 2, 2024 · 4c5bff2 · 4c5bff2
2 parents f74fd4a + dcdf859
commit 4c5bff2
Show file tree

Hide file tree

Showing 4 changed files with 805 additions and 2 deletions.
diff --git a/internal/proxy/task_test.go b/internal/proxy/task_test.go
@@ -3597,3 +3597,22 @@ func TestClusteringKey(t *testing.T) {
 		assert.Error(t, err)
 	})
 }
+
+func TestAlterCollectionCheckLoaded(t *testing.T) {
+	qc := &mocks.MockQueryCoordClient{}
+	qc.EXPECT().ShowCollections(mock.Anything, mock.Anything).Return(&querypb.ShowCollectionsResponse{
+		Status:              &commonpb.Status{ErrorCode: commonpb.ErrorCode_Success},
+		CollectionIDs:       []int64{1},
+		InMemoryPercentages: []int64{100},
+	}, nil)
+	task := &alterCollectionTask{
+		AlterCollectionRequest: &milvuspb.AlterCollectionRequest{
+			Base:         &commonpb.MsgBase{},
+			CollectionID: 1,
+			Properties:   []*commonpb.KeyValuePair{{Key: common.MmapEnabledKey, Value: "true"}},
+		},
+		queryCoord: qc,
+	}
+	err := task.PreExecute(context.Background())
+	assert.Equal(t, merr.Code(merr.ErrCollectionLoaded), merr.Code(err))
+}
diff --git a/tests/python_client/base/client_base.py b/tests/python_client/base/client_base.py
@@ -61,7 +61,8 @@ def teardown_method(self, method):
             """ Drop collection before disconnect """
             if not self.connection_wrap.has_connection(alias=DefaultConfig.DEFAULT_USING)[0]:
                 self.connection_wrap.connect(alias=DefaultConfig.DEFAULT_USING, host=cf.param_info.param_host,
-                                             port=cf.param_info.param_port)
+                                             port=cf.param_info.param_port, user=ct.default_user,
+                                             password=ct.default_password)
 
             if self.collection_wrap.collection is not None:
                 if self.collection_wrap.collection.name.startswith("alias"):

diff --git a/tests/python_client/base/high_level_api_wrapper.py b/tests/python_client/base/high_level_api_wrapper.py
@@ -4,6 +4,7 @@
 from numpy import NaN
 
 from pymilvus import Collection
+from pymilvus import MilvusClient
 
 sys.path.append("..")
 from check.func_check import ResponseChecker
@@ -23,9 +24,22 @@
 
 class HighLevelApiWrapper:
 
+    milvus_client = None
+
     def __init__(self, active_trace=False):
         self.active_trace = active_trace
 
+    def init_milvus_client(self, uri, user="", password="", db_name="", token="", timeout=None,
+                           check_task=None, check_items=None, active_trace=False, **kwargs):
+        self.active_trace = active_trace
+        func_name = sys._getframe().f_code.co_name
+        res, is_succ = api_request([MilvusClient, uri, user, password, db_name, token, timeout], **kwargs)
+        self.milvus_client = res if is_succ else None
+        check_result = ResponseChecker(res, func_name, check_task, check_items, is_succ,
+                                       uri=uri, user=user, password=password, db_name=db_name, token=token,
+                                       timeout=timeout, **kwargs).run()
+        return res, check_result
+
     @trace()
     def create_schema(self, client, timeout=None, check_task=None,
                       check_items=None, **kwargs):
@@ -523,4 +537,144 @@ def using_database(self, client, db_name, timeout=None, check_task=None, check_i
                                        check_items, check,
                                        db_name=db_name,
                                        **kwargs).run()
-        return res, check_result
+        return res, check_result
+
+    def create_user(self, user_name, password, timeout=None, check_task=None, check_items=None, **kwargs):
+        timeout = TIMEOUT if timeout is None else timeout
+        kwargs.update({"timeout": timeout})
+        func_name = sys._getframe().f_code.co_name
+        res, check = api_request([self.milvus_client.create_user, user_name, password], **kwargs)
+        check_result = ResponseChecker(res, func_name, check_task,
+                                       check_items, check, user_name=user_name,
+                                       password=password, **kwargs).run()
+        return res, check_result
+
+    @trace()
+    def drop_user(self, user_name, timeout=None, check_task=None, check_items=None, **kwargs):
+        timeout = TIMEOUT if timeout is None else timeout
+        kwargs.update({"timeout": timeout})
+        func_name = sys._getframe().f_code.co_name
+        res, check = api_request([self.milvus_client.drop_user, user_name], **kwargs)
+        check_result = ResponseChecker(res, func_name, check_task,
+                                       check_items, check, user_name=user_name, **kwargs).run()
+        return res, check_result
+
+    @trace()
+    def update_password(self, user_name, old_password, new_password, reset_connection=False,
+                        timeout=None, check_task=None, check_items=None, **kwargs):
+        timeout = TIMEOUT if timeout is None else timeout
+        kwargs.update({"timeout": timeout})
+        func_name = sys._getframe().f_code.co_name
+        res, check = api_request([self.milvus_client.update_password, user_name, old_password, new_password,
+                                  reset_connection], **kwargs)
+        check_result = ResponseChecker(res, func_name, check_task,
+                                       check_items, check, user_name=user_name, old_password=old_password,
+                                       new_password=new_password, reset_connection=reset_connection,
+                                       **kwargs).run()
+        return res, check_result
+
+    @trace()
+    def list_users(self, timeout=None, check_task=None, check_items=None, **kwargs):
+        timeout = TIMEOUT if timeout is None else timeout
+        kwargs.update({"timeout": timeout})
+        func_name = sys._getframe().f_code.co_name
+        res, check = api_request([self.milvus_client.list_users], **kwargs)
+        check_result = ResponseChecker(res, func_name, check_task,
+                                       check_items, check, **kwargs).run()
+        return res, check_result
+
+    @trace()
+    def describe_user(self, user_name, timeout=None, check_task=None, check_items=None, **kwargs):
+        timeout = TIMEOUT if timeout is None else timeout
+        kwargs.update({"timeout": timeout})
+        func_name = sys._getframe().f_code.co_name
+        res, check = api_request([self.milvus_client.describe_user, user_name], **kwargs)
+        check_result = ResponseChecker(res, func_name, check_task,
+                                       check_items, check, user_name=user_name, **kwargs).run()
+        return res, check_result
+
+    @trace()
+    def create_role(self, role_name, timeout=None, check_task=None, check_items=None, **kwargs):
+        timeout = TIMEOUT if timeout is None else timeout
+        kwargs.update({"timeout": timeout})
+        func_name = sys._getframe().f_code.co_name
+        res, check = api_request([self.milvus_client.create_role, role_name], **kwargs)
+        check_result = ResponseChecker(res, func_name, check_task,
+                                       check_items, check, role_name=role_name, **kwargs).run()
+        return res, check_result
+
+    @trace()
+    def drop_role(self, role_name, timeout=None, check_task=None, check_items=None, **kwargs):
+        timeout = TIMEOUT if timeout is None else timeout
+        kwargs.update({"timeout": timeout})
+        func_name = sys._getframe().f_code.co_name
+        res, check = api_request([self.milvus_client.drop_role, role_name], **kwargs)
+        check_result = ResponseChecker(res, func_name, check_task,
+                                       check_items, check, role_name=role_name, **kwargs).run()
+        return res, check_result
+
+    @trace()
+    def describe_role(self, role_name, timeout=None, check_task=None, check_items=None, **kwargs):
+        timeout = TIMEOUT if timeout is None else timeout
+        kwargs.update({"timeout": timeout})
+        func_name = sys._getframe().f_code.co_name
+        res, check = api_request([self.milvus_client.describe_role, role_name], **kwargs)
+        check_result = ResponseChecker(res, func_name, check_task,
+                                       check_items, check, role_name=role_name, **kwargs).run()
+        return res, check_result
+
+    @trace()
+    def list_roles(self, timeout=None, check_task=None, check_items=None, **kwargs):
+        timeout = TIMEOUT if timeout is None else timeout
+        kwargs.update({"timeout": timeout})
+        func_name = sys._getframe().f_code.co_name
+        res, check = api_request([self.milvus_client.list_roles], **kwargs)
+        check_result = ResponseChecker(res, func_name, check_task,
+                                       check_items, check, **kwargs).run()
+        return res, check_result
+
+    @trace()
+    def grant_role(self, user_name, role_name, timeout=None, check_task=None, check_items=None, **kwargs):
+        timeout = TIMEOUT if timeout is None else timeout
+        kwargs.update({"timeout": timeout})
+        func_name = sys._getframe().f_code.co_name
+        res, check = api_request([self.milvus_client.grant_role, user_name, role_name], **kwargs)
+        check_result = ResponseChecker(res, func_name, check_task, check_items, check,
+                                       user_name=user_name, role_name=role_name, **kwargs).run()
+        return res, check_result
+
+    @trace()
+    def revoke_role(self, user_name, role_name, timeout=None, check_task=None, check_items=None, **kwargs):
+        timeout = TIMEOUT if timeout is None else timeout
+        kwargs.update({"timeout": timeout})
+        func_name = sys._getframe().f_code.co_name
+        res, check = api_request([self.milvus_client.revoke_role, user_name, role_name], **kwargs)
+        check_result = ResponseChecker(res, func_name, check_task, check_items, check,
+                                       user_name=user_name, role_name=role_name, **kwargs).run()
+        return res, check_result
+
+    @trace()
+    def grant_privilege(self, role_name, object_type, privilege, object_name, db_name="",
+                        timeout=None, check_task=None, check_items=None, **kwargs):
+        timeout = TIMEOUT if timeout is None else timeout
+        kwargs.update({"timeout": timeout})
+        func_name = sys._getframe().f_code.co_name
+        res, check = api_request([self.milvus_client.grant_privilege, role_name, object_type, privilege,
+                                  object_name, db_name], **kwargs)
+        check_result = ResponseChecker(res, func_name, check_task, check_items, check,
+                                       role_name=role_name, object_type=object_type, privilege=privilege,
+                                       object_name=object_name, db_name=db_name, **kwargs).run()
+        return res, check_result
+
+    @trace()
+    def revoke_privilege(self, role_name, object_type, privilege, object_name, db_name="",
+                         timeout=None, check_task=None, check_items=None, **kwargs):
+        timeout = TIMEOUT if timeout is None else timeout
+        kwargs.update({"timeout": timeout})
+        func_name = sys._getframe().f_code.co_name
+        res, check = api_request([self.milvus_client.revoke_privilege, role_name, object_type, privilege,
+                                  object_name, db_name], **kwargs)
+        check_result = ResponseChecker(res, func_name, check_task, check_items, check,
+                                       role_name=role_name, object_type=object_type, privilege=privilege,
+                                       object_name=object_name, db_name=db_name, **kwargs).run()
+        return res, check_result