diff --git a/internal/core/src/pb/milvus.pb.cc b/internal/core/src/pb/milvus.pb.cc
index bec839b17c97a8dd32d454d48dd4ca4bc23654a0..01fde233846eefbf724ee3f79d556ed147598bc5 100644
--- a/internal/core/src/pb/milvus.pb.cc
+++ b/internal/core/src/pb/milvus.pb.cc
@@ -1144,7 +1144,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_milvus_2eproto::offsets[] PROT
   ~0u,  // no _weak_field_map_
   PROTOBUF_FIELD_OFFSET(::milvus::proto::milvus::FlushRequest, base_),
   PROTOBUF_FIELD_OFFSET(::milvus::proto::milvus::FlushRequest, db_name_),
-  PROTOBUF_FIELD_OFFSET(::milvus::proto::milvus::FlushRequest, collection_name_),
+  PROTOBUF_FIELD_OFFSET(::milvus::proto::milvus::FlushRequest, collection_names_),
   ~0u,  // no _has_bits_
   PROTOBUF_FIELD_OFFSET(::milvus::proto::milvus::RegisterLinkResponse, _internal_metadata_),
   ~0u,  // no _extensions_
@@ -1359,72 +1359,72 @@ const char descriptor_table_protodef_milvus_2eproto[] PROTOBUF_SECTION_VARIABLE(
   "s\022\013\n\003IDs\030\001 \003(\003\022\020\n\010row_data\030\002 \003(\014\022\016\n\006scor"
   "es\030\003 \003(\002\"J\n\rSearchResults\022+\n\006status\030\001 \001("
   "\0132\033.milvus.proto.common.Status\022\014\n\004hits\030\002"
-  " \003(\014\"d\n\014FlushRequest\022*\n\004base\030\001 \001(\0132\034.mil"
+  " \003(\014\"e\n\014FlushRequest\022*\n\004base\030\001 \001(\0132\034.mil"
   "vus.proto.common.MsgBase\022\017\n\007db_name\030\002 \001("
-  "\t\022\027\n\017collection_name\030\003 \001(\t\"r\n\024RegisterLi"
-  "nkResponse\022-\n\007address\030\001 \001(\0132\034.milvus.pro"
-  "to.common.Address\022+\n\006status\030\002 \001(\0132\033.milv"
-  "us.proto.common.Status*@\n\017PlaceholderTyp"
-  "e\022\010\n\004NONE\020\000\022\021\n\rVECTOR_BINARY\020d\022\020\n\014VECTOR"
-  "_FLOAT\020e2\357\020\n\rMilvusService\022_\n\020CreateColl"
-  "ection\022,.milvus.proto.milvus.CreateColle"
-  "ctionRequest\032\033.milvus.proto.common.Statu"
-  "s\"\000\022[\n\016DropCollection\022*.milvus.proto.mil"
-  "vus.DropCollectionRequest\032\033.milvus.proto"
-  ".common.Status\"\000\022_\n\rHasCollection\022).milv"
-  "us.proto.milvus.HasCollectionRequest\032!.m"
-  "ilvus.proto.milvus.BoolResponse\"\000\022[\n\016Loa"
-  "dCollection\022*.milvus.proto.milvus.LoadCo"
-  "llectionRequest\032\033.milvus.proto.common.St"
-  "atus\"\000\022a\n\021ReleaseCollection\022-.milvus.pro"
-  "to.milvus.ReleaseCollectionRequest\032\033.mil"
-  "vus.proto.common.Status\"\000\022w\n\022DescribeCol"
-  "lection\022..milvus.proto.milvus.DescribeCo"
-  "llectionRequest\032/.milvus.proto.milvus.De"
-  "scribeCollectionResponse\"\000\022v\n\027GetCollect"
-  "ionStatistics\022+.milvus.proto.milvus.Coll"
-  "ectionStatsRequest\032,.milvus.proto.milvus"
-  ".CollectionStatsResponse\"\000\022l\n\017ShowCollec"
-  "tions\022*.milvus.proto.milvus.ShowCollecti"
-  "onRequest\032+.milvus.proto.milvus.ShowColl"
-  "ectionResponse\"\000\022]\n\017CreatePartition\022+.mi"
-  "lvus.proto.milvus.CreatePartitionRequest"
-  "\032\033.milvus.proto.common.Status\"\000\022Y\n\rDropP"
-  "artition\022).milvus.proto.milvus.DropParti"
-  "tionRequest\032\033.milvus.proto.common.Status"
-  "\"\000\022]\n\014HasPartition\022(.milvus.proto.milvus"
-  ".HasPartitionRequest\032!.milvus.proto.milv"
-  "us.BoolResponse\"\000\022Y\n\016LoadPartitions\022(.mi"
-  "lvus.proto.milvus.LoadPartitonRequest\032\033."
-  "milvus.proto.common.Status\"\000\022`\n\021ReleaseP"
-  "artitions\022,.milvus.proto.milvus.ReleaseP"
-  "artitionRequest\032\033.milvus.proto.common.St"
-  "atus\"\000\022s\n\026GetPartitionStatistics\022*.milvu"
-  "s.proto.milvus.PartitionStatsRequest\032+.m"
-  "ilvus.proto.milvus.PartitionStatsRespons"
-  "e\"\000\022i\n\016ShowPartitions\022).milvus.proto.mil"
-  "vus.ShowPartitionRequest\032*.milvus.proto."
-  "milvus.ShowPartitionResponse\"\000\022U\n\013Create"
-  "Index\022\'.milvus.proto.milvus.CreateIndexR"
-  "equest\032\033.milvus.proto.common.Status\"\000\022h\n"
-  "\rDescribeIndex\022).milvus.proto.milvus.Des"
-  "cribeIndexRequest\032*.milvus.proto.milvus."
-  "DescribeIndexResponse\"\000\022b\n\rGetIndexState"
-  "\022&.milvus.proto.milvus.IndexStateRequest"
-  "\032\'.milvus.proto.milvus.IndexStateRespons"
-  "e\"\000\022S\n\006Insert\022\".milvus.proto.milvus.Inse"
-  "rtRequest\032#.milvus.proto.milvus.InsertRe"
-  "sponse\"\000\022R\n\006Search\022\".milvus.proto.milvus"
-  ".SearchRequest\032\".milvus.proto.milvus.Sea"
-  "rchResults\"\000\022I\n\005Flush\022!.milvus.proto.mil"
-  "vus.FlushRequest\032\033.milvus.proto.common.S"
-  "tatus\"\000\022Q\n\014GetDdChannel\022\032.milvus.proto.c"
-  "ommon.Empty\032#.milvus.proto.milvus.String"
-  "Response\"\0002g\n\014ProxyService\022W\n\014RegisterLi"
-  "nk\022\032.milvus.proto.common.Empty\032).milvus."
-  "proto.milvus.RegisterLinkResponse\"\000BBZ@g"
-  "ithub.com/zilliztech/milvus-distributed/"
-  "internal/proto/milvuspbb\006proto3"
+  "\t\022\030\n\020collection_names\030\003 \003(\t\"r\n\024RegisterL"
+  "inkResponse\022-\n\007address\030\001 \001(\0132\034.milvus.pr"
+  "oto.common.Address\022+\n\006status\030\002 \001(\0132\033.mil"
+  "vus.proto.common.Status*@\n\017PlaceholderTy"
+  "pe\022\010\n\004NONE\020\000\022\021\n\rVECTOR_BINARY\020d\022\020\n\014VECTO"
+  "R_FLOAT\020e2\357\020\n\rMilvusService\022_\n\020CreateCol"
+  "lection\022,.milvus.proto.milvus.CreateColl"
+  "ectionRequest\032\033.milvus.proto.common.Stat"
+  "us\"\000\022[\n\016DropCollection\022*.milvus.proto.mi"
+  "lvus.DropCollectionRequest\032\033.milvus.prot"
+  "o.common.Status\"\000\022_\n\rHasCollection\022).mil"
+  "vus.proto.milvus.HasCollectionRequest\032!."
+  "milvus.proto.milvus.BoolResponse\"\000\022[\n\016Lo"
+  "adCollection\022*.milvus.proto.milvus.LoadC"
+  "ollectionRequest\032\033.milvus.proto.common.S"
+  "tatus\"\000\022a\n\021ReleaseCollection\022-.milvus.pr"
+  "oto.milvus.ReleaseCollectionRequest\032\033.mi"
+  "lvus.proto.common.Status\"\000\022w\n\022DescribeCo"
+  "llection\022..milvus.proto.milvus.DescribeC"
+  "ollectionRequest\032/.milvus.proto.milvus.D"
+  "escribeCollectionResponse\"\000\022v\n\027GetCollec"
+  "tionStatistics\022+.milvus.proto.milvus.Col"
+  "lectionStatsRequest\032,.milvus.proto.milvu"
+  "s.CollectionStatsResponse\"\000\022l\n\017ShowColle"
+  "ctions\022*.milvus.proto.milvus.ShowCollect"
+  "ionRequest\032+.milvus.proto.milvus.ShowCol"
+  "lectionResponse\"\000\022]\n\017CreatePartition\022+.m"
+  "ilvus.proto.milvus.CreatePartitionReques"
+  "t\032\033.milvus.proto.common.Status\"\000\022Y\n\rDrop"
+  "Partition\022).milvus.proto.milvus.DropPart"
+  "itionRequest\032\033.milvus.proto.common.Statu"
+  "s\"\000\022]\n\014HasPartition\022(.milvus.proto.milvu"
+  "s.HasPartitionRequest\032!.milvus.proto.mil"
+  "vus.BoolResponse\"\000\022Y\n\016LoadPartitions\022(.m"
+  "ilvus.proto.milvus.LoadPartitonRequest\032\033"
+  ".milvus.proto.common.Status\"\000\022`\n\021Release"
+  "Partitions\022,.milvus.proto.milvus.Release"
+  "PartitionRequest\032\033.milvus.proto.common.S"
+  "tatus\"\000\022s\n\026GetPartitionStatistics\022*.milv"
+  "us.proto.milvus.PartitionStatsRequest\032+."
+  "milvus.proto.milvus.PartitionStatsRespon"
+  "se\"\000\022i\n\016ShowPartitions\022).milvus.proto.mi"
+  "lvus.ShowPartitionRequest\032*.milvus.proto"
+  ".milvus.ShowPartitionResponse\"\000\022U\n\013Creat"
+  "eIndex\022\'.milvus.proto.milvus.CreateIndex"
+  "Request\032\033.milvus.proto.common.Status\"\000\022h"
+  "\n\rDescribeIndex\022).milvus.proto.milvus.De"
+  "scribeIndexRequest\032*.milvus.proto.milvus"
+  ".DescribeIndexResponse\"\000\022b\n\rGetIndexStat"
+  "e\022&.milvus.proto.milvus.IndexStateReques"
+  "t\032\'.milvus.proto.milvus.IndexStateRespon"
+  "se\"\000\022S\n\006Insert\022\".milvus.proto.milvus.Ins"
+  "ertRequest\032#.milvus.proto.milvus.InsertR"
+  "esponse\"\000\022R\n\006Search\022\".milvus.proto.milvu"
+  "s.SearchRequest\032\".milvus.proto.milvus.Se"
+  "archResults\"\000\022I\n\005Flush\022!.milvus.proto.mi"
+  "lvus.FlushRequest\032\033.milvus.proto.common."
+  "Status\"\000\022Q\n\014GetDdChannel\022\032.milvus.proto."
+  "common.Empty\032#.milvus.proto.milvus.Strin"
+  "gResponse\"\0002g\n\014ProxyService\022W\n\014RegisterL"
+  "ink\022\032.milvus.proto.common.Empty\032).milvus"
+  ".proto.milvus.RegisterLinkResponse\"\000BBZ@"
+  "github.com/zilliztech/milvus-distributed"
+  "/internal/proto/milvuspbb\006proto3"
   ;
 static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_milvus_2eproto_deps[2] = {
   &::descriptor_table_common_2eproto,
@@ -1476,7 +1476,7 @@ static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_mil
 static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_milvus_2eproto_once;
 static bool descriptor_table_milvus_2eproto_initialized = false;
 const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_milvus_2eproto = {
-  &descriptor_table_milvus_2eproto_initialized, descriptor_table_protodef_milvus_2eproto, "milvus.proto", 7311,
+  &descriptor_table_milvus_2eproto_initialized, descriptor_table_protodef_milvus_2eproto, "milvus.proto", 7312,
   &descriptor_table_milvus_2eproto_once, descriptor_table_milvus_2eproto_sccs, descriptor_table_milvus_2eproto_deps, 41, 2,
   schemas, file_default_instances, TableStruct_milvus_2eproto::offsets,
   file_level_metadata_milvus_2eproto, 41, file_level_enum_descriptors_milvus_2eproto, file_level_service_descriptors_milvus_2eproto,
@@ -17153,16 +17153,13 @@ FlushRequest::FlushRequest()
 }
 FlushRequest::FlushRequest(const FlushRequest& from)
   : ::PROTOBUF_NAMESPACE_ID::Message(),
-      _internal_metadata_(nullptr) {
+      _internal_metadata_(nullptr),
+      collection_names_(from.collection_names_) {
   _internal_metadata_.MergeFrom(from._internal_metadata_);
   db_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
   if (!from.db_name().empty()) {
     db_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.db_name_);
   }
-  collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  if (!from.collection_name().empty()) {
-    collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_);
-  }
   if (from.has_base()) {
     base_ = new ::milvus::proto::common::MsgBase(*from.base_);
   } else {
@@ -17174,7 +17171,6 @@ FlushRequest::FlushRequest(const FlushRequest& from)
 void FlushRequest::SharedCtor() {
   ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_FlushRequest_milvus_2eproto.base);
   db_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
   base_ = nullptr;
 }
 
@@ -17185,7 +17181,6 @@ FlushRequest::~FlushRequest() {
 
 void FlushRequest::SharedDtor() {
   db_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  collection_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
   if (this != internal_default_instance()) delete base_;
 }
 
@@ -17204,8 +17199,8 @@ void FlushRequest::Clear() {
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
 
+  collection_names_.Clear();
   db_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-  collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
   if (GetArenaNoVirtual() == nullptr && base_ != nullptr) {
     delete base_;
   }
@@ -17235,11 +17230,16 @@ const char* FlushRequest::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_I
           CHK_(ptr);
         } else goto handle_unusual;
         continue;
-      // string collection_name = 3;
+      // repeated string collection_names = 3;
       case 3:
         if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
-          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_collection_name(), ptr, ctx, "milvus.proto.milvus.FlushRequest.collection_name");
-          CHK_(ptr);
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(add_collection_names(), ptr, ctx, "milvus.proto.milvus.FlushRequest.collection_names");
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 26);
         } else goto handle_unusual;
         continue;
       default: {
@@ -17298,15 +17298,16 @@ bool FlushRequest::MergePartialFromCodedStream(
         break;
       }
 
-      // string collection_name = 3;
+      // repeated string collection_names = 3;
       case 3: {
         if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) {
           DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
-                input, this->mutable_collection_name()));
+                input, this->add_collection_names()));
           DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
