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 {