admin/milvus
1
0
Fork 0
mirror of https://gitee.com/milvus-io/milvus.git synced 2025-12-08 01:58:34 +08:00
Code Issues Packages Projects Releases Wiki Activity

Remove redudent ctx and openTracing logic

Browse Source 
Signed-off-by: zhenshan.cao <zhenshan.cao@zilliz.com>
This commit is contained in:
zhenshan.cao 2021-02-03 16:34:56 +08:00 committed by yefu.chen
parent 35f6f4b7c2
commit b853020ef9
8 changed files with 402 additions and 761 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

213
internal/core/src/pb/milvus.pb.cc
View File

@ -1144,7 +1144,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_milvus_2eproto::offsets[] PROT
~0u, // no _weak_field_map_ ~0u, // no _weak_field_map_
PROTOBUF_FIELD_OFFSET(::milvus::proto::milvus::FlushRequest, base_), PROTOBUF_FIELD_OFFSET(::milvus::proto::milvus::FlushRequest, base_),
PROTOBUF_FIELD_OFFSET(::milvus::proto::milvus::FlushRequest, db_name_), 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_ ~0u, // no _has_bits_
PROTOBUF_FIELD_OFFSET(::milvus::proto::milvus::RegisterLinkResponse, _internal_metadata_), PROTOBUF_FIELD_OFFSET(::milvus::proto::milvus::RegisterLinkResponse, _internal_metadata_),
~0u, // no _extensions_ ~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" "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(" "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" "\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(" "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" "\t\022\030\n\020collection_names\030\003 \003(\t\"r\n\024RegisterL"
"nkResponse\022-\n\007address\030\001 \001(\0132\034.milvus.pro" "inkResponse\022-\n\007address\030\001 \001(\0132\034.milvus.pr"
"to.common.Address\022+\n\006status\030\002 \001(\0132\033.milv" "oto.common.Address\022+\n\006status\030\002 \001(\0132\033.mil"
"us.proto.common.Status*@\n\017PlaceholderTyp" "vus.proto.common.Status*@\n\017PlaceholderTy"
"e\022\010\n\004NONE\020\000\022\021\n\rVECTOR_BINARY\020d\022\020\n\014VECTOR" "pe\022\010\n\004NONE\020\000\022\021\n\rVECTOR_BINARY\020d\022\020\n\014VECTO"
"_FLOAT\020e2\357\020\n\rMilvusService\022_\n\020CreateColl" "R_FLOAT\020e2\357\020\n\rMilvusService\022_\n\020CreateCol"
"ection\022,.milvus.proto.milvus.CreateColle" "lection\022,.milvus.proto.milvus.CreateColl"
"ctionRequest\032\033.milvus.proto.common.Statu" "ectionRequest\032\033.milvus.proto.common.Stat"
"s\"\000\022[\n\016DropCollection\022*.milvus.proto.mil" "us\"\000\022[\n\016DropCollection\022*.milvus.proto.mi"
"vus.DropCollectionRequest\032\033.milvus.proto" "lvus.DropCollectionRequest\032\033.milvus.prot"
".common.Status\"\000\022_\n\rHasCollection\022).milv" "o.common.Status\"\000\022_\n\rHasCollection\022).mil"
"us.proto.milvus.HasCollectionRequest\032!.m" "vus.proto.milvus.HasCollectionRequest\032!."
"ilvus.proto.milvus.BoolResponse\"\000\022[\n\016Loa" "milvus.proto.milvus.BoolResponse\"\000\022[\n\016Lo"
"dCollection\022*.milvus.proto.milvus.LoadCo" "adCollection\022*.milvus.proto.milvus.LoadC"
"llectionRequest\032\033.milvus.proto.common.St" "ollectionRequest\032\033.milvus.proto.common.S"
"atus\"\000\022a\n\021ReleaseCollection\022-.milvus.pro" "tatus\"\000\022a\n\021ReleaseCollection\022-.milvus.pr"
"to.milvus.ReleaseCollectionRequest\032\033.mil" "oto.milvus.ReleaseCollectionRequest\032\033.mi"
"vus.proto.common.Status\"\000\022w\n\022DescribeCol" "lvus.proto.common.Status\"\000\022w\n\022DescribeCo"
"lection\022..milvus.proto.milvus.DescribeCo" "llection\022..milvus.proto.milvus.DescribeC"
"llectionRequest\032/.milvus.proto.milvus.De" "ollectionRequest\032/.milvus.proto.milvus.D"
"scribeCollectionResponse\"\000\022v\n\027GetCollect" "escribeCollectionResponse\"\000\022v\n\027GetCollec"
"ionStatistics\022+.milvus.proto.milvus.Coll" "tionStatistics\022+.milvus.proto.milvus.Col"
"ectionStatsRequest\032,.milvus.proto.milvus" "lectionStatsRequest\032,.milvus.proto.milvu"
".CollectionStatsResponse\"\000\022l\n\017ShowCollec" "s.CollectionStatsResponse\"\000\022l\n\017ShowColle"
"tions\022*.milvus.proto.milvus.ShowCollecti" "ctions\022*.milvus.proto.milvus.ShowCollect"
"onRequest\032+.milvus.proto.milvus.ShowColl" "ionRequest\032+.milvus.proto.milvus.ShowCol"
"ectionResponse\"\000\022]\n\017CreatePartition\022+.mi" "lectionResponse\"\000\022]\n\017CreatePartition\022+.m"
"lvus.proto.milvus.CreatePartitionRequest" "ilvus.proto.milvus.CreatePartitionReques"
"\032\033.milvus.proto.common.Status\"\000\022Y\n\rDropP" "t\032\033.milvus.proto.common.Status\"\000\022Y\n\rDrop"
"artition\022).milvus.proto.milvus.DropParti" "Partition\022).milvus.proto.milvus.DropPart"
"tionRequest\032\033.milvus.proto.common.Status" "itionRequest\032\033.milvus.proto.common.Statu"
"\"\000\022]\n\014HasPartition\022(.milvus.proto.milvus" "s\"\000\022]\n\014HasPartition\022(.milvus.proto.milvu"
".HasPartitionRequest\032!.milvus.proto.milv" "s.HasPartitionRequest\032!.milvus.proto.mil"
"us.BoolResponse\"\000\022Y\n\016LoadPartitions\022(.mi" "vus.BoolResponse\"\000\022Y\n\016LoadPartitions\022(.m"
"lvus.proto.milvus.LoadPartitonRequest\032\033." "ilvus.proto.milvus.LoadPartitonRequest\032\033"
"milvus.proto.common.Status\"\000\022`\n\021ReleaseP" ".milvus.proto.common.Status\"\000\022`\n\021Release"
"artitions\022,.milvus.proto.milvus.ReleaseP" "Partitions\022,.milvus.proto.milvus.Release"
"artitionRequest\032\033.milvus.proto.common.St" "PartitionRequest\032\033.milvus.proto.common.S"
"atus\"\000\022s\n\026GetPartitionStatistics\022*.milvu" "tatus\"\000\022s\n\026GetPartitionStatistics\022*.milv"
"s.proto.milvus.PartitionStatsRequest\032+.m" "us.proto.milvus.PartitionStatsRequest\032+."
"ilvus.proto.milvus.PartitionStatsRespons" "milvus.proto.milvus.PartitionStatsRespon"
"e\"\000\022i\n\016ShowPartitions\022).milvus.proto.mil" "se\"\000\022i\n\016ShowPartitions\022).milvus.proto.mi"
"vus.ShowPartitionRequest\032*.milvus.proto." "lvus.ShowPartitionRequest\032*.milvus.proto"
"milvus.ShowPartitionResponse\"\000\022U\n\013Create" ".milvus.ShowPartitionResponse\"\000\022U\n\013Creat"
"Index\022\'.milvus.proto.milvus.CreateIndexR" "eIndex\022\'.milvus.proto.milvus.CreateIndex"
"equest\032\033.milvus.proto.common.Status\"\000\022h\n" "Request\032\033.milvus.proto.common.Status\"\000\022h"
"\rDescribeIndex\022).milvus.proto.milvus.Des" "\n\rDescribeIndex\022).milvus.proto.milvus.De"
"cribeIndexRequest\032*.milvus.proto.milvus." "scribeIndexRequest\032*.milvus.proto.milvus"
"DescribeIndexResponse\"\000\022b\n\rGetIndexState" ".DescribeIndexResponse\"\000\022b\n\rGetIndexStat"
"\022&.milvus.proto.milvus.IndexStateRequest" "e\022&.milvus.proto.milvus.IndexStateReques"
"\032\'.milvus.proto.milvus.IndexStateRespons" "t\032\'.milvus.proto.milvus.IndexStateRespon"
"e\"\000\022S\n\006Insert\022\".milvus.proto.milvus.Inse" "se\"\000\022S\n\006Insert\022\".milvus.proto.milvus.Ins"
"rtRequest\032#.milvus.proto.milvus.InsertRe" "ertRequest\032#.milvus.proto.milvus.InsertR"
"sponse\"\000\022R\n\006Search\022\".milvus.proto.milvus" "esponse\"\000\022R\n\006Search\022\".milvus.proto.milvu"
".SearchRequest\032\".milvus.proto.milvus.Sea" "s.SearchRequest\032\".milvus.proto.milvus.Se"
"rchResults\"\000\022I\n\005Flush\022!.milvus.proto.mil" "archResults\"\000\022I\n\005Flush\022!.milvus.proto.mi"
"vus.FlushRequest\032\033.milvus.proto.common.S" "lvus.FlushRequest\032\033.milvus.proto.common."
"tatus\"\000\022Q\n\014GetDdChannel\022\032.milvus.proto.c" "Status\"\000\022Q\n\014GetDdChannel\022\032.milvus.proto."
"ommon.Empty\032#.milvus.proto.milvus.String" "common.Empty\032#.milvus.proto.milvus.Strin"
"Response\"\0002g\n\014ProxyService\022W\n\014RegisterLi" "gResponse\"\0002g\n\014ProxyService\022W\n\014RegisterL"
"nk\022\032.milvus.proto.common.Empty\032).milvus." "ink\022\032.milvus.proto.common.Empty\032).milvus"
"proto.milvus.RegisterLinkResponse\"\000BBZ@g" ".proto.milvus.RegisterLinkResponse\"\000BBZ@"
"ithub.com/zilliztech/milvus-distributed/" "github.com/zilliztech/milvus-distributed"
"internal/proto/milvuspbb\006proto3" "/internal/proto/milvuspbb\006proto3"
; ;
static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_milvus_2eproto_deps[2] = { static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_milvus_2eproto_deps[2] = {
&::descriptor_table_common_2eproto, &::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 ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_milvus_2eproto_once;
static bool descriptor_table_milvus_2eproto_initialized = false; static bool descriptor_table_milvus_2eproto_initialized = false;
const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_milvus_2eproto = { 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, &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, 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, 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) FlushRequest::FlushRequest(const FlushRequest& from)
: ::PROTOBUF_NAMESPACE_ID::Message(), : ::PROTOBUF_NAMESPACE_ID::Message(),
_internal_metadata_(nullptr) { _internal_metadata_(nullptr),
collection_names_(from.collection_names_) {
_internal_metadata_.MergeFrom(from._internal_metadata_); _internal_metadata_.MergeFrom(from._internal_metadata_);
db_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); db_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
if (!from.db_name().empty()) { if (!from.db_name().empty()) {
db_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.db_name_); 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()) { if (from.has_base()) {
base_ = new ::milvus::proto::common::MsgBase(*from.base_); base_ = new ::milvus::proto::common::MsgBase(*from.base_);
} else { } else {
@ -17174,7 +17171,6 @@ FlushRequest::FlushRequest(const FlushRequest& from)
void FlushRequest::SharedCtor() { void FlushRequest::SharedCtor() {
::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_FlushRequest_milvus_2eproto.base); ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_FlushRequest_milvus_2eproto.base);
db_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); db_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
base_ = nullptr; base_ = nullptr;
} }
@ -17185,7 +17181,6 @@ FlushRequest::~FlushRequest() {
void FlushRequest::SharedDtor() { void FlushRequest::SharedDtor() {
db_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); db_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
collection_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
if (this != internal_default_instance()) delete base_; if (this != internal_default_instance()) delete base_;
} }
@ -17204,8 +17199,8 @@ void FlushRequest::Clear() {
// Prevent compiler warnings about cached_has_bits being unused // Prevent compiler warnings about cached_has_bits being unused
(void) cached_has_bits; (void) cached_has_bits;
collection_names_.Clear();
db_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); db_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
if (GetArenaNoVirtual() == nullptr && base_ != nullptr) { if (GetArenaNoVirtual() == nullptr && base_ != nullptr) {
delete base_; delete base_;
} }
@ -17235,11 +17230,16 @@ const char* FlushRequest::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_I
CHK_(ptr); CHK_(ptr);
} else goto handle_unusual; } else goto handle_unusual;
continue; continue;
// string collection_name = 3; // repeated string collection_names = 3;
case 3: case 3:
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { 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"); ptr -= 1;
CHK_(ptr); 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; } else goto handle_unusual;
continue; continue;
default: { default: {
@ -17298,15 +17298,16 @@ bool FlushRequest::MergePartialFromCodedStream(
break; break;
} }
// string collection_name = 3; // repeated string collection_names = 3;
case 3: { case 3: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) { if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) {
DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
input, this->mutable_collection_name())); input, this->add_collection_names()));
DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( 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, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE,
"milvus.proto.milvus.FlushRequest.collection_name")); "milvus.proto.milvus.FlushRequest.collection_names"));
} else { } else {
goto handle_unusual; goto handle_unusual;
} }
@ -17356,14 +17357,14 @@ void FlushRequest::SerializeWithCachedSizes(
2, this->db_name(), output); 2, this->db_name(), output);
} }
// string collection_name = 3; // repeated string collection_names = 3;
if (this->collection_name().size() > 0) { for (int i = 0, n = this->collection_names_size(); i < n; i++) {
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( ::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, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
"milvus.proto.milvus.FlushRequest.collection_name"); "milvus.proto.milvus.FlushRequest.collection_names");
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteString(
3, this->collection_name(), output); 3, this->collection_names(i), output);
} }
if (_internal_metadata_.have_unknown_fields()) { if (_internal_metadata_.have_unknown_fields()) {
@ -17397,15 +17398,14 @@ void FlushRequest::SerializeWithCachedSizes(
2, this->db_name(), target); 2, this->db_name(), target);
} }
// string collection_name = 3; // repeated string collection_names = 3;
if (this->collection_name().size() > 0) { for (int i = 0, n = this->collection_names_size(); i < n; i++) {
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( ::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, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
"milvus.proto.milvus.FlushRequest.collection_name"); "milvus.proto.milvus.FlushRequest.collection_names");
target = target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( WriteStringToArray(3, this->collection_names(i), target);
3, this->collection_name(), target);
} }
if (_internal_metadata_.have_unknown_fields()) { if (_internal_metadata_.have_unknown_fields()) {
@ -17429,6 +17429,14 @@ size_t FlushRequest::ByteSizeLong() const {
// Prevent compiler warnings about cached_has_bits being unused // Prevent compiler warnings about cached_has_bits being unused
(void) cached_has_bits; (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; // string db_name = 2;
if (this->db_name().size() > 0) { if (this->db_name().size() > 0) {
total_size += 1 + total_size += 1 +
@ -17436,13 +17444,6 @@ size_t FlushRequest::ByteSizeLong() const {
this->db_name()); 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; // .milvus.proto.common.MsgBase base = 1;
if (this->has_base()) { if (this->has_base()) {
total_size += 1 + total_size += 1 +
@ -17477,14 +17478,11 @@ void FlushRequest::MergeFrom(const FlushRequest& from) {
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
(void) cached_has_bits; (void) cached_has_bits;
collection_names_.MergeFrom(from.collection_names_);
if (from.db_name().size() > 0) { if (from.db_name().size() > 0) {
db_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.db_name_); 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()) { if (from.has_base()) {
mutable_base()->::milvus::proto::common::MsgBase::MergeFrom(from.base()); mutable_base()->::milvus::proto::common::MsgBase::MergeFrom(from.base());
} }
@ -17511,10 +17509,9 @@ bool FlushRequest::IsInitialized() const {
void FlushRequest::InternalSwap(FlushRequest* other) { void FlushRequest::InternalSwap(FlushRequest* other) {
using std::swap; using std::swap;
_internal_metadata_.Swap(&other->_internal_metadata_); _internal_metadata_.Swap(&other->_internal_metadata_);
collection_names_.InternalSwap(CastToBase(&other->collection_names_));
db_name_.Swap(&other->db_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), db_name_.Swap(&other->db_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
GetArenaNoVirtual()); GetArenaNoVirtual());
collection_name_.Swap(&other->collection_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
GetArenaNoVirtual());
swap(base_, other->base_); swap(base_, other->base_);
} }

126
internal/core/src/pb/milvus.pb.h
View File

@ -6689,10 +6689,27 @@ class FlushRequest :
// accessors ------------------------------------------------------- // accessors -------------------------------------------------------
enum : int { enum : int {
kCollectionNamesFieldNumber = 3,
kDbNameFieldNumber = 2, kDbNameFieldNumber = 2,
kCollectionNameFieldNumber = 3,
kBaseFieldNumber = 1, 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; // string db_name = 2;
void clear_db_name(); void clear_db_name();
const std::string& db_name() const; const std::string& db_name() const;
@ -6704,17 +6721,6 @@ class FlushRequest :
std::string* release_db_name(); std::string* release_db_name();
void set_allocated_db_name(std::string* 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; // .milvus.proto.common.MsgBase base = 1;
bool has_base() const; bool has_base() const;
void clear_base(); void clear_base();
@ -6728,8 +6734,8 @@ class FlushRequest :
class _Internal; class _Internal;
::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; ::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 db_name_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_;
::milvus::proto::common::MsgBase* base_; ::milvus::proto::common::MsgBase* base_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
friend struct ::TableStruct_milvus_2eproto; 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) // @@protoc_insertion_point(field_set_allocated:milvus.proto.milvus.FlushRequest.db_name)
} }
// string collection_name = 3; // repeated string collection_names = 3;
inline void FlushRequest::clear_collection_name() { inline int FlushRequest::collection_names_size() const {
collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); return collection_names_.size();
} }
inline const std::string& FlushRequest::collection_name() const { inline void FlushRequest::clear_collection_names() {
// @@protoc_insertion_point(field_get:milvus.proto.milvus.FlushRequest.collection_name) collection_names_.Clear();
return collection_name_.GetNoArena();
} }
inline void FlushRequest::set_collection_name(const std::string& value) { inline const std::string& FlushRequest::collection_names(int index) const {
// @@protoc_insertion_point(field_get:milvus.proto.milvus.FlushRequest.collection_names)
collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); return collection_names_.Get(index);
// @@protoc_insertion_point(field_set:milvus.proto.milvus.FlushRequest.collection_name)
} }
inline void FlushRequest::set_collection_name(std::string&& value) { inline std::string* FlushRequest::mutable_collection_names(int index) {
// @@protoc_insertion_point(field_mutable:milvus.proto.milvus.FlushRequest.collection_names)
collection_name_.SetNoArena( return collection_names_.Mutable(index);
&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
// @@protoc_insertion_point(field_set_rvalue:milvus.proto.milvus.FlushRequest.collection_name)
} }
inline void FlushRequest::set_collection_name(const char* value) { 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_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); GOOGLE_DCHECK(value != nullptr);
collection_names_.Mutable(index)->assign(value);
collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); // @@protoc_insertion_point(field_set_char:milvus.proto.milvus.FlushRequest.collection_names)
// @@protoc_insertion_point(field_set_char:milvus.proto.milvus.FlushRequest.collection_name)
} }
inline void FlushRequest::set_collection_name(const char* value, size_t size) { inline void FlushRequest::set_collection_names(int index, const char* value, size_t size) {
collection_names_.Mutable(index)->assign(
collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), reinterpret_cast<const char*>(value), size);
::std::string(reinterpret_cast<const char*>(value), size)); // @@protoc_insertion_point(field_set_pointer:milvus.proto.milvus.FlushRequest.collection_names)
// @@protoc_insertion_point(field_set_pointer:milvus.proto.milvus.FlushRequest.collection_name)
} }
inline std::string* FlushRequest::mutable_collection_name() { inline std::string* FlushRequest::add_collection_names() {
// @@protoc_insertion_point(field_add_mutable:milvus.proto.milvus.FlushRequest.collection_names)
// @@protoc_insertion_point(field_mutable:milvus.proto.milvus.FlushRequest.collection_name) return collection_names_.Add();
return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
} }
inline std::string* FlushRequest::release_collection_name() { inline void FlushRequest::add_collection_names(const std::string& value) {
// @@protoc_insertion_point(field_release:milvus.proto.milvus.FlushRequest.collection_name) collection_names_.Add()->assign(value);
// @@protoc_insertion_point(field_add:milvus.proto.milvus.FlushRequest.collection_names)
return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
} }
inline void FlushRequest::set_allocated_collection_name(std::string* collection_name) { inline void FlushRequest::add_collection_names(std::string&& value) {
if (collection_name != nullptr) { collection_names_.Add(std::move(value));
// @@protoc_insertion_point(field_add:milvus.proto.milvus.FlushRequest.collection_names)
} else { }
inline void FlushRequest::add_collection_names(const char* value) {
} GOOGLE_DCHECK(value != nullptr);
collection_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), collection_name); collection_names_.Add()->assign(value);
// @@protoc_insertion_point(field_set_allocated:milvus.proto.milvus.FlushRequest.collection_name) // @@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_;
} }
// ------------------------------------------------------------------- // -------------------------------------------------------------------

2
internal/proto/milvus.proto
View File

@ -263,7 +263,7 @@ message SearchResults {
message FlushRequest { message FlushRequest {
common.MsgBase base = 1; common.MsgBase base = 1;
string db_name = 2; string db_name = 2;
string collection_name = 3; repeated string collection_names = 3;
} }
service MilvusService { service MilvusService {

221
internal/proto/milvuspb/milvus.pb.go
View File

@ -2261,7 +2261,7 @@ func (m *SearchResults) GetHits() [][]byte {
type FlushRequest struct { type FlushRequest struct {
Base *commonpb.MsgBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"` 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"` 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_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"` XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"` XXX_sizecache int32 `json:"-"`
@ -2306,11 +2306,11 @@ func (m *FlushRequest) GetDbName() string {
return "" return ""
} }
func (m *FlushRequest) GetCollectionName() string { func (m *FlushRequest) GetCollectionNames() []string {
if m != nil { if m != nil {
return m.CollectionName return m.CollectionNames
} }
return "" return nil
} }
type RegisterLinkResponse struct { type RegisterLinkResponse struct {
@ -2408,112 +2408,113 @@ func init() {
func init() { proto.RegisterFile("milvus.proto", fileDescriptor_02345ba45cc0e303) } func init() { proto.RegisterFile("milvus.proto", fileDescriptor_02345ba45cc0e303) }
var fileDescriptor_02345ba45cc0e303 = []byte{ var fileDescriptor_02345ba45cc0e303 = []byte{
// 1676 bytes of a gzipped FileDescriptorProto // 1685 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x59, 0xdd, 0x6f, 0x1b, 0xc5, 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x59, 0xdd, 0x6f, 0xdb, 0x46,
0x16, 0xcf, 0xda, 0x8e, 0x93, 0x9c, 0xac, 0x1d, 0x67, 0xf2, 0xe5, 0xba, 0xed, 0x6d, 0xba, 0xf7, 0x12, 0x37, 0x25, 0x59, 0xb6, 0xc7, 0x94, 0x2c, 0xaf, 0xbf, 0x14, 0x25, 0xb9, 0x38, 0x7b, 0x97,
0xf6, 0x26, 0xfd, 0x4a, 0xae, 0xd2, 0xfb, 0xf9, 0x70, 0xa5, 0x36, 0x71, 0x9a, 0x5a, 0x6d, 0xd3, 0xb3, 0xf3, 0x65, 0x1f, 0x9c, 0xfb, 0x7c, 0x38, 0x20, 0xb1, 0xe5, 0x38, 0x42, 0x12, 0xc7, 0x47,
0xdc, 0x75, 0x6e, 0x21, 0x54, 0x95, 0x59, 0x7b, 0x07, 0x7b, 0xe9, 0x7a, 0xd7, 0xec, 0x8c, 0xf3, 0xf9, 0x72, 0xe7, 0x0b, 0x02, 0x1d, 0x25, 0xee, 0x49, 0xbc, 0x50, 0xa4, 0xca, 0x5d, 0xf9, 0x23,
0xd1, 0x27, 0x04, 0x12, 0x48, 0x80, 0xe0, 0x99, 0x57, 0x24, 0x5e, 0x11, 0x14, 0xc4, 0x7f, 0x80, 0x4f, 0x45, 0x53, 0xb4, 0x40, 0x5b, 0xb4, 0xcf, 0x7d, 0x2d, 0xd0, 0xd7, 0xa2, 0x4d, 0x8b, 0xfe,
0xc4, 0xff, 0x82, 0x10, 0x7f, 0x01, 0x12, 0xda, 0x99, 0xf5, 0x7a, 0x77, 0x33, 0x1b, 0x9b, 0x1a, 0x07, 0x05, 0xfa, 0xbf, 0x14, 0x45, 0xff, 0x82, 0x02, 0x05, 0x97, 0x14, 0x45, 0xd2, 0x4b, 0x4b,
0x88, 0xf3, 0xe6, 0x39, 0x3e, 0x73, 0xe6, 0x37, 0xbf, 0x73, 0xce, 0xcc, 0x99, 0xb3, 0x20, 0x37, 0x8d, 0x9a, 0x5a, 0x7e, 0xd3, 0x8e, 0x66, 0x67, 0x7f, 0xfb, 0x9b, 0x99, 0xdd, 0xd9, 0x21, 0xc8,
0x0d, 0x73, 0xbf, 0x4d, 0x56, 0x5a, 0x8e, 0x4d, 0x6d, 0x34, 0x13, 0x1c, 0xad, 0xf0, 0x41, 0x41, 0x4d, 0xdd, 0xd8, 0x6f, 0xd3, 0x95, 0x96, 0x6d, 0x31, 0x0b, 0xcd, 0x04, 0x47, 0x2b, 0xee, 0xa0,
0xae, 0xd9, 0xcd, 0xa6, 0x6d, 0x71, 0x61, 0x41, 0x26, 0xb5, 0x06, 0x6e, 0x6a, 0x7c, 0xa4, 0x7c, 0x20, 0xd7, 0xac, 0x66, 0xd3, 0x32, 0x5d, 0x61, 0x41, 0xa6, 0xb5, 0x06, 0x69, 0xaa, 0xee, 0x08,
0x2e, 0xc1, 0xc2, 0x86, 0x83, 0x35, 0x8a, 0x37, 0x6c, 0xd3, 0xc4, 0x35, 0x6a, 0xd8, 0x96, 0x8a, 0x7f, 0x2a, 0xc1, 0xc2, 0x86, 0x4d, 0x54, 0x46, 0x36, 0x2c, 0xc3, 0x20, 0x35, 0xa6, 0x5b, 0xa6,
0xdf, 0x6a, 0x63, 0x42, 0xd1, 0xdf, 0x20, 0x55, 0xd5, 0x08, 0xce, 0x4b, 0x8b, 0xd2, 0xf2, 0xe4, 0x42, 0xde, 0x68, 0x13, 0xca, 0xd0, 0x1f, 0x20, 0x55, 0x55, 0x29, 0xc9, 0x4b, 0x8b, 0xd2, 0xf2,
0xda, 0x85, 0x95, 0x90, 0x6d, 0xcf, 0xe6, 0x43, 0x52, 0x5f, 0xd7, 0x08, 0x56, 0x99, 0x26, 0x5a, 0xe4, 0xda, 0x85, 0x95, 0x90, 0x6d, 0xcf, 0xe6, 0x43, 0x5a, 0x5f, 0x57, 0x29, 0x51, 0xb8, 0x26,
0x80, 0x31, 0xbd, 0x5a, 0xb1, 0xb4, 0x26, 0xce, 0x27, 0x16, 0xa5, 0xe5, 0x09, 0x35, 0xad, 0x57, 0x5a, 0x80, 0x31, 0xad, 0x5a, 0x31, 0xd5, 0x26, 0xc9, 0x27, 0x16, 0xa5, 0xe5, 0x09, 0x25, 0xad,
0xb7, 0xb5, 0x26, 0x46, 0x4b, 0x30, 0x55, 0xf3, 0xed, 0x73, 0x85, 0x24, 0x53, 0xc8, 0x76, 0xc5, 0x55, 0xb7, 0xd5, 0x26, 0x41, 0x4b, 0x30, 0x55, 0xf3, 0xed, 0xbb, 0x0a, 0x49, 0xae, 0x90, 0xed,
0x4c, 0x71, 0x1e, 0xd2, 0x1c, 0x5f, 0x3e, 0xb5, 0x28, 0x2d, 0xcb, 0xaa, 0x37, 0x52, 0x3e, 0x94, 0x8a, 0xb9, 0xe2, 0x3c, 0xa4, 0x5d, 0x7c, 0xf9, 0xd4, 0xa2, 0xb4, 0x2c, 0x2b, 0xde, 0x08, 0xbf,
0x60, 0xae, 0xe8, 0xd8, 0xad, 0xa1, 0x40, 0xa9, 0x7c, 0x20, 0xc1, 0xec, 0x3d, 0x8d, 0x0c, 0x07, 0x2f, 0xc1, 0x5c, 0xd1, 0xb6, 0x5a, 0x43, 0x81, 0x12, 0xbf, 0x27, 0xc1, 0xec, 0x3d, 0x95, 0x0e,
0x98, 0x3d, 0x90, 0xd7, 0x6d, 0xdb, 0x54, 0x31, 0x69, 0xd9, 0x16, 0xc1, 0xe8, 0x16, 0xa4, 0x09, 0x07, 0x98, 0x3d, 0x90, 0xd7, 0x2d, 0xcb, 0x50, 0x08, 0x6d, 0x59, 0x26, 0x25, 0xe8, 0x16, 0xa4,
0xd5, 0x68, 0x9b, 0x78, 0x28, 0xce, 0x0b, 0x51, 0x94, 0x99, 0x8a, 0xea, 0xa9, 0xa2, 0x59, 0x18, 0x29, 0x53, 0x59, 0x9b, 0x7a, 0x28, 0xce, 0x0b, 0x51, 0x94, 0xb9, 0x8a, 0xe2, 0xa9, 0xa2, 0x59,
0xdd, 0xd7, 0xcc, 0x36, 0x07, 0x31, 0xae, 0xf2, 0x81, 0xf2, 0x04, 0xb2, 0x65, 0xea, 0x18, 0x56, 0x18, 0xdd, 0x57, 0x8d, 0xb6, 0x0b, 0x62, 0x5c, 0x71, 0x07, 0xf8, 0x09, 0x64, 0xcb, 0xcc, 0xd6,
0xfd, 0x37, 0x34, 0x3e, 0xd1, 0x31, 0xfe, 0x89, 0x04, 0xe7, 0x8a, 0x98, 0xd4, 0x1c, 0xa3, 0x3a, 0xcd, 0xfa, 0x2f, 0x68, 0x7c, 0xa2, 0x63, 0xfc, 0x23, 0x09, 0xce, 0x15, 0x09, 0xad, 0xd9, 0x7a,
0x1c, 0xc1, 0xa7, 0x7c, 0x23, 0x41, 0x41, 0x84, 0x68, 0x90, 0xbd, 0xff, 0xd7, 0x0f, 0xe8, 0x04, 0x75, 0x38, 0x82, 0x0f, 0x7f, 0x25, 0x41, 0x41, 0x84, 0x68, 0x90, 0xbd, 0xff, 0xdd, 0x0f, 0xe8,
0x9b, 0x74, 0x25, 0x3c, 0xc9, 0x4b, 0xc6, 0xee, 0x6a, 0x65, 0x26, 0xe8, 0xc4, 0x3d, 0x52, 0x40, 0x04, 0x9f, 0x74, 0x25, 0x3c, 0xc9, 0x4b, 0xc6, 0xee, 0x6a, 0x65, 0x2e, 0xe8, 0xc4, 0x3d, 0xc2,
0xee, 0x82, 0x2c, 0x15, 0x19, 0xf0, 0xa4, 0x1a, 0x92, 0xb1, 0xdc, 0x78, 0x60, 0x6b, 0xfa, 0x70, 0x20, 0x77, 0x41, 0x96, 0x8a, 0x1c, 0x78, 0x52, 0x09, 0xc9, 0x78, 0x6e, 0x3c, 0xb0, 0x54, 0x6d,
0x90, 0xf8, 0xb1, 0x04, 0x79, 0x15, 0x9b, 0x58, 0x23, 0x43, 0xe2, 0xd5, 0x8f, 0x24, 0x98, 0x0f, 0x38, 0x48, 0xfc, 0x50, 0x82, 0xbc, 0x42, 0x0c, 0xa2, 0xd2, 0x21, 0xf1, 0xea, 0x07, 0x12, 0xcc,
0xf0, 0x4b, 0x35, 0x4a, 0x4e, 0x13, 0xce, 0xfb, 0xee, 0x89, 0x1b, 0x85, 0x33, 0x48, 0x84, 0xfd, 0x07, 0xf8, 0x65, 0x2a, 0xa3, 0xa7, 0x09, 0xe7, 0x5d, 0xe7, 0xc4, 0x8d, 0xc2, 0x19, 0x24, 0xc2,
0x0b, 0x46, 0xdd, 0x5f, 0x24, 0x9f, 0x58, 0x4c, 0x2e, 0x4f, 0xae, 0x5d, 0x16, 0xce, 0xb9, 0x8f, 0xfe, 0x02, 0xa3, 0xce, 0x2f, 0x9a, 0x4f, 0x2c, 0x26, 0x97, 0x27, 0xd7, 0x2e, 0x0b, 0xe7, 0xdc,
0x8f, 0x1e, 0xbb, 0x59, 0xb7, 0xa3, 0x19, 0x8e, 0xca, 0xf5, 0x95, 0x2a, 0xcc, 0x95, 0x1b, 0xf6, 0x27, 0x47, 0x8f, 0x9d, 0xac, 0xdb, 0x51, 0x75, 0x5b, 0x71, 0xf5, 0x71, 0x15, 0xe6, 0xca, 0x0d,
0xc1, 0xef, 0xe9, 0x25, 0xe5, 0x10, 0xe6, 0xa3, 0x6b, 0x0c, 0xb2, 0xd7, 0xab, 0x90, 0x8b, 0xb0, 0xeb, 0xe0, 0x75, 0x7a, 0x09, 0x1f, 0xc2, 0x7c, 0x74, 0x8d, 0x41, 0xf6, 0x7a, 0x15, 0x72, 0x11,
0xcc, 0xb7, 0x3d, 0xa1, 0x4e, 0x85, 0x69, 0x26, 0xca, 0xd7, 0xae, 0xdb, 0xd9, 0xcd, 0xb6, 0xa3, 0x96, 0xdd, 0x6d, 0x4f, 0x28, 0x53, 0x61, 0x9a, 0x29, 0xfe, 0xd2, 0x71, 0x3b, 0xbf, 0xd9, 0x76,
0x39, 0xd4, 0x38, 0xed, 0x8b, 0xed, 0x0a, 0x64, 0x5b, 0x1d, 0x1c, 0x5c, 0x2f, 0xc5, 0xf4, 0x32, 0x54, 0x9b, 0xe9, 0xa7, 0x7d, 0xb1, 0x5d, 0x81, 0x6c, 0xab, 0x83, 0xc3, 0xd5, 0x4b, 0x71, 0xbd,
0xbe, 0x94, 0xf1, 0xf5, 0x95, 0x04, 0xb3, 0xee, 0x3d, 0x77, 0x96, 0x30, 0x7f, 0x29, 0xc1, 0xcc, 0x8c, 0x2f, 0xe5, 0x7c, 0x7d, 0x21, 0xc1, 0xac, 0x73, 0xcf, 0x9d, 0x25, 0xcc, 0x9f, 0x4b, 0x30,
0x3d, 0x8d, 0x9c, 0x25, 0xc8, 0x2f, 0x24, 0x98, 0x71, 0x8f, 0x4c, 0x8e, 0xf9, 0x74, 0x21, 0x2f, 0x73, 0x4f, 0xa5, 0x67, 0x09, 0xf2, 0x4b, 0x09, 0x66, 0x9c, 0x23, 0xd3, 0xc5, 0x7c, 0xba, 0x90,
0xc1, 0x54, 0x18, 0x32, 0xc9, 0xa7, 0x58, 0x48, 0x67, 0x43, 0x98, 0x89, 0xf2, 0xad, 0x04, 0x0b, 0x97, 0x60, 0x2a, 0x0c, 0x99, 0xe6, 0x53, 0x3c, 0xa4, 0xb3, 0x21, 0xcc, 0x14, 0x7f, 0x2d, 0xc1,
0xde, 0xc9, 0x3a, 0x14, 0x5c, 0xf7, 0x0d, 0xfc, 0x85, 0x04, 0x73, 0x3e, 0xe2, 0xd3, 0x3e, 0x80, 0x82, 0x77, 0xb2, 0x0e, 0x05, 0xd7, 0x7d, 0x03, 0x7f, 0x29, 0xc1, 0x9c, 0x8f, 0xf8, 0xb4, 0x0f,
0xfb, 0x0d, 0x91, 0xf7, 0x24, 0x98, 0x8f, 0x82, 0x3e, 0x95, 0x63, 0xfa, 0x0b, 0x09, 0x66, 0xdd, 0xe0, 0x7e, 0x43, 0xe4, 0x1d, 0x09, 0xe6, 0xa3, 0xa0, 0x4f, 0xe5, 0x98, 0xfe, 0x4c, 0x82, 0x59,
0x33, 0x74, 0x28, 0x7c, 0x1e, 0xad, 0x47, 0x52, 0x82, 0x7a, 0xe4, 0x53, 0x89, 0x5f, 0x2c, 0x01, 0xe7, 0x0c, 0x1d, 0x0a, 0x9f, 0x47, 0xeb, 0x91, 0x94, 0xa0, 0x1e, 0xf9, 0x58, 0x72, 0x2f, 0x96,
0xc0, 0x83, 0x10, 0x27, 0x08, 0xb3, 0x84, 0x28, 0xcc, 0x5c, 0x6c, 0xbe, 0xa4, 0x54, 0x24, 0xf9, 0x00, 0xe0, 0x41, 0x88, 0x13, 0x84, 0x59, 0x42, 0x14, 0x66, 0x0e, 0x36, 0x5f, 0x52, 0x2a, 0xd2,
0xe4, 0x62, 0xd2, 0xc5, 0x16, 0x94, 0xb1, 0x62, 0xa0, 0x53, 0xe2, 0x95, 0x71, 0xbd, 0x89, 0x2d, 0x7c, 0x72, 0x31, 0xe9, 0x60, 0x0b, 0xca, 0x78, 0x31, 0xd0, 0x29, 0xf1, 0xca, 0xa4, 0xde, 0x24,
0xfa, 0xf2, 0x74, 0x46, 0xc9, 0x48, 0x1c, 0x27, 0x03, 0x5d, 0x80, 0x09, 0xc2, 0xd7, 0xf1, 0xab, 0x26, 0x7b, 0x75, 0x3a, 0xa3, 0x64, 0x24, 0x8e, 0x93, 0x81, 0x2e, 0xc0, 0x04, 0x75, 0xd7, 0xf1,
0xb7, 0xae, 0x40, 0x79, 0x47, 0x82, 0x85, 0x63, 0x70, 0x06, 0x21, 0x2b, 0x0f, 0x63, 0x86, 0xa5, 0xab, 0xb7, 0xae, 0x00, 0xbf, 0x25, 0xc1, 0xc2, 0x31, 0x38, 0x83, 0x90, 0x95, 0x87, 0x31, 0xdd,
0xe3, 0x43, 0x1f, 0x4d, 0x67, 0xe8, 0xfe, 0x53, 0x6d, 0x1b, 0xa6, 0xee, 0xc3, 0xe8, 0x0c, 0x5d, 0xd4, 0xc8, 0xa1, 0x8f, 0xa6, 0x33, 0x74, 0xfe, 0xa9, 0xb6, 0x75, 0x43, 0xf3, 0x61, 0x74, 0x86,
0x4e, 0x90, 0xeb, 0xaf, 0x3f, 0x84, 0x8f, 0x45, 0x98, 0x0c, 0x38, 0xc4, 0x83, 0x12, 0x14, 0x29, 0x0e, 0x27, 0xc8, 0xf1, 0xd7, 0xaf, 0xc2, 0xc7, 0x22, 0x4c, 0x06, 0x1c, 0xe2, 0x41, 0x09, 0x8a,
0x6f, 0xc2, 0x4c, 0x08, 0xcd, 0x20, 0x74, 0xfc, 0x09, 0xc0, 0x27, 0x9b, 0x87, 0x4d, 0x52, 0x0d, 0xf0, 0xff, 0x61, 0x26, 0x84, 0x66, 0x10, 0x3a, 0x7e, 0x03, 0xe0, 0x93, 0xed, 0x86, 0x4d, 0x52,
0x48, 0x94, 0x1f, 0x25, 0x40, 0xbc, 0x48, 0x28, 0xb9, 0x34, 0x9d, 0x66, 0x66, 0x5d, 0x04, 0x78, 0x09, 0x48, 0xf0, 0xf7, 0x12, 0x20, 0xb7, 0x48, 0x28, 0x39, 0x34, 0x9d, 0x66, 0x66, 0x5d, 0x04,
0xc3, 0xc0, 0xa6, 0x1e, 0x3c, 0x92, 0x26, 0x98, 0x84, 0xfd, 0x5d, 0x04, 0x19, 0x1f, 0x52, 0x47, 0xf8, 0x9f, 0x4e, 0x0c, 0x2d, 0x78, 0x24, 0x4d, 0x70, 0x09, 0xff, 0xbb, 0x08, 0x32, 0x39, 0x64,
0xab, 0xb4, 0x34, 0x47, 0x6b, 0x92, 0xfc, 0x68, 0xbf, 0xa7, 0xc8, 0x24, 0x9b, 0xb6, 0xc3, 0x66, 0xb6, 0x5a, 0x69, 0xa9, 0xb6, 0xda, 0xa4, 0xf9, 0xd1, 0x7e, 0x4f, 0x91, 0x49, 0x3e, 0x6d, 0x87,
0x29, 0xdf, 0xbb, 0xe5, 0x85, 0x17, 0x6f, 0xc3, 0xbe, 0xe3, 0x8b, 0x00, 0x2c, 0x76, 0xf9, 0xdf, 0xcf, 0xc2, 0xdf, 0x3a, 0xe5, 0x85, 0x17, 0x6f, 0xc3, 0xbe, 0xe3, 0x8b, 0x00, 0x3c, 0x76, 0xdd,
0xa3, 0xfc, 0x6f, 0x26, 0x61, 0xe7, 0xb3, 0x09, 0x39, 0xb6, 0x03, 0xbe, 0x9d, 0x96, 0x6b, 0x35, 0xbf, 0x47, 0xdd, 0xbf, 0xb9, 0x84, 0x9f, 0xcf, 0x06, 0xe4, 0xf8, 0x0e, 0xdc, 0xed, 0xb4, 0x1c,
0x32, 0x45, 0x8a, 0x4c, 0x41, 0xff, 0x81, 0xb4, 0xc7, 0x5e, 0xdf, 0x67, 0xb0, 0x37, 0x41, 0xf9, 0xab, 0x91, 0x29, 0x52, 0x64, 0x0a, 0xfa, 0x1b, 0xa4, 0x3d, 0xf6, 0xfa, 0x3e, 0x83, 0xbd, 0x09,
0x4c, 0x82, 0xb9, 0x08, 0x71, 0x83, 0xc4, 0xe5, 0x2e, 0x20, 0x0e, 0x54, 0xef, 0xa2, 0xef, 0xa0, 0xf8, 0x13, 0x09, 0xe6, 0x22, 0xc4, 0x0d, 0x12, 0x97, 0xbb, 0x80, 0x5c, 0xa0, 0x5a, 0x17, 0x7d,
0x8a, 0xbc, 0x10, 0xbd, 0x41, 0x74, 0xaf, 0xea, 0xb4, 0x11, 0x91, 0x10, 0xe5, 0x3b, 0x09, 0xa6, 0x07, 0x55, 0xe4, 0x85, 0xe8, 0x0d, 0xa2, 0x7b, 0x55, 0xa6, 0xf5, 0x88, 0x84, 0xe2, 0x6f, 0x24,
0x99, 0x9e, 0xbb, 0x1a, 0x3e, 0xbb, 0xae, 0x7d, 0x5b, 0x02, 0x14, 0xdc, 0xc7, 0x20, 0x4c, 0xff, 0x98, 0xe6, 0x7a, 0xce, 0x6a, 0xe4, 0xec, 0xba, 0xf6, 0x4d, 0x09, 0x50, 0x70, 0x1f, 0x83, 0x30,
0x83, 0x5f, 0xbb, 0x7c, 0x27, 0xd9, 0xb5, 0x4b, 0xc2, 0x39, 0x81, 0xc5, 0xb8, 0xb6, 0xf2, 0xb3, 0xfd, 0x27, 0xf7, 0xda, 0x75, 0x77, 0x92, 0x5d, 0xbb, 0x24, 0x9c, 0x13, 0x58, 0xcc, 0xd5, 0xc6,
0x04, 0x99, 0x92, 0x45, 0xb0, 0x43, 0x87, 0xbf, 0x54, 0x41, 0x7f, 0x87, 0x71, 0xc7, 0x3e, 0xa8, 0x3f, 0x4a, 0x90, 0x29, 0x99, 0x94, 0xd8, 0x6c, 0xf8, 0x4b, 0x15, 0xf4, 0x47, 0x18, 0xb7, 0xad,
0xe8, 0x1a, 0xd5, 0xbc, 0x73, 0xe1, 0x9c, 0x10, 0xde, 0xba, 0x69, 0x57, 0xd5, 0x31, 0xc7, 0x3e, 0x83, 0x8a, 0xa6, 0x32, 0xd5, 0x3b, 0x17, 0xce, 0x09, 0xe1, 0xad, 0x1b, 0x56, 0x55, 0x19, 0xb3,
0x28, 0x6a, 0x54, 0x43, 0xe7, 0x61, 0xa2, 0xa1, 0x91, 0x46, 0xe5, 0x19, 0x3e, 0x22, 0xf9, 0xf4, 0xad, 0x83, 0xa2, 0xca, 0x54, 0x74, 0x1e, 0x26, 0x1a, 0x2a, 0x6d, 0x54, 0x9e, 0x91, 0x23, 0x9a,
0x62, 0x72, 0x39, 0xa3, 0x8e, 0xbb, 0x82, 0xfb, 0xf8, 0x88, 0x28, 0xef, 0x4a, 0x90, 0xed, 0xec, 0x4f, 0x2f, 0x26, 0x97, 0x33, 0xca, 0xb8, 0x23, 0xb8, 0x4f, 0x8e, 0x28, 0x7e, 0x21, 0x41, 0xb6,
0x7f, 0x10, 0xfa, 0x2f, 0xc1, 0xa4, 0x63, 0x1f, 0x94, 0x8a, 0x95, 0x2a, 0xae, 0x1b, 0x96, 0x77, 0xb3, 0xff, 0x41, 0xe8, 0xbf, 0x04, 0x93, 0xb6, 0x75, 0x50, 0x2a, 0x56, 0xaa, 0xa4, 0xae, 0x9b,
0x23, 0x00, 0x13, 0xad, 0xbb, 0x12, 0x17, 0x05, 0x57, 0xc0, 0x96, 0xee, 0xdd, 0x06, 0xe3, 0x4c, 0xde, 0x8d, 0x00, 0x5c, 0xb4, 0xee, 0x48, 0x1c, 0x14, 0xae, 0x02, 0x31, 0x35, 0xef, 0x36, 0x18,
0xb0, 0x69, 0xe9, 0xca, 0x3e, 0xe4, 0x76, 0x4c, 0xad, 0x86, 0x1b, 0xb6, 0xa9, 0x63, 0x87, 0x65, 0xe7, 0x82, 0x4d, 0x53, 0xc3, 0xfb, 0x90, 0xdb, 0x31, 0xd4, 0x1a, 0x69, 0x58, 0x86, 0x46, 0x6c,
0x25, 0xca, 0x41, 0x92, 0x6a, 0x75, 0x2f, 0xb9, 0xdd, 0x9f, 0xe8, 0xdf, 0x90, 0xa2, 0x47, 0xad, 0x9e, 0x95, 0x28, 0x07, 0x49, 0xa6, 0xd6, 0xbd, 0xe4, 0x76, 0x7e, 0xa2, 0xbf, 0x42, 0x8a, 0x1d,
0x8e, 0x87, 0xff, 0x22, 0x4c, 0x9f, 0x80, 0x99, 0xdd, 0xa3, 0x16, 0x56, 0xd9, 0x0c, 0x34, 0x0f, 0xb5, 0x3a, 0x1e, 0xfe, 0x9d, 0x30, 0x7d, 0x02, 0x66, 0x76, 0x8f, 0x5a, 0x44, 0xe1, 0x33, 0xd0,
0x69, 0xd6, 0x8b, 0xe2, 0xb5, 0x82, 0xac, 0x7a, 0x23, 0xe5, 0x69, 0x68, 0xdd, 0x2d, 0xc7, 0x6e, 0x3c, 0xa4, 0x79, 0x2f, 0xca, 0xad, 0x15, 0x64, 0xc5, 0x1b, 0xe1, 0xa7, 0xa1, 0x75, 0xb7, 0x6c,
0xb7, 0x50, 0x09, 0xe4, 0x56, 0x57, 0xe6, 0x92, 0x10, 0x9f, 0xac, 0x51, 0xd0, 0x6a, 0x68, 0xaa, 0xab, 0xdd, 0x42, 0x25, 0x90, 0x5b, 0x5d, 0x99, 0x43, 0x42, 0x7c, 0xb2, 0x46, 0x41, 0x2b, 0xa1,
0xf2, 0x83, 0x04, 0x99, 0x32, 0xd6, 0x9c, 0x5a, 0xe3, 0x2c, 0x94, 0xef, 0x2e, 0xe3, 0x3a, 0x31, 0xa9, 0xf8, 0x3b, 0x09, 0x32, 0x65, 0xa2, 0xda, 0xb5, 0xc6, 0x59, 0x28, 0xdf, 0x1d, 0xc6, 0x35,
0xbd, 0x34, 0x75, 0x7f, 0xa2, 0xeb, 0x30, 0x1d, 0xd8, 0x50, 0xa5, 0xee, 0x12, 0x94, 0x4f, 0xb3, 0x6a, 0x78, 0x69, 0xea, 0xfc, 0x44, 0xd7, 0x61, 0x3a, 0xb0, 0xa1, 0x4a, 0xdd, 0x21, 0x28, 0x9f,
0x86, 0x6d, 0xae, 0x15, 0x21, 0x4e, 0xb9, 0x0f, 0xa9, 0x7b, 0x06, 0x65, 0x66, 0xdc, 0x4b, 0x58, 0xe6, 0x0d, 0xdb, 0x5c, 0x2b, 0x42, 0x1c, 0xbe, 0x0f, 0xa9, 0x7b, 0x3a, 0xe3, 0x66, 0x9c, 0x4b,
0x62, 0x97, 0xb0, 0xfb, 0x13, 0x9d, 0x0b, 0xc4, 0x6d, 0x82, 0x39, 0xc0, 0x0f, 0x4e, 0xd6, 0x07, 0x58, 0xe2, 0x97, 0xb0, 0xf3, 0x13, 0x9d, 0x0b, 0xc4, 0x6d, 0x82, 0x3b, 0xc0, 0x0f, 0x4e, 0xde,
0xb6, 0x1d, 0xcf, 0x33, 0x09, 0xd5, 0x1b, 0x29, 0xaf, 0x76, 0x99, 0x23, 0x6d, 0x93, 0x92, 0x97, 0x07, 0xb6, 0x6c, 0xcf, 0x33, 0x09, 0xc5, 0x1b, 0xe1, 0x7f, 0x77, 0x99, 0xa3, 0x6d, 0x83, 0xd1,
0x8b, 0x4a, 0x04, 0xa9, 0x86, 0xe1, 0x95, 0xe2, 0xb2, 0xca, 0x7e, 0xbb, 0xa5, 0x98, 0x7c, 0xd7, 0x57, 0x8b, 0x4a, 0x04, 0xa9, 0x86, 0xee, 0x95, 0xe2, 0xb2, 0xc2, 0x7f, 0xe3, 0xb7, 0x25, 0x90,
0x6c, 0x93, 0xd3, 0xf4, 0x89, 0x9b, 0x76, 0xb3, 0x2a, 0xae, 0x1b, 0x84, 0x62, 0xe7, 0x81, 0x61, 0xef, 0x1a, 0x6d, 0xfa, 0x3a, 0x7c, 0x22, 0x6a, 0x5b, 0x24, 0xc5, 0x6d, 0x8b, 0x17, 0x12, 0xcc,
0x3d, 0xf3, 0x93, 0xef, 0x9f, 0x30, 0xa6, 0xe9, 0xba, 0x83, 0x09, 0x39, 0x11, 0xcf, 0x1d, 0xae, 0x2a, 0xa4, 0xae, 0x53, 0x46, 0xec, 0x07, 0xba, 0xf9, 0xcc, 0x4f, 0xbf, 0x3f, 0xc3, 0x98, 0xaa,
0xa3, 0x76, 0x94, 0x03, 0xf4, 0x24, 0xfa, 0xa6, 0xe7, 0xda, 0x6d, 0x98, 0x8a, 0xe4, 0x0b, 0x1a, 0x69, 0x36, 0xa1, 0xf4, 0x44, 0x44, 0x77, 0x5c, 0x1d, 0xa5, 0xa3, 0x1c, 0x20, 0x28, 0xd1, 0x37,
0x87, 0xd4, 0xf6, 0xa3, 0xed, 0xcd, 0xdc, 0x08, 0x9a, 0x86, 0xcc, 0xe3, 0xcd, 0x8d, 0xdd, 0x47, 0x41, 0xd7, 0x6e, 0xc3, 0x54, 0x24, 0x63, 0xd0, 0x38, 0xa4, 0xb6, 0x1f, 0x6d, 0x6f, 0xe6, 0x46,
0x6a, 0x65, 0xbd, 0xb4, 0x7d, 0x47, 0xdd, 0xcb, 0xe9, 0x28, 0x07, 0xb2, 0x27, 0xba, 0xfb, 0xe0, 0xd0, 0x34, 0x64, 0x1e, 0x6f, 0x6e, 0xec, 0x3e, 0x52, 0x2a, 0xeb, 0xa5, 0xed, 0x3b, 0xca, 0x5e,
0xd1, 0x9d, 0xdd, 0x1c, 0x5e, 0xfb, 0x29, 0x07, 0x99, 0x87, 0x6c, 0xa1, 0x32, 0x76, 0xf6, 0x8d, 0x4e, 0x43, 0x39, 0x90, 0x3d, 0xd1, 0xdd, 0x07, 0x8f, 0xee, 0xec, 0xe6, 0xc8, 0xda, 0x0f, 0x39,
0x1a, 0x46, 0x15, 0xc8, 0x45, 0xbf, 0x33, 0xa0, 0x1b, 0xc2, 0xe4, 0x89, 0xf9, 0x1c, 0x51, 0x38, 0xc8, 0x3c, 0xe4, 0x0b, 0x95, 0x89, 0xbd, 0xaf, 0xd7, 0x08, 0xaa, 0x40, 0x2e, 0xfa, 0xa5, 0x01,
0x09, 0xba, 0x32, 0x82, 0x9e, 0x40, 0x36, 0xfc, 0x81, 0x00, 0x5d, 0x13, 0x9a, 0x17, 0x7e, 0x45, 0xdd, 0x10, 0xa6, 0x4f, 0xcc, 0x07, 0x89, 0xc2, 0x49, 0xd0, 0xf1, 0x08, 0x7a, 0x02, 0xd9, 0xf0,
0xe8, 0x65, 0xbc, 0x02, 0x99, 0x50, 0xbf, 0x1f, 0x5d, 0x15, 0xda, 0x16, 0x7d, 0x13, 0x28, 0x5c, 0x27, 0x02, 0x74, 0x4d, 0x68, 0x5e, 0xf8, 0x1d, 0xa1, 0x97, 0xf1, 0x0a, 0x64, 0x42, 0x1d, 0x7f,
0x16, 0xaa, 0x06, 0x5b, 0xf6, 0x1c, 0x7d, 0xb8, 0x85, 0x1b, 0x83, 0x5e, 0xd8, 0xe7, 0xed, 0x85, 0x74, 0x55, 0x68, 0x5b, 0xf4, 0x55, 0xa0, 0x70, 0x59, 0xa8, 0x1a, 0x6c, 0xda, 0xbb, 0xe8, 0xc3,
0x5e, 0x83, 0xe9, 0x63, 0x1d, 0x59, 0x74, 0x53, 0x68, 0x3f, 0xae, 0x73, 0xdb, 0x6b, 0x89, 0x03, 0x4d, 0xdc, 0x18, 0xf4, 0xc2, 0x4e, 0x6f, 0x2f, 0xf4, 0x2a, 0x4c, 0x1f, 0xeb, 0xc9, 0xa2, 0x9b,
0x40, 0xc7, 0x3b, 0xe7, 0x68, 0x45, 0xec, 0x81, 0xb8, 0xa6, 0x7f, 0x61, 0xb5, 0x6f, 0x7d, 0x9f, 0x42, 0xfb, 0x71, 0xbd, 0xdb, 0x5e, 0x4b, 0x1c, 0x00, 0x3a, 0xde, 0x3b, 0x47, 0x2b, 0x62, 0x0f,
0xb8, 0x7d, 0x58, 0xd8, 0xc2, 0x34, 0xdc, 0x50, 0x35, 0x08, 0x35, 0x6a, 0x04, 0x5d, 0x17, 0x87, 0xc4, 0xb5, 0xfd, 0x0b, 0xab, 0x7d, 0xeb, 0xfb, 0xc4, 0xed, 0xc3, 0xc2, 0x16, 0x61, 0xe1, 0x96,
0x97, 0xb0, 0x15, 0x5c, 0xb8, 0xd1, 0x9f, 0xb2, 0xbf, 0xae, 0x09, 0x53, 0xe1, 0xc6, 0x26, 0x89, 0xaa, 0x4e, 0x99, 0x5e, 0xa3, 0xe8, 0xba, 0x38, 0xbc, 0x84, 0xcd, 0xe0, 0xc2, 0x8d, 0xfe, 0x94,
0xf1, 0x98, 0xb0, 0xc5, 0x5a, 0xb8, 0xde, 0x97, 0xae, 0xbf, 0xda, 0x53, 0x98, 0x8a, 0xf4, 0x32, 0xfd, 0x75, 0x0d, 0x98, 0x0a, 0xb7, 0x36, 0x69, 0x8c, 0xc7, 0x84, 0x4d, 0xd6, 0xc2, 0xf5, 0xbe,
0xe3, 0x76, 0x27, 0xec, 0x78, 0xf6, 0xf2, 0xde, 0x1e, 0x64, 0x42, 0x4d, 0xc7, 0x98, 0xf0, 0x16, 0x74, 0xfd, 0xd5, 0x9e, 0xc2, 0x54, 0xa4, 0x9b, 0x19, 0xb7, 0x3b, 0x61, 0xcf, 0xb3, 0x97, 0xf7,
0x35, 0x26, 0x7b, 0x99, 0x7e, 0x0a, 0x72, 0xb0, 0x37, 0x88, 0x96, 0xe3, 0x12, 0xe7, 0x98, 0xe1, 0xf6, 0x20, 0x13, 0x6a, 0x3b, 0xc6, 0x84, 0xb7, 0xa8, 0x35, 0xd9, 0xcb, 0xf4, 0x53, 0x90, 0x83,
0xbe, 0xf2, 0x66, 0x8f, 0xe7, 0x8d, 0x3f, 0x99, 0xc4, 0x2c, 0x20, 0x68, 0xf6, 0xf5, 0x42, 0xfe, 0xdd, 0x41, 0xb4, 0x1c, 0x97, 0x38, 0xc7, 0x0c, 0xf7, 0x95, 0x37, 0x7b, 0x6e, 0xde, 0xf8, 0x93,
0xba, 0x9f, 0x35, 0x01, 0xeb, 0x37, 0x4e, 0xca, 0x9a, 0x5f, 0xcb, 0x0d, 0x81, 0xf9, 0x2d, 0x4c, 0x69, 0xcc, 0x02, 0x82, 0x76, 0x5f, 0x2f, 0xe4, 0xff, 0xf5, 0xb3, 0x26, 0x60, 0xfd, 0xc6, 0x49,
0x43, 0x4d, 0x26, 0x2f, 0x74, 0xc5, 0xa1, 0x24, 0xec, 0xa1, 0xc5, 0x84, 0x92, 0xb8, 0x75, 0xa5, 0x59, 0xf3, 0x73, 0xb9, 0xa1, 0x30, 0xbf, 0x45, 0x58, 0xa8, 0xcd, 0xe4, 0x85, 0xae, 0x38, 0x94,
0x8c, 0x20, 0x03, 0xb2, 0xa1, 0xe6, 0x0c, 0x89, 0x71, 0xb6, 0xa8, 0xe5, 0x54, 0xb8, 0xd6, 0x8f, 0x84, 0x5d, 0xb4, 0x98, 0x50, 0x12, 0x37, 0xaf, 0xf0, 0x08, 0xd2, 0x21, 0x1b, 0x6a, 0xcf, 0xd0,
0xaa, 0xbf, 0xd4, 0xff, 0x61, 0x32, 0xf0, 0xb8, 0x46, 0x4b, 0x27, 0x44, 0x6c, 0xf0, 0x31, 0xda, 0x18, 0x67, 0x8b, 0x9a, 0x4e, 0x85, 0x6b, 0xfd, 0xa8, 0xfa, 0x4b, 0xfd, 0x13, 0x26, 0x03, 0xcf,
0x8b, 0xb6, 0x06, 0x64, 0x42, 0x4f, 0xb1, 0xb8, 0x68, 0x15, 0xbc, 0x73, 0x63, 0x36, 0x20, 0x7c, 0x6b, 0xb4, 0x74, 0x42, 0xc4, 0x06, 0x9f, 0xa3, 0xbd, 0x68, 0x6b, 0x40, 0x26, 0xf4, 0x18, 0x8b,
0xd9, 0x29, 0x23, 0xa8, 0x0a, 0x99, 0x2d, 0x4c, 0xbb, 0xaf, 0x03, 0xf4, 0xd7, 0xf8, 0xb7, 0x59, 0x8b, 0x56, 0xc1, 0x4b, 0x37, 0x66, 0x03, 0xc2, 0xb7, 0x1d, 0x1e, 0x41, 0x55, 0xc8, 0x6c, 0x11,
0xf0, 0xcd, 0x55, 0x58, 0xea, 0xa9, 0xe7, 0xaf, 0x51, 0x86, 0x34, 0x2f, 0xb4, 0x91, 0x12, 0x33, 0xd6, 0x7d, 0x1f, 0xa0, 0xdf, 0xc7, 0xbf, 0xce, 0x82, 0xaf, 0xae, 0xc2, 0x52, 0x4f, 0x3d, 0x7f,
0x29, 0xf0, 0x0a, 0x29, 0xfc, 0xf9, 0x44, 0x1d, 0xdf, 0xa8, 0x0a, 0x69, 0x5e, 0x26, 0xc5, 0x18, 0x8d, 0x32, 0xa4, 0xdd, 0x52, 0x1b, 0xe1, 0x98, 0x49, 0x81, 0x77, 0x48, 0xe1, 0xb7, 0x27, 0xea,
0x0d, 0x55, 0x9f, 0x85, 0x93, 0x75, 0x58, 0x9d, 0xa5, 0x8c, 0xa0, 0x12, 0x8c, 0xb2, 0xfa, 0x08, 0xf8, 0x46, 0x15, 0x48, 0xbb, 0x85, 0x52, 0x8c, 0xd1, 0x50, 0xfd, 0x59, 0x38, 0x59, 0x87, 0x57,
0x89, 0x13, 0x33, 0x58, 0x3b, 0xf5, 0xf2, 0xe0, 0xff, 0x40, 0xde, 0xc2, 0xb4, 0xa8, 0x6f, 0x34, 0x5a, 0x78, 0x04, 0x95, 0x60, 0x94, 0x57, 0x48, 0x48, 0x9c, 0x98, 0xc1, 0xea, 0xa9, 0x97, 0x07,
0x34, 0xcb, 0xc2, 0x26, 0x2a, 0x08, 0xd5, 0x37, 0x9b, 0x2d, 0x7a, 0x14, 0xb3, 0xe3, 0xf0, 0x67, 0xff, 0x01, 0xf2, 0x16, 0x61, 0x45, 0x6d, 0xa3, 0xa1, 0x9a, 0x26, 0x31, 0x50, 0x41, 0xa8, 0xbe,
0x69, 0x65, 0x64, 0xad, 0x0e, 0xf2, 0x8e, 0x63, 0x1f, 0x1e, 0x75, 0xea, 0x8d, 0x57, 0x40, 0x0e, 0xd9, 0x6c, 0xb1, 0xa3, 0x98, 0x1d, 0x87, 0x3f, 0x4c, 0xe3, 0x91, 0xb5, 0x3a, 0xc8, 0x3b, 0xb6,
0x16, 0x52, 0x27, 0x2e, 0x71, 0x35, 0x26, 0xa9, 0x8f, 0xd7, 0x61, 0xca, 0xc8, 0xfa, 0xfa, 0x6b, 0x75, 0x78, 0xd4, 0xa9, 0x37, 0xfe, 0x05, 0x72, 0xb0, 0x90, 0x3a, 0x71, 0x89, 0xab, 0x31, 0x49,
0xb7, 0xeb, 0x06, 0x6d, 0xb4, 0xab, 0xae, 0x8d, 0xd5, 0xe7, 0x86, 0x69, 0x1a, 0xcf, 0x29, 0xae, 0x7d, 0xbc, 0x0e, 0xc3, 0x23, 0xeb, 0xeb, 0xff, 0xb9, 0x5d, 0xd7, 0x59, 0xa3, 0x5d, 0x75, 0x6c,
0x35, 0x56, 0xf9, 0xb4, 0x9b, 0xba, 0x41, 0xa8, 0x63, 0x54, 0xdb, 0x14, 0xeb, 0xab, 0x86, 0x45, 0xac, 0x3e, 0xd7, 0x0d, 0x43, 0x7f, 0xce, 0x48, 0xad, 0xb1, 0xea, 0x4e, 0xbb, 0xa9, 0xe9, 0x94,
0xb1, 0x63, 0x69, 0xe6, 0x2a, 0x33, 0xec, 0x69, 0xb4, 0xaa, 0xd5, 0x34, 0x1b, 0xdf, 0xfa, 0x25, 0xd9, 0x7a, 0xb5, 0xcd, 0x88, 0xb6, 0xaa, 0x9b, 0x8c, 0xd8, 0xa6, 0x6a, 0xac, 0x72, 0xc3, 0x9e,
0x00, 0x00, 0xff, 0xff, 0x47, 0x3b, 0x71, 0x2a, 0xbd, 0x21, 0x00, 0x00, 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. // Reference imports to suppress errors if they are not otherwise used.

5
internal/proxynode/condition.go
View File

@ -9,6 +9,7 @@ import (
type Condition interface { type Condition interface {
WaitToFinish() error WaitToFinish() error
Notify(err error) Notify(err error)
Ctx() context.Context
} }
type TaskCondition struct { type TaskCondition struct {
@ -31,6 +32,10 @@ func (tc *TaskCondition) Notify(err error) {
tc.done <- err tc.done <- err
} }
func (tc *TaskCondition) Ctx() context.Context {
return tc.ctx
}
func NewTaskCondition(ctx context.Context) *TaskCondition { func NewTaskCondition(ctx context.Context) *TaskCondition {
return &TaskCondition{ return &TaskCondition{
done: make(chan error), done: make(chan error),

123
internal/proxynode/grpc_service.go
View File

@ -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
//}

298
internal/proxynode/impl.go
View File

@ -6,11 +6,9 @@ import (
"strconv" "strconv"
"time" "time"
"github.com/opentracing/opentracing-go"
"github.com/zilliztech/milvus-distributed/internal/msgstream" "github.com/zilliztech/milvus-distributed/internal/msgstream"
"github.com/zilliztech/milvus-distributed/internal/proto/internalpb2" "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/commonpb"
"github.com/zilliztech/milvus-distributed/internal/proto/milvuspb" "github.com/zilliztech/milvus-distributed/internal/proto/milvuspb"
"github.com/zilliztech/milvus-distributed/internal/proto/proxypb" "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) { func (node *NodeImpl) CreateCollection(request *milvuspb.CreateCollectionRequest) (*commonpb.Status, error) {
log.Println("create collection: ", request) log.Println("create collection: ", request)
ctx := context.Background() ctx, cancel := context.WithTimeout(context.Background(), reqTimeoutInterval)
defer cancel()
cct := &CreateCollectionTask{ cct := &CreateCollectionTask{
Condition: NewTaskCondition(ctx), Condition: NewTaskCondition(ctx),
CreateCollectionRequest: request, CreateCollectionRequest: request,
masterClient: node.masterClient, masterClient: node.masterClient,
dataServiceClient: node.dataServiceClient, dataServiceClient: node.dataServiceClient,
} }
var cancel func()
cct.ctx, cancel = context.WithTimeout(ctx, reqTimeoutInterval)
defer cancel()
fn := func() error { err := node.sched.DdQueue.Enqueue(cct)
select {
case <-ctx.Done():
return errors.New("create collection timeout")
default:
return node.sched.DdQueue.Enqueue(cct)
}
}
err := fn()
if err != nil { if err != nil {
return &commonpb.Status{ return &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UNEXPECTED_ERROR, 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) { func (node *NodeImpl) DropCollection(request *milvuspb.DropCollectionRequest) (*commonpb.Status, error) {
log.Println("drop collection: ", request) log.Println("drop collection: ", request)
ctx := context.Background() ctx, cancel := context.WithTimeout(context.Background(), reqTimeoutInterval)
defer cancel()
dct := &DropCollectionTask{ dct := &DropCollectionTask{
Condition: NewTaskCondition(ctx), Condition: NewTaskCondition(ctx),
DropCollectionRequest: request, DropCollectionRequest: request,
masterClient: node.masterClient, masterClient: node.masterClient,
} }
var cancel func()
dct.ctx, cancel = context.WithTimeout(ctx, reqTimeoutInterval)
defer cancel()
fn := func() error { err := node.sched.DdQueue.Enqueue(dct)
select {
case <-ctx.Done():
return errors.New("create collection timeout")
default:
return node.sched.DdQueue.Enqueue(dct)
}
}
err := fn()
if err != nil { if err != nil {
return &commonpb.Status{ return &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UNEXPECTED_ERROR, 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) { func (node *NodeImpl) HasCollection(request *milvuspb.HasCollectionRequest) (*milvuspb.BoolResponse, error) {
log.Println("has collection: ", request) log.Println("has collection: ", request)
ctx := context.Background() ctx, cancel := context.WithTimeout(context.Background(), reqTimeoutInterval)
defer cancel()
hct := &HasCollectionTask{ hct := &HasCollectionTask{
Condition: NewTaskCondition(ctx), Condition: NewTaskCondition(ctx),
HasCollectionRequest: request, HasCollectionRequest: request,
masterClient: node.masterClient, masterClient: node.masterClient,
} }
var cancel func()
hct.ctx, cancel = context.WithTimeout(ctx, reqTimeoutInterval)
defer cancel()
fn := func() error { err := node.sched.DdQueue.Enqueue(hct)
select {
case <-ctx.Done():
return errors.New("create collection timeout")
default:
return node.sched.DdQueue.Enqueue(hct)
}
}
err := fn()
if err != nil { if err != nil {
return &milvuspb.BoolResponse{ return &milvuspb.BoolResponse{
Status: &commonpb.Status{ Status: &commonpb.Status{
@ -165,25 +136,16 @@ func (node *NodeImpl) ReleaseCollection(request *milvuspb.ReleaseCollectionReque
func (node *NodeImpl) DescribeCollection(request *milvuspb.DescribeCollectionRequest) (*milvuspb.DescribeCollectionResponse, error) { func (node *NodeImpl) DescribeCollection(request *milvuspb.DescribeCollectionRequest) (*milvuspb.DescribeCollectionResponse, error) {
log.Println("describe collection: ", request) log.Println("describe collection: ", request)
ctx := context.Background() ctx, cancel := context.WithTimeout(context.Background(), reqTimeoutInterval)
defer cancel()
dct := &DescribeCollectionTask{ dct := &DescribeCollectionTask{
Condition: NewTaskCondition(ctx), Condition: NewTaskCondition(ctx),
DescribeCollectionRequest: request, DescribeCollectionRequest: request,
masterClient: node.masterClient, masterClient: node.masterClient,
} }
var cancel func()
dct.ctx, cancel = context.WithTimeout(ctx, reqTimeoutInterval)
defer cancel()
fn := func() error { err := node.sched.DdQueue.Enqueue(dct)
select {
case <-ctx.Done():
return errors.New("create collection timeout")
default:
return node.sched.DdQueue.Enqueue(dct)
}
}
err := fn()
if err != nil { if err != nil {
return &milvuspb.DescribeCollectionResponse{ return &milvuspb.DescribeCollectionResponse{
Status: &commonpb.Status{ Status: &commonpb.Status{
@ -208,25 +170,15 @@ func (node *NodeImpl) DescribeCollection(request *milvuspb.DescribeCollectionReq
func (node *NodeImpl) GetCollectionStatistics(request *milvuspb.CollectionStatsRequest) (*milvuspb.CollectionStatsResponse, error) { func (node *NodeImpl) GetCollectionStatistics(request *milvuspb.CollectionStatsRequest) (*milvuspb.CollectionStatsResponse, error) {
log.Println("get collection statistics") log.Println("get collection statistics")
ctx := context.Background() ctx, cancel := context.WithTimeout(context.Background(), reqTimeoutInterval)
defer cancel()
g := &GetCollectionsStatisticsTask{ g := &GetCollectionsStatisticsTask{
Condition: NewTaskCondition(ctx), Condition: NewTaskCondition(ctx),
CollectionStatsRequest: request, CollectionStatsRequest: request,
dataServiceClient: node.dataServiceClient, dataServiceClient: node.dataServiceClient,
} }
var cancel func()
g.ctx, cancel = context.WithTimeout(ctx, reqTimeoutInterval)
defer cancel()
fn := func() error { err := node.sched.DdQueue.Enqueue(g)
select {
case <-ctx.Done():
return errors.New("create collection timeout")
default:
return node.sched.DdQueue.Enqueue(g)
}
}
err := fn()
if err != nil { if err != nil {
return &milvuspb.CollectionStatsResponse{ return &milvuspb.CollectionStatsResponse{
Status: &commonpb.Status{ Status: &commonpb.Status{
@ -251,25 +203,15 @@ func (node *NodeImpl) GetCollectionStatistics(request *milvuspb.CollectionStatsR
func (node *NodeImpl) ShowCollections(request *milvuspb.ShowCollectionRequest) (*milvuspb.ShowCollectionResponse, error) { func (node *NodeImpl) ShowCollections(request *milvuspb.ShowCollectionRequest) (*milvuspb.ShowCollectionResponse, error) {
log.Println("show collections") log.Println("show collections")
ctx := context.Background() ctx, cancel := context.WithTimeout(context.Background(), reqTimeoutInterval)
defer cancel()
sct := &ShowCollectionsTask{ sct := &ShowCollectionsTask{
Condition: NewTaskCondition(ctx), Condition: NewTaskCondition(ctx),
ShowCollectionRequest: request, ShowCollectionRequest: request,
masterClient: node.masterClient, masterClient: node.masterClient,
} }
var cancel func()
sct.ctx, cancel = context.WithTimeout(ctx, reqTimeoutInterval)
defer cancel()
fn := func() error { err := node.sched.DdQueue.Enqueue(sct)
select {
case <-ctx.Done():
return errors.New("create collection timeout")
default:
return node.sched.DdQueue.Enqueue(sct)
}
}
err := fn()
if err != nil { if err != nil {
return &milvuspb.ShowCollectionResponse{ return &milvuspb.ShowCollectionResponse{
Status: &commonpb.Status{ Status: &commonpb.Status{
@ -294,27 +236,16 @@ func (node *NodeImpl) ShowCollections(request *milvuspb.ShowCollectionRequest) (
func (node *NodeImpl) CreatePartition(request *milvuspb.CreatePartitionRequest) (*commonpb.Status, error) { func (node *NodeImpl) CreatePartition(request *milvuspb.CreatePartitionRequest) (*commonpb.Status, error) {
log.Println("create partition", request) log.Println("create partition", request)
ctx := context.Background() ctx, cancel := context.WithTimeout(context.Background(), reqTimeoutInterval)
defer cancel()
cpt := &CreatePartitionTask{ cpt := &CreatePartitionTask{
Condition: NewTaskCondition(ctx), Condition: NewTaskCondition(ctx),
CreatePartitionRequest: request, CreatePartitionRequest: request,
masterClient: node.masterClient, masterClient: node.masterClient,
result: nil, 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 { if err != nil {
return &commonpb.Status{ return &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UNEXPECTED_ERROR, 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) { func (node *NodeImpl) DropPartition(request *milvuspb.DropPartitionRequest) (*commonpb.Status, error) {
log.Println("drop partition: ", request) log.Println("drop partition: ", request)
ctx := context.Background() ctx, cancel := context.WithTimeout(context.Background(), reqTimeoutInterval)
defer cancel()
dpt := &DropPartitionTask{ dpt := &DropPartitionTask{
Condition: NewTaskCondition(ctx), Condition: NewTaskCondition(ctx),
DropPartitionRequest: request, DropPartitionRequest: request,
masterClient: node.masterClient, masterClient: node.masterClient,
result: nil, result: nil,
ctx: nil,
} }
var cancel func() err := node.sched.DdQueue.Enqueue(dpt)
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)
}
}()
if err != nil { if err != nil {
return &commonpb.Status{ 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) { func (node *NodeImpl) HasPartition(request *milvuspb.HasPartitionRequest) (*milvuspb.BoolResponse, error) {
log.Println("has partition: ", request) log.Println("has partition: ", request)
ctx := context.Background() ctx, cancel := context.WithTimeout(context.Background(), reqTimeoutInterval)
defer cancel()
hpt := &HasPartitionTask{ hpt := &HasPartitionTask{
Condition: NewTaskCondition(ctx), Condition: NewTaskCondition(ctx),
HasPartitionRequest: request, HasPartitionRequest: request,
masterClient: node.masterClient, masterClient: node.masterClient,
result: nil, result: nil,
ctx: nil,
} }
var cancel func() err := node.sched.DdQueue.Enqueue(hpt)
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)
}
}()
if err != nil { if err != nil {
return &milvuspb.BoolResponse{ return &milvuspb.BoolResponse{
@ -431,27 +340,16 @@ func (node *NodeImpl) GetPartitionStatistics(request *milvuspb.PartitionStatsReq
func (node *NodeImpl) ShowPartitions(request *milvuspb.ShowPartitionRequest) (*milvuspb.ShowPartitionResponse, error) { func (node *NodeImpl) ShowPartitions(request *milvuspb.ShowPartitionRequest) (*milvuspb.ShowPartitionResponse, error) {
log.Println("show partitions: ", request) log.Println("show partitions: ", request)
ctx := context.Background() ctx, cancel := context.WithTimeout(context.Background(), reqTimeoutInterval)
defer cancel()
spt := &ShowPartitionsTask{ spt := &ShowPartitionsTask{
Condition: NewTaskCondition(ctx), Condition: NewTaskCondition(ctx),
ShowPartitionRequest: request, ShowPartitionRequest: request,
masterClient: node.masterClient, masterClient: node.masterClient,
result: nil, result: nil,
ctx: nil,
} }
var cancel func() err := node.sched.DdQueue.Enqueue(spt)
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)
}
}()
if err != nil { if err != nil {
return &milvuspb.ShowPartitionResponse{ 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) { func (node *NodeImpl) CreateIndex(request *milvuspb.CreateIndexRequest) (*commonpb.Status, error) {
log.Println("create index for: ", request) log.Println("create index for: ", request)
ctx := context.Background() ctx, cancel := context.WithTimeout(context.Background(), reqTimeoutInterval)
defer cancel()
cit := &CreateIndexTask{ cit := &CreateIndexTask{
Condition: NewTaskCondition(ctx), Condition: NewTaskCondition(ctx),
CreateIndexRequest: request, CreateIndexRequest: request,
masterClient: node.masterClient, masterClient: node.masterClient,
} }
var cancel func() err := node.sched.DdQueue.Enqueue(cit)
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()
if err != nil { if err != nil {
return &commonpb.Status{ return &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UNEXPECTED_ERROR, 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) { func (node *NodeImpl) DescribeIndex(request *milvuspb.DescribeIndexRequest) (*milvuspb.DescribeIndexResponse, error) {
log.Println("Describe index for: ", request) log.Println("Describe index for: ", request)
ctx := context.Background() ctx, cancel := context.WithTimeout(context.Background(), reqTimeoutInterval)
defer cancel()
dit := &DescribeIndexTask{ dit := &DescribeIndexTask{
Condition: NewTaskCondition(ctx), Condition: NewTaskCondition(ctx),
DescribeIndexRequest: request, DescribeIndexRequest: request,
masterClient: node.masterClient, masterClient: node.masterClient,
} }
var cancel func() err := node.sched.DdQueue.Enqueue(dit)
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()
if err != nil { if err != nil {
return &milvuspb.DescribeIndexResponse{ return &milvuspb.DescribeIndexResponse{
Status: &commonpb.Status{ 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) { func (node *NodeImpl) GetIndexState(request *milvuspb.IndexStateRequest) (*milvuspb.IndexStateResponse, error) {
// log.Println("Describe index progress for: ", request) // log.Println("Describe index progress for: ", request)
ctx := context.Background() ctx, cancel := context.WithTimeout(context.Background(), reqTimeoutInterval)
defer cancel()
dipt := &GetIndexStateTask{ dipt := &GetIndexStateTask{
Condition: NewTaskCondition(ctx), Condition: NewTaskCondition(ctx),
IndexStateRequest: request, IndexStateRequest: request,
} }
var cancel func() err := node.sched.DdQueue.Enqueue(dipt)
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 { if err != nil {
return &milvuspb.IndexStateResponse{ return &milvuspb.IndexStateResponse{
Status: &commonpb.Status{ 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) { func (node *NodeImpl) Insert(request *milvuspb.InsertRequest) (*milvuspb.InsertResponse, error) {
ctx := context.Background() ctx, cancel := context.WithTimeout(context.Background(), reqTimeoutInterval)
span, ctx := opentracing.StartSpanFromContext(ctx, "insert grpc received") defer cancel()
defer span.Finish()
span.SetTag("collection name", request.CollectionName)
span.SetTag("partition tag", request.PartitionName)
log.Println("insert into: ", request.CollectionName)
it := &InsertTask{ it := &InsertTask{
ctx: ctx,
Condition: NewTaskCondition(ctx), Condition: NewTaskCondition(ctx),
dataServiceClient: node.dataServiceClient, dataServiceClient: node.dataServiceClient,
BaseInsertTask: BaseInsertTask{ BaseInsertTask: BaseInsertTask{
@ -632,20 +493,7 @@ func (node *NodeImpl) Insert(request *milvuspb.InsertRequest) (*milvuspb.InsertR
it.PartitionName = Params.DefaultPartitionTag it.PartitionName = Params.DefaultPartitionTag
} }
var cancel func() err := node.sched.DmQueue.Enqueue(it)
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()
if err != nil { if err != nil {
return &milvuspb.InsertResponse{ 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) { func (node *NodeImpl) Search(request *milvuspb.SearchRequest) (*milvuspb.SearchResults, error) {
ctx := context.Background() ctx, cancel := context.WithTimeout(context.Background(), reqTimeoutInterval)
span, ctx := opentracing.StartSpanFromContext(ctx, "search grpc received") defer cancel()
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)
qt := &SearchTask{ qt := &SearchTask{
ctx: ctx,
Condition: NewTaskCondition(ctx), Condition: NewTaskCondition(ctx),
SearchRequest: internalpb2.SearchRequest{ SearchRequest: internalpb2.SearchRequest{
Base: &commonpb.MsgBase{ Base: &commonpb.MsgBase{
@ -691,20 +534,8 @@ func (node *NodeImpl) Search(request *milvuspb.SearchRequest) (*milvuspb.SearchR
resultBuf: make(chan []*internalpb2.SearchResults), resultBuf: make(chan []*internalpb2.SearchResults),
query: request, 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 { err := node.sched.DqQueue.Enqueue(qt)
select {
case <-ctx.Done():
return errors.New("create collection timeout")
default:
return node.sched.DqQueue.Enqueue(qt)
}
}
err := fn()
if err != nil { if err != nil {
return &milvuspb.SearchResults{ return &milvuspb.SearchResults{
Status: &commonpb.Status{ 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) { 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) { func (node *NodeImpl) GetDdChannel(request *commonpb.Empty) (*milvuspb.StringResponse, error) {

175
internal/proxynode/task.go
View File

@ -1,7 +1,6 @@
package proxynode package proxynode
import ( import (
"context"
"errors" "errors"
"log" "log"
"math" "math"
@ -9,9 +8,6 @@ import (
"github.com/zilliztech/milvus-distributed/internal/proto/datapb" "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/golang/protobuf/proto"
"github.com/zilliztech/milvus-distributed/internal/allocator" "github.com/zilliztech/milvus-distributed/internal/allocator"
"github.com/zilliztech/milvus-distributed/internal/msgstream" "github.com/zilliztech/milvus-distributed/internal/msgstream"
@ -45,7 +41,6 @@ type InsertTask struct {
Condition Condition
dataServiceClient DataServiceClient dataServiceClient DataServiceClient
result *milvuspb.InsertResponse result *milvuspb.InsertResponse
ctx context.Context
rowIDAllocator *allocator.IDAllocator rowIDAllocator *allocator.IDAllocator
} }
@ -87,21 +82,12 @@ func (it *InsertTask) PreExecute() error {
it.Base.MsgType = commonpb.MsgType_kInsert it.Base.MsgType = commonpb.MsgType_kInsert
it.Base.SourceID = Params.ProxyID 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 collectionName := it.BaseInsertTask.CollectionName
if err := ValidateCollectionName(collectionName); err != nil { if err := ValidateCollectionName(collectionName); err != nil {
span.LogFields(oplog.Error(err))
span.Finish()
return err return err
} }
partitionTag := it.BaseInsertTask.PartitionName partitionTag := it.BaseInsertTask.PartitionName
if err := ValidatePartitionTag(partitionTag, true); err != nil { if err := ValidatePartitionTag(partitionTag, true); err != nil {
span.LogFields(oplog.Error(err))
span.Finish()
return err return err
} }
@ -109,13 +95,7 @@ func (it *InsertTask) PreExecute() error {
} }
func (it *InsertTask) Execute() 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 collectionName := it.BaseInsertTask.CollectionName
span.LogFields(oplog.String("collection_name", collectionName))
collSchema, err := globalMetaCache.GetCollectionSchema(collectionName) collSchema, err := globalMetaCache.GetCollectionSchema(collectionName)
if err != nil { if err != nil {
return err return err
@ -131,14 +111,11 @@ func (it *InsertTask) Execute() error {
return err return err
} }
it.PartitionID = partitionID it.PartitionID = partitionID
span.LogFields(oplog.Bool("auto_id", autoID))
var rowIDBegin UniqueID var rowIDBegin UniqueID
var rowIDEnd UniqueID var rowIDEnd UniqueID
rowNums := len(it.BaseInsertTask.RowData) rowNums := len(it.BaseInsertTask.RowData)
rowIDBegin, rowIDEnd, _ = it.rowIDAllocator.Alloc(uint32(rowNums)) 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) it.BaseInsertTask.RowIDs = make([]UniqueID, rowNums)
for i := rowIDBegin; i < rowIDEnd; i++ { for i := rowIDBegin; i < rowIDEnd; i++ {
offset := i - rowIDBegin offset := i - rowIDBegin
@ -161,8 +138,7 @@ func (it *InsertTask) Execute() error {
EndTs: it.EndTs(), EndTs: it.EndTs(),
Msgs: make([]msgstream.TsMsg, 1), Msgs: make([]msgstream.TsMsg, 1),
} }
tsMsg.SetMsgContext(ctx) tsMsg.SetMsgContext(it.Ctx())
span.LogFields(oplog.String("send msg", "send msg"))
it.result = &milvuspb.InsertResponse{ it.result = &milvuspb.InsertResponse{
Status: &commonpb.Status{ Status: &commonpb.Status{
@ -198,7 +174,6 @@ func (it *InsertTask) Execute() error {
if err != nil { if err != nil {
it.result.Status.ErrorCode = commonpb.ErrorCode_UNEXPECTED_ERROR it.result.Status.ErrorCode = commonpb.ErrorCode_UNEXPECTED_ERROR
it.result.Status.Reason = err.Error() it.result.Status.Reason = err.Error()
span.LogFields(oplog.Error(err))
return err return err
} }
@ -206,7 +181,6 @@ func (it *InsertTask) Execute() error {
if err != nil { if err != nil {
it.result.Status.ErrorCode = commonpb.ErrorCode_UNEXPECTED_ERROR it.result.Status.ErrorCode = commonpb.ErrorCode_UNEXPECTED_ERROR
it.result.Status.Reason = err.Error() it.result.Status.Reason = err.Error()
span.LogFields(oplog.Error(err))
return err return err
} }
@ -214,8 +188,6 @@ func (it *InsertTask) Execute() error {
} }
func (it *InsertTask) PostExecute() error { func (it *InsertTask) PostExecute() error {
span, _ := opentracing.StartSpanFromContext(it.ctx, "InsertTask postExecute")
defer span.Finish()
return nil return nil
} }
@ -225,7 +197,6 @@ type CreateCollectionTask struct {
masterClient MasterClient masterClient MasterClient
dataServiceClient DataServiceClient dataServiceClient DataServiceClient
result *commonpb.Status result *commonpb.Status
ctx context.Context
schema *schemapb.CollectionSchema schema *schemapb.CollectionSchema
} }
@ -366,7 +337,6 @@ type DropCollectionTask struct {
*milvuspb.DropCollectionRequest *milvuspb.DropCollectionRequest
masterClient MasterClient masterClient MasterClient
result *commonpb.Status result *commonpb.Status
ctx context.Context
} }
func (dct *DropCollectionTask) OnEnqueue() error { func (dct *DropCollectionTask) OnEnqueue() error {
@ -435,7 +405,6 @@ type SearchTask struct {
queryMsgStream *pulsarms.PulsarMsgStream queryMsgStream *pulsarms.PulsarMsgStream
resultBuf chan []*internalpb2.SearchResults resultBuf chan []*internalpb2.SearchResults
result *milvuspb.SearchResults result *milvuspb.SearchResults
ctx context.Context
query *milvuspb.SearchRequest query *milvuspb.SearchRequest
} }
@ -471,38 +440,24 @@ func (st *SearchTask) PreExecute() error {
st.Base.MsgType = commonpb.MsgType_kSearch st.Base.MsgType = commonpb.MsgType_kSearch
st.Base.SourceID = Params.ProxyID 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 collectionName := st.query.CollectionName
_, err := globalMetaCache.GetCollectionID(collectionName) _, err := globalMetaCache.GetCollectionID(collectionName)
if err != nil { // err is not nil if collection not exists if err != nil { // err is not nil if collection not exists
span.LogFields(oplog.Error(err))
span.Finish()
return err return err
} }
if err := ValidateCollectionName(st.query.CollectionName); err != nil { if err := ValidateCollectionName(st.query.CollectionName); err != nil {
span.LogFields(oplog.Error(err))
span.Finish()
return err return err
} }
for _, tag := range st.query.PartitionNames { for _, tag := range st.query.PartitionNames {
if err := ValidatePartitionTag(tag, false); err != nil { if err := ValidatePartitionTag(tag, false); err != nil {
span.LogFields(oplog.Error(err))
span.Finish()
return err return err
} }
} }
st.Base.MsgType = commonpb.MsgType_kSearch st.Base.MsgType = commonpb.MsgType_kSearch
queryBytes, err := proto.Marshal(st.query) queryBytes, err := proto.Marshal(st.query)
if err != nil { if err != nil {
span.LogFields(oplog.Error(err))
span.Finish()
return err return err
} }
st.Query = &commonpb.Blob{ st.Query = &commonpb.Blob{
@ -512,11 +467,6 @@ func (st *SearchTask) PreExecute() error {
} }
func (st *SearchTask) Execute() 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{ var tsMsg msgstream.TsMsg = &msgstream.SearchMsg{
SearchRequest: st.SearchRequest, SearchRequest: st.SearchRequest,
BaseMsg: msgstream.BaseMsg{ BaseMsg: msgstream.BaseMsg{
@ -530,32 +480,24 @@ func (st *SearchTask) Execute() error {
EndTs: st.Base.Timestamp, EndTs: st.Base.Timestamp,
Msgs: make([]msgstream.TsMsg, 1), Msgs: make([]msgstream.TsMsg, 1),
} }
tsMsg.SetMsgContext(ctx) tsMsg.SetMsgContext(st.Ctx())
msgPack.Msgs[0] = tsMsg msgPack.Msgs[0] = tsMsg
err := st.queryMsgStream.Produce(msgPack) err := st.queryMsgStream.Produce(msgPack)
log.Printf("[NodeImpl] length of searchMsg: %v", len(msgPack.Msgs)) log.Printf("[NodeImpl] length of searchMsg: %v", len(msgPack.Msgs))
if err != nil { if err != nil {
span.LogFields(oplog.Error(err))
span.Finish()
log.Printf("[NodeImpl] send search request failed: %v", err) log.Printf("[NodeImpl] send search request failed: %v", err)
} }
return err return err
} }
func (st *SearchTask) PostExecute() error { 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 { for {
select { select {
case <-st.ctx.Done(): case <-st.Ctx().Done():
log.Print("SearchTask: wait to finish failed, timeout!, taskID:", st.ID()) 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)) return errors.New("SearchTask:wait to finish failed, timeout:" + strconv.FormatInt(st.ID(), 10))
case searchResults := <-st.resultBuf: case searchResults := <-st.resultBuf:
// fmt.Println("searchResults: ", searchResults) // fmt.Println("searchResults: ", searchResults)
span.LogFields(oplog.String("receive result", "receive result"))
filterSearchResult := make([]*internalpb2.SearchResults, 0) filterSearchResult := make([]*internalpb2.SearchResults, 0)
var filterReason string var filterReason string
for _, partialSearchResult := range searchResults { for _, partialSearchResult := range searchResults {
@ -584,7 +526,6 @@ func (st *SearchTask) PostExecute() error {
Reason: filterReason, Reason: filterReason,
}, },
} }
span.LogFields(oplog.Error(errors.New(filterReason)))
return errors.New(filterReason) return errors.New(filterReason)
} }
@ -693,7 +634,6 @@ func (st *SearchTask) PostExecute() error {
reducedHitsBs, err := proto.Marshal(reducedHits) reducedHitsBs, err := proto.Marshal(reducedHits)
if err != nil { if err != nil {
log.Println("marshal error") log.Println("marshal error")
span.LogFields(oplog.Error(err))
return err return err
} }
st.result.Hits = append(st.result.Hits, reducedHitsBs) st.result.Hits = append(st.result.Hits, reducedHitsBs)
@ -708,7 +648,6 @@ type HasCollectionTask struct {
*milvuspb.HasCollectionRequest *milvuspb.HasCollectionRequest
masterClient MasterClient masterClient MasterClient
result *milvuspb.BoolResponse result *milvuspb.BoolResponse
ctx context.Context
} }
func (hct *HasCollectionTask) OnEnqueue() error { func (hct *HasCollectionTask) OnEnqueue() error {
@ -765,7 +704,6 @@ type DescribeCollectionTask struct {
*milvuspb.DescribeCollectionRequest *milvuspb.DescribeCollectionRequest
masterClient MasterClient masterClient MasterClient
result *milvuspb.DescribeCollectionResponse result *milvuspb.DescribeCollectionResponse
ctx context.Context
} }
func (dct *DescribeCollectionTask) OnEnqueue() error { func (dct *DescribeCollectionTask) OnEnqueue() error {
@ -825,7 +763,6 @@ type GetCollectionsStatisticsTask struct {
*milvuspb.CollectionStatsRequest *milvuspb.CollectionStatsRequest
dataServiceClient DataServiceClient dataServiceClient DataServiceClient
result *milvuspb.CollectionStatsResponse result *milvuspb.CollectionStatsResponse
ctx context.Context
} }
func (g *GetCollectionsStatisticsTask) ID() UniqueID { func (g *GetCollectionsStatisticsTask) ID() UniqueID {
@ -901,7 +838,6 @@ type ShowCollectionsTask struct {
*milvuspb.ShowCollectionRequest *milvuspb.ShowCollectionRequest
masterClient MasterClient masterClient MasterClient
result *milvuspb.ShowCollectionResponse result *milvuspb.ShowCollectionResponse
ctx context.Context
} }
func (sct *ShowCollectionsTask) OnEnqueue() error { func (sct *ShowCollectionsTask) OnEnqueue() error {
@ -955,7 +891,6 @@ type CreatePartitionTask struct {
*milvuspb.CreatePartitionRequest *milvuspb.CreatePartitionRequest
masterClient MasterClient masterClient MasterClient
result *commonpb.Status result *commonpb.Status
ctx context.Context
} }
func (cpt *CreatePartitionTask) OnEnqueue() error { func (cpt *CreatePartitionTask) OnEnqueue() error {
@ -1018,7 +953,6 @@ type DropPartitionTask struct {
*milvuspb.DropPartitionRequest *milvuspb.DropPartitionRequest
masterClient MasterClient masterClient MasterClient
result *commonpb.Status result *commonpb.Status
ctx context.Context
} }
func (dpt *DropPartitionTask) OnEnqueue() error { func (dpt *DropPartitionTask) OnEnqueue() error {
@ -1081,7 +1015,6 @@ type HasPartitionTask struct {
*milvuspb.HasPartitionRequest *milvuspb.HasPartitionRequest
masterClient MasterClient masterClient MasterClient
result *milvuspb.BoolResponse result *milvuspb.BoolResponse
ctx context.Context
} }
func (hpt *HasPartitionTask) OnEnqueue() error { func (hpt *HasPartitionTask) OnEnqueue() error {
@ -1138,66 +1071,11 @@ func (hpt *HasPartitionTask) PostExecute() error {
return nil 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 { type ShowPartitionsTask struct {
Condition Condition
*milvuspb.ShowPartitionRequest *milvuspb.ShowPartitionRequest
masterClient MasterClient masterClient MasterClient
result *milvuspb.ShowPartitionResponse result *milvuspb.ShowPartitionResponse
ctx context.Context
} }
func (spt *ShowPartitionsTask) OnEnqueue() error { func (spt *ShowPartitionsTask) OnEnqueue() error {
@ -1257,7 +1135,6 @@ type CreateIndexTask struct {
*milvuspb.CreateIndexRequest *milvuspb.CreateIndexRequest
masterClient MasterClient masterClient MasterClient
result *commonpb.Status result *commonpb.Status
ctx context.Context
} }
func (cit *CreateIndexTask) OnEnqueue() error { func (cit *CreateIndexTask) OnEnqueue() error {
@ -1320,7 +1197,6 @@ type DescribeIndexTask struct {
*milvuspb.DescribeIndexRequest *milvuspb.DescribeIndexRequest
masterClient MasterClient masterClient MasterClient
result *milvuspb.DescribeIndexResponse result *milvuspb.DescribeIndexResponse
ctx context.Context
} }
func (dit *DescribeIndexTask) OnEnqueue() error { func (dit *DescribeIndexTask) OnEnqueue() error {
@ -1384,7 +1260,6 @@ type GetIndexStateTask struct {
*milvuspb.IndexStateRequest *milvuspb.IndexStateRequest
indexServiceClient IndexServiceClient indexServiceClient IndexServiceClient
result *milvuspb.IndexStateResponse result *milvuspb.IndexStateResponse
ctx context.Context
} }
func (dipt *GetIndexStateTask) OnEnqueue() error { func (dipt *GetIndexStateTask) OnEnqueue() error {
@ -1457,7 +1332,6 @@ type FlushTask struct {
*milvuspb.FlushRequest *milvuspb.FlushRequest
dataServiceClient DataServiceClient dataServiceClient DataServiceClient
result *commonpb.Status result *commonpb.Status
ctx context.Context
} }
func (ft *FlushTask) OnEnqueue() error { func (ft *FlushTask) OnEnqueue() error {
@ -1496,23 +1370,34 @@ func (ft *FlushTask) PreExecute() error {
} }
func (ft *FlushTask) Execute() error { func (ft *FlushTask) Execute() error {
var err error for _, collName := range ft.CollectionNames {
collID, err := globalMetaCache.GetCollectionID(ft.CollectionName) collID, err := globalMetaCache.GetCollectionID(collName)
if err != nil { if err != nil {
return err 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{ ft.result = &commonpb.Status{
Base: &commonpb.MsgBase{ ErrorCode: commonpb.ErrorCode_SUCCESS,
MsgType: commonpb.MsgType_kFlush,
MsgID: ft.Base.MsgID,
Timestamp: ft.Base.Timestamp,
SourceID: ft.Base.SourceID,
},
DbID: 0,
CollectionID: collID,
} }
ft.result, err = ft.dataServiceClient.Flush(flushReq) return nil
return err
} }
func (ft *FlushTask) PostExecute() error { func (ft *FlushTask) PostExecute() error {