-            this->collection_name().data(), static_cast<int>(this->collection_name().length()),
+            this->collection_names(this->collection_names_size() - 1).data(),
+            static_cast<int>(this->collection_names(this->collection_names_size() - 1).length()),
             ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE,
-            "milvus.proto.milvus.FlushRequest.collection_name"));
+            "milvus.proto.milvus.FlushRequest.collection_names"));
         } else {
           goto handle_unusual;
         }
@@ -17356,14 +17357,14 @@ void FlushRequest::SerializeWithCachedSizes(
       2, this->db_name(), output);
   }
 
-  // string collection_name = 3;
-  if (this->collection_name().size() > 0) {
+  // repeated string collection_names = 3;
+  for (int i = 0, n = this->collection_names_size(); i < n; i++) {
     ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
-      this->collection_name().data(), static_cast<int>(this->collection_name().length()),
+      this->collection_names(i).data(), static_cast<int>(this->collection_names(i).length()),
       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
-      "milvus.proto.milvus.FlushRequest.collection_name");
-    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased(
-      3, this->collection_name(), output);
+      "milvus.proto.milvus.FlushRequest.collection_names");
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteString(
+      3, this->collection_names(i), output);
   }
 
   if (_internal_metadata_.have_unknown_fields()) {
@@ -17397,15 +17398,14 @@ void FlushRequest::SerializeWithCachedSizes(
         2, this->db_name(), target);
   }
 
-  // string collection_name = 3;
-  if (this->collection_name().size() > 0) {
+  // repeated string collection_names = 3;
+  for (int i = 0, n = this->collection_names_size(); i < n; i++) {
     ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
-      this->collection_name().data(), static_cast<int>(this->collection_name().length()),
+      this->collection_names(i).data(), static_cast<int>(this->collection_names(i).length()),
       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
-      "milvus.proto.milvus.FlushRequest.collection_name");
-    target =
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray(
-        3, this->collection_name(), target);
+      "milvus.proto.milvus.FlushRequest.collection_names");
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      WriteStringToArray(3, this->collection_names(i), target);
   }
 
   if (_internal_metadata_.have_unknown_fields()) {
@@ -17429,6 +17429,14 @@ size_t FlushRequest::ByteSizeLong() const {
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
 
+  // repeated string collection_names = 3;
+  total_size += 1 *
+      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->collection_names_size());
+  for (int i = 0, n = this->collection_names_size(); i < n; i++) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+      this->collection_names(i));
+  }
+
   // string db_name = 2;
   if (this->db_name().size() > 0) {
     total_size += 1 +
@@ -17436,13 +17444,6 @@ size_t FlushRequest::ByteSizeLong() const {
         this->db_name());
   }
 
-  // string collection_name = 3;
-  if (this->collection_name().size() > 0) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
-        this->collection_name());
-  }
-
   // .milvus.proto.common.MsgBase base = 1;
   if (this->has_base()) {
     total_size += 1 +
@@ -17477,14 +17478,11 @@ void FlushRequest::MergeFrom(const FlushRequest& from) {
   ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
   (void) cached_has_bits;
 
+  collection_names_.MergeFrom(from.collection_names_);
   if (from.db_name().size() > 0) {
 
     db_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.db_name_);
   }
-  if (from.collection_name().size() > 0) {
-
-    collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_);
-  }
   if (from.has_base()) {
     mutable_base()->::milvus::proto::common::MsgBase::MergeFrom(from.base());
   }
@@ -17511,10 +17509,9 @@ bool FlushRequest::IsInitialized() const {
 void FlushRequest::InternalSwap(FlushRequest* other) {
   using std::swap;
   _internal_metadata_.Swap(&other->_internal_metadata_);
+  collection_names_.InternalSwap(CastToBase(&other->collection_names_));
   db_name_.Swap(&other->db_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
     GetArenaNoVirtual());
-  collection_name_.Swap(&other->collection_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-    GetArenaNoVirtual());
   swap(base_, other->base_);
 }
 
diff --git a/internal/core/src/pb/milvus.pb.h b/internal/core/src/pb/milvus.pb.h
index be0356236bcf46327ba05cd7bf8fff28ac8fb60c..9cc8cc3ee4f63858e6c43106781cac70e47f755f 100644
--- a/internal/core/src/pb/milvus.pb.h
+++ b/internal/core/src/pb/milvus.pb.h
@@ -6689,10 +6689,27 @@ class FlushRequest :
   // accessors -------------------------------------------------------
 
   enum : int {
+    kCollectionNamesFieldNumber = 3,
     kDbNameFieldNumber = 2,
-    kCollectionNameFieldNumber = 3,
     kBaseFieldNumber = 1,
   };
+  // repeated string collection_names = 3;
+  int collection_names_size() const;
+  void clear_collection_names();
+  const std::string& collection_names(int index) const;
+  std::string* mutable_collection_names(int index);
+  void set_collection_names(int index, const std::string& value);
+  void set_collection_names(int index, std::string&& value);
+  void set_collection_names(int index, const char* value);
+  void set_collection_names(int index, const char* value, size_t size);
+  std::string* add_collection_names();
+  void add_collection_names(const std::string& value);
+  void add_collection_names(std::string&& value);
+  void add_collection_names(const char* value);
+  void add_collection_names(const char* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& collection_names() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_collection_names();
+
   // string db_name = 2;
   void clear_db_name();
   const std::string& db_name() const;
@@ -6704,17 +6721,6 @@ class FlushRequest :
   std::string* release_db_name();
   void set_allocated_db_name(std::string* db_name);
 
-  // string collection_name = 3;
-  void clear_collection_name();
-  const std::string& collection_name() const;
-  void set_collection_name(const std::string& value);
-  void set_collection_name(std::string&& value);
-  void set_collection_name(const char* value);
-  void set_collection_name(const char* value, size_t size);
-  std::string* mutable_collection_name();
-  std::string* release_collection_name();
-  void set_allocated_collection_name(std::string* collection_name);
-
   // .milvus.proto.common.MsgBase base = 1;
   bool has_base() const;
   void clear_base();
@@ -6728,8 +6734,8 @@ class FlushRequest :
   class _Internal;
 
   ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> collection_names_;
   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr db_name_;
-  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_;
   ::milvus::proto::common::MsgBase* base_;
   mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
   friend struct ::TableStruct_milvus_2eproto;
@@ -12613,55 +12619,69 @@ inline void FlushRequest::set_allocated_db_name(std::string* db_name) {
   // @@protoc_insertion_point(field_set_allocated:milvus.proto.milvus.FlushRequest.db_name)
 }
 
-// string collection_name = 3;
-inline void FlushRequest::clear_collection_name() {
-  collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+// repeated string collection_names = 3;
+inline int FlushRequest::collection_names_size() const {
+  return collection_names_.size();
 }
-inline const std::string& FlushRequest::collection_name() const {
-  // @@protoc_insertion_point(field_get:milvus.proto.milvus.FlushRequest.collection_name)
-  return collection_name_.GetNoArena();
+inline void FlushRequest::clear_collection_names() {
+  collection_names_.Clear();
 }
-inline void FlushRequest::set_collection_name(const std::string& value) {
-  
-  collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
-  // @@protoc_insertion_point(field_set:milvus.proto.milvus.FlushRequest.collection_name)
+inline const std::string& FlushRequest::collection_names(int index) const {
+  // @@protoc_insertion_point(field_get:milvus.proto.milvus.FlushRequest.collection_names)
+  return collection_names_.Get(index);
 }
-inline void FlushRequest::set_collection_name(std::string&& value) {
-  
-  collection_name_.SetNoArena(
-    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
-  // @@protoc_insertion_point(field_set_rvalue:milvus.proto.milvus.FlushRequest.collection_name)
+inline std::string* FlushRequest::mutable_collection_names(int index) {
+  // @@protoc_insertion_point(field_mutable:milvus.proto.milvus.FlushRequest.collection_names)
+  return collection_names_.Mutable(index);
+}
+inline void FlushRequest::set_collection_names(int index, const std::string& value) {
+  // @@protoc_insertion_point(field_set:milvus.proto.milvus.FlushRequest.collection_names)
+  collection_names_.Mutable(index)->assign(value);
 }
-inline void FlushRequest::set_collection_name(const char* value) {
+inline void FlushRequest::set_collection_names(int index, std::string&& value) {
+  // @@protoc_insertion_point(field_set:milvus.proto.milvus.FlushRequest.collection_names)
+  collection_names_.Mutable(index)->assign(std::move(value));
+}
+inline void FlushRequest::set_collection_names(int index, const char* value) {
   GOOGLE_DCHECK(value != nullptr);
-  
-  collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
-  // @@protoc_insertion_point(field_set_char:milvus.proto.milvus.FlushRequest.collection_name)
+  collection_names_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:milvus.proto.milvus.FlushRequest.collection_names)
 }
-inline void FlushRequest::set_collection_name(const char* value, size_t size) {
-  
-  collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
-      ::std::string(reinterpret_cast<const char*>(value), size));
-  // @@protoc_insertion_point(field_set_pointer:milvus.proto.milvus.FlushRequest.collection_name)
+inline void FlushRequest::set_collection_names(int index, const char* value, size_t size) {
+  collection_names_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:milvus.proto.milvus.FlushRequest.collection_names)
 }
-inline std::string* FlushRequest::mutable_collection_name() {
-  
-  // @@protoc_insertion_point(field_mutable:milvus.proto.milvus.FlushRequest.collection_name)
-  return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+inline std::string* FlushRequest::add_collection_names() {
+  // @@protoc_insertion_point(field_add_mutable:milvus.proto.milvus.FlushRequest.collection_names)
+  return collection_names_.Add();
 }
-inline std::string* FlushRequest::release_collection_name() {
-  // @@protoc_insertion_point(field_release:milvus.proto.milvus.FlushRequest.collection_name)
-  
-  return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+inline void FlushRequest::add_collection_names(const std::string& value) {
+  collection_names_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:milvus.proto.milvus.FlushRequest.collection_names)
 }
-inline void FlushRequest::set_allocated_collection_name(std::string* collection_name) {
-  if (collection_name != nullptr) {
-    
-  } else {
-    
-  }
-  collection_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), collection_name);
-  // @@protoc_insertion_point(field_set_allocated:milvus.proto.milvus.FlushRequest.collection_name)
+inline void FlushRequest::add_collection_names(std::string&& value) {
+  collection_names_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:milvus.proto.milvus.FlushRequest.collection_names)
+}
+inline void FlushRequest::add_collection_names(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  collection_names_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:milvus.proto.milvus.FlushRequest.collection_names)
+}
+inline void FlushRequest::add_collection_names(const char* value, size_t size) {
+  collection_names_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:milvus.proto.milvus.FlushRequest.collection_names)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+FlushRequest::collection_names() const {
+  // @@protoc_insertion_point(field_list:milvus.proto.milvus.FlushRequest.collection_names)
+  return collection_names_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+FlushRequest::mutable_collection_names() {
+  // @@protoc_insertion_point(field_mutable_list:milvus.proto.milvus.FlushRequest.collection_names)
+  return &collection_names_;
 }
 
 // -------------------------------------------------------------------
diff --git a/internal/proto/milvus.proto b/internal/proto/milvus.proto
index afee18388a5417e93a2426e544cef9b45ed8f258..33a4cbbab99f38431c6ae556e84582617ee75bd7 100644
--- a/internal/proto/milvus.proto
+++ b/internal/proto/milvus.proto
@@ -263,7 +263,7 @@ message SearchResults {
 message FlushRequest {
   common.MsgBase base = 1;
   string db_name = 2;
-  string collection_name = 3;
+  repeated string collection_names = 3;
 }
 
 service MilvusService {
diff --git a/internal/proto/milvuspb/milvus.pb.go b/internal/proto/milvuspb/milvus.pb.go
index 57f3c2386916f41ab8f784c5353df3c185ddef05..66fca8c54d3c08ab56fc285ff0a9ba5656f3aa49 100644
--- a/internal/proto/milvuspb/milvus.pb.go
+++ b/internal/proto/milvuspb/milvus.pb.go
@@ -2261,7 +2261,7 @@ func (m *SearchResults) GetHits() [][]byte {
 type FlushRequest struct {
 	Base                 *commonpb.MsgBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
 	DbName               string            `protobuf:"bytes,2,opt,name=db_name,json=dbName,proto3" json:"db_name,omitempty"`
-	CollectionName       string            `protobuf:"bytes,3,opt,name=collection_name,json=collectionName,proto3" json:"collection_name,omitempty"`
+	CollectionNames      []string          `protobuf:"bytes,3,rep,name=collection_names,json=collectionNames,proto3" json:"collection_names,omitempty"`
 	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
 	XXX_unrecognized     []byte            `json:"-"`
 	XXX_sizecache        int32             `json:"-"`
@@ -2306,11 +2306,11 @@ func (m *FlushRequest) GetDbName() string {
 	return ""
 }
 
-func (m *FlushRequest) GetCollectionName() string {
+func (m *FlushRequest) GetCollectionNames() []string {
 	if m != nil {
-		return m.CollectionName
+		return m.CollectionNames
 	}
-	return ""
+	return nil
 }
 
 type RegisterLinkResponse struct {
@@ -2408,112 +2408,113 @@ func init() {
 func init() { proto.RegisterFile("milvus.proto", fileDescriptor_02345ba45cc0e303) }
 
 var fileDescriptor_02345ba45cc0e303 = []byte{
-	// 1676 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x59, 0xdd, 0x6f, 0x1b, 0xc5,
-	0x16, 0xcf, 0xda, 0x8e, 0x93, 0x9c, 0xac, 0x1d, 0x67, 0xf2, 0xe5, 0xba, 0xed, 0x6d, 0xba, 0xf7,
-	0xf6, 0x26, 0xfd, 0x4a, 0xae, 0xd2, 0xfb, 0xf9, 0x70, 0xa5, 0x36, 0x71, 0x9a, 0x5a, 0x6d, 0xd3,
-	0xdc, 0x75, 0x6e, 0x21, 0x54, 0x95, 0x59, 0x7b, 0x07, 0x7b, 0xe9, 0x7a, 0xd7, 0xec, 0x8c, 0xf3,
-	0xd1, 0x27, 0x04, 0x12, 0x48, 0x80, 0xe0, 0x99, 0x57, 0x24, 0x5e, 0x11, 0x14, 0xc4, 0x7f, 0x80,
-	0xc4, 0xff, 0x82, 0x10, 0x7f, 0x01, 0x12, 0xda, 0x99, 0xf5, 0x7a, 0x77, 0x33, 0x1b, 0x9b, 0x1a,
-	0x88, 0xf3, 0xe6, 0x39, 0x3e, 0x73, 0xe6, 0x37, 0xbf, 0x73, 0xce, 0xcc, 0x99, 0xb3, 0x20, 0x37,
-	0x0d, 0x73, 0xbf, 0x4d, 0x56, 0x5a, 0x8e, 0x4d, 0x6d, 0x34, 0x13, 0x1c, 0xad, 0xf0, 0x41, 0x41,
-	0xae, 0xd9, 0xcd, 0xa6, 0x6d, 0x71, 0x61, 0x41, 0x26, 0xb5, 0x06, 0x6e, 0x6a, 0x7c, 0xa4, 0x7c,
-	0x2e, 0xc1, 0xc2, 0x86, 0x83, 0x35, 0x8a, 0x37, 0x6c, 0xd3, 0xc4, 0x35, 0x6a, 0xd8, 0x96, 0x8a,
-	0xdf, 0x6a, 0x63, 0x42, 0xd1, 0xdf, 0x20, 0x55, 0xd5, 0x08, 0xce, 0x4b, 0x8b, 0xd2, 0xf2, 0xe4,
-	0xda, 0x85, 0x95, 0x90, 0x6d, 0xcf, 0xe6, 0x43, 0x52, 0x5f, 0xd7, 0x08, 0x56, 0x99, 0x26, 0x5a,
-	0x80, 0x31, 0xbd, 0x5a, 0xb1, 0xb4, 0x26, 0xce, 0x27, 0x16, 0xa5, 0xe5, 0x09, 0x35, 0xad, 0x57,
-	0xb7, 0xb5, 0x26, 0x46, 0x4b, 0x30, 0x55, 0xf3, 0xed, 0x73, 0x85, 0x24, 0x53, 0xc8, 0x76, 0xc5,
-	0x4c, 0x71, 0x1e, 0xd2, 0x1c, 0x5f, 0x3e, 0xb5, 0x28, 0x2d, 0xcb, 0xaa, 0x37, 0x52, 0x3e, 0x94,
-	0x60, 0xae, 0xe8, 0xd8, 0xad, 0xa1, 0x40, 0xa9, 0x7c, 0x20, 0xc1, 0xec, 0x3d, 0x8d, 0x0c, 0x07,
-	0x98, 0x3d, 0x90, 0xd7, 0x6d, 0xdb, 0x54, 0x31, 0x69, 0xd9, 0x16, 0xc1, 0xe8, 0x16, 0xa4, 0x09,
-	0xd5, 0x68, 0x9b, 0x78, 0x28, 0xce, 0x0b, 0x51, 0x94, 0x99, 0x8a, 0xea, 0xa9, 0xa2, 0x59, 0x18,
-	0xdd, 0xd7, 0xcc, 0x36, 0x07, 0x31, 0xae, 0xf2, 0x81, 0xf2, 0x04, 0xb2, 0x65, 0xea, 0x18, 0x56,
-	0xfd, 0x37, 0x34, 0x3e, 0xd1, 0x31, 0xfe, 0x89, 0x04, 0xe7, 0x8a, 0x98, 0xd4, 0x1c, 0xa3, 0x3a,
-	0x1c, 0xc1, 0xa7, 0x7c, 0x23, 0x41, 0x41, 0x84, 0x68, 0x90, 0xbd, 0xff, 0xd7, 0x0f, 0xe8, 0x04,
-	0x9b, 0x74, 0x25, 0x3c, 0xc9, 0x4b, 0xc6, 0xee, 0x6a, 0x65, 0x26, 0xe8, 0xc4, 0x3d, 0x52, 0x40,
-	0xee, 0x82, 0x2c, 0x15, 0x19, 0xf0, 0xa4, 0x1a, 0x92, 0xb1, 0xdc, 0x78, 0x60, 0x6b, 0xfa, 0x70,
-	0x90, 0xf8, 0xb1, 0x04, 0x79, 0x15, 0x9b, 0x58, 0x23, 0x43, 0xe2, 0xd5, 0x8f, 0x24, 0x98, 0x0f,
-	0xf0, 0x4b, 0x35, 0x4a, 0x4e, 0x13, 0xce, 0xfb, 0xee, 0x89, 0x1b, 0x85, 0x33, 0x48, 0x84, 0xfd,
-	0x0b, 0x46, 0xdd, 0x5f, 0x24, 0x9f, 0x58, 0x4c, 0x2e, 0x4f, 0xae, 0x5d, 0x16, 0xce, 0xb9, 0x8f,
-	0x8f, 0x1e, 0xbb, 0x59, 0xb7, 0xa3, 0x19, 0x8e, 0xca, 0xf5, 0x95, 0x2a, 0xcc, 0x95, 0x1b, 0xf6,
-	0xc1, 0xef, 0xe9, 0x25, 0xe5, 0x10, 0xe6, 0xa3, 0x6b, 0x0c, 0xb2, 0xd7, 0xab, 0x90, 0x8b, 0xb0,
-	0xcc, 0xb7, 0x3d, 0xa1, 0x4e, 0x85, 0x69, 0x26, 0xca, 0xd7, 0xae, 0xdb, 0xd9, 0xcd, 0xb6, 0xa3,
-	0x39, 0xd4, 0x38, 0xed, 0x8b, 0xed, 0x0a, 0x64, 0x5b, 0x1d, 0x1c, 0x5c, 0x2f, 0xc5, 0xf4, 0x32,
-	0xbe, 0x94, 0xf1, 0xf5, 0x95, 0x04, 0xb3, 0xee, 0x3d, 0x77, 0x96, 0x30, 0x7f, 0x29, 0xc1, 0xcc,
-	0x3d, 0x8d, 0x9c, 0x25, 0xc8, 0x2f, 0x24, 0x98, 0x71, 0x8f, 0x4c, 0x8e, 0xf9, 0x74, 0x21, 0x2f,
-	0xc1, 0x54, 0x18, 0x32, 0xc9, 0xa7, 0x58, 0x48, 0x67, 0x43, 0x98, 0x89, 0xf2, 0xad, 0x04, 0x0b,
-	0xde, 0xc9, 0x3a, 0x14, 0x5c, 0xf7, 0x0d, 0xfc, 0x85, 0x04, 0x73, 0x3e, 0xe2, 0xd3, 0x3e, 0x80,
-	0xfb, 0x0d, 0x91, 0xf7, 0x24, 0x98, 0x8f, 0x82, 0x3e, 0x95, 0x63, 0xfa, 0x0b, 0x09, 0x66, 0xdd,
-	0x33, 0x74, 0x28, 0x7c, 0x1e, 0xad, 0x47, 0x52, 0x82, 0x7a, 0xe4, 0x53, 0x89, 0x5f, 0x2c, 0x01,
-	0xc0, 0x83, 0x10, 0x27, 0x08, 0xb3, 0x84, 0x28, 0xcc, 0x5c, 0x6c, 0xbe, 0xa4, 0x54, 0x24, 0xf9,
-	0xe4, 0x62, 0xd2, 0xc5, 0x16, 0x94, 0xb1, 0x62, 0xa0, 0x53, 0xe2, 0x95, 0x71, 0xbd, 0x89, 0x2d,
-	0xfa, 0xf2, 0x74, 0x46, 0xc9, 0x48, 0x1c, 0x27, 0x03, 0x5d, 0x80, 0x09, 0xc2, 0xd7, 0xf1, 0xab,
-	0xb7, 0xae, 0x40, 0x79, 0x47, 0x82, 0x85, 0x63, 0x70, 0x06, 0x21, 0x2b, 0x0f, 0x63, 0x86, 0xa5,
-	0xe3, 0x43, 0x1f, 0x4d, 0x67, 0xe8, 0xfe, 0x53, 0x6d, 0x1b, 0xa6, 0xee, 0xc3, 0xe8, 0x0c, 0x5d,
-	0x4e, 0x90, 0xeb, 0xaf, 0x3f, 0x84, 0x8f, 0x45, 0x98, 0x0c, 0x38, 0xc4, 0x83, 0x12, 0x14, 0x29,
-	0x6f, 0xc2, 0x4c, 0x08, 0xcd, 0x20, 0x74, 0xfc, 0x09, 0xc0, 0x27, 0x9b, 0x87, 0x4d, 0x52, 0x0d,
-	0x48, 0x94, 0x1f, 0x25, 0x40, 0xbc, 0x48, 0x28, 0xb9, 0x34, 0x9d, 0x66, 0x66, 0x5d, 0x04, 0x78,
-	0xc3, 0xc0, 0xa6, 0x1e, 0x3c, 0x92, 0x26, 0x98, 0x84, 0xfd, 0x5d, 0x04, 0x19, 0x1f, 0x52, 0x47,
-	0xab, 0xb4, 0x34, 0x47, 0x6b, 0x92, 0xfc, 0x68, 0xbf, 0xa7, 0xc8, 0x24, 0x9b, 0xb6, 0xc3, 0x66,
-	0x29, 0xdf, 0xbb, 0xe5, 0x85, 0x17, 0x6f, 0xc3, 0xbe, 0xe3, 0x8b, 0x00, 0x2c, 0x76, 0xf9, 0xdf,
-	0xa3, 0xfc, 0x6f, 0x26, 0x61, 0xe7, 0xb3, 0x09, 0x39, 0xb6, 0x03, 0xbe, 0x9d, 0x96, 0x6b, 0x35,
-	0x32, 0x45, 0x8a, 0x4c, 0x41, 0xff, 0x81, 0xb4, 0xc7, 0x5e, 0xdf, 0x67, 0xb0, 0x37, 0x41, 0xf9,
-	0x4c, 0x82, 0xb9, 0x08, 0x71, 0x83, 0xc4, 0xe5, 0x2e, 0x20, 0x0e, 0x54, 0xef, 0xa2, 0xef, 0xa0,
-	0x8a, 0xbc, 0x10, 0xbd, 0x41, 0x74, 0xaf, 0xea, 0xb4, 0x11, 0x91, 0x10, 0xe5, 0x3b, 0x09, 0xa6,
-	0x99, 0x9e, 0xbb, 0x1a, 0x3e, 0xbb, 0xae, 0x7d, 0x5b, 0x02, 0x14, 0xdc, 0xc7, 0x20, 0x4c, 0xff,
-	0x83, 0x5f, 0xbb, 0x7c, 0x27, 0xd9, 0xb5, 0x4b, 0xc2, 0x39, 0x81, 0xc5, 0xb8, 0xb6, 0xf2, 0xb3,
-	0x04, 0x99, 0x92, 0x45, 0xb0, 0x43, 0x87, 0xbf, 0x54, 0x41, 0x7f, 0x87, 0x71, 0xc7, 0x3e, 0xa8,
-	0xe8, 0x1a, 0xd5, 0xbc, 0x73, 0xe1, 0x9c, 0x10, 0xde, 0xba, 0x69, 0x57, 0xd5, 0x31, 0xc7, 0x3e,
-	0x28, 0x6a, 0x54, 0x43, 0xe7, 0x61, 0xa2, 0xa1, 0x91, 0x46, 0xe5, 0x19, 0x3e, 0x22, 0xf9, 0xf4,
-	0x62, 0x72, 0x39, 0xa3, 0x8e, 0xbb, 0x82, 0xfb, 0xf8, 0x88, 0x28, 0xef, 0x4a, 0x90, 0xed, 0xec,
-	0x7f, 0x10, 0xfa, 0x2f, 0xc1, 0xa4, 0x63, 0x1f, 0x94, 0x8a, 0x95, 0x2a, 0xae, 0x1b, 0x96, 0x77,
-	0x23, 0x00, 0x13, 0xad, 0xbb, 0x12, 0x17, 0x05, 0x57, 0xc0, 0x96, 0xee, 0xdd, 0x06, 0xe3, 0x4c,
-	0xb0, 0x69, 0xe9, 0xca, 0x3e, 0xe4, 0x76, 0x4c, 0xad, 0x86, 0x1b, 0xb6, 0xa9, 0x63, 0x87, 0x65,
-	0x25, 0xca, 0x41, 0x92, 0x6a, 0x75, 0x2f, 0xb9, 0xdd, 0x9f, 0xe8, 0xdf, 0x90, 0xa2, 0x47, 0xad,
-	0x8e, 0x87, 0xff, 0x22, 0x4c, 0x9f, 0x80, 0x99, 0xdd, 0xa3, 0x16, 0x56, 0xd9, 0x0c, 0x34, 0x0f,
-	0x69, 0xd6, 0x8b, 0xe2, 0xb5, 0x82, 0xac, 0x7a, 0x23, 0xe5, 0x69, 0x68, 0xdd, 0x2d, 0xc7, 0x6e,
-	0xb7, 0x50, 0x09, 0xe4, 0x56, 0x57, 0xe6, 0x92, 0x10, 0x9f, 0xac, 0x51, 0xd0, 0x6a, 0x68, 0xaa,
-	0xf2, 0x83, 0x04, 0x99, 0x32, 0xd6, 0x9c, 0x5a, 0xe3, 0x2c, 0x94, 0xef, 0x2e, 0xe3, 0x3a, 0x31,
-	0xbd, 0x34, 0x75, 0x7f, 0xa2, 0xeb, 0x30, 0x1d, 0xd8, 0x50, 0xa5, 0xee, 0x12, 0x94, 0x4f, 0xb3,
-	0x86, 0x6d, 0xae, 0x15, 0x21, 0x4e, 0xb9, 0x0f, 0xa9, 0x7b, 0x06, 0x65, 0x66, 0xdc, 0x4b, 0x58,
-	0x62, 0x97, 0xb0, 0xfb, 0x13, 0x9d, 0x0b, 0xc4, 0x6d, 0x82, 0x39, 0xc0, 0x0f, 0x4e, 0xd6, 0x07,
-	0xb6, 0x1d, 0xcf, 0x33, 0x09, 0xd5, 0x1b, 0x29, 0xaf, 0x76, 0x99, 0x23, 0x6d, 0x93, 0x92, 0x97,
-	0x8b, 0x4a, 0x04, 0xa9, 0x86, 0xe1, 0x95, 0xe2, 0xb2, 0xca, 0x7e, 0xbb, 0xa5, 0x98, 0x7c, 0xd7,
-	0x6c, 0x93, 0xd3, 0xf4, 0x89, 0x9b, 0x76, 0xb3, 0x2a, 0xae, 0x1b, 0x84, 0x62, 0xe7, 0x81, 0x61,
-	0x3d, 0xf3, 0x93, 0xef, 0x9f, 0x30, 0xa6, 0xe9, 0xba, 0x83, 0x09, 0x39, 0x11, 0xcf, 0x1d, 0xae,
-	0xa3, 0x76, 0x94, 0x03, 0xf4, 0x24, 0xfa, 0xa6, 0xe7, 0xda, 0x6d, 0x98, 0x8a, 0xe4, 0x0b, 0x1a,
-	0x87, 0xd4, 0xf6, 0xa3, 0xed, 0xcd, 0xdc, 0x08, 0x9a, 0x86, 0xcc, 0xe3, 0xcd, 0x8d, 0xdd, 0x47,
-	0x6a, 0x65, 0xbd, 0xb4, 0x7d, 0x47, 0xdd, 0xcb, 0xe9, 0x28, 0x07, 0xb2, 0x27, 0xba, 0xfb, 0xe0,
-	0xd1, 0x9d, 0xdd, 0x1c, 0x5e, 0xfb, 0x29, 0x07, 0x99, 0x87, 0x6c, 0xa1, 0x32, 0x76, 0xf6, 0x8d,
-	0x1a, 0x46, 0x15, 0xc8, 0x45, 0xbf, 0x33, 0xa0, 0x1b, 0xc2, 0xe4, 0x89, 0xf9, 0x1c, 0x51, 0x38,
-	0x09, 0xba, 0x32, 0x82, 0x9e, 0x40, 0x36, 0xfc, 0x81, 0x00, 0x5d, 0x13, 0x9a, 0x17, 0x7e, 0x45,
-	0xe8, 0x65, 0xbc, 0x02, 0x99, 0x50, 0xbf, 0x1f, 0x5d, 0x15, 0xda, 0x16, 0x7d, 0x13, 0x28, 0x5c,
-	0x16, 0xaa, 0x06, 0x5b, 0xf6, 0x1c, 0x7d, 0xb8, 0x85, 0x1b, 0x83, 0x5e, 0xd8, 0xe7, 0xed, 0x85,
-	0x5e, 0x83, 0xe9, 0x63, 0x1d, 0x59, 0x74, 0x53, 0x68, 0x3f, 0xae, 0x73, 0xdb, 0x6b, 0x89, 0x03,
-	0x40, 0xc7, 0x3b, 0xe7, 0x68, 0x45, 0xec, 0x81, 0xb8, 0xa6, 0x7f, 0x61, 0xb5, 0x6f, 0x7d, 0x9f,
-	0xb8, 0x7d, 0x58, 0xd8, 0xc2, 0x34, 0xdc, 0x50, 0x35, 0x08, 0x35, 0x6a, 0x04, 0x5d, 0x17, 0x87,
-	0x97, 0xb0, 0x15, 0x5c, 0xb8, 0xd1, 0x9f, 0xb2, 0xbf, 0xae, 0x09, 0x53, 0xe1, 0xc6, 0x26, 0x89,
-	0xf1, 0x98, 0xb0, 0xc5, 0x5a, 0xb8, 0xde, 0x97, 0xae, 0xbf, 0xda, 0x53, 0x98, 0x8a, 0xf4, 0x32,
-	0xe3, 0x76, 0x27, 0xec, 0x78, 0xf6, 0xf2, 0xde, 0x1e, 0x64, 0x42, 0x4d, 0xc7, 0x98, 0xf0, 0x16,
-	0x35, 0x26, 0x7b, 0x99, 0x7e, 0x0a, 0x72, 0xb0, 0x37, 0x88, 0x96, 0xe3, 0x12, 0xe7, 0x98, 0xe1,
-	0xbe, 0xf2, 0x66, 0x8f, 0xe7, 0x8d, 0x3f, 0x99, 0xc4, 0x2c, 0x20, 0x68, 0xf6, 0xf5, 0x42, 0xfe,
-	0xba, 0x9f, 0x35, 0x01, 0xeb, 0x37, 0x4e, 0xca, 0x9a, 0x5f, 0xcb, 0x0d, 0x81, 0xf9, 0x2d, 0x4c,
-	0x43, 0x4d, 0x26, 0x2f, 0x74, 0xc5, 0xa1, 0x24, 0xec, 0xa1, 0xc5, 0x84, 0x92, 0xb8, 0x75, 0xa5,
-	0x8c, 0x20, 0x03, 0xb2, 0xa1, 0xe6, 0x0c, 0x89, 0x71, 0xb6, 0xa8, 0xe5, 0x54, 0xb8, 0xd6, 0x8f,
-	0xaa, 0xbf, 0xd4, 0xff, 0x61, 0x32, 0xf0, 0xb8, 0x46, 0x4b, 0x27, 0x44, 0x6c, 0xf0, 0x31, 0xda,
-	0x8b, 0xb6, 0x06, 0x64, 0x42, 0x4f, 0xb1, 0xb8, 0x68, 0x15, 0xbc, 0x73, 0x63, 0x36, 0x20, 0x7c,
-	0xd9, 0x29, 0x23, 0xa8, 0x0a, 0x99, 0x2d, 0x4c, 0xbb, 0xaf, 0x03, 0xf4, 0xd7, 0xf8, 0xb7, 0x59,
-	0xf0, 0xcd, 0x55, 0x58, 0xea, 0xa9, 0xe7, 0xaf, 0x51, 0x86, 0x34, 0x2f, 0xb4, 0x91, 0x12, 0x33,
-	0x29, 0xf0, 0x0a, 0x29, 0xfc, 0xf9, 0x44, 0x1d, 0xdf, 0xa8, 0x0a, 0x69, 0x5e, 0x26, 0xc5, 0x18,
-	0x0d, 0x55, 0x9f, 0x85, 0x93, 0x75, 0x58, 0x9d, 0xa5, 0x8c, 0xa0, 0x12, 0x8c, 0xb2, 0xfa, 0x08,
-	0x89, 0x13, 0x33, 0x58, 0x3b, 0xf5, 0xf2, 0xe0, 0xff, 0x40, 0xde, 0xc2, 0xb4, 0xa8, 0x6f, 0x34,
-	0x34, 0xcb, 0xc2, 0x26, 0x2a, 0x08, 0xd5, 0x37, 0x9b, 0x2d, 0x7a, 0x14, 0xb3, 0xe3, 0xf0, 0x67,
-	0x69, 0x65, 0x64, 0xad, 0x0e, 0xf2, 0x8e, 0x63, 0x1f, 0x1e, 0x75, 0xea, 0x8d, 0x57, 0x40, 0x0e,
-	0x16, 0x52, 0x27, 0x2e, 0x71, 0x35, 0x26, 0xa9, 0x8f, 0xd7, 0x61, 0xca, 0xc8, 0xfa, 0xfa, 0x6b,
-	0xb7, 0xeb, 0x06, 0x6d, 0xb4, 0xab, 0xae, 0x8d, 0xd5, 0xe7, 0x86, 0x69, 0x1a, 0xcf, 0x29, 0xae,
-	0x35, 0x56, 0xf9, 0xb4, 0x9b, 0xba, 0x41, 0xa8, 0x63, 0x54, 0xdb, 0x14, 0xeb, 0xab, 0x86, 0x45,
-	0xb1, 0x63, 0x69, 0xe6, 0x2a, 0x33, 0xec, 0x69, 0xb4, 0xaa, 0xd5, 0x34, 0x1b, 0xdf, 0xfa, 0x25,
-	0x00, 0x00, 0xff, 0xff, 0x47, 0x3b, 0x71, 0x2a, 0xbd, 0x21, 0x00, 0x00,
+	// 1685 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x59, 0xdd, 0x6f, 0xdb, 0x46,
+	0x12, 0x37, 0x25, 0x59, 0xb6, 0xc7, 0x94, 0x2c, 0xaf, 0xbf, 0x14, 0x25, 0xb9, 0x38, 0x7b, 0x97,
+	0xb3, 0xf3, 0x65, 0x1f, 0x9c, 0xfb, 0x7c, 0x38, 0x20, 0xb1, 0xe5, 0x38, 0x42, 0x12, 0xc7, 0x47,
+	0xf9, 0x72, 0xe7, 0x0b, 0x02, 0x1d, 0x25, 0xee, 0x49, 0xbc, 0x50, 0xa4, 0xca, 0x5d, 0xf9, 0x23,
+	0x4f, 0x45, 0x53, 0xb4, 0x40, 0x5b, 0xb4, 0xcf, 0x7d, 0x2d, 0xd0, 0xd7, 0xa2, 0x4d, 0x8b, 0xfe,
+	0x07, 0x05, 0xfa, 0xbf, 0x14, 0x45, 0xff, 0x82, 0x02, 0x05, 0x97, 0x14, 0x45, 0xd2, 0x4b, 0x4b,
+	0x8d, 0x9a, 0x5a, 0x7e, 0xd3, 0x8e, 0x66, 0x67, 0x7f, 0xfb, 0x9b, 0x99, 0xdd, 0xd9, 0x21, 0xc8,
+	0x4d, 0xdd, 0xd8, 0x6f, 0xd3, 0x95, 0x96, 0x6d, 0x31, 0x0b, 0xcd, 0x04, 0x47, 0x2b, 0xee, 0xa0,
+	0x20, 0xd7, 0xac, 0x66, 0xd3, 0x32, 0x5d, 0x61, 0x41, 0xa6, 0xb5, 0x06, 0x69, 0xaa, 0xee, 0x08,
+	0x7f, 0x2a, 0xc1, 0xc2, 0x86, 0x4d, 0x54, 0x46, 0x36, 0x2c, 0xc3, 0x20, 0x35, 0xa6, 0x5b, 0xa6,
+	0x42, 0xde, 0x68, 0x13, 0xca, 0xd0, 0x1f, 0x20, 0x55, 0x55, 0x29, 0xc9, 0x4b, 0x8b, 0xd2, 0xf2,
+	0xe4, 0xda, 0x85, 0x95, 0x90, 0x6d, 0xcf, 0xe6, 0x43, 0x5a, 0x5f, 0x57, 0x29, 0x51, 0xb8, 0x26,
+	0x5a, 0x80, 0x31, 0xad, 0x5a, 0x31, 0xd5, 0x26, 0xc9, 0x27, 0x16, 0xa5, 0xe5, 0x09, 0x25, 0xad,
+	0x55, 0xb7, 0xd5, 0x26, 0x41, 0x4b, 0x30, 0x55, 0xf3, 0xed, 0xbb, 0x0a, 0x49, 0xae, 0x90, 0xed,
+	0x8a, 0xb9, 0xe2, 0x3c, 0xa4, 0x5d, 0x7c, 0xf9, 0xd4, 0xa2, 0xb4, 0x2c, 0x2b, 0xde, 0x08, 0xbf,
+	0x2f, 0xc1, 0x5c, 0xd1, 0xb6, 0x5a, 0x43, 0x81, 0x12, 0xbf, 0x27, 0xc1, 0xec, 0x3d, 0x95, 0x0e,
+	0x07, 0x98, 0x3d, 0x90, 0xd7, 0x2d, 0xcb, 0x50, 0x08, 0x6d, 0x59, 0x26, 0x25, 0xe8, 0x16, 0xa4,
+	0x29, 0x53, 0x59, 0x9b, 0x7a, 0x28, 0xce, 0x0b, 0x51, 0x94, 0xb9, 0x8a, 0xe2, 0xa9, 0xa2, 0x59,
+	0x18, 0xdd, 0x57, 0x8d, 0xb6, 0x0b, 0x62, 0x5c, 0x71, 0x07, 0xf8, 0x09, 0x64, 0xcb, 0xcc, 0xd6,
+	0xcd, 0xfa, 0x2f, 0x68, 0x7c, 0xa2, 0x63, 0xfc, 0x23, 0x09, 0xce, 0x15, 0x09, 0xad, 0xd9, 0x7a,
+	0x75, 0x38, 0x82, 0x0f, 0x7f, 0x25, 0x41, 0x41, 0x84, 0x68, 0x90, 0xbd, 0xff, 0xdd, 0x0f, 0xe8,
+	0x04, 0x9f, 0x74, 0x25, 0x3c, 0xc9, 0x4b, 0xc6, 0xee, 0x6a, 0x65, 0x2e, 0xe8, 0xc4, 0x3d, 0xc2,
+	0x20, 0x77, 0x41, 0x96, 0x8a, 0x1c, 0x78, 0x52, 0x09, 0xc9, 0x78, 0x6e, 0x3c, 0xb0, 0x54, 0x6d,
+	0x38, 0x48, 0xfc, 0x50, 0x82, 0xbc, 0x42, 0x0c, 0xa2, 0xd2, 0x21, 0xf1, 0xea, 0x07, 0x12, 0xcc,
+	0x07, 0xf8, 0x65, 0x2a, 0xa3, 0xa7, 0x09, 0xe7, 0x5d, 0xe7, 0xc4, 0x8d, 0xc2, 0x19, 0x24, 0xc2,
+	0xfe, 0x02, 0xa3, 0xce, 0x2f, 0x9a, 0x4f, 0x2c, 0x26, 0x97, 0x27, 0xd7, 0x2e, 0x0b, 0xe7, 0xdc,
+	0x27, 0x47, 0x8f, 0x9d, 0xac, 0xdb, 0x51, 0x75, 0x5b, 0x71, 0xf5, 0x71, 0x15, 0xe6, 0xca, 0x0d,
+	0xeb, 0xe0, 0x75, 0x7a, 0x09, 0x1f, 0xc2, 0x7c, 0x74, 0x8d, 0x41, 0xf6, 0x7a, 0x15, 0x72, 0x11,
+	0x96, 0xdd, 0x6d, 0x4f, 0x28, 0x53, 0x61, 0x9a, 0x29, 0xfe, 0xd2, 0x71, 0x3b, 0xbf, 0xd9, 0x76,
+	0x54, 0x9b, 0xe9, 0xa7, 0x7d, 0xb1, 0x5d, 0x81, 0x6c, 0xab, 0x83, 0xc3, 0xd5, 0x4b, 0x71, 0xbd,
+	0x8c, 0x2f, 0xe5, 0x7c, 0x7d, 0x21, 0xc1, 0xac, 0x73, 0xcf, 0x9d, 0x25, 0xcc, 0x9f, 0x4b, 0x30,
+	0x73, 0x4f, 0xa5, 0x67, 0x09, 0xf2, 0x4b, 0x09, 0x66, 0x9c, 0x23, 0xd3, 0xc5, 0x7c, 0xba, 0x90,
+	0x97, 0x60, 0x2a, 0x0c, 0x99, 0xe6, 0x53, 0x3c, 0xa4, 0xb3, 0x21, 0xcc, 0x14, 0x7f, 0x2d, 0xc1,
+	0x82, 0x77, 0xb2, 0x0e, 0x05, 0xd7, 0x7d, 0x03, 0x7f, 0x29, 0xc1, 0x9c, 0x8f, 0xf8, 0xb4, 0x0f,
+	0xe0, 0x7e, 0x43, 0xe4, 0x1d, 0x09, 0xe6, 0xa3, 0xa0, 0x4f, 0xe5, 0x98, 0xfe, 0x4c, 0x82, 0x59,
+	0xe7, 0x0c, 0x1d, 0x0a, 0x9f, 0x47, 0xeb, 0x91, 0x94, 0xa0, 0x1e, 0xf9, 0x58, 0x72, 0x2f, 0x96,
+	0x00, 0xe0, 0x41, 0x88, 0x13, 0x84, 0x59, 0x42, 0x14, 0x66, 0x0e, 0x36, 0x5f, 0x52, 0x2a, 0xd2,
+	0x7c, 0x72, 0x31, 0xe9, 0x60, 0x0b, 0xca, 0x78, 0x31, 0xd0, 0x29, 0xf1, 0xca, 0xa4, 0xde, 0x24,
+	0x26, 0x7b, 0x75, 0x3a, 0xa3, 0x64, 0x24, 0x8e, 0x93, 0x81, 0x2e, 0xc0, 0x04, 0x75, 0xd7, 0xf1,
+	0xab, 0xb7, 0xae, 0x00, 0xbf, 0x25, 0xc1, 0xc2, 0x31, 0x38, 0x83, 0x90, 0x95, 0x87, 0x31, 0xdd,
+	0xd4, 0xc8, 0xa1, 0x8f, 0xa6, 0x33, 0x74, 0xfe, 0xa9, 0xb6, 0x75, 0x43, 0xf3, 0x61, 0x74, 0x86,
+	0x0e, 0x27, 0xc8, 0xf1, 0xd7, 0xaf, 0xc2, 0xc7, 0x22, 0x4c, 0x06, 0x1c, 0xe2, 0x41, 0x09, 0x8a,
+	0xf0, 0xff, 0x61, 0x26, 0x84, 0x66, 0x10, 0x3a, 0x7e, 0x03, 0xe0, 0x93, 0xed, 0x86, 0x4d, 0x52,
+	0x09, 0x48, 0xf0, 0xf7, 0x12, 0x20, 0xb7, 0x48, 0x28, 0x39, 0x34, 0x9d, 0x66, 0x66, 0x5d, 0x04,
+	0xf8, 0x9f, 0x4e, 0x0c, 0x2d, 0x78, 0x24, 0x4d, 0x70, 0x09, 0xff, 0xbb, 0x08, 0x32, 0x39, 0x64,
+	0xb6, 0x5a, 0x69, 0xa9, 0xb6, 0xda, 0xa4, 0xf9, 0xd1, 0x7e, 0x4f, 0x91, 0x49, 0x3e, 0x6d, 0x87,
+	0xcf, 0xc2, 0xdf, 0x3a, 0xe5, 0x85, 0x17, 0x6f, 0xc3, 0xbe, 0xe3, 0x8b, 0x00, 0x3c, 0x76, 0xdd,
+	0xbf, 0x47, 0xdd, 0xbf, 0xb9, 0x84, 0x9f, 0xcf, 0x06, 0xe4, 0xf8, 0x0e, 0xdc, 0xed, 0xb4, 0x1c,
+	0xab, 0x91, 0x29, 0x52, 0x64, 0x0a, 0xfa, 0x1b, 0xa4, 0x3d, 0xf6, 0xfa, 0x3e, 0x83, 0xbd, 0x09,
+	0xf8, 0x13, 0x09, 0xe6, 0x22, 0xc4, 0x0d, 0x12, 0x97, 0xbb, 0x80, 0x5c, 0xa0, 0x5a, 0x17, 0x7d,
+	0x07, 0x55, 0xe4, 0x85, 0xe8, 0x0d, 0xa2, 0x7b, 0x55, 0xa6, 0xf5, 0x88, 0x84, 0xe2, 0x6f, 0x24,
+	0x98, 0xe6, 0x7a, 0xce, 0x6a, 0xe4, 0xec, 0xba, 0xf6, 0x4d, 0x09, 0x50, 0x70, 0x1f, 0x83, 0x30,
+	0xfd, 0x27, 0xf7, 0xda, 0x75, 0x77, 0x92, 0x5d, 0xbb, 0x24, 0x9c, 0x13, 0x58, 0xcc, 0xd5, 0xc6,
+	0x3f, 0x4a, 0x90, 0x29, 0x99, 0x94, 0xd8, 0x6c, 0xf8, 0x4b, 0x15, 0xf4, 0x47, 0x18, 0xb7, 0xad,
+	0x83, 0x8a, 0xa6, 0x32, 0xd5, 0x3b, 0x17, 0xce, 0x09, 0xe1, 0xad, 0x1b, 0x56, 0x55, 0x19, 0xb3,
+	0xad, 0x83, 0xa2, 0xca, 0x54, 0x74, 0x1e, 0x26, 0x1a, 0x2a, 0x6d, 0x54, 0x9e, 0x91, 0x23, 0x9a,
+	0x4f, 0x2f, 0x26, 0x97, 0x33, 0xca, 0xb8, 0x23, 0xb8, 0x4f, 0x8e, 0x28, 0x7e, 0x21, 0x41, 0xb6,
+	0xb3, 0xff, 0x41, 0xe8, 0xbf, 0x04, 0x93, 0xb6, 0x75, 0x50, 0x2a, 0x56, 0xaa, 0xa4, 0xae, 0x9b,
+	0xde, 0x8d, 0x00, 0x5c, 0xb4, 0xee, 0x48, 0x1c, 0x14, 0xae, 0x02, 0x31, 0x35, 0xef, 0x36, 0x18,
+	0xe7, 0x82, 0x4d, 0x53, 0xc3, 0xfb, 0x90, 0xdb, 0x31, 0xd4, 0x1a, 0x69, 0x58, 0x86, 0x46, 0x6c,
+	0x9e, 0x95, 0x28, 0x07, 0x49, 0xa6, 0xd6, 0xbd, 0xe4, 0x76, 0x7e, 0xa2, 0xbf, 0x42, 0x8a, 0x1d,
+	0xb5, 0x3a, 0x1e, 0xfe, 0x9d, 0x30, 0x7d, 0x02, 0x66, 0x76, 0x8f, 0x5a, 0x44, 0xe1, 0x33, 0xd0,
+	0x3c, 0xa4, 0x79, 0x2f, 0xca, 0xad, 0x15, 0x64, 0xc5, 0x1b, 0xe1, 0xa7, 0xa1, 0x75, 0xb7, 0x6c,
+	0xab, 0xdd, 0x42, 0x25, 0x90, 0x5b, 0x5d, 0x99, 0x43, 0x42, 0x7c, 0xb2, 0x46, 0x41, 0x2b, 0xa1,
+	0xa9, 0xf8, 0x3b, 0x09, 0x32, 0x65, 0xa2, 0xda, 0xb5, 0xc6, 0x59, 0x28, 0xdf, 0x1d, 0xc6, 0x35,
+	0x6a, 0x78, 0x69, 0xea, 0xfc, 0x44, 0xd7, 0x61, 0x3a, 0xb0, 0xa1, 0x4a, 0xdd, 0x21, 0x28, 0x9f,
+	0xe6, 0x0d, 0xdb, 0x5c, 0x2b, 0x42, 0x1c, 0xbe, 0x0f, 0xa9, 0x7b, 0x3a, 0xe3, 0x66, 0x9c, 0x4b,
+	0x58, 0xe2, 0x97, 0xb0, 0xf3, 0x13, 0x9d, 0x0b, 0xc4, 0x6d, 0x82, 0x3b, 0xc0, 0x0f, 0x4e, 0xde,
+	0x07, 0xb6, 0x6c, 0xcf, 0x33, 0x09, 0xc5, 0x1b, 0xe1, 0x7f, 0x77, 0x99, 0xa3, 0x6d, 0x83, 0xd1,
+	0x57, 0x8b, 0x4a, 0x04, 0xa9, 0x86, 0xee, 0x95, 0xe2, 0xb2, 0xc2, 0x7f, 0xe3, 0xb7, 0x25, 0x90,
+	0xef, 0x1a, 0x6d, 0xfa, 0x3a, 0x7c, 0x22, 0x6a, 0x5b, 0x24, 0xc5, 0x6d, 0x8b, 0x17, 0x12, 0xcc,
+	0x2a, 0xa4, 0xae, 0x53, 0x46, 0xec, 0x07, 0xba, 0xf9, 0xcc, 0x4f, 0xbf, 0x3f, 0xc3, 0x98, 0xaa,
+	0x69, 0x36, 0xa1, 0xf4, 0x44, 0x44, 0x77, 0x5c, 0x1d, 0xa5, 0xa3, 0x1c, 0x20, 0x28, 0xd1, 0x37,
+	0x41, 0xd7, 0x6e, 0xc3, 0x54, 0x24, 0x63, 0xd0, 0x38, 0xa4, 0xb6, 0x1f, 0x6d, 0x6f, 0xe6, 0x46,
+	0xd0, 0x34, 0x64, 0x1e, 0x6f, 0x6e, 0xec, 0x3e, 0x52, 0x2a, 0xeb, 0xa5, 0xed, 0x3b, 0xca, 0x5e,
+	0x4e, 0x43, 0x39, 0x90, 0x3d, 0xd1, 0xdd, 0x07, 0x8f, 0xee, 0xec, 0xe6, 0xc8, 0xda, 0x0f, 0x39,
+	0xc8, 0x3c, 0xe4, 0x0b, 0x95, 0x89, 0xbd, 0xaf, 0xd7, 0x08, 0xaa, 0x40, 0x2e, 0xfa, 0xa5, 0x01,
+	0xdd, 0x10, 0xa6, 0x4f, 0xcc, 0x07, 0x89, 0xc2, 0x49, 0xd0, 0xf1, 0x08, 0x7a, 0x02, 0xd9, 0xf0,
+	0x27, 0x02, 0x74, 0x4d, 0x68, 0x5e, 0xf8, 0x1d, 0xa1, 0x97, 0xf1, 0x0a, 0x64, 0x42, 0x1d, 0x7f,
+	0x74, 0x55, 0x68, 0x5b, 0xf4, 0x55, 0xa0, 0x70, 0x59, 0xa8, 0x1a, 0x6c, 0xda, 0xbb, 0xe8, 0xc3,
+	0x4d, 0xdc, 0x18, 0xf4, 0xc2, 0x4e, 0x6f, 0x2f, 0xf4, 0x2a, 0x4c, 0x1f, 0xeb, 0xc9, 0xa2, 0x9b,
+	0x42, 0xfb, 0x71, 0xbd, 0xdb, 0x5e, 0x4b, 0x1c, 0x00, 0x3a, 0xde, 0x3b, 0x47, 0x2b, 0x62, 0x0f,
+	0xc4, 0xb5, 0xfd, 0x0b, 0xab, 0x7d, 0xeb, 0xfb, 0xc4, 0xed, 0xc3, 0xc2, 0x16, 0x61, 0xe1, 0x96,
+	0xaa, 0x4e, 0x99, 0x5e, 0xa3, 0xe8, 0xba, 0x38, 0xbc, 0x84, 0xcd, 0xe0, 0xc2, 0x8d, 0xfe, 0x94,
+	0xfd, 0x75, 0x0d, 0x98, 0x0a, 0xb7, 0x36, 0x69, 0x8c, 0xc7, 0x84, 0x4d, 0xd6, 0xc2, 0xf5, 0xbe,
+	0x74, 0xfd, 0xd5, 0x9e, 0xc2, 0x54, 0xa4, 0x9b, 0x19, 0xb7, 0x3b, 0x61, 0xcf, 0xb3, 0x97, 0xf7,
+	0xf6, 0x20, 0x13, 0x6a, 0x3b, 0xc6, 0x84, 0xb7, 0xa8, 0x35, 0xd9, 0xcb, 0xf4, 0x53, 0x90, 0x83,
+	0xdd, 0x41, 0xb4, 0x1c, 0x97, 0x38, 0xc7, 0x0c, 0xf7, 0x95, 0x37, 0x7b, 0x6e, 0xde, 0xf8, 0x93,
+	0x69, 0xcc, 0x02, 0x82, 0x76, 0x5f, 0x2f, 0xe4, 0xff, 0xf5, 0xb3, 0x26, 0x60, 0xfd, 0xc6, 0x49,
+	0x59, 0xf3, 0x73, 0xb9, 0xa1, 0x30, 0xbf, 0x45, 0x58, 0xa8, 0xcd, 0xe4, 0x85, 0xae, 0x38, 0x94,
+	0x84, 0x5d, 0xb4, 0x98, 0x50, 0x12, 0x37, 0xaf, 0xf0, 0x08, 0xd2, 0x21, 0x1b, 0x6a, 0xcf, 0xd0,
+	0x18, 0x67, 0x8b, 0x9a, 0x4e, 0x85, 0x6b, 0xfd, 0xa8, 0xfa, 0x4b, 0xfd, 0x13, 0x26, 0x03, 0xcf,
+	0x6b, 0xb4, 0x74, 0x42, 0xc4, 0x06, 0x9f, 0xa3, 0xbd, 0x68, 0x6b, 0x40, 0x26, 0xf4, 0x18, 0x8b,
+	0x8b, 0x56, 0xc1, 0x4b, 0x37, 0x66, 0x03, 0xc2, 0xb7, 0x1d, 0x1e, 0x41, 0x55, 0xc8, 0x6c, 0x11,
+	0xd6, 0x7d, 0x1f, 0xa0, 0xdf, 0xc7, 0xbf, 0xce, 0x82, 0xaf, 0xae, 0xc2, 0x52, 0x4f, 0x3d, 0x7f,
+	0x8d, 0x32, 0xa4, 0xdd, 0x52, 0x1b, 0xe1, 0x98, 0x49, 0x81, 0x77, 0x48, 0xe1, 0xb7, 0x27, 0xea,
+	0xf8, 0x46, 0x15, 0x48, 0xbb, 0x85, 0x52, 0x8c, 0xd1, 0x50, 0xfd, 0x59, 0x38, 0x59, 0x87, 0x57,
+	0x5a, 0x78, 0x04, 0x95, 0x60, 0x94, 0x57, 0x48, 0x48, 0x9c, 0x98, 0xc1, 0xea, 0xa9, 0x97, 0x07,
+	0xff, 0x01, 0xf2, 0x16, 0x61, 0x45, 0x6d, 0xa3, 0xa1, 0x9a, 0x26, 0x31, 0x50, 0x41, 0xa8, 0xbe,
+	0xd9, 0x6c, 0xb1, 0xa3, 0x98, 0x1d, 0x87, 0x3f, 0x4c, 0xe3, 0x91, 0xb5, 0x3a, 0xc8, 0x3b, 0xb6,
+	0x75, 0x78, 0xd4, 0xa9, 0x37, 0xfe, 0x05, 0x72, 0xb0, 0x90, 0x3a, 0x71, 0x89, 0xab, 0x31, 0x49,
+	0x7d, 0xbc, 0x0e, 0xc3, 0x23, 0xeb, 0xeb, 0xff, 0xb9, 0x5d, 0xd7, 0x59, 0xa3, 0x5d, 0x75, 0x6c,
+	0xac, 0x3e, 0xd7, 0x0d, 0x43, 0x7f, 0xce, 0x48, 0xad, 0xb1, 0xea, 0x4e, 0xbb, 0xa9, 0xe9, 0x94,
+	0xd9, 0x7a, 0xb5, 0xcd, 0x88, 0xb6, 0xaa, 0x9b, 0x8c, 0xd8, 0xa6, 0x6a, 0xac, 0x72, 0xc3, 0x9e,
+	0x46, 0xab, 0x5a, 0x4d, 0xf3, 0xf1, 0xad, 0x9f, 0x02, 0x00, 0x00, 0xff, 0xff, 0x14, 0x2f, 0x38,
+	0x4a, 0xbf, 0x21, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
diff --git a/internal/proxynode/condition.go b/internal/proxynode/condition.go
index 2ebf078b919f876022eb2bf7ea468b14a8c17ced..a55ec9d63f56390df768ce6d04bfa3ad38cfa2c1 100644
--- a/internal/proxynode/condition.go
+++ b/internal/proxynode/condition.go
@@ -9,6 +9,7 @@ import (
 type Condition interface {
 	WaitToFinish() error
 	Notify(err error)
+	Ctx() context.Context
 }
 
 type TaskCondition struct {
@@ -31,6 +32,10 @@ func (tc *TaskCondition) Notify(err error) {
 	tc.done <- err
 }
 
+func (tc *TaskCondition) Ctx() context.Context {
+	return tc.ctx
+}
+
 func NewTaskCondition(ctx context.Context) *TaskCondition {
 	return &TaskCondition{
 		done: make(chan error),
diff --git a/internal/proxynode/grpc_service.go b/internal/proxynode/grpc_service.go
deleted file mode 100644
index 4ca7faf6a4f746a5014c0bd01a2d02df81ee73a0..0000000000000000000000000000000000000000
--- a/internal/proxynode/grpc_service.go
+++ /dev/null
@@ -1,123 +0,0 @@
-package proxynode
-
-//
-//func (node *NodeImpl) DescribePartition(ctx context.Context, in *milvuspb.PartitionName) (*milvuspb.PartitionDescription, error) {
-//	log.Println("describe partition: ", in)
-//
-//	return &milvuspb.PartitionDescription{
-//		Status: &commonpb.Status{
-//			ErrorCode: commonpb.ErrorCode_UNEXPECTED_ERROR,
-//			Reason:    "Deprecated!",
-//		},
-//		Name:       in,
-//		Statistics: nil,
-//	}, nil
-//
-//}
-//
-//func (p *NodeImpl) DescribePartition2(ctx context.Context, in *milvuspb.PartitionName) (*milvuspb.PartitionDescription, error) {
-//	log.Println("describe partition: ", in)
-//	dpt := &DescribePartitionTask{
-//		Condition: NewTaskCondition(ctx),
-//		DescribePartitionRequest: internalpb.DescribePartitionRequest{
-//			MsgType:       commonpb.MsgType_kDescribePartition,
-//			ReqID:         0,
-//			Timestamp:     0,
-//			ProxyID:       0,
-//			PartitionName: in,
-//			//TODO, ReqID,Timestamp,ProxyID
-//		},
-//		masterClient: p.masterClient,
-//		result:       nil,
-//		ctx:          nil,
-//	}
-//
-//	var cancel func()
-//	dpt.ctx, cancel = context.WithTimeout(ctx, reqTimeoutInterval)
-//	defer cancel()
-//
-//	err := func() error {
-//		select {
-//		case <-ctx.Done():
-//			return errors.New("describe partion timeout")
-//		default:
-//			return p.sched.DdQueue.Enqueue(dpt)
-//		}
-//	}()
-//
-//	if err != nil {
-//		return &milvuspb.PartitionDescription{
-//			Status: &commonpb.Status{
-//				ErrorCode: commonpb.ErrorCode_UNEXPECTED_ERROR,
-//				Reason:    err.Error(),
-//			},
-//			Name:       in,
-//			Statistics: nil,
-//		}, nil
-//	}
-//
-//	err = dpt.WaitToFinish()
-//	if err != nil {
-//		return &milvuspb.PartitionDescription{
-//			Status: &commonpb.Status{
-//				ErrorCode: commonpb.ErrorCode_UNEXPECTED_ERROR,
-//				Reason:    err.Error(),
-//			},
-//			Name:       in,
-//			Statistics: nil,
-//		}, nil
-//	}
-//	return dpt.result, nil
-//}
-//
-//func (node *NodeImpl) DescribeIndexProgress(ctx context.Context, req *milvuspb.DescribeIndexProgressRequest) (*milvuspb.BoolResponse, error) {
-//	log.Println("Describe index progress for: ", req.FieldName)
-//	dipt := &GetIndexStateTask{
-//		Condition: NewTaskCondition(ctx),
-//		IndexStateRequest: milvuspb.IndexStateRequest{
-//			Base: &commonpb.MsgBase{
-//				MsgType:  commonpb.MsgType_kGetIndexState,
-//				SourceID: Params.ProxyID(),
-//			},
-//			CollectionName: req.CollectionName,
-//			FieldName:      req.FieldName,
-//		},
-//		masterClient: node.masterClient,
-//	}
-//
-//	var cancel func()
-//	dipt.ctx, cancel = context.WithTimeout(ctx, reqTimeoutInterval)
-//	defer cancel()
-//
-//	fn := func() error {
-//		select {
-//		case <-ctx.Done():
-//			return errors.New("create index timeout")
-//		default:
-//			return node.sched.DdQueue.Enqueue(dipt)
-//		}
-//	}
-//	err := fn()
-//	if err != nil {
-//		return &milvuspb.BoolResponse{
-//			Status: &commonpb.Status{
-//				ErrorCode: commonpb.ErrorCode_UNEXPECTED_ERROR,
-//				Reason:    err.Error(),
-//			},
-//			Value: false,
-//		}, nil
-//	}
-//
-//	err = dipt.WaitToFinish()
-//	if err != nil {
-//		return &milvuspb.BoolResponse{
-//			Status: &commonpb.Status{
-//				ErrorCode: commonpb.ErrorCode_UNEXPECTED_ERROR,
-//				Reason:    err.Error(),
-//			},
-//			Value: false,
-//		}, nil
-//	}
-//
-//	return dipt.result, nil
-//}
diff --git a/internal/proxynode/impl.go b/internal/proxynode/impl.go
index 23f04f45993236c72230e28218d697907530e933..593ac8b7e7afd9a9f97e62f45cb152f6b449a669 100644
--- a/internal/proxynode/impl.go
+++ b/internal/proxynode/impl.go
@@ -6,11 +6,9 @@ import (
 	"strconv"
 	"time"
 
-	"github.com/opentracing/opentracing-go"
 	"github.com/zilliztech/milvus-distributed/internal/msgstream"
 	"github.com/zilliztech/milvus-distributed/internal/proto/internalpb2"
 
-	"github.com/zilliztech/milvus-distributed/internal/errors"
 	"github.com/zilliztech/milvus-distributed/internal/proto/commonpb"
 	"github.com/zilliztech/milvus-distributed/internal/proto/milvuspb"
 	"github.com/zilliztech/milvus-distributed/internal/proto/proxypb"
@@ -35,26 +33,17 @@ func (node *NodeImpl) InvalidateCollectionMetaCache(ctx context.Context, request
 
 func (node *NodeImpl) CreateCollection(request *milvuspb.CreateCollectionRequest) (*commonpb.Status, error) {
 	log.Println("create collection: ", request)
-	ctx := context.Background()
+	ctx, cancel := context.WithTimeout(context.Background(), reqTimeoutInterval)
+	defer cancel()
+
 	cct := &CreateCollectionTask{
 		Condition:               NewTaskCondition(ctx),
 		CreateCollectionRequest: request,
 		masterClient:            node.masterClient,
 		dataServiceClient:       node.dataServiceClient,
 	}
-	var cancel func()
-	cct.ctx, cancel = context.WithTimeout(ctx, reqTimeoutInterval)
-	defer cancel()
 
-	fn := func() error {
-		select {
-		case <-ctx.Done():
-			return errors.New("create collection timeout")
-		default:
-			return node.sched.DdQueue.Enqueue(cct)
-		}
-	}
-	err := fn()
+	err := node.sched.DdQueue.Enqueue(cct)
 	if err != nil {
 		return &commonpb.Status{
 			ErrorCode: commonpb.ErrorCode_UNEXPECTED_ERROR,
@@ -75,25 +64,16 @@ func (node *NodeImpl) CreateCollection(request *milvuspb.CreateCollectionRequest
 
 func (node *NodeImpl) DropCollection(request *milvuspb.DropCollectionRequest) (*commonpb.Status, error) {
 	log.Println("drop collection: ", request)
-	ctx := context.Background()
+	ctx, cancel := context.WithTimeout(context.Background(), reqTimeoutInterval)
+	defer cancel()
+
 	dct := &DropCollectionTask{
 		Condition:             NewTaskCondition(ctx),
 		DropCollectionRequest: request,
 		masterClient:          node.masterClient,
 	}
-	var cancel func()
-	dct.ctx, cancel = context.WithTimeout(ctx, reqTimeoutInterval)
-	defer cancel()
 
-	fn := func() error {
-		select {
-		case <-ctx.Done():
-			return errors.New("create collection timeout")
-		default:
-			return node.sched.DdQueue.Enqueue(dct)
-		}
-	}
-	err := fn()
+	err := node.sched.DdQueue.Enqueue(dct)
 	if err != nil {
 		return &commonpb.Status{
 			ErrorCode: commonpb.ErrorCode_UNEXPECTED_ERROR,
@@ -114,25 +94,16 @@ func (node *NodeImpl) DropCollection(request *milvuspb.DropCollectionRequest) (*
 
 func (node *NodeImpl) HasCollection(request *milvuspb.HasCollectionRequest) (*milvuspb.BoolResponse, error) {
 	log.Println("has collection: ", request)
-	ctx := context.Background()
+	ctx, cancel := context.WithTimeout(context.Background(), reqTimeoutInterval)
+	defer cancel()
+
 	hct := &HasCollectionTask{
 		Condition:            NewTaskCondition(ctx),
 		HasCollectionRequest: request,
 		masterClient:         node.masterClient,
 	}
-	var cancel func()
-	hct.ctx, cancel = context.WithTimeout(ctx, reqTimeoutInterval)
-	defer cancel()
 
-	fn := func() error {
-		select {
-		case <-ctx.Done():
-			return errors.New("create collection timeout")
-		default:
-			return node.sched.DdQueue.Enqueue(hct)
-		}
-	}
-	err := fn()
+	err := node.sched.DdQueue.Enqueue(hct)
 	if err != nil {
 		return &milvuspb.BoolResponse{
 			Status: &commonpb.Status{
@@ -165,25 +136,16 @@ func (node *NodeImpl) ReleaseCollection(request *milvuspb.ReleaseCollectionReque
 
 func (node *NodeImpl) DescribeCollection(request *milvuspb.DescribeCollectionRequest) (*milvuspb.DescribeCollectionResponse, error) {
 	log.Println("describe collection: ", request)
-	ctx := context.Background()
+	ctx, cancel := context.WithTimeout(context.Background(), reqTimeoutInterval)
+	defer cancel()
+
 	dct := &DescribeCollectionTask{
 		Condition:                 NewTaskCondition(ctx),
 		DescribeCollectionRequest: request,
 		masterClient:              node.masterClient,
 	}
-	var cancel func()
-	dct.ctx, cancel = context.WithTimeout(ctx, reqTimeoutInterval)
-	defer cancel()
 
-	fn := func() error {
-		select {
-		case <-ctx.Done():
-			return errors.New("create collection timeout")
-		default:
-			return node.sched.DdQueue.Enqueue(dct)
-		}
-	}
-	err := fn()
+	err := node.sched.DdQueue.Enqueue(dct)
 	if err != nil {
 		return &milvuspb.DescribeCollectionResponse{
 			Status: &commonpb.Status{
@@ -208,25 +170,15 @@ func (node *NodeImpl) DescribeCollection(request *milvuspb.DescribeCollectionReq
 
 func (node *NodeImpl) GetCollectionStatistics(request *milvuspb.CollectionStatsRequest) (*milvuspb.CollectionStatsResponse, error) {
 	log.Println("get collection statistics")
-	ctx := context.Background()
+	ctx, cancel := context.WithTimeout(context.Background(), reqTimeoutInterval)
+	defer cancel()
 	g := &GetCollectionsStatisticsTask{
 		Condition:              NewTaskCondition(ctx),
 		CollectionStatsRequest: request,
 		dataServiceClient:      node.dataServiceClient,
 	}
-	var cancel func()
-	g.ctx, cancel = context.WithTimeout(ctx, reqTimeoutInterval)
-	defer cancel()
 
-	fn := func() error {
-		select {
-		case <-ctx.Done():
-			return errors.New("create collection timeout")
-		default:
-			return node.sched.DdQueue.Enqueue(g)
-		}
-	}
-	err := fn()
+	err := node.sched.DdQueue.Enqueue(g)
 	if err != nil {
 		return &milvuspb.CollectionStatsResponse{
 			Status: &commonpb.Status{
@@ -251,25 +203,15 @@ func (node *NodeImpl) GetCollectionStatistics(request *milvuspb.CollectionStatsR
 
 func (node *NodeImpl) ShowCollections(request *milvuspb.ShowCollectionRequest) (*milvuspb.ShowCollectionResponse, error) {
 	log.Println("show collections")
-	ctx := context.Background()
+	ctx, cancel := context.WithTimeout(context.Background(), reqTimeoutInterval)
+	defer cancel()
 	sct := &ShowCollectionsTask{
 		Condition:             NewTaskCondition(ctx),
 		ShowCollectionRequest: request,
 		masterClient:          node.masterClient,
 	}
-	var cancel func()
-	sct.ctx, cancel = context.WithTimeout(ctx, reqTimeoutInterval)
-	defer cancel()
 
-	fn := func() error {
-		select {
-		case <-ctx.Done():
-			return errors.New("create collection timeout")
-		default:
-			return node.sched.DdQueue.Enqueue(sct)
-		}
-	}
-	err := fn()
+	err := node.sched.DdQueue.Enqueue(sct)
 	if err != nil {
 		return &milvuspb.ShowCollectionResponse{
 			Status: &commonpb.Status{
@@ -294,27 +236,16 @@ func (node *NodeImpl) ShowCollections(request *milvuspb.ShowCollectionRequest) (
 
 func (node *NodeImpl) CreatePartition(request *milvuspb.CreatePartitionRequest) (*commonpb.Status, error) {
 	log.Println("create partition", request)
-	ctx := context.Background()
+	ctx, cancel := context.WithTimeout(context.Background(), reqTimeoutInterval)
+	defer cancel()
 	cpt := &CreatePartitionTask{
 		Condition:              NewTaskCondition(ctx),
 		CreatePartitionRequest: request,
 		masterClient:           node.masterClient,
 		result:                 nil,
-		ctx:                    nil,
 	}
-	var cancel func()
-	cpt.ctx, cancel = context.WithTimeout(ctx, reqTimeoutInterval)
-	defer cancel()
-
-	err := func() error {
-		select {
-		case <-ctx.Done():
-			return errors.New("create partition timeout")
-		default:
-			return node.sched.DdQueue.Enqueue(cpt)
-		}
-	}()
 
+	err := node.sched.DdQueue.Enqueue(cpt)
 	if err != nil {
 		return &commonpb.Status{
 			ErrorCode: commonpb.ErrorCode_UNEXPECTED_ERROR,
@@ -333,27 +264,16 @@ func (node *NodeImpl) CreatePartition(request *milvuspb.CreatePartitionRequest)
 
 func (node *NodeImpl) DropPartition(request *milvuspb.DropPartitionRequest) (*commonpb.Status, error) {
 	log.Println("drop partition: ", request)
-	ctx := context.Background()
+	ctx, cancel := context.WithTimeout(context.Background(), reqTimeoutInterval)
+	defer cancel()
 	dpt := &DropPartitionTask{
 		Condition:            NewTaskCondition(ctx),
 		DropPartitionRequest: request,
 		masterClient:         node.masterClient,
 		result:               nil,
-		ctx:                  nil,
 	}
 
-	var cancel func()
-	dpt.ctx, cancel = context.WithTimeout(ctx, reqTimeoutInterval)
-	defer cancel()
-
-	err := func() error {
-		select {
-		case <-ctx.Done():
-			return errors.New("drop partition timeout")
-		default:
-			return node.sched.DdQueue.Enqueue(dpt)
-		}
-	}()
+	err := node.sched.DdQueue.Enqueue(dpt)
 
 	if err != nil {
 		return &commonpb.Status{
@@ -373,27 +293,16 @@ func (node *NodeImpl) DropPartition(request *milvuspb.DropPartitionRequest) (*co
 
 func (node *NodeImpl) HasPartition(request *milvuspb.HasPartitionRequest) (*milvuspb.BoolResponse, error) {
 	log.Println("has partition: ", request)
-	ctx := context.Background()
+	ctx, cancel := context.WithTimeout(context.Background(), reqTimeoutInterval)
+	defer cancel()
 	hpt := &HasPartitionTask{
 		Condition:           NewTaskCondition(ctx),
 		HasPartitionRequest: request,
 		masterClient:        node.masterClient,
 		result:              nil,
-		ctx:                 nil,
 	}
 
-	var cancel func()
-	hpt.ctx, cancel = context.WithTimeout(ctx, reqTimeoutInterval)
-	defer cancel()
-
-	err := func() error {
-		select {
-		case <-ctx.Done():
-			return errors.New("has partition timeout")
-		default:
-			return node.sched.DdQueue.Enqueue(hpt)
-		}
-	}()
+	err := node.sched.DdQueue.Enqueue(hpt)
 
 	if err != nil {
 		return &milvuspb.BoolResponse{
@@ -431,27 +340,16 @@ func (node *NodeImpl) GetPartitionStatistics(request *milvuspb.PartitionStatsReq
 
 func (node *NodeImpl) ShowPartitions(request *milvuspb.ShowPartitionRequest) (*milvuspb.ShowPartitionResponse, error) {
 	log.Println("show partitions: ", request)
-	ctx := context.Background()
+	ctx, cancel := context.WithTimeout(context.Background(), reqTimeoutInterval)
+	defer cancel()
 	spt := &ShowPartitionsTask{
 		Condition:            NewTaskCondition(ctx),
 		ShowPartitionRequest: request,
 		masterClient:         node.masterClient,
 		result:               nil,
-		ctx:                  nil,
 	}
 
-	var cancel func()
-	spt.ctx, cancel = context.WithTimeout(ctx, reqTimeoutInterval)
-	defer cancel()
-
-	err := func() error {
-		select {
-		case <-ctx.Done():
-			return errors.New("show partition timeout")
-		default:
-			return node.sched.DdQueue.Enqueue(spt)
-		}
-	}()
+	err := node.sched.DdQueue.Enqueue(spt)
 
 	if err != nil {
 		return &milvuspb.ShowPartitionResponse{
@@ -476,26 +374,15 @@ func (node *NodeImpl) ShowPartitions(request *milvuspb.ShowPartitionRequest) (*m
 
 func (node *NodeImpl) CreateIndex(request *milvuspb.CreateIndexRequest) (*commonpb.Status, error) {
 	log.Println("create index for: ", request)
-	ctx := context.Background()
+	ctx, cancel := context.WithTimeout(context.Background(), reqTimeoutInterval)
+	defer cancel()
 	cit := &CreateIndexTask{
 		Condition:          NewTaskCondition(ctx),
 		CreateIndexRequest: request,
 		masterClient:       node.masterClient,
 	}
 
-	var cancel func()
-	cit.ctx, cancel = context.WithTimeout(ctx, reqTimeoutInterval)
-	defer cancel()
-
-	fn := func() error {
-		select {
-		case <-ctx.Done():
-			return errors.New("create index timeout")
-		default:
-			return node.sched.DdQueue.Enqueue(cit)
-		}
-	}
-	err := fn()
+	err := node.sched.DdQueue.Enqueue(cit)
 	if err != nil {
 		return &commonpb.Status{
 			ErrorCode: commonpb.ErrorCode_UNEXPECTED_ERROR,
@@ -516,26 +403,15 @@ func (node *NodeImpl) CreateIndex(request *milvuspb.CreateIndexRequest) (*common
 
 func (node *NodeImpl) DescribeIndex(request *milvuspb.DescribeIndexRequest) (*milvuspb.DescribeIndexResponse, error) {
 	log.Println("Describe index for: ", request)
-	ctx := context.Background()
+	ctx, cancel := context.WithTimeout(context.Background(), reqTimeoutInterval)
+	defer cancel()
 	dit := &DescribeIndexTask{
 		Condition:            NewTaskCondition(ctx),
 		DescribeIndexRequest: request,
 		masterClient:         node.masterClient,
 	}
 
-	var cancel func()
-	dit.ctx, cancel = context.WithTimeout(ctx, reqTimeoutInterval)
-	defer cancel()
-
-	fn := func() error {
-		select {
-		case <-ctx.Done():
-			return errors.New("create index timeout")
-		default:
-			return node.sched.DdQueue.Enqueue(dit)
-		}
-	}
-	err := fn()
+	err := node.sched.DdQueue.Enqueue(dit)
 	if err != nil {
 		return &milvuspb.DescribeIndexResponse{
 			Status: &commonpb.Status{
@@ -560,25 +436,14 @@ func (node *NodeImpl) DescribeIndex(request *milvuspb.DescribeIndexRequest) (*mi
 
 func (node *NodeImpl) GetIndexState(request *milvuspb.IndexStateRequest) (*milvuspb.IndexStateResponse, error) {
 	// log.Println("Describe index progress for: ", request)
-	ctx := context.Background()
+	ctx, cancel := context.WithTimeout(context.Background(), reqTimeoutInterval)
+	defer cancel()
 	dipt := &GetIndexStateTask{
 		Condition:         NewTaskCondition(ctx),
 		IndexStateRequest: request,
 	}
 
-	var cancel func()
-	dipt.ctx, cancel = context.WithTimeout(ctx, reqTimeoutInterval)
-	defer cancel()
-
-	fn := func() error {
-		select {
-		case <-ctx.Done():
-			return errors.New("create index timeout")
-		default:
-			return node.sched.DdQueue.Enqueue(dipt)
-		}
-	}
-	err := fn()
+	err := node.sched.DdQueue.Enqueue(dipt)
 	if err != nil {
 		return &milvuspb.IndexStateResponse{
 			Status: &commonpb.Status{
@@ -602,14 +467,10 @@ func (node *NodeImpl) GetIndexState(request *milvuspb.IndexStateRequest) (*milvu
 }
 
 func (node *NodeImpl) Insert(request *milvuspb.InsertRequest) (*milvuspb.InsertResponse, error) {
-	ctx := context.Background()
-	span, ctx := opentracing.StartSpanFromContext(ctx, "insert grpc received")
-	defer span.Finish()
-	span.SetTag("collection name", request.CollectionName)
-	span.SetTag("partition tag", request.PartitionName)
-	log.Println("insert into: ", request.CollectionName)
+	ctx, cancel := context.WithTimeout(context.Background(), reqTimeoutInterval)
+	defer cancel()
+
 	it := &InsertTask{
-		ctx:               ctx,
 		Condition:         NewTaskCondition(ctx),
 		dataServiceClient: node.dataServiceClient,
 		BaseInsertTask: BaseInsertTask{
@@ -632,20 +493,7 @@ func (node *NodeImpl) Insert(request *milvuspb.InsertRequest) (*milvuspb.InsertR
 		it.PartitionName = Params.DefaultPartitionTag
 	}
 
-	var cancel func()
-	it.ctx, cancel = context.WithTimeout(ctx, reqTimeoutInterval)
-
-	defer cancel()
-
-	fn := func() error {
-		select {
-		case <-ctx.Done():
-			return errors.New("insert timeout")
-		default:
-			return node.sched.DmQueue.Enqueue(it)
-		}
-	}
-	err := fn()
+	err := node.sched.DmQueue.Enqueue(it)
 
 	if err != nil {
 		return &milvuspb.InsertResponse{
@@ -670,15 +518,10 @@ func (node *NodeImpl) Insert(request *milvuspb.InsertRequest) (*milvuspb.InsertR
 }
 
 func (node *NodeImpl) Search(request *milvuspb.SearchRequest) (*milvuspb.SearchResults, error) {
-	ctx := context.Background()
-	span, ctx := opentracing.StartSpanFromContext(ctx, "search grpc received")
-	defer span.Finish()
-	span.SetTag("collection name", request.CollectionName)
-	span.SetTag("partition tag", request.PartitionNames)
-	span.SetTag("dsl", request.Dsl)
-	log.Println("search: ", request.CollectionName, request.Dsl)
+	ctx, cancel := context.WithTimeout(context.Background(), reqTimeoutInterval)
+	defer cancel()
+
 	qt := &SearchTask{
-		ctx:       ctx,
 		Condition: NewTaskCondition(ctx),
 		SearchRequest: internalpb2.SearchRequest{
 			Base: &commonpb.MsgBase{
@@ -691,20 +534,8 @@ func (node *NodeImpl) Search(request *milvuspb.SearchRequest) (*milvuspb.SearchR
 		resultBuf:      make(chan []*internalpb2.SearchResults),
 		query:          request,
 	}
-	var cancel func()
-	qt.ctx, cancel = context.WithTimeout(ctx, reqTimeoutInterval)
-	log.Printf("grpc address of query task: %p", qt)
-	defer cancel()
 
-	fn := func() error {
-		select {
-		case <-ctx.Done():
-			return errors.New("create collection timeout")
-		default:
-			return node.sched.DqQueue.Enqueue(qt)
-		}
-	}
-	err := fn()
+	err := node.sched.DqQueue.Enqueue(qt)
 	if err != nil {
 		return &milvuspb.SearchResults{
 			Status: &commonpb.Status{
@@ -728,7 +559,32 @@ func (node *NodeImpl) Search(request *milvuspb.SearchRequest) (*milvuspb.SearchR
 }
 
 func (node *NodeImpl) Flush(request *milvuspb.FlushRequest) (*commonpb.Status, error) {
-	panic("implement me")
+	log.Println("AA Flush collections: ", request.CollectionNames)
+	ctx, cancel := context.WithTimeout(context.Background(), reqTimeoutInterval)
+	defer cancel()
+	ft := &FlushTask{
+		Condition:         NewTaskCondition(ctx),
+		FlushRequest:      request,
+		dataServiceClient: node.dataServiceClient,
+	}
+
+	err := node.sched.DdQueue.Enqueue(ft)
+	if err != nil {
+		return &commonpb.Status{
+			ErrorCode: commonpb.ErrorCode_UNEXPECTED_ERROR,
+			Reason:    err.Error(),
+		}, nil
+	}
+
+	err = ft.WaitToFinish()
+	if err != nil {
+		return &commonpb.Status{
+			ErrorCode: commonpb.ErrorCode_UNEXPECTED_ERROR,
+			Reason:    err.Error(),
+		}, nil
+	}
+
+	return ft.result, nil
 }
 
 func (node *NodeImpl) GetDdChannel(request *commonpb.Empty) (*milvuspb.StringResponse, error) {
diff --git a/internal/proxynode/task.go b/internal/proxynode/task.go
index 02907910abee0e0434a3f8b1af01114c503ca9b1..7f64e697d0e9d584e36e83f6fea24519cd603dae 100644
--- a/internal/proxynode/task.go
+++ b/internal/proxynode/task.go
@@ -1,7 +1,6 @@
 package proxynode
 
 import (
-	"context"
 	"errors"
 	"log"
 	"math"
@@ -9,9 +8,6 @@ import (
 
 	"github.com/zilliztech/milvus-distributed/internal/proto/datapb"
 
-	"github.com/opentracing/opentracing-go"
-	oplog "github.com/opentracing/opentracing-go/log"
-
 	"github.com/golang/protobuf/proto"
 	"github.com/zilliztech/milvus-distributed/internal/allocator"
 	"github.com/zilliztech/milvus-distributed/internal/msgstream"
@@ -45,7 +41,6 @@ type InsertTask struct {
 	Condition
 	dataServiceClient DataServiceClient
 	result            *milvuspb.InsertResponse
-	ctx               context.Context
 	rowIDAllocator    *allocator.IDAllocator
 }
 
@@ -87,21 +82,12 @@ func (it *InsertTask) PreExecute() error {
 	it.Base.MsgType = commonpb.MsgType_kInsert
 	it.Base.SourceID = Params.ProxyID
 
-	span, ctx := opentracing.StartSpanFromContext(it.ctx, "InsertTask preExecute")
-	defer span.Finish()
-	it.ctx = ctx
-	span.SetTag("hash keys", it.Base.MsgID)
-	span.SetTag("start time", it.BeginTs())
 	collectionName := it.BaseInsertTask.CollectionName
 	if err := ValidateCollectionName(collectionName); err != nil {
-		span.LogFields(oplog.Error(err))
-		span.Finish()
 		return err
 	}
 	partitionTag := it.BaseInsertTask.PartitionName
 	if err := ValidatePartitionTag(partitionTag, true); err != nil {
-		span.LogFields(oplog.Error(err))
-		span.Finish()
 		return err
 	}
 
@@ -109,13 +95,7 @@ func (it *InsertTask) PreExecute() error {
 }
 
 func (it *InsertTask) Execute() error {
-	span, ctx := opentracing.StartSpanFromContext(it.ctx, "InsertTask Execute")
-	defer span.Finish()
-	it.ctx = ctx
-	span.SetTag("hash keys", it.Base.MsgID)
-	span.SetTag("start time", it.BeginTs())
 	collectionName := it.BaseInsertTask.CollectionName
-	span.LogFields(oplog.String("collection_name", collectionName))
 	collSchema, err := globalMetaCache.GetCollectionSchema(collectionName)
 	if err != nil {
 		return err
@@ -131,14 +111,11 @@ func (it *InsertTask) Execute() error {
 		return err
 	}
 	it.PartitionID = partitionID
-	span.LogFields(oplog.Bool("auto_id", autoID))
 	var rowIDBegin UniqueID
 	var rowIDEnd UniqueID
 	rowNums := len(it.BaseInsertTask.RowData)
 	rowIDBegin, rowIDEnd, _ = it.rowIDAllocator.Alloc(uint32(rowNums))
-	span.LogFields(oplog.Int("rowNums", rowNums),
-		oplog.Int("rowIDBegin", int(rowIDBegin)),
-		oplog.Int("rowIDEnd", int(rowIDEnd)))
+
 	it.BaseInsertTask.RowIDs = make([]UniqueID, rowNums)
 	for i := rowIDBegin; i < rowIDEnd; i++ {
 		offset := i - rowIDBegin
@@ -161,8 +138,7 @@ func (it *InsertTask) Execute() error {
 		EndTs:   it.EndTs(),
 		Msgs:    make([]msgstream.TsMsg, 1),
 	}
-	tsMsg.SetMsgContext(ctx)
-	span.LogFields(oplog.String("send msg", "send msg"))
+	tsMsg.SetMsgContext(it.Ctx())
 
 	it.result = &milvuspb.InsertResponse{
 		Status: &commonpb.Status{
@@ -198,7 +174,6 @@ func (it *InsertTask) Execute() error {
 	if err != nil {
 		it.result.Status.ErrorCode = commonpb.ErrorCode_UNEXPECTED_ERROR
 		it.result.Status.Reason = err.Error()
-		span.LogFields(oplog.Error(err))
 		return err
 	}
 
@@ -206,7 +181,6 @@ func (it *InsertTask) Execute() error {
 	if err != nil {
 		it.result.Status.ErrorCode = commonpb.ErrorCode_UNEXPECTED_ERROR
 		it.result.Status.Reason = err.Error()
-		span.LogFields(oplog.Error(err))
 		return err
 	}
 
@@ -214,8 +188,6 @@ func (it *InsertTask) Execute() error {
 }
 
 func (it *InsertTask) PostExecute() error {
-	span, _ := opentracing.StartSpanFromContext(it.ctx, "InsertTask postExecute")
-	defer span.Finish()
 	return nil
 }
 
@@ -225,7 +197,6 @@ type CreateCollectionTask struct {
 	masterClient      MasterClient
 	dataServiceClient DataServiceClient
 	result            *commonpb.Status
-	ctx               context.Context
 	schema            *schemapb.CollectionSchema
 }
 
@@ -366,7 +337,6 @@ type DropCollectionTask struct {
 	*milvuspb.DropCollectionRequest
 	masterClient MasterClient
 	result       *commonpb.Status
-	ctx          context.Context
 }
 
 func (dct *DropCollectionTask) OnEnqueue() error {
@@ -435,7 +405,6 @@ type SearchTask struct {
 	queryMsgStream *pulsarms.PulsarMsgStream
 	resultBuf      chan []*internalpb2.SearchResults
 	result         *milvuspb.SearchResults
-	ctx            context.Context
 	query          *milvuspb.SearchRequest
 }
 
@@ -471,38 +440,24 @@ func (st *SearchTask) PreExecute() error {
 	st.Base.MsgType = commonpb.MsgType_kSearch
 	st.Base.SourceID = Params.ProxyID
 
-	span, ctx := opentracing.StartSpanFromContext(st.ctx, "SearchTask preExecute")
-	defer span.Finish()
-	st.ctx = ctx
-	span.SetTag("hash keys", st.Base.MsgID)
-	span.SetTag("start time", st.BeginTs())
-
 	collectionName := st.query.CollectionName
 	_, err := globalMetaCache.GetCollectionID(collectionName)
 	if err != nil { // err is not nil if collection not exists
-		span.LogFields(oplog.Error(err))
-		span.Finish()
 		return err
 	}
 
 	if err := ValidateCollectionName(st.query.CollectionName); err != nil {
-		span.LogFields(oplog.Error(err))
-		span.Finish()
 		return err
 	}
 
 	for _, tag := range st.query.PartitionNames {
 		if err := ValidatePartitionTag(tag, false); err != nil {
-			span.LogFields(oplog.Error(err))
-			span.Finish()
 			return err
 		}
 	}
 	st.Base.MsgType = commonpb.MsgType_kSearch
 	queryBytes, err := proto.Marshal(st.query)
 	if err != nil {
-		span.LogFields(oplog.Error(err))
-		span.Finish()
 		return err
 	}
 	st.Query = &commonpb.Blob{
@@ -512,11 +467,6 @@ func (st *SearchTask) PreExecute() error {
 }
 
 func (st *SearchTask) Execute() error {
-	span, ctx := opentracing.StartSpanFromContext(st.ctx, "SearchTask Execute")
-	defer span.Finish()
-	st.ctx = ctx
-	span.SetTag("hash keys", st.Base.MsgID)
-	span.SetTag("start time", st.BeginTs())
 	var tsMsg msgstream.TsMsg = &msgstream.SearchMsg{
 		SearchRequest: st.SearchRequest,
 		BaseMsg: msgstream.BaseMsg{
@@ -530,32 +480,24 @@ func (st *SearchTask) Execute() error {
 		EndTs:   st.Base.Timestamp,
 		Msgs:    make([]msgstream.TsMsg, 1),
 	}
-	tsMsg.SetMsgContext(ctx)
+	tsMsg.SetMsgContext(st.Ctx())
 	msgPack.Msgs[0] = tsMsg
 	err := st.queryMsgStream.Produce(msgPack)
 	log.Printf("[NodeImpl] length of searchMsg: %v", len(msgPack.Msgs))
 	if err != nil {
-		span.LogFields(oplog.Error(err))
-		span.Finish()
 		log.Printf("[NodeImpl] send search request failed: %v", err)
 	}
 	return err
 }
 
 func (st *SearchTask) PostExecute() error {
-	span, _ := opentracing.StartSpanFromContext(st.ctx, "SearchTask postExecute")
-	defer span.Finish()
-	span.SetTag("hash keys", st.Base.MsgID)
-	span.SetTag("start time", st.BeginTs())
 	for {
 		select {
-		case <-st.ctx.Done():
+		case <-st.Ctx().Done():
 			log.Print("SearchTask: wait to finish failed, timeout!, taskID:", st.ID())
-			span.LogFields(oplog.String("wait to finish failed, timeout", "wait to finish failed, timeout"))
 			return errors.New("SearchTask:wait to finish failed, timeout:" + strconv.FormatInt(st.ID(), 10))
 		case searchResults := <-st.resultBuf:
 			// fmt.Println("searchResults: ", searchResults)
-			span.LogFields(oplog.String("receive result", "receive result"))
 			filterSearchResult := make([]*internalpb2.SearchResults, 0)
 			var filterReason string
 			for _, partialSearchResult := range searchResults {
@@ -584,7 +526,6 @@ func (st *SearchTask) PostExecute() error {
 						Reason:    filterReason,
 					},
 				}
-				span.LogFields(oplog.Error(errors.New(filterReason)))
 				return errors.New(filterReason)
 			}
 
@@ -693,7 +634,6 @@ func (st *SearchTask) PostExecute() error {
 				reducedHitsBs, err := proto.Marshal(reducedHits)
 				if err != nil {
 					log.Println("marshal error")
-					span.LogFields(oplog.Error(err))
 					return err
 				}
 				st.result.Hits = append(st.result.Hits, reducedHitsBs)
@@ -708,7 +648,6 @@ type HasCollectionTask struct {
 	*milvuspb.HasCollectionRequest
 	masterClient MasterClient
 	result       *milvuspb.BoolResponse
-	ctx          context.Context
 }
 
 func (hct *HasCollectionTask) OnEnqueue() error {
@@ -765,7 +704,6 @@ type DescribeCollectionTask struct {
 	*milvuspb.DescribeCollectionRequest
 	masterClient MasterClient
 	result       *milvuspb.DescribeCollectionResponse
-	ctx          context.Context
 }
 
 func (dct *DescribeCollectionTask) OnEnqueue() error {
@@ -825,7 +763,6 @@ type GetCollectionsStatisticsTask struct {
 	*milvuspb.CollectionStatsRequest
 	dataServiceClient DataServiceClient
 	result            *milvuspb.CollectionStatsResponse
-	ctx               context.Context
 }
 
 func (g *GetCollectionsStatisticsTask) ID() UniqueID {
@@ -901,7 +838,6 @@ type ShowCollectionsTask struct {
 	*milvuspb.ShowCollectionRequest
 	masterClient MasterClient
 	result       *milvuspb.ShowCollectionResponse
-	ctx          context.Context
 }
 
 func (sct *ShowCollectionsTask) OnEnqueue() error {
@@ -955,7 +891,6 @@ type CreatePartitionTask struct {
 	*milvuspb.CreatePartitionRequest
 	masterClient MasterClient
 	result       *commonpb.Status
-	ctx          context.Context
 }
 
 func (cpt *CreatePartitionTask) OnEnqueue() error {
@@ -1018,7 +953,6 @@ type DropPartitionTask struct {
 	*milvuspb.DropPartitionRequest
 	masterClient MasterClient
 	result       *commonpb.Status
-	ctx          context.Context
 }
 
 func (dpt *DropPartitionTask) OnEnqueue() error {
@@ -1081,7 +1015,6 @@ type HasPartitionTask struct {
 	*milvuspb.HasPartitionRequest
 	masterClient MasterClient
 	result       *milvuspb.BoolResponse
-	ctx          context.Context
 }
 
 func (hpt *HasPartitionTask) OnEnqueue() error {
@@ -1138,66 +1071,11 @@ func (hpt *HasPartitionTask) PostExecute() error {
 	return nil
 }
 
-//type DescribePartitionTask struct {
-//	Condition
-//	internalpb.DescribePartitionRequest
-//	masterClient masterpb.MasterServiceClient
-//	result       *milvuspb.PartitionDescription
-//	ctx          context.Context
-//}
-//
-//func (dpt *DescribePartitionTask) ID() UniqueID {
-//	return dpt.ReqID
-//}
-//
-//func (dpt *DescribePartitionTask) SetID(uid UniqueID) {
-//	dpt.ReqID = uid
-//}
-//
-//func (dpt *DescribePartitionTask) Type() commonpb.MsgType {
-//	return dpt.MsgType
-//}
-//
-//func (dpt *DescribePartitionTask) BeginTs() Timestamp {
-//	return dpt.Timestamp
-//}
-//
-//func (dpt *DescribePartitionTask) EndTs() Timestamp {
-//	return dpt.Timestamp
-//}
-//
-//func (dpt *DescribePartitionTask) SetTs(ts Timestamp) {
-//	dpt.Timestamp = ts
-//}
-//
-//func (dpt *DescribePartitionTask) PreExecute() error {
-//	collName, partitionTag := dpt.PartitionName.CollectionName, dpt.PartitionName.Tag
-//
-//	if err := ValidateCollectionName(collName); err != nil {
-//		return err
-//	}
-//
-//	if err := ValidatePartitionTag(partitionTag, true); err != nil {
-//		return err
-//	}
-//	return nil
-//}
-//
-//func (dpt *DescribePartitionTask) Execute() (err error) {
-//	dpt.result, err = dpt.masterClient.DescribePartition(dpt.ctx, &dpt.DescribePartitionRequest)
-//	return err
-//}
-//
-//func (dpt *DescribePartitionTask) PostExecute() error {
-//	return nil
-//}
-
 type ShowPartitionsTask struct {
 	Condition
 	*milvuspb.ShowPartitionRequest
 	masterClient MasterClient
 	result       *milvuspb.ShowPartitionResponse
-	ctx          context.Context
 }
 
 func (spt *ShowPartitionsTask) OnEnqueue() error {
@@ -1257,7 +1135,6 @@ type CreateIndexTask struct {
 	*milvuspb.CreateIndexRequest
 	masterClient MasterClient
 	result       *commonpb.Status
-	ctx          context.Context
 }
 
 func (cit *CreateIndexTask) OnEnqueue() error {
@@ -1320,7 +1197,6 @@ type DescribeIndexTask struct {
 	*milvuspb.DescribeIndexRequest
 	masterClient MasterClient
 	result       *milvuspb.DescribeIndexResponse
-	ctx          context.Context
 }
 
 func (dit *DescribeIndexTask) OnEnqueue() error {
@@ -1384,7 +1260,6 @@ type GetIndexStateTask struct {
 	*milvuspb.IndexStateRequest
 	indexServiceClient IndexServiceClient
 	result             *milvuspb.IndexStateResponse
-	ctx                context.Context
 }
 
 func (dipt *GetIndexStateTask) OnEnqueue() error {
@@ -1457,7 +1332,6 @@ type FlushTask struct {
 	*milvuspb.FlushRequest
 	dataServiceClient DataServiceClient
 	result            *commonpb.Status
-	ctx               context.Context
 }
 
 func (ft *FlushTask) OnEnqueue() error {
@@ -1496,23 +1370,34 @@ func (ft *FlushTask) PreExecute() error {
 }
 
 func (ft *FlushTask) Execute() error {
-	var err error
-	collID, err := globalMetaCache.GetCollectionID(ft.CollectionName)
-	if err != nil {
-		return err
+	for _, collName := range ft.CollectionNames {
+		collID, err := globalMetaCache.GetCollectionID(collName)
+		if err != nil {
+			return err
+		}
+		flushReq := &datapb.FlushRequest{
+			Base: &commonpb.MsgBase{
+				MsgType:   commonpb.MsgType_kFlush,
+				MsgID:     ft.Base.MsgID,
+				Timestamp: ft.Base.Timestamp,
+				SourceID:  ft.Base.SourceID,
+			},
+			DbID:         0,
+			CollectionID: collID,
+		}
+		var status *commonpb.Status
+		status, err = ft.dataServiceClient.Flush(flushReq)
+		if err != nil {
+			return nil
+		}
+		if status.ErrorCode != commonpb.ErrorCode_SUCCESS {
+			return errors.New(status.Reason)
+		}
 	}
-	flushReq := &datapb.FlushRequest{
-		Base: &commonpb.MsgBase{
-			MsgType:   commonpb.MsgType_kFlush,
-			MsgID:     ft.Base.MsgID,
-			Timestamp: ft.Base.Timestamp,
-			SourceID:  ft.Base.SourceID,
-		},
-		DbID:         0,
-		CollectionID: collID,
+	ft.result = &commonpb.Status{
+		ErrorCode: commonpb.ErrorCode_SUCCESS,
 	}
-	ft.result, err = ft.dataServiceClient.Flush(flushReq)
-	return err
+	return nil
 }
 
 func (ft *FlushTask) PostExecute() error {