milvus-io
/
milvus
mirror of https://github.com/milvus-io/milvus.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Refactor showCollection/showPartition to get load state in memory (#6935) 

* refactor showCollection/showPartition to get load state in memory

Signed-off-by: xige-16 <xi.ge@zilliz.com>

* update proto

Signed-off-by: xige-16 <xi.ge@zilliz.com>

* update proto

Signed-off-by: xige-16 <xi.ge@zilliz.com>

* update milvus.proto

Signed-off-by: xige-16 <xi.ge@zilliz.com>

* add show result log to debug

Signed-off-by: xige-16 <xi.ge@zilliz.com>

* fix wrong err message

Signed-off-by: xige-16 <xi.ge@zilliz.com>

* update pymilvus-orm version

Signed-off-by: xige-16 <xi.ge@zilliz.com>

* fix repeated load error

Signed-off-by: xige-16 <xi.ge@zilliz.com>

* update proto

Signed-off-by: xige-16 <xi.ge@zilliz.com>

* fix status nil error

Signed-off-by: xige-16 <xi.ge@zilliz.com>
pull/6959/head
xige-16 2021-08-02 22:39:25 +08:00 committed by GitHub
parent 5c81951449
commit 87c5a49d9a
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
19 changed files with 2632 additions and 1193 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

File diff suppressed because it is too large Load Diff

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

@ -324,30 +324,30 @@ namespace milvus {
namespace proto {
namespace milvus {
enum ShowCollectionsType : int {
enum ShowType : int {
All = 0,
InMemory = 1,
ShowCollectionsType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
ShowCollectionsType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
ShowType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
ShowType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool ShowCollectionsType_IsValid(int value);
constexpr ShowCollectionsType ShowCollectionsType_MIN = All;
constexpr ShowCollectionsType ShowCollectionsType_MAX = InMemory;
constexpr int ShowCollectionsType_ARRAYSIZE = ShowCollectionsType_MAX + 1;
bool ShowType_IsValid(int value);
constexpr ShowType ShowType_MIN = All;
constexpr ShowType ShowType_MAX = InMemory;
constexpr int ShowType_ARRAYSIZE = ShowType_MAX + 1;
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ShowCollectionsType_descriptor();
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ShowType_descriptor();
template<typename T>
inline const std::string& ShowCollectionsType_Name(T enum_t_value) {
static_assert(::std::is_same<T, ShowCollectionsType>::value ||
inline const std::string& ShowType_Name(T enum_t_value) {
static_assert(::std::is_same<T, ShowType>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function ShowCollectionsType_Name.");
"Incorrect type passed to function ShowType_Name.");
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
ShowCollectionsType_descriptor(), enum_t_value);
ShowType_descriptor(), enum_t_value);
}
inline bool ShowCollectionsType_Parse(
const std::string& name, ShowCollectionsType* value) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ShowCollectionsType>(
ShowCollectionsType_descriptor(), name, value);
inline bool ShowType_Parse(
const std::string& name, ShowType* value) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ShowType>(
ShowType_descriptor(), name, value);
}
enum PlaceholderType : int {
None = 0,
@ -2289,11 +2289,29 @@ class ShowCollectionsRequest :
// accessors -------------------------------------------------------
enum : int {
kCollectionNamesFieldNumber = 5,
kDbNameFieldNumber = 2,
kBaseFieldNumber = 1,
kTimeStampFieldNumber = 3,
kTypeFieldNumber = 4,
};
// repeated string collection_names = 5;
int collection_names_size() const;
void clear_collection_names();
const std::string& collection_names(int index) const;
std::string* mutable_collection_names(int index);
void set_collection_names(int index, const std::string& value);
void set_collection_names(int index, std::string&& value);
void set_collection_names(int index, const char* value);
void set_collection_names(int index, const char* value, size_t size);
std::string* add_collection_names();
void add_collection_names(const std::string& value);
void add_collection_names(std::string&& value);
void add_collection_names(const char* value);
void add_collection_names(const char* value, size_t size);
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& collection_names() const;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_collection_names();
// string db_name = 2;
void clear_db_name();
const std::string& db_name() const;
@ -2318,16 +2336,17 @@ class ShowCollectionsRequest :
::PROTOBUF_NAMESPACE_ID::uint64 time_stamp() const;
void set_time_stamp(::PROTOBUF_NAMESPACE_ID::uint64 value);
// .milvus.proto.milvus.ShowCollectionsType type = 4;
// .milvus.proto.milvus.ShowType type = 4;
void clear_type();
::milvus::proto::milvus::ShowCollectionsType type() const;
void set_type(::milvus::proto::milvus::ShowCollectionsType value);
::milvus::proto::milvus::ShowType type() const;
void set_type(::milvus::proto::milvus::ShowType value);
// @@protoc_insertion_point(class_scope:milvus.proto.milvus.ShowCollectionsRequest)
private:
class _Internal;
::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> collection_names_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr db_name_;
::milvus::proto::common::MsgBase* base_;
::PROTOBUF_NAMESPACE_ID::uint64 time_stamp_;
@ -2454,6 +2473,7 @@ class ShowCollectionsResponse :
kCollectionIdsFieldNumber = 3,
kCreatedTimestampsFieldNumber = 4,
kCreatedUtcTimestampsFieldNumber = 5,
kInMemoryPercentagesFieldNumber = 6,
kStatusFieldNumber = 1,
};
// repeated string collection_names = 2;
@ -2506,6 +2526,17 @@ class ShowCollectionsResponse :
::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint64 >*
mutable_created_utc_timestamps();
// repeated int64 inMemory_percentages = 6;
int inmemory_percentages_size() const;
void clear_inmemory_percentages();
::PROTOBUF_NAMESPACE_ID::int64 inmemory_percentages(int index) const;
void set_inmemory_percentages(int index, ::PROTOBUF_NAMESPACE_ID::int64 value);
void add_inmemory_percentages(::PROTOBUF_NAMESPACE_ID::int64 value);
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
inmemory_percentages() const;
::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
mutable_inmemory_percentages();
// .milvus.proto.common.Status status = 1;
bool has_status() const;
void clear_status();
@ -2526,6 +2557,8 @@ class ShowCollectionsResponse :
mutable std::atomic<int> _created_timestamps_cached_byte_size_;
::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint64 > created_utc_timestamps_;
mutable std::atomic<int> _created_utc_timestamps_cached_byte_size_;
::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > inmemory_percentages_;
mutable std::atomic<int> _inmemory_percentages_cached_byte_size_;
::milvus::proto::common::Status* status_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
friend struct ::TableStruct_milvus_2eproto;
@ -3842,11 +3875,30 @@ class ShowPartitionsRequest :
// accessors -------------------------------------------------------
enum : int {
kPartitionNamesFieldNumber = 5,
kDbNameFieldNumber = 2,
kCollectionNameFieldNumber = 3,
kBaseFieldNumber = 1,
kCollectionIDFieldNumber = 4,
kTypeFieldNumber = 6,
};
// repeated string partition_names = 5;
int partition_names_size() const;
void clear_partition_names();
const std::string& partition_names(int index) const;
std::string* mutable_partition_names(int index);
void set_partition_names(int index, const std::string& value);
void set_partition_names(int index, std::string&& value);
void set_partition_names(int index, const char* value);
void set_partition_names(int index, const char* value, size_t size);
std::string* add_partition_names();
void add_partition_names(const std::string& value);
void add_partition_names(std::string&& value);
void add_partition_names(const char* value);
void add_partition_names(const char* value, size_t size);
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& partition_names() const;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_partition_names();
// string db_name = 2;
void clear_db_name();
const std::string& db_name() const;
@ -3882,15 +3934,22 @@ class ShowPartitionsRequest :
::PROTOBUF_NAMESPACE_ID::int64 collectionid() const;
void set_collectionid(::PROTOBUF_NAMESPACE_ID::int64 value);
// .milvus.proto.milvus.ShowType type = 6;
void clear_type();
::milvus::proto::milvus::ShowType type() const;
void set_type(::milvus::proto::milvus::ShowType value);
// @@protoc_insertion_point(class_scope:milvus.proto.milvus.ShowPartitionsRequest)
private:
class _Internal;
::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> partition_names_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr db_name_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_;
::milvus::proto::common::MsgBase* base_;
::PROTOBUF_NAMESPACE_ID::int64 collectionid_;
int type_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
friend struct ::TableStruct_milvus_2eproto;
};
@ -4013,6 +4072,7 @@ class ShowPartitionsResponse :
kPartitionIDsFieldNumber = 3,
kCreatedTimestampsFieldNumber = 4,
kCreatedUtcTimestampsFieldNumber = 5,
kInMemoryPercentagesFieldNumber = 6,
kStatusFieldNumber = 1,
};
// repeated string partition_names = 2;
@ -4065,6 +4125,17 @@ class ShowPartitionsResponse :
::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint64 >*
mutable_created_utc_timestamps();
// repeated int64 inMemory_percentages = 6;
int inmemory_percentages_size() const;
void clear_inmemory_percentages();
::PROTOBUF_NAMESPACE_ID::int64 inmemory_percentages(int index) const;
void set_inmemory_percentages(int index, ::PROTOBUF_NAMESPACE_ID::int64 value);
void add_inmemory_percentages(::PROTOBUF_NAMESPACE_ID::int64 value);
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
inmemory_percentages() const;
::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
mutable_inmemory_percentages();
// .milvus.proto.common.Status status = 1;
bool has_status() const;
void clear_status();
@ -4085,6 +4156,8 @@ class ShowPartitionsResponse :
mutable std::atomic<int> _created_timestamps_cached_byte_size_;
::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint64 > created_utc_timestamps_;
mutable std::atomic<int> _created_utc_timestamps_cached_byte_size_;
::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > inmemory_percentages_;
mutable std::atomic<int> _inmemory_percentages_cached_byte_size_;
::milvus::proto::common::Status* status_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
friend struct ::TableStruct_milvus_2eproto;
@ -12584,20 +12657,85 @@ inline void ShowCollectionsRequest::set_time_stamp(::PROTOBUF_NAMESPACE_ID::uint
// @@protoc_insertion_point(field_set:milvus.proto.milvus.ShowCollectionsRequest.time_stamp)
}
// .milvus.proto.milvus.ShowCollectionsType type = 4;
// .milvus.proto.milvus.ShowType type = 4;
inline void ShowCollectionsRequest::clear_type() {
type_ = 0;
}
inline ::milvus::proto::milvus::ShowCollectionsType ShowCollectionsRequest::type() const {
inline ::milvus::proto::milvus::ShowType ShowCollectionsRequest::type() const {
// @@protoc_insertion_point(field_get:milvus.proto.milvus.ShowCollectionsRequest.type)
return static_cast< ::milvus::proto::milvus::ShowCollectionsType >(type_);
return static_cast< ::milvus::proto::milvus::ShowType >(type_);
}
inline void ShowCollectionsRequest::set_type(::milvus::proto::milvus::ShowCollectionsType value) {
inline void ShowCollectionsRequest::set_type(::milvus::proto::milvus::ShowType value) {
type_ = value;
// @@protoc_insertion_point(field_set:milvus.proto.milvus.ShowCollectionsRequest.type)
}
// repeated string collection_names = 5;
inline int ShowCollectionsRequest::collection_names_size() const {
return collection_names_.size();
}
inline void ShowCollectionsRequest::clear_collection_names() {
collection_names_.Clear();
}
inline const std::string& ShowCollectionsRequest::collection_names(int index) const {
// @@protoc_insertion_point(field_get:milvus.proto.milvus.ShowCollectionsRequest.collection_names)
return collection_names_.Get(index);
}
inline std::string* ShowCollectionsRequest::mutable_collection_names(int index) {
// @@protoc_insertion_point(field_mutable:milvus.proto.milvus.ShowCollectionsRequest.collection_names)
return collection_names_.Mutable(index);
}
inline void ShowCollectionsRequest::set_collection_names(int index, const std::string& value) {
// @@protoc_insertion_point(field_set:milvus.proto.milvus.ShowCollectionsRequest.collection_names)
collection_names_.Mutable(index)->assign(value);
}
inline void ShowCollectionsRequest::set_collection_names(int index, std::string&& value) {
// @@protoc_insertion_point(field_set:milvus.proto.milvus.ShowCollectionsRequest.collection_names)
collection_names_.Mutable(index)->assign(std::move(value));
}
inline void ShowCollectionsRequest::set_collection_names(int index, const char* value) {
GOOGLE_DCHECK(value != nullptr);
collection_names_.Mutable(index)->assign(value);
// @@protoc_insertion_point(field_set_char:milvus.proto.milvus.ShowCollectionsRequest.collection_names)
}
inline void ShowCollectionsRequest::set_collection_names(int index, const char* value, size_t size) {
collection_names_.Mutable(index)->assign(
reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_set_pointer:milvus.proto.milvus.ShowCollectionsRequest.collection_names)
}
inline std::string* ShowCollectionsRequest::add_collection_names() {
// @@protoc_insertion_point(field_add_mutable:milvus.proto.milvus.ShowCollectionsRequest.collection_names)
return collection_names_.Add();
}
inline void ShowCollectionsRequest::add_collection_names(const std::string& value) {
collection_names_.Add()->assign(value);
// @@protoc_insertion_point(field_add:milvus.proto.milvus.ShowCollectionsRequest.collection_names)
}
inline void ShowCollectionsRequest::add_collection_names(std::string&& value) {
collection_names_.Add(std::move(value));
// @@protoc_insertion_point(field_add:milvus.proto.milvus.ShowCollectionsRequest.collection_names)
}
inline void ShowCollectionsRequest::add_collection_names(const char* value) {
GOOGLE_DCHECK(value != nullptr);
collection_names_.Add()->assign(value);
// @@protoc_insertion_point(field_add_char:milvus.proto.milvus.ShowCollectionsRequest.collection_names)
}
inline void ShowCollectionsRequest::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.ShowCollectionsRequest.collection_names)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
ShowCollectionsRequest::collection_names() const {
// @@protoc_insertion_point(field_list:milvus.proto.milvus.ShowCollectionsRequest.collection_names)
return collection_names_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
ShowCollectionsRequest::mutable_collection_names() {
// @@protoc_insertion_point(field_mutable_list:milvus.proto.milvus.ShowCollectionsRequest.collection_names)
return &collection_names_;
}
// -------------------------------------------------------------------
// ShowCollectionsResponse
@ -12802,6 +12940,36 @@ ShowCollectionsResponse::mutable_created_utc_timestamps() {
return &created_utc_timestamps_;
}
// repeated int64 inMemory_percentages = 6;
inline int ShowCollectionsResponse::inmemory_percentages_size() const {
return inmemory_percentages_.size();
}
inline void ShowCollectionsResponse::clear_inmemory_percentages() {
inmemory_percentages_.Clear();
}
inline ::PROTOBUF_NAMESPACE_ID::int64 ShowCollectionsResponse::inmemory_percentages(int index) const {
// @@protoc_insertion_point(field_get:milvus.proto.milvus.ShowCollectionsResponse.inMemory_percentages)
return inmemory_percentages_.Get(index);
}
inline void ShowCollectionsResponse::set_inmemory_percentages(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) {
inmemory_percentages_.Set(index, value);
// @@protoc_insertion_point(field_set:milvus.proto.milvus.ShowCollectionsResponse.inMemory_percentages)
}
inline void ShowCollectionsResponse::add_inmemory_percentages(::PROTOBUF_NAMESPACE_ID::int64 value) {
inmemory_percentages_.Add(value);
// @@protoc_insertion_point(field_add:milvus.proto.milvus.ShowCollectionsResponse.inMemory_percentages)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
ShowCollectionsResponse::inmemory_percentages() const {
// @@protoc_insertion_point(field_list:milvus.proto.milvus.ShowCollectionsResponse.inMemory_percentages)
return inmemory_percentages_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
ShowCollectionsResponse::mutable_inmemory_percentages() {
// @@protoc_insertion_point(field_mutable_list:milvus.proto.milvus.ShowCollectionsResponse.inMemory_percentages)
return &inmemory_percentages_;
}
// -------------------------------------------------------------------
// CreatePartitionRequest
@ -14283,6 +14451,85 @@ inline void ShowPartitionsRequest::set_collectionid(::PROTOBUF_NAMESPACE_ID::int
// @@protoc_insertion_point(field_set:milvus.proto.milvus.ShowPartitionsRequest.collectionID)
}
// repeated string partition_names = 5;
inline int ShowPartitionsRequest::partition_names_size() const {
return partition_names_.size();
}
inline void ShowPartitionsRequest::clear_partition_names() {
partition_names_.Clear();
}
inline const std::string& ShowPartitionsRequest::partition_names(int index) const {
// @@protoc_insertion_point(field_get:milvus.proto.milvus.ShowPartitionsRequest.partition_names)
return partition_names_.Get(index);
}
inline std::string* ShowPartitionsRequest::mutable_partition_names(int index) {
// @@protoc_insertion_point(field_mutable:milvus.proto.milvus.ShowPartitionsRequest.partition_names)
return partition_names_.Mutable(index);
}
inline void ShowPartitionsRequest::set_partition_names(int index, const std::string& value) {
// @@protoc_insertion_point(field_set:milvus.proto.milvus.ShowPartitionsRequest.partition_names)
partition_names_.Mutable(index)->assign(value);
}
inline void ShowPartitionsRequest::set_partition_names(int index, std::string&& value) {
// @@protoc_insertion_point(field_set:milvus.proto.milvus.ShowPartitionsRequest.partition_names)
partition_names_.Mutable(index)->assign(std::move(value));
}
inline void ShowPartitionsRequest::set_partition_names(int index, const char* value) {
GOOGLE_DCHECK(value != nullptr);
partition_names_.Mutable(index)->assign(value);
// @@protoc_insertion_point(field_set_char:milvus.proto.milvus.ShowPartitionsRequest.partition_names)
}
inline void ShowPartitionsRequest::set_partition_names(int index, const char* value, size_t size) {
partition_names_.Mutable(index)->assign(
reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_set_pointer:milvus.proto.milvus.ShowPartitionsRequest.partition_names)
}
inline std::string* ShowPartitionsRequest::add_partition_names() {
// @@protoc_insertion_point(field_add_mutable:milvus.proto.milvus.ShowPartitionsRequest.partition_names)
return partition_names_.Add();
}
inline void ShowPartitionsRequest::add_partition_names(const std::string& value) {
partition_names_.Add()->assign(value);
// @@protoc_insertion_point(field_add:milvus.proto.milvus.ShowPartitionsRequest.partition_names)
}
inline void ShowPartitionsRequest::add_partition_names(std::string&& value) {
partition_names_.Add(std::move(value));
// @@protoc_insertion_point(field_add:milvus.proto.milvus.ShowPartitionsRequest.partition_names)
}
inline void ShowPartitionsRequest::add_partition_names(const char* value) {
GOOGLE_DCHECK(value != nullptr);
partition_names_.Add()->assign(value);
// @@protoc_insertion_point(field_add_char:milvus.proto.milvus.ShowPartitionsRequest.partition_names)
}
inline void ShowPartitionsRequest::add_partition_names(const char* value, size_t size) {
partition_names_.Add()->assign(reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_add_pointer:milvus.proto.milvus.ShowPartitionsRequest.partition_names)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
ShowPartitionsRequest::partition_names() const {
// @@protoc_insertion_point(field_list:milvus.proto.milvus.ShowPartitionsRequest.partition_names)
return partition_names_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
ShowPartitionsRequest::mutable_partition_names() {
// @@protoc_insertion_point(field_mutable_list:milvus.proto.milvus.ShowPartitionsRequest.partition_names)
return &partition_names_;
}
// .milvus.proto.milvus.ShowType type = 6;
inline void ShowPartitionsRequest::clear_type() {
type_ = 0;
}
inline ::milvus::proto::milvus::ShowType ShowPartitionsRequest::type() const {
// @@protoc_insertion_point(field_get:milvus.proto.milvus.ShowPartitionsRequest.type)
return static_cast< ::milvus::proto::milvus::ShowType >(type_);
}
inline void ShowPartitionsRequest::set_type(::milvus::proto::milvus::ShowType value) {
type_ = value;
// @@protoc_insertion_point(field_set:milvus.proto.milvus.ShowPartitionsRequest.type)
}
// -------------------------------------------------------------------
// ShowPartitionsResponse
@ -14487,6 +14734,36 @@ ShowPartitionsResponse::mutable_created_utc_timestamps() {
return &created_utc_timestamps_;
}
// repeated int64 inMemory_percentages = 6;
inline int ShowPartitionsResponse::inmemory_percentages_size() const {
return inmemory_percentages_.size();
}
inline void ShowPartitionsResponse::clear_inmemory_percentages() {
inmemory_percentages_.Clear();
}
inline ::PROTOBUF_NAMESPACE_ID::int64 ShowPartitionsResponse::inmemory_percentages(int index) const {
// @@protoc_insertion_point(field_get:milvus.proto.milvus.ShowPartitionsResponse.inMemory_percentages)
return inmemory_percentages_.Get(index);
}
inline void ShowPartitionsResponse::set_inmemory_percentages(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) {
inmemory_percentages_.Set(index, value);
// @@protoc_insertion_point(field_set:milvus.proto.milvus.ShowPartitionsResponse.inMemory_percentages)
}
inline void ShowPartitionsResponse::add_inmemory_percentages(::PROTOBUF_NAMESPACE_ID::int64 value) {
inmemory_percentages_.Add(value);
// @@protoc_insertion_point(field_add:milvus.proto.milvus.ShowPartitionsResponse.inMemory_percentages)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
ShowPartitionsResponse::inmemory_percentages() const {
// @@protoc_insertion_point(field_list:milvus.proto.milvus.ShowPartitionsResponse.inMemory_percentages)
return inmemory_percentages_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
ShowPartitionsResponse::mutable_inmemory_percentages() {
// @@protoc_insertion_point(field_mutable_list:milvus.proto.milvus.ShowPartitionsResponse.inMemory_percentages)
return &inmemory_percentages_;
}
// -------------------------------------------------------------------
// DescribeSegmentRequest
@ -20602,10 +20879,10 @@ inline void RegisterLinkResponse::set_allocated_status(::milvus::proto::common::
PROTOBUF_NAMESPACE_OPEN
template <> struct is_proto_enum< ::milvus::proto::milvus::ShowCollectionsType> : ::std::true_type {};
template <> struct is_proto_enum< ::milvus::proto::milvus::ShowType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::milvus::proto::milvus::ShowCollectionsType>() {
return ::milvus::proto::milvus::ShowCollectionsType_descriptor();
inline const EnumDescriptor* GetEnumDescriptor< ::milvus::proto::milvus::ShowType>() {
return ::milvus::proto::milvus::ShowType_descriptor();
}
template <> struct is_proto_enum< ::milvus::proto::milvus::PlaceholderType> : ::std::true_type {};
template <>

9
internal/proto/milvus.proto
View File

@ -119,7 +119,7 @@ message GetCollectionStatisticsResponse {
repeated common.KeyValuePair stats = 2;
}
enum ShowCollectionsType {
enum ShowType {
All = 0;
InMemory = 1;
}
@ -128,7 +128,8 @@ message ShowCollectionsRequest {
common.MsgBase base = 1; // must
string db_name = 2;
uint64 time_stamp = 3;
ShowCollectionsType type = 4;
ShowType type = 4;
repeated string collection_names = 5; // show collection in querynode, showType = InMemory
}
message ShowCollectionsResponse {
@ -137,6 +138,7 @@ message ShowCollectionsResponse {
repeated int64 collection_ids = 3;
repeated uint64 created_timestamps = 4; // hybrid timestamps
repeated uint64 created_utc_timestamps = 5; // physical timestamps
repeated int64 inMemory_percentages = 6; // load percentage on querynode
}
message CreatePartitionRequest {
@ -191,6 +193,8 @@ message ShowPartitionsRequest {
string db_name = 2;
string collection_name = 3; // must
int64 collectionID = 4;
repeated string partition_names = 5; // show partition in querynode, showType = InMemory
ShowType type = 6;
}
message ShowPartitionsResponse {
@ -199,6 +203,7 @@ message ShowPartitionsResponse {
repeated int64 partitionIDs = 3;
repeated uint64 created_timestamps = 4; // hybrid timestamps
repeated uint64 created_utc_timestamps = 5; // physical timestamps
repeated int64 inMemory_percentages = 6; // load percentage on querynode
}
message DescribeSegmentRequest {

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

@ -26,28 +26,28 @@ var _ = math.Inf
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
type ShowCollectionsType int32
type ShowType int32
const (
ShowCollectionsType_All ShowCollectionsType = 0
ShowCollectionsType_InMemory ShowCollectionsType = 1
ShowType_All ShowType = 0
ShowType_InMemory ShowType = 1
)
var ShowCollectionsType_name = map[int32]string{
var ShowType_name = map[int32]string{
0: "All",
1: "InMemory",
}
var ShowCollectionsType_value = map[string]int32{
var ShowType_value = map[string]int32{
"All": 0,
"InMemory": 1,
}
func (x ShowCollectionsType) String() string {
return proto.EnumName(ShowCollectionsType_name, int32(x))
func (x ShowType) String() string {
return proto.EnumName(ShowType_name, int32(x))
}
func (ShowCollectionsType) EnumDescriptor() ([]byte, []int) {
func (ShowType) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_02345ba45cc0e303, []int{0}
}
@ -734,13 +734,14 @@ func (m *GetCollectionStatisticsResponse) GetStats() []*commonpb.KeyValuePair {
}
type ShowCollectionsRequest struct {
Base *commonpb.MsgBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
DbName string `protobuf:"bytes,2,opt,name=db_name,json=dbName,proto3" json:"db_name,omitempty"`
TimeStamp uint64 `protobuf:"varint,3,opt,name=time_stamp,json=timeStamp,proto3" json:"time_stamp,omitempty"`
Type ShowCollectionsType `protobuf:"varint,4,opt,name=type,proto3,enum=milvus.proto.milvus.ShowCollectionsType" json:"type,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
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"`
TimeStamp uint64 `protobuf:"varint,3,opt,name=time_stamp,json=timeStamp,proto3" json:"time_stamp,omitempty"`
Type ShowType `protobuf:"varint,4,opt,name=type,proto3,enum=milvus.proto.milvus.ShowType" json:"type,omitempty"`
CollectionNames []string `protobuf:"bytes,5,rep,name=collection_names,json=collectionNames,proto3" json:"collection_names,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ShowCollectionsRequest) Reset() { *m = ShowCollectionsRequest{} }
@ -789,11 +790,18 @@ func (m *ShowCollectionsRequest) GetTimeStamp() uint64 {
return 0
}
func (m *ShowCollectionsRequest) GetType() ShowCollectionsType {
func (m *ShowCollectionsRequest) GetType() ShowType {
if m != nil {
return m.Type
}
return ShowCollectionsType_All
return ShowType_All
}
func (m *ShowCollectionsRequest) GetCollectionNames() []string {
if m != nil {
return m.CollectionNames
}
return nil
}
type ShowCollectionsResponse struct {
@ -802,6 +810,7 @@ type ShowCollectionsResponse struct {
CollectionIds []int64 `protobuf:"varint,3,rep,packed,name=collection_ids,json=collectionIds,proto3" json:"collection_ids,omitempty"`
CreatedTimestamps []uint64 `protobuf:"varint,4,rep,packed,name=created_timestamps,json=createdTimestamps,proto3" json:"created_timestamps,omitempty"`
CreatedUtcTimestamps []uint64 `protobuf:"varint,5,rep,packed,name=created_utc_timestamps,json=createdUtcTimestamps,proto3" json:"created_utc_timestamps,omitempty"`
InMemoryPercentages []int64 `protobuf:"varint,6,rep,packed,name=inMemory_percentages,json=inMemoryPercentages,proto3" json:"inMemory_percentages,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
@ -867,6 +876,13 @@ func (m *ShowCollectionsResponse) GetCreatedUtcTimestamps() []uint64 {
return nil
}
func (m *ShowCollectionsResponse) GetInMemoryPercentages() []int64 {
if m != nil {
return m.InMemoryPercentages
}
return nil
}
type CreatePartitionRequest struct {
Base *commonpb.MsgBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
DbName string `protobuf:"bytes,2,opt,name=db_name,json=dbName,proto3" json:"db_name,omitempty"`
@ -1297,6 +1313,8 @@ type ShowPartitionsRequest struct {
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"`
CollectionID int64 `protobuf:"varint,4,opt,name=collectionID,proto3" json:"collectionID,omitempty"`
PartitionNames []string `protobuf:"bytes,5,rep,name=partition_names,json=partitionNames,proto3" json:"partition_names,omitempty"`
Type ShowType `protobuf:"varint,6,opt,name=type,proto3,enum=milvus.proto.milvus.ShowType" json:"type,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
@ -1355,12 +1373,27 @@ func (m *ShowPartitionsRequest) GetCollectionID() int64 {
return 0
}
func (m *ShowPartitionsRequest) GetPartitionNames() []string {
if m != nil {
return m.PartitionNames
}
return nil
}
func (m *ShowPartitionsRequest) GetType() ShowType {
if m != nil {
return m.Type
}
return ShowType_All
}
type ShowPartitionsResponse struct {
Status *commonpb.Status `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
PartitionNames []string `protobuf:"bytes,2,rep,name=partition_names,json=partitionNames,proto3" json:"partition_names,omitempty"`
PartitionIDs []int64 `protobuf:"varint,3,rep,packed,name=partitionIDs,proto3" json:"partitionIDs,omitempty"`
CreatedTimestamps []uint64 `protobuf:"varint,4,rep,packed,name=created_timestamps,json=createdTimestamps,proto3" json:"created_timestamps,omitempty"`
CreatedUtcTimestamps []uint64 `protobuf:"varint,5,rep,packed,name=created_utc_timestamps,json=createdUtcTimestamps,proto3" json:"created_utc_timestamps,omitempty"`
InMemoryPercentages []int64 `protobuf:"varint,6,rep,packed,name=inMemory_percentages,json=inMemoryPercentages,proto3" json:"inMemory_percentages,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
@ -1426,6 +1459,13 @@ func (m *ShowPartitionsResponse) GetCreatedUtcTimestamps() []uint64 {
return nil
}
func (m *ShowPartitionsResponse) GetInMemoryPercentages() []int64 {
if m != nil {
return m.InMemoryPercentages
}
return nil
}
type DescribeSegmentRequest struct {
Base *commonpb.MsgBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
CollectionID int64 `protobuf:"varint,2,opt,name=collectionID,proto3" json:"collectionID,omitempty"`
@ -3929,7 +3969,7 @@ func (m *RegisterLinkResponse) GetStatus() *commonpb.Status {
}
func init() {
proto.RegisterEnum("milvus.proto.milvus.ShowCollectionsType", ShowCollectionsType_name, ShowCollectionsType_value)
proto.RegisterEnum("milvus.proto.milvus.ShowType", ShowType_name, ShowType_value)
proto.RegisterEnum("milvus.proto.milvus.PlaceholderType", PlaceholderType_name, PlaceholderType_value)
proto.RegisterType((*CreateCollectionRequest)(nil), "milvus.proto.milvus.CreateCollectionRequest")
proto.RegisterType((*DropCollectionRequest)(nil), "milvus.proto.milvus.DropCollectionRequest")
@ -3999,192 +4039,194 @@ func init() {
func init() { proto.RegisterFile("milvus.proto", fileDescriptor_02345ba45cc0e303) }
var fileDescriptor_02345ba45cc0e303 = []byte{
// 2951 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x1a, 0x4d, 0x6f, 0x24, 0xc5,
0xd5, 0x35, 0xe3, 0xf9, 0x7a, 0xd3, 0x63, 0xcf, 0x96, 0xd7, 0x5e, 0x33, 0xec, 0xb2, 0xde, 0x86,
0x0d, 0xde, 0x5d, 0xd8, 0x05, 0x2f, 0x04, 0x02, 0x24, 0xb0, 0xbb, 0x0e, 0xbb, 0x16, 0xbb, 0xc4,
0xb4, 0x01, 0x85, 0x20, 0x34, 0x6a, 0x4f, 0x97, 0x67, 0x5a, 0xee, 0xe9, 0x9e, 0x74, 0xd5, 0xd8,
0x3b, 0x9c, 0x22, 0x01, 0x91, 0xa2, 0x24, 0xa0, 0x28, 0x51, 0xa2, 0x5c, 0x93, 0x70, 0xc8, 0x29,
0x41, 0x44, 0x8a, 0x94, 0x53, 0x0e, 0x1c, 0x72, 0x88, 0x94, 0x8f, 0x6b, 0xae, 0xc9, 0x91, 0x3f,
0x10, 0x45, 0x22, 0xaa, 0xaa, 0xee, 0x9e, 0xee, 0x76, 0xf5, 0x78, 0xbc, 0x03, 0xd8, 0xbe, 0x75,
0xbf, 0x7a, 0xaf, 0xea, 0x7d, 0xd5, 0x7b, 0x55, 0xaf, 0x1e, 0x68, 0x5d, 0xdb, 0xd9, 0xe9, 0xd3,
0xcb, 0x3d, 0xdf, 0x63, 0x1e, 0x9e, 0x8b, 0xff, 0x5d, 0x96, 0x3f, 0x0d, 0xad, 0xe5, 0x75, 0xbb,
0x9e, 0x2b, 0x81, 0x0d, 0x8d, 0xb6, 0x3a, 0xa4, 0x6b, 0xca, 0x3f, 0xfd, 0x13, 0x04, 0xa7, 0x6e,
0xf8, 0xc4, 0x64, 0xe4, 0x86, 0xe7, 0x38, 0xa4, 0xc5, 0x6c, 0xcf, 0x35, 0xc8, 0x77, 0xfb, 0x84,
0x32, 0xfc, 0x18, 0x4c, 0x6f, 0x9a, 0x94, 0x2c, 0xa2, 0x25, 0xb4, 0x5c, 0x5d, 0x39, 0x7d, 0x39,
0x31, 0x77, 0x30, 0xe7, 0x1d, 0xda, 0xbe, 0x6e, 0x52, 0x62, 0x08, 0x4c, 0x7c, 0x0a, 0x4a, 0xd6,
0x66, 0xd3, 0x35, 0xbb, 0x64, 0x31, 0xb7, 0x84, 0x96, 0x2b, 0x46, 0xd1, 0xda, 0x7c, 0xd9, 0xec,
0x12, 0xfc, 0x30, 0xcc, 0xb6, 0xa2, 0xf9, 0x25, 0x42, 0x5e, 0x20, 0xcc, 0x0c, 0xc1, 0x02, 0x71,
0x01, 0x8a, 0x92, 0xbf, 0xc5, 0xe9, 0x25, 0xb4, 0xac, 0x19, 0xc1, 0x1f, 0x3e, 0x03, 0x40, 0x3b,
0xa6, 0x6f, 0xd1, 0xa6, 0xdb, 0xef, 0x2e, 0x16, 0x96, 0xd0, 0x72, 0xc1, 0xa8, 0x48, 0xc8, 0xcb,
0xfd, 0xae, 0xfe, 0x43, 0x04, 0xf3, 0xab, 0xbe, 0xd7, 0x3b, 0x12, 0x42, 0xe8, 0xbf, 0x45, 0x70,
0xf2, 0x96, 0x49, 0x8f, 0x86, 0x46, 0xcf, 0x00, 0x30, 0xbb, 0x4b, 0x9a, 0x94, 0x99, 0xdd, 0x9e,
0xd0, 0xea, 0xb4, 0x51, 0xe1, 0x90, 0x0d, 0x0e, 0xd0, 0xdf, 0x00, 0xed, 0xba, 0xe7, 0x39, 0x06,
0xa1, 0x3d, 0xcf, 0xa5, 0x04, 0x5f, 0x85, 0x22, 0x65, 0x26, 0xeb, 0xd3, 0x80, 0xc9, 0xfb, 0x95,
0x4c, 0x6e, 0x08, 0x14, 0x23, 0x40, 0xc5, 0x27, 0xa1, 0xb0, 0x63, 0x3a, 0x7d, 0xc9, 0x63, 0xd9,
0x90, 0x3f, 0xfa, 0x9b, 0x30, 0xb3, 0xc1, 0x7c, 0xdb, 0x6d, 0x7f, 0x8e, 0x93, 0x57, 0xc2, 0xc9,
0xff, 0x89, 0xe0, 0xbe, 0x55, 0x42, 0x5b, 0xbe, 0xbd, 0x79, 0x44, 0x5c, 0x57, 0x07, 0x6d, 0x08,
0x59, 0x5b, 0x15, 0xaa, 0xce, 0x1b, 0x09, 0x58, 0xca, 0x18, 0x85, 0xb4, 0x31, 0x3e, 0xcb, 0x41,
0x43, 0x25, 0xd4, 0x24, 0xea, 0xfb, 0x7a, 0xb4, 0xa3, 0x72, 0x82, 0xe8, 0x7c, 0x92, 0x28, 0x88,
0x06, 0xc3, 0xd5, 0x36, 0x04, 0x20, 0xda, 0x78, 0x69, 0xa9, 0xf2, 0x0a, 0xa9, 0x56, 0x60, 0x7e,
0xc7, 0xf6, 0x59, 0xdf, 0x74, 0x9a, 0xad, 0x8e, 0xe9, 0xba, 0xc4, 0x11, 0x7a, 0xa2, 0x8b, 0xd3,
0x4b, 0xf9, 0xe5, 0x8a, 0x31, 0x17, 0x0c, 0xde, 0x90, 0x63, 0x5c, 0x59, 0x14, 0x3f, 0x01, 0x0b,
0xbd, 0xce, 0x80, 0xda, 0xad, 0x3d, 0x44, 0x05, 0x41, 0x74, 0x32, 0x1c, 0x4d, 0x50, 0x5d, 0x82,
0x13, 0x2d, 0x11, 0xad, 0xac, 0x26, 0xd7, 0x9a, 0x54, 0x63, 0x51, 0xa8, 0xb1, 0x1e, 0x0c, 0xbc,
0x1a, 0xc2, 0x39, 0x5b, 0x21, 0x72, 0x9f, 0xb5, 0x62, 0x04, 0x25, 0x41, 0x30, 0x17, 0x0c, 0xbe,
0xc6, 0x5a, 0x11, 0x8d, 0x08, 0x24, 0xb7, 0x3d, 0xd3, 0x3a, 0x1a, 0x81, 0xe4, 0x7d, 0x04, 0x8b,
0x06, 0x71, 0x88, 0x49, 0x8f, 0x86, 0x8f, 0xeb, 0x3f, 0x43, 0xf0, 0xc0, 0x4d, 0xc2, 0x62, 0xde,
0xc2, 0x4c, 0x66, 0x53, 0x66, 0xb7, 0xe8, 0x61, 0xb2, 0xf5, 0x01, 0x82, 0xb3, 0x99, 0x6c, 0x4d,
0xb2, 0x79, 0x9e, 0x82, 0x02, 0xff, 0xa2, 0x8b, 0xb9, 0xa5, 0xfc, 0x72, 0x75, 0xe5, 0x9c, 0x92,
0xe6, 0x25, 0x32, 0x78, 0x9d, 0xc7, 0xa4, 0x75, 0xd3, 0xf6, 0x0d, 0x89, 0xaf, 0xff, 0x19, 0xc1,
0xc2, 0x46, 0xc7, 0xdb, 0x1d, 0xb2, 0xf4, 0x45, 0x28, 0x28, 0x19, 0x4e, 0xf2, 0xa9, 0x70, 0x82,
0x9f, 0x83, 0x69, 0x36, 0xe8, 0x11, 0x11, 0x89, 0x66, 0x56, 0x96, 0x2f, 0x2b, 0x0e, 0x07, 0x97,
0x53, 0x4c, 0xbe, 0x3a, 0xe8, 0x11, 0x43, 0x50, 0xe9, 0xef, 0xe5, 0xe0, 0xd4, 0x1e, 0x11, 0x26,
0x51, 0xe6, 0x05, 0xa8, 0xa7, 0xcc, 0x29, 0xf5, 0x5a, 0x31, 0x66, 0x93, 0xf6, 0xa4, 0xf8, 0x3c,
0xc4, 0x4c, 0xdc, 0xb4, 0x2d, 0xba, 0x98, 0x5f, 0xca, 0x2f, 0xe7, 0x8d, 0x5a, 0x2c, 0xee, 0x58,
0x14, 0x3f, 0x0a, 0x78, 0x4f, 0x38, 0x90, 0x51, 0x67, 0xda, 0x38, 0x91, 0x8e, 0x07, 0x22, 0xe6,
0x28, 0x03, 0x82, 0x8c, 0x39, 0xd3, 0xc6, 0x49, 0x45, 0x44, 0xa0, 0xfa, 0xc7, 0x08, 0x16, 0xe4,
0x11, 0x69, 0xdd, 0xf4, 0x99, 0x7d, 0xd8, 0x69, 0xe6, 0x3c, 0xcc, 0xf4, 0x42, 0x3e, 0x24, 0xde,
0xb4, 0xc0, 0xab, 0x45, 0x50, 0xb1, 0x25, 0x3e, 0x42, 0x70, 0x92, 0x9f, 0x88, 0x8e, 0x13, 0xcf,
0xbf, 0x47, 0x30, 0x77, 0xcb, 0xa4, 0xc7, 0x89, 0xe5, 0x3f, 0x04, 0xf9, 0x22, 0xe2, 0xf9, 0x30,
0xe3, 0x20, 0x47, 0x4c, 0x32, 0x1d, 0xa6, 0xe0, 0x99, 0x04, 0xd7, 0x54, 0xff, 0xe3, 0x30, 0xb1,
0x1c, 0x33, 0xce, 0xff, 0x84, 0xe0, 0xcc, 0x4d, 0xc2, 0x22, 0xae, 0x8f, 0x44, 0x02, 0x1a, 0xd7,
0x5b, 0xde, 0x97, 0xe9, 0x53, 0xc9, 0xfc, 0xa1, 0xa4, 0xa9, 0xdf, 0x21, 0x98, 0xe7, 0x31, 0xfe,
0x68, 0x38, 0xc1, 0x18, 0x27, 0x68, 0xfd, 0xb3, 0x20, 0xb1, 0xc6, 0x39, 0x9e, 0x44, 0x75, 0x0a,
0xc7, 0xcb, 0xa9, 0x1c, 0x8f, 0x33, 0x17, 0x41, 0xd6, 0x56, 0xc3, 0x84, 0x94, 0x80, 0x7d, 0x39,
0xf9, 0xe8, 0x47, 0x08, 0x16, 0xc2, 0x4b, 0xc2, 0x06, 0x69, 0x77, 0x89, 0xcb, 0xee, 0xdd, 0x68,
0x69, 0x95, 0xe7, 0x14, 0xc7, 0xfb, 0xd3, 0x50, 0xa1, 0x72, 0x9d, 0xe8, 0xfc, 0x3f, 0x04, 0xe8,
0x1f, 0x22, 0x38, 0xb5, 0x87, 0x9d, 0x49, 0x2c, 0xb2, 0x08, 0x25, 0xdb, 0xb5, 0xc8, 0xdd, 0x88,
0x9b, 0xf0, 0x97, 0x8f, 0x6c, 0xf6, 0x6d, 0xc7, 0x8a, 0xd8, 0x08, 0x7f, 0xf1, 0x39, 0xd0, 0x88,
0x6b, 0x6e, 0x3a, 0xa4, 0x29, 0x70, 0x85, 0xe7, 0x94, 0x8d, 0xaa, 0x84, 0xad, 0x71, 0x90, 0xfe,
0x63, 0x04, 0x73, 0xdc, 0x71, 0x02, 0x1e, 0xe9, 0x17, 0xab, 0xb3, 0x25, 0xa8, 0xc6, 0x3c, 0x23,
0x60, 0x37, 0x0e, 0xd2, 0xb7, 0xe1, 0x64, 0x92, 0x9d, 0x49, 0x74, 0xf6, 0x00, 0x40, 0x64, 0x11,
0xe9, 0xc0, 0x79, 0x23, 0x06, 0xd1, 0x3f, 0x45, 0x80, 0xe5, 0x19, 0x46, 0x28, 0xe3, 0x90, 0xeb,
0x11, 0x5b, 0x36, 0x71, 0xac, 0x78, 0x98, 0xac, 0x08, 0x88, 0x18, 0x5e, 0x05, 0x8d, 0xdc, 0x65,
0xbe, 0xd9, 0xec, 0x99, 0xbe, 0xd9, 0x95, 0x3b, 0x61, 0xac, 0x88, 0x56, 0x15, 0x64, 0xeb, 0x82,
0x4a, 0xff, 0x0b, 0x3f, 0xfd, 0x04, 0x4e, 0x79, 0xd4, 0x25, 0x3e, 0x03, 0x20, 0x9c, 0x56, 0x0e,
0x17, 0xe4, 0xb0, 0x80, 0x88, 0x9c, 0xf1, 0x21, 0x82, 0xba, 0x10, 0x41, 0xca, 0xd3, 0xe3, 0xd3,
0xa6, 0x68, 0x50, 0x8a, 0x66, 0xc4, 0x16, 0xfa, 0x1a, 0x14, 0x03, 0xc5, 0xe6, 0xc7, 0x55, 0x6c,
0x40, 0xb0, 0x8f, 0x18, 0xfa, 0xaf, 0x10, 0xcc, 0xa7, 0x54, 0x3e, 0x89, 0x47, 0xbf, 0x0a, 0x58,
0x4a, 0x68, 0x0d, 0xc5, 0x0e, 0xf3, 0xdb, 0x79, 0xe5, 0x4d, 0x26, 0xad, 0x24, 0xe3, 0x84, 0x9d,
0x82, 0x50, 0xfd, 0xef, 0x08, 0x4e, 0xdf, 0x24, 0x4c, 0xa0, 0x5e, 0xe7, 0xb1, 0x63, 0xdd, 0xf7,
0xda, 0x3e, 0xa1, 0xf4, 0xf8, 0xfa, 0xc7, 0xcf, 0xe5, 0x81, 0x48, 0x25, 0xd2, 0x24, 0xfa, 0x3f,
0x07, 0x9a, 0x58, 0x83, 0x58, 0x4d, 0xdf, 0xdb, 0xa5, 0x81, 0x1f, 0x55, 0x03, 0x98, 0xe1, 0xed,
0x0a, 0x87, 0x60, 0x1e, 0x33, 0x1d, 0x89, 0x10, 0x24, 0x06, 0x01, 0xe1, 0xc3, 0x62, 0x0f, 0x86,
0x8c, 0xf1, 0xc9, 0xc9, 0xf1, 0xd5, 0xf1, 0x6f, 0x10, 0xcc, 0xa7, 0x44, 0x99, 0x44, 0xb7, 0x4f,
0xca, 0xe3, 0x9a, 0x14, 0x66, 0x66, 0xe5, 0xac, 0x92, 0x26, 0xb6, 0x98, 0xc4, 0xc6, 0x67, 0xa1,
0xba, 0x65, 0xda, 0x4e, 0xd3, 0x27, 0x26, 0xf5, 0xdc, 0x40, 0x50, 0xe0, 0x20, 0x43, 0x40, 0xf4,
0x4f, 0x10, 0xd4, 0xf9, 0x9d, 0xef, 0x98, 0x47, 0xbc, 0x5f, 0xe7, 0xa0, 0xb6, 0xe6, 0x52, 0xe2,
0xb3, 0xa3, 0x7f, 0xa4, 0xc7, 0xcf, 0x43, 0x55, 0x08, 0x46, 0x9b, 0x96, 0xc9, 0xcc, 0x20, 0x5d,
0x3d, 0xa0, 0xac, 0xb1, 0xbe, 0xc8, 0xf1, 0x56, 0x4d, 0x66, 0x1a, 0x52, 0x3b, 0x94, 0x7f, 0xe3,
0xfb, 0xa1, 0xd2, 0x31, 0x69, 0xa7, 0xb9, 0x4d, 0x06, 0x74, 0xb1, 0xb8, 0x94, 0x5f, 0xae, 0x19,
0x65, 0x0e, 0x78, 0x89, 0x0c, 0x28, 0xbe, 0x0f, 0xca, 0x6e, 0xbf, 0x2b, 0x37, 0x58, 0x69, 0x09,
0x2d, 0xd7, 0x8c, 0x92, 0xdb, 0xef, 0x8a, 0xed, 0xf5, 0xd7, 0x1c, 0xcc, 0xdc, 0xe9, 0xf3, 0x0b,
0x84, 0xa8, 0x10, 0xf7, 0x1d, 0x76, 0x6f, 0xce, 0x78, 0x11, 0xf2, 0xf2, 0xcc, 0xc0, 0x29, 0x16,
0x95, 0x8c, 0xaf, 0xad, 0x52, 0x83, 0x23, 0x89, 0x57, 0x98, 0x7e, 0xab, 0x15, 0x1c, 0xb2, 0xf2,
0x82, 0xd9, 0x0a, 0x87, 0x08, 0x8f, 0xe3, 0xa2, 0x10, 0xdf, 0x8f, 0x8e, 0x60, 0x42, 0x14, 0xe2,
0xfb, 0x72, 0x50, 0x07, 0xcd, 0x6c, 0x6d, 0xbb, 0xde, 0xae, 0x43, 0xac, 0x36, 0xb1, 0x84, 0xd9,
0xcb, 0x46, 0x02, 0x26, 0x1d, 0x83, 0x1b, 0xbe, 0xd9, 0x72, 0x99, 0xa8, 0xeb, 0xe6, 0xb9, 0x63,
0x70, 0xc8, 0x0d, 0x97, 0xf1, 0x61, 0x8b, 0x38, 0x84, 0x11, 0x31, 0x5c, 0x92, 0xc3, 0x12, 0x12,
0x0c, 0xf7, 0x7b, 0x11, 0x75, 0x59, 0x0e, 0x4b, 0x08, 0x1f, 0x3e, 0x0d, 0x95, 0x61, 0x09, 0xb8,
0x32, 0xac, 0x95, 0xc9, 0xc2, 0xef, 0x0e, 0xd4, 0xd7, 0x1d, 0xb3, 0x45, 0x3a, 0x9e, 0x63, 0x11,
0x5f, 0x64, 0x3f, 0x5c, 0x87, 0x3c, 0x33, 0xdb, 0x41, 0x7a, 0xe5, 0x9f, 0xf8, 0xe9, 0xa0, 0xa2,
0x26, 0x37, 0xee, 0x43, 0xca, 0x3c, 0x14, 0x9b, 0x66, 0x58, 0x4d, 0xc3, 0x0b, 0x50, 0x14, 0x0f,
0x17, 0x32, 0xf1, 0x6a, 0x46, 0xf0, 0xa7, 0xbf, 0x95, 0x58, 0xf7, 0xa6, 0xef, 0xf5, 0x7b, 0x78,
0x0d, 0xb4, 0xde, 0x10, 0xc6, 0xad, 0x99, 0x9d, 0xf5, 0xd2, 0x4c, 0x1b, 0x09, 0x52, 0xfd, 0xd3,
0x3c, 0xd4, 0x36, 0x88, 0xe9, 0xb7, 0x3a, 0xc7, 0xe1, 0x76, 0xcf, 0x35, 0x6e, 0x51, 0x27, 0x08,
0x09, 0xfc, 0x13, 0x5f, 0x82, 0x13, 0x31, 0x81, 0x9a, 0x6d, 0xae, 0x20, 0xe1, 0x19, 0x9a, 0x51,
0xef, 0xa5, 0x15, 0xf7, 0x14, 0x94, 0x2d, 0xea, 0x34, 0x85, 0x89, 0x4a, 0xc2, 0x44, 0x6a, 0xf9,
0x56, 0xa9, 0x23, 0x4c, 0x53, 0xb2, 0xe4, 0x07, 0x7e, 0x10, 0x6a, 0x5e, 0x9f, 0xf5, 0xfa, 0xac,
0x29, 0x77, 0xe6, 0x62, 0x59, 0xb0, 0xa7, 0x49, 0xa0, 0xd8, 0xb8, 0x14, 0xbf, 0x08, 0x35, 0x2a,
0x54, 0x19, 0x9e, 0x4d, 0x2b, 0xe3, 0x1e, 0xa1, 0x34, 0x49, 0x27, 0x0f, 0xa7, 0xf8, 0x02, 0xd4,
0x99, 0x6f, 0xee, 0x10, 0x27, 0xf6, 0x24, 0x01, 0xc2, 0x1f, 0x67, 0x25, 0x7c, 0xf8, 0x84, 0x71,
0x05, 0xe6, 0xda, 0x7d, 0xd3, 0x37, 0x5d, 0x46, 0x48, 0x0c, 0xbb, 0x2a, 0xb0, 0x71, 0x34, 0x34,
0x7c, 0xbf, 0xf8, 0x57, 0x0e, 0x66, 0x0d, 0xc2, 0x7c, 0x9b, 0xec, 0x90, 0x63, 0x61, 0xf1, 0x8b,
0x90, 0xb7, 0x2d, 0x2a, 0x2c, 0x3e, 0x32, 0xfc, 0xd8, 0x16, 0xdd, 0x6b, 0xa5, 0xa2, 0xc2, 0x4a,
0x2a, 0xed, 0x96, 0x0e, 0xa4, 0xdd, 0x72, 0xa6, 0x76, 0x3f, 0x46, 0x71, 0xed, 0xf2, 0x98, 0x4b,
0xef, 0x39, 0xe8, 0x72, 0xa9, 0x73, 0xe3, 0x48, 0x9d, 0xca, 0x30, 0xf9, 0x83, 0x66, 0x18, 0xfd,
0x25, 0x98, 0xbe, 0x65, 0x33, 0xb1, 0xb9, 0x78, 0xa4, 0x47, 0xe2, 0x76, 0x28, 0xe2, 0xf9, 0x7d,
0x50, 0xf6, 0xbd, 0x5d, 0x39, 0x6f, 0x4e, 0x84, 0xa5, 0x92, 0xef, 0xed, 0x8a, 0xb4, 0x24, 0x1e,
0xe2, 0x3d, 0x3f, 0x88, 0x57, 0x39, 0x23, 0xf8, 0xd3, 0xdf, 0x43, 0xc3, 0x80, 0x32, 0x81, 0x02,
0x9e, 0x87, 0x92, 0x2f, 0xe9, 0x47, 0x3e, 0x4b, 0xc6, 0x57, 0x12, 0x72, 0x85, 0x54, 0xfa, 0xbb,
0x08, 0xb4, 0x17, 0x9d, 0x3e, 0xfd, 0x22, 0xe2, 0x9a, 0xea, 0xa1, 0x22, 0xaf, 0x7c, 0xa8, 0xd0,
0x7f, 0x92, 0x83, 0x5a, 0xc0, 0xc6, 0x24, 0x27, 0xc2, 0x4c, 0x56, 0x36, 0xa0, 0xca, 0x97, 0x6c,
0x52, 0xd2, 0x0e, 0x8b, 0x4e, 0xd5, 0x95, 0x15, 0x65, 0x26, 0x48, 0xb0, 0x21, 0x1e, 0x74, 0x37,
0x04, 0xd1, 0x37, 0x5d, 0xe6, 0x0f, 0x0c, 0x68, 0x45, 0x80, 0xc6, 0x5b, 0x30, 0x9b, 0x1a, 0xe6,
0xbe, 0xb1, 0x4d, 0x06, 0x61, 0xaa, 0xdb, 0x26, 0x03, 0xfc, 0x44, 0xfc, 0xd9, 0x3d, 0xcb, 0xe1,
0x6e, 0x7b, 0x6e, 0xfb, 0x9a, 0xef, 0x9b, 0x83, 0xe0, 0x59, 0xfe, 0x99, 0xdc, 0xd3, 0x48, 0xff,
0x37, 0x02, 0xed, 0x95, 0x3e, 0xf1, 0x07, 0x87, 0x19, 0x80, 0x30, 0x4c, 0x93, 0xbb, 0x3d, 0x3f,
0x38, 0xb4, 0x89, 0xef, 0xbd, 0xf1, 0xa3, 0xa0, 0x88, 0x1f, 0x8a, 0xc8, 0x55, 0x54, 0x56, 0xa2,
0xdf, 0x1d, 0x8a, 0x39, 0xd1, 0x46, 0x48, 0xec, 0xee, 0xdc, 0x81, 0x77, 0xf7, 0x47, 0x08, 0x2a,
0xaf, 0x93, 0x16, 0xf3, 0x7c, 0xbe, 0xa3, 0x15, 0xfa, 0x41, 0x63, 0x1c, 0xd1, 0x73, 0xe9, 0x23,
0xfa, 0x55, 0x28, 0xdb, 0x56, 0xd3, 0xe4, 0xa6, 0x15, 0x0a, 0x1e, 0x15, 0xa5, 0x4a, 0xb6, 0x25,
0x7c, 0x60, 0xfc, 0x22, 0xfe, 0x2f, 0x10, 0x68, 0x92, 0x67, 0x2a, 0x29, 0x9f, 0x8d, 0x2d, 0x87,
0x54, 0xfe, 0x16, 0xfc, 0x44, 0x82, 0xde, 0x9a, 0x1a, 0x2e, 0x7b, 0x0d, 0x80, 0xeb, 0x2e, 0x20,
0x97, 0xee, 0xba, 0xa4, 0xe4, 0x56, 0x92, 0x0b, 0x3d, 0xde, 0x9a, 0x32, 0x2a, 0x9c, 0x4a, 0x4c,
0x71, 0xbd, 0x04, 0x05, 0x41, 0xad, 0xff, 0x0f, 0xc1, 0xdc, 0x0d, 0xd3, 0x69, 0xad, 0xda, 0x94,
0x99, 0x6e, 0x6b, 0x82, 0x1c, 0xfa, 0x0c, 0x94, 0xbc, 0x5e, 0xd3, 0x21, 0x5b, 0x2c, 0x60, 0xe9,
0xdc, 0x08, 0x89, 0xa4, 0x1a, 0x8c, 0xa2, 0xd7, 0xbb, 0x4d, 0xb6, 0x18, 0x7e, 0x0e, 0xca, 0x5e,
0xaf, 0xe9, 0xdb, 0xed, 0x0e, 0x0b, 0xb4, 0x3f, 0x06, 0x71, 0xc9, 0xeb, 0x19, 0x9c, 0x22, 0x56,
0xe3, 0x99, 0x3e, 0x60, 0x8d, 0x47, 0xff, 0xc7, 0x1e, 0xf1, 0x27, 0x70, 0xed, 0x67, 0xa0, 0x6c,
0xbb, 0xac, 0x69, 0xd9, 0x34, 0x54, 0xc1, 0x19, 0xb5, 0x0f, 0xb9, 0x4c, 0x48, 0x20, 0x6c, 0xea,
0x32, 0xbe, 0x36, 0x7e, 0x01, 0x60, 0xcb, 0xf1, 0xcc, 0x80, 0x5a, 0xea, 0xe0, 0xac, 0x7a, 0x57,
0x70, 0xb4, 0x90, 0xbe, 0x22, 0x88, 0xf8, 0x0c, 0x43, 0x93, 0xfe, 0x0d, 0xc1, 0xfc, 0x3a, 0xf1,
0xa9, 0x4d, 0x19, 0x71, 0x59, 0x50, 0x6f, 0x5d, 0x73, 0xb7, 0xbc, 0x64, 0x61, 0x1b, 0xa5, 0x0a,
0xdb, 0x9f, 0x4f, 0x99, 0x37, 0x71, 0x83, 0x93, 0xef, 0x19, 0xe1, 0x0d, 0x2e, 0x7c, 0xb5, 0x91,
0x37, 0xe0, 0x99, 0x0c, 0x33, 0x05, 0xfc, 0xc6, 0x0b, 0x01, 0xfa, 0x4f, 0x65, 0xbb, 0x83, 0x52,
0xa8, 0x7b, 0x77, 0xd8, 0x05, 0x08, 0x82, 0x6c, 0x2a, 0xe4, 0x7e, 0x05, 0x52, 0xb1, 0x23, 0xa3,
0x09, 0xe3, 0x97, 0x08, 0x96, 0xb2, 0xb9, 0x9a, 0x24, 0x3b, 0xbe, 0x00, 0x05, 0xdb, 0xdd, 0xf2,
0xc2, 0xf2, 0xdf, 0x45, 0xf5, 0x45, 0x48, 0xb9, 0xae, 0x24, 0xd4, 0xff, 0x83, 0xa0, 0x2e, 0x62,
0xf5, 0x21, 0x98, 0xbf, 0x4b, 0xba, 0x4d, 0x6a, 0xbf, 0x4d, 0x42, 0xf3, 0x77, 0x49, 0x77, 0xc3,
0x7e, 0x9b, 0x24, 0x3c, 0xa3, 0x90, 0xf4, 0x8c, 0x64, 0x81, 0xa4, 0x38, 0xa2, 0xbc, 0x5b, 0x4a,
0x94, 0x77, 0xf5, 0xf7, 0x11, 0x34, 0x6e, 0x12, 0x96, 0x16, 0xf5, 0xf0, 0x9c, 0xe2, 0x03, 0x04,
0xf7, 0x2b, 0x19, 0x9a, 0xc4, 0x1f, 0x9e, 0x4d, 0xfa, 0x83, 0xfa, 0x62, 0xbc, 0x67, 0xc9, 0xc0,
0x15, 0x1e, 0x07, 0x6d, 0xb5, 0xdf, 0xed, 0x46, 0x87, 0x93, 0x73, 0xa0, 0xf9, 0xf2, 0x53, 0xde,
0x1b, 0x65, 0xba, 0xac, 0x06, 0x30, 0x7e, 0x3b, 0xd4, 0x2f, 0x41, 0x2d, 0x20, 0x09, 0xb8, 0x6e,
0x40, 0xd9, 0x0f, 0xbe, 0x03, 0xfc, 0xe8, 0x5f, 0x9f, 0x87, 0x39, 0x83, 0xb4, 0xb9, 0x27, 0xfa,
0xb7, 0x6d, 0x77, 0x3b, 0x58, 0x46, 0x7f, 0x07, 0xc1, 0xc9, 0x24, 0x3c, 0x98, 0xeb, 0xab, 0x50,
0x32, 0x2d, 0xcb, 0x27, 0x94, 0x8e, 0x34, 0xcb, 0x35, 0x89, 0x63, 0x84, 0xc8, 0x31, 0xcd, 0xe5,
0xc6, 0xd6, 0xdc, 0xc5, 0x47, 0xe4, 0x1b, 0x58, 0xaa, 0xe1, 0x07, 0x97, 0x20, 0x7f, 0xcd, 0x71,
0xea, 0x53, 0x58, 0x83, 0xf2, 0x9a, 0x7b, 0x87, 0x74, 0x3d, 0x7f, 0x50, 0x47, 0x17, 0xbf, 0x01,
0xb3, 0xa9, 0x62, 0x06, 0x2e, 0xc3, 0xf4, 0xcb, 0x9e, 0x4b, 0xea, 0x53, 0xb8, 0x0e, 0xda, 0x75,
0xdb, 0x35, 0xfd, 0x81, 0x4c, 0x42, 0x75, 0x0b, 0xcf, 0x42, 0x55, 0x04, 0xe3, 0x00, 0x40, 0x56,
0xfe, 0x7b, 0x0a, 0x6a, 0x77, 0x04, 0x53, 0x1b, 0xc4, 0xdf, 0xb1, 0x5b, 0x04, 0x37, 0xa1, 0x9e,
0xee, 0x36, 0xc6, 0x8f, 0x28, 0xcd, 0x97, 0xd1, 0x94, 0xdc, 0x18, 0x25, 0xa6, 0x3e, 0x85, 0xdf,
0x84, 0x99, 0x64, 0x1f, 0x30, 0x56, 0x47, 0x0b, 0x65, 0xb3, 0xf0, 0x7e, 0x93, 0x37, 0xa1, 0x96,
0x68, 0xeb, 0xc5, 0x17, 0x94, 0x73, 0xab, 0x5a, 0x7f, 0x1b, 0xea, 0x04, 0x1e, 0x6f, 0xbd, 0x95,
0xdc, 0x27, 0x9b, 0x0f, 0x33, 0xb8, 0x57, 0x76, 0x28, 0xee, 0xc7, 0xbd, 0x09, 0x27, 0xf6, 0xf4,
0x12, 0xe2, 0x47, 0x95, 0xf3, 0x67, 0xf5, 0x1c, 0xee, 0xb7, 0xc4, 0x2e, 0xe0, 0xbd, 0xed, 0xab,
0xf8, 0xb2, 0xda, 0x02, 0x59, 0xcd, 0xbb, 0x8d, 0x2b, 0x63, 0xe3, 0x47, 0x8a, 0xfb, 0x3e, 0x82,
0x53, 0x19, 0x0d, 0x80, 0xf8, 0xaa, 0x72, 0xba, 0xd1, 0x5d, 0x8c, 0x8d, 0x27, 0x0e, 0x46, 0x14,
0x31, 0xe2, 0xc2, 0x6c, 0x6a, 0x83, 0xe1, 0x4b, 0xe3, 0xf4, 0xdd, 0x85, 0xeb, 0x3e, 0x32, 0x1e,
0x72, 0xb4, 0x1e, 0xbf, 0xca, 0x25, 0x7b, 0xd3, 0x32, 0xd6, 0x53, 0x77, 0xb0, 0xed, 0x67, 0xd0,
0x37, 0xa0, 0x96, 0x68, 0x22, 0xcb, 0xf0, 0x78, 0x55, 0xa3, 0xd9, 0x7e, 0x53, 0xbf, 0x05, 0x5a,
0xbc, 0xd7, 0x0b, 0x2f, 0x67, 0xed, 0xa5, 0x3d, 0x13, 0x1f, 0x64, 0x2b, 0x0d, 0xdb, 0x44, 0x46,
0x6c, 0xa5, 0x3d, 0xdd, 0x2f, 0xe3, 0x6f, 0xa5, 0xd8, 0xfc, 0x23, 0xb7, 0xd2, 0x81, 0x97, 0x78,
0x07, 0xc1, 0x82, 0xba, 0x55, 0x08, 0xaf, 0x64, 0xf9, 0x66, 0x76, 0x53, 0x54, 0xe3, 0xea, 0x81,
0x68, 0x22, 0x2d, 0x6e, 0xc3, 0x4c, 0xb2, 0xd9, 0x26, 0x43, 0x8b, 0xca, 0x1e, 0xa2, 0xc6, 0xa5,
0xb1, 0x70, 0xa3, 0xc5, 0x5e, 0x83, 0x6a, 0xac, 0x47, 0x01, 0x3f, 0x3c, 0xc2, 0x8f, 0xe3, 0x2f,
0x5c, 0xfb, 0x69, 0xb2, 0x03, 0xb5, 0xc4, 0xbb, 0x74, 0x96, 0x0f, 0x2b, 0xda, 0x05, 0x1a, 0x17,
0xc7, 0x41, 0x8d, 0x04, 0xe8, 0x40, 0x2d, 0xf1, 0x4a, 0x98, 0xb1, 0x92, 0xea, 0x51, 0x34, 0x63,
0x25, 0xe5, 0xa3, 0xa3, 0x3e, 0x85, 0xbf, 0x17, 0x7b, 0x90, 0x4c, 0x3c, 0xfa, 0xe2, 0xc7, 0x47,
0xce, 0xa3, 0x7a, 0xf3, 0x6e, 0xac, 0x1c, 0x84, 0x24, 0x62, 0xe1, 0x15, 0xa8, 0x44, 0x6f, 0x8d,
0xf8, 0x7c, 0x66, 0x58, 0x38, 0x88, 0xa5, 0x36, 0xa0, 0x28, 0xdf, 0xfd, 0xb0, 0x9e, 0xf1, 0xc2,
0x1f, 0x7b, 0x14, 0x6c, 0x3c, 0xa8, 0xc4, 0x49, 0x3e, 0x89, 0xe9, 0x53, 0xd8, 0x80, 0xa2, 0xac,
0x22, 0x66, 0x4c, 0x9a, 0x78, 0x1d, 0x69, 0x8c, 0xc6, 0x91, 0xa5, 0xc7, 0x29, 0xfc, 0x6d, 0x28,
0x87, 0x65, 0x60, 0xfc, 0x50, 0xc6, 0xb6, 0x4f, 0xd4, 0xe0, 0x1b, 0xfb, 0x61, 0x85, 0x33, 0xaf,
0x43, 0x41, 0xd4, 0xf1, 0xf0, 0xb9, 0x51, 0x35, 0xbe, 0x51, 0xbc, 0x26, 0xca, 0x80, 0xfa, 0x14,
0xfe, 0x16, 0x14, 0xc4, 0x51, 0x38, 0x63, 0xc6, 0x78, 0xa1, 0xae, 0x31, 0x12, 0x25, 0x64, 0xd1,
0x02, 0x2d, 0x5e, 0x22, 0xc8, 0x08, 0xdc, 0x8a, 0x22, 0x4a, 0x63, 0x1c, 0xcc, 0x70, 0x95, 0x1f,
0x20, 0x58, 0xcc, 0xba, 0x4d, 0xe2, 0xcc, 0xec, 0x3c, 0xea, 0x4a, 0xdc, 0x78, 0xf2, 0x80, 0x54,
0x91, 0x0a, 0xdf, 0x86, 0x39, 0xc5, 0x1d, 0x06, 0x5f, 0xc9, 0x9a, 0x2f, 0xe3, 0xfa, 0xd5, 0x78,
0x6c, 0x7c, 0x82, 0x68, 0xed, 0x75, 0x28, 0x88, 0xbb, 0x47, 0x86, 0xf9, 0xe2, 0x57, 0x99, 0x0c,
0x87, 0x48, 0x5c, 0x5d, 0xf4, 0x29, 0x4c, 0x40, 0x8b, 0x5f, 0x44, 0x32, 0xec, 0xa7, 0xb8, 0xc3,
0x34, 0x2e, 0x8c, 0x81, 0x19, 0x2e, 0xb3, 0xd2, 0x07, 0x6d, 0xdd, 0xf7, 0xee, 0x0e, 0xc2, 0xa3,
0xff, 0x97, 0xb3, 0xec, 0xf5, 0x27, 0xbf, 0x73, 0xb5, 0x6d, 0xb3, 0x4e, 0x7f, 0x93, 0x47, 0x97,
0x2b, 0x12, 0xf7, 0x51, 0xdb, 0x0b, 0xbe, 0xae, 0xd8, 0x2e, 0x23, 0xbe, 0x6b, 0x3a, 0x57, 0xc4,
0x5c, 0x01, 0xb4, 0xb7, 0xb9, 0x59, 0x14, 0xff, 0x57, 0xff, 0x1f, 0x00, 0x00, 0xff, 0xff, 0x12,
0x6b, 0x2a, 0xc1, 0x4f, 0x39, 0x00, 0x00,
// 2989 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x1a, 0x5d, 0x6f, 0x24, 0x47,
0xd1, 0xb3, 0xeb, 0xfd, 0xaa, 0x9d, 0xb5, 0xf7, 0xda, 0x1f, 0xe7, 0x6c, 0xee, 0x72, 0xf6, 0x24,
0x47, 0x7c, 0x77, 0xc9, 0x5d, 0xce, 0x97, 0x90, 0x90, 0x00, 0xc9, 0xdd, 0x99, 0xdc, 0x59, 0xb9,
0x0b, 0xce, 0x38, 0x89, 0x08, 0x51, 0xb4, 0x1a, 0xef, 0xb4, 0x77, 0x47, 0x9e, 0x9d, 0x59, 0xa6,
0x7b, 0xed, 0xdb, 0x3c, 0x21, 0x25, 0x20, 0xa1, 0x40, 0x22, 0x04, 0x02, 0xf1, 0x0a, 0xe4, 0x81,
0x37, 0x42, 0x90, 0x40, 0x3c, 0xe7, 0x81, 0x07, 0x24, 0x3e, 0x5e, 0x79, 0xe1, 0x01, 0x1e, 0xf3,
0x07, 0x10, 0x12, 0xa8, 0x3f, 0x66, 0x76, 0x66, 0xb7, 0x67, 0xbd, 0xbe, 0x4d, 0xb0, 0xfd, 0x36,
0x53, 0x5d, 0xd5, 0x5d, 0x55, 0x5d, 0x5d, 0xd5, 0x5d, 0x55, 0xa0, 0xb7, 0x1d, 0x77, 0xaf, 0x4b,
0x2e, 0x77, 0x02, 0x9f, 0xfa, 0x68, 0x2e, 0xfe, 0x77, 0x59, 0xfc, 0xd4, 0xf4, 0x86, 0xdf, 0x6e,
0xfb, 0x9e, 0x00, 0xd6, 0x74, 0xd2, 0x68, 0xe1, 0xb6, 0x25, 0xfe, 0x8c, 0x4f, 0x34, 0x38, 0x7d,
0x33, 0xc0, 0x16, 0xc5, 0x37, 0x7d, 0xd7, 0xc5, 0x0d, 0xea, 0xf8, 0x9e, 0x89, 0xbf, 0xd5, 0xc5,
0x84, 0xa2, 0x27, 0x60, 0x7a, 0xdb, 0x22, 0x78, 0x49, 0x5b, 0xd6, 0x56, 0xcb, 0x6b, 0x67, 0x2e,
0x27, 0xe6, 0x96, 0x73, 0xde, 0x25, 0xcd, 0x1b, 0x16, 0xc1, 0x26, 0xc7, 0x44, 0xa7, 0xa1, 0x60,
0x6f, 0xd7, 0x3d, 0xab, 0x8d, 0x97, 0x32, 0xcb, 0xda, 0x6a, 0xc9, 0xcc, 0xdb, 0xdb, 0x2f, 0x5b,
0x6d, 0x8c, 0x1e, 0x85, 0xd9, 0x46, 0x34, 0xbf, 0x40, 0xc8, 0x72, 0x84, 0x99, 0x3e, 0x98, 0x23,
0x2e, 0x42, 0x5e, 0xf0, 0xb7, 0x34, 0xbd, 0xac, 0xad, 0xea, 0xa6, 0xfc, 0x43, 0x67, 0x01, 0x48,
0xcb, 0x0a, 0x6c, 0x52, 0xf7, 0xba, 0xed, 0xa5, 0xdc, 0xb2, 0xb6, 0x9a, 0x33, 0x4b, 0x02, 0xf2,
0x72, 0xb7, 0x6d, 0xbc, 0xa7, 0xc1, 0xc2, 0x7a, 0xe0, 0x77, 0x8e, 0x85, 0x10, 0xc6, 0xaf, 0x34,
0x98, 0xbf, 0x6d, 0x91, 0xe3, 0xa1, 0xd1, 0xb3, 0x00, 0xd4, 0x69, 0xe3, 0x3a, 0xa1, 0x56, 0xbb,
0xc3, 0xb5, 0x3a, 0x6d, 0x96, 0x18, 0x64, 0x8b, 0x01, 0x8c, 0x37, 0x40, 0xbf, 0xe1, 0xfb, 0xae,
0x89, 0x49, 0xc7, 0xf7, 0x08, 0x46, 0xd7, 0x20, 0x4f, 0xa8, 0x45, 0xbb, 0x44, 0x32, 0xf9, 0xa0,
0x92, 0xc9, 0x2d, 0x8e, 0x62, 0x4a, 0x54, 0x34, 0x0f, 0xb9, 0x3d, 0xcb, 0xed, 0x0a, 0x1e, 0x8b,
0xa6, 0xf8, 0x31, 0xde, 0x84, 0x99, 0x2d, 0x1a, 0x38, 0x5e, 0xf3, 0x33, 0x9c, 0xbc, 0x14, 0x4e,
0xfe, 0x37, 0x0d, 0x1e, 0x58, 0xc7, 0xa4, 0x11, 0x38, 0xdb, 0xc7, 0xc4, 0x74, 0x0d, 0xd0, 0xfb,
0x90, 0x8d, 0x75, 0xae, 0xea, 0xac, 0x99, 0x80, 0x0d, 0x6c, 0x46, 0x6e, 0x70, 0x33, 0xfe, 0x9b,
0x81, 0x9a, 0x4a, 0xa8, 0x49, 0xd4, 0xf7, 0x95, 0xe8, 0x44, 0x65, 0x38, 0xd1, 0xf9, 0x24, 0x91,
0xf4, 0x06, 0xfd, 0xd5, 0xb6, 0x38, 0x20, 0x3a, 0x78, 0x83, 0x52, 0x65, 0x15, 0x52, 0xad, 0xc1,
0xc2, 0x9e, 0x13, 0xd0, 0xae, 0xe5, 0xd6, 0x1b, 0x2d, 0xcb, 0xf3, 0xb0, 0xcb, 0xf5, 0x44, 0x96,
0xa6, 0x97, 0xb3, 0xab, 0x25, 0x73, 0x4e, 0x0e, 0xde, 0x14, 0x63, 0x4c, 0x59, 0x04, 0x3d, 0x09,
0x8b, 0x9d, 0x56, 0x8f, 0x38, 0x8d, 0x21, 0xa2, 0x1c, 0x27, 0x9a, 0x0f, 0x47, 0x13, 0x54, 0x97,
0xe0, 0x54, 0x83, 0x7b, 0x2b, 0xbb, 0xce, 0xb4, 0x26, 0xd4, 0x98, 0xe7, 0x6a, 0xac, 0xca, 0x81,
0x57, 0x43, 0x38, 0x63, 0x2b, 0x44, 0xee, 0xd2, 0x46, 0x8c, 0xa0, 0xc0, 0x09, 0xe6, 0xe4, 0xe0,
0x6b, 0xb4, 0x11, 0xd1, 0x70, 0x47, 0x72, 0xc7, 0xb7, 0xec, 0xe3, 0xe1, 0x48, 0xde, 0xd7, 0x60,
0xc9, 0xc4, 0x2e, 0xb6, 0xc8, 0xf1, 0xb0, 0x71, 0xe3, 0xc7, 0x1a, 0x3c, 0x74, 0x0b, 0xd3, 0x98,
0xb5, 0x50, 0x8b, 0x3a, 0x84, 0x3a, 0x0d, 0x72, 0x94, 0x6c, 0x7d, 0xa0, 0xc1, 0xb9, 0x54, 0xb6,
0x26, 0x39, 0x3c, 0x4f, 0x43, 0x8e, 0x7d, 0x91, 0xa5, 0xcc, 0x72, 0x76, 0xb5, 0xbc, 0xb6, 0xa2,
0xa4, 0x79, 0x09, 0xf7, 0x5e, 0x67, 0x3e, 0x69, 0xd3, 0x72, 0x02, 0x53, 0xe0, 0x1b, 0xff, 0xd0,
0x60, 0x71, 0xab, 0xe5, 0xef, 0xf7, 0x59, 0xfa, 0x3c, 0x14, 0x94, 0x74, 0x27, 0xd9, 0x01, 0x77,
0x82, 0xae, 0xc2, 0x34, 0xed, 0x75, 0x30, 0xf7, 0x44, 0x33, 0x6b, 0x67, 0x2f, 0x2b, 0x2e, 0x07,
0x97, 0x19, 0x93, 0xaf, 0xf6, 0x3a, 0xd8, 0xe4, 0xa8, 0xe8, 0x02, 0x54, 0x07, 0x54, 0x1e, 0x1e,
0xc8, 0xd9, 0xa4, 0xce, 0x89, 0xf1, 0xfb, 0x0c, 0x9c, 0x1e, 0x12, 0x71, 0x12, 0x65, 0xab, 0xd6,
0xce, 0x28, 0xd7, 0x46, 0xe7, 0x21, 0x66, 0x02, 0x75, 0xc7, 0x26, 0x4b, 0xd9, 0xe5, 0xec, 0x6a,
0xd6, 0xac, 0xc4, 0xfc, 0x92, 0x4d, 0xd0, 0xe3, 0x80, 0x86, 0xdc, 0x85, 0xf0, 0x4a, 0xd3, 0xe6,
0xa9, 0x41, 0x7f, 0xc1, 0x7d, 0x92, 0xd2, 0x61, 0x08, 0x15, 0x4c, 0x9b, 0xf3, 0x0a, 0x8f, 0x41,
0xd0, 0x55, 0x98, 0x77, 0xbc, 0xbb, 0xb8, 0xed, 0x07, 0xbd, 0x7a, 0x07, 0x07, 0x0d, 0xec, 0x51,
0xab, 0x89, 0xc9, 0x52, 0x9e, 0x73, 0x34, 0x17, 0x8e, 0x6d, 0xf6, 0x87, 0x8c, 0x8f, 0x35, 0x58,
0x14, 0xb7, 0xae, 0x4d, 0x2b, 0xa0, 0xce, 0x51, 0x47, 0xae, 0xf3, 0x30, 0xd3, 0x09, 0xf9, 0x10,
0x78, 0xd3, 0x1c, 0xaf, 0x12, 0x41, 0xf9, 0x29, 0xfb, 0x48, 0x83, 0x79, 0x76, 0xc9, 0x3a, 0x49,
0x3c, 0xff, 0x5a, 0x83, 0xb9, 0xdb, 0x16, 0x39, 0x49, 0x2c, 0xff, 0x56, 0x86, 0xa0, 0x88, 0xe7,
0xa3, 0x74, 0xad, 0x0c, 0x31, 0xc9, 0x74, 0x18, 0xd5, 0x67, 0x12, 0x5c, 0x13, 0xe3, 0x77, 0xfd,
0x58, 0x75, 0xc2, 0x38, 0xff, 0x83, 0x06, 0x67, 0x6f, 0x61, 0x1a, 0x71, 0x7d, 0x2c, 0x62, 0xda,
0xb8, 0xd6, 0xf2, 0xbe, 0x88, 0xc8, 0x4a, 0xe6, 0x8f, 0x24, 0xf2, 0xbd, 0x97, 0x81, 0x05, 0x16,
0x16, 0x8e, 0x87, 0x11, 0x8c, 0x73, 0x29, 0x57, 0x18, 0x4a, 0x4e, 0x65, 0x28, 0x51, 0x3c, 0xcd,
0x8f, 0x1d, 0x4f, 0x8d, 0xdf, 0x64, 0xc4, 0x3d, 0x20, 0xae, 0x8d, 0x49, 0xb6, 0x45, 0xc1, 0x6b,
0x46, 0xc9, 0xab, 0x01, 0x7a, 0x04, 0xd9, 0x58, 0x0f, 0xe3, 0x63, 0x02, 0x76, 0x6c, 0xc3, 0xe3,
0xf7, 0x35, 0x58, 0x0c, 0x9f, 0x41, 0x5b, 0xb8, 0xd9, 0xc6, 0x1e, 0xbd, 0x7f, 0x1b, 0x1a, 0xb4,
0x80, 0x8c, 0xc2, 0x02, 0xce, 0x40, 0x89, 0x88, 0x75, 0xa2, 0x17, 0x4e, 0x1f, 0x60, 0x7c, 0xa8,
0xc1, 0xe9, 0x21, 0x76, 0x26, 0xd9, 0xc4, 0x25, 0x28, 0x38, 0x9e, 0x8d, 0xef, 0x45, 0xdc, 0x84,
0xbf, 0x6c, 0x64, 0xbb, 0xeb, 0xb8, 0x76, 0xc4, 0x46, 0xf8, 0x8b, 0x56, 0x40, 0xc7, 0x9e, 0xb5,
0xed, 0xe2, 0x3a, 0xc7, 0xe5, 0x86, 0x5c, 0x34, 0xcb, 0x02, 0xb6, 0xc1, 0x40, 0xc6, 0x0f, 0x34,
0x98, 0x63, 0xb6, 0x26, 0x79, 0x24, 0x9f, 0xaf, 0xce, 0x96, 0xa1, 0x1c, 0x33, 0x26, 0xc9, 0x6e,
0x1c, 0x64, 0xec, 0xc2, 0x7c, 0x92, 0x9d, 0x49, 0x74, 0xf6, 0x10, 0x40, 0xb4, 0x23, 0xc2, 0xe6,
0xb3, 0x66, 0x0c, 0x62, 0x7c, 0xaa, 0x01, 0x12, 0x57, 0x2a, 0xae, 0x8c, 0x23, 0xce, 0xb8, 0xec,
0x38, 0xd8, 0xb5, 0xe3, 0x5e, 0xbb, 0xc4, 0x21, 0x7c, 0x78, 0x1d, 0x74, 0x7c, 0x8f, 0x06, 0x56,
0xbd, 0x63, 0x05, 0x56, 0x5b, 0x1c, 0x9e, 0xb1, 0x1c, 0x6c, 0x99, 0x93, 0x6d, 0x72, 0x2a, 0xe3,
0x8f, 0xec, 0x32, 0x26, 0x8d, 0xf2, 0xb8, 0x4b, 0x7c, 0x16, 0x80, 0x1b, 0xad, 0x18, 0xce, 0x89,
0x61, 0x0e, 0xe1, 0x21, 0xec, 0x43, 0x0d, 0xaa, 0x5c, 0x04, 0x21, 0x4f, 0x87, 0x4d, 0x3b, 0x40,
0xa3, 0x0d, 0xd0, 0x8c, 0x38, 0x42, 0x5f, 0x82, 0xbc, 0x54, 0x6c, 0x76, 0x5c, 0xc5, 0x4a, 0x82,
0x03, 0xc4, 0x30, 0x7e, 0xae, 0xc1, 0xc2, 0x80, 0xca, 0x27, 0xb1, 0xe8, 0x57, 0x01, 0x09, 0x09,
0xed, 0xbe, 0xd8, 0x61, 0xb8, 0x3d, 0xaf, 0x8c, 0x2d, 0x83, 0x4a, 0x32, 0x4f, 0x39, 0x03, 0x10,
0x62, 0xfc, 0x45, 0x83, 0x33, 0xb7, 0x30, 0xe5, 0xa8, 0x37, 0x98, 0xef, 0xd8, 0x0c, 0xfc, 0x66,
0x80, 0x09, 0x39, 0xb9, 0xf6, 0xf1, 0x13, 0x71, 0x3f, 0x53, 0x89, 0x34, 0x89, 0xfe, 0x57, 0x40,
0xe7, 0x6b, 0x60, 0xbb, 0x1e, 0xf8, 0xfb, 0x44, 0xda, 0x51, 0x59, 0xc2, 0x4c, 0x7f, 0x9f, 0x1b,
0x04, 0xf5, 0xa9, 0xe5, 0x0a, 0x04, 0x19, 0x18, 0x38, 0x84, 0x0d, 0xf3, 0x33, 0x18, 0x32, 0xc6,
0x26, 0xc7, 0x27, 0x57, 0xc7, 0xbf, 0xd4, 0x60, 0x61, 0x40, 0x94, 0x49, 0x74, 0xfb, 0x94, 0xb8,
0x3d, 0x0a, 0x61, 0x66, 0xd6, 0xce, 0x29, 0x69, 0x62, 0x8b, 0x09, 0x6c, 0x74, 0x0e, 0xca, 0x3b,
0x96, 0xe3, 0xd6, 0x03, 0x6c, 0x11, 0xdf, 0x93, 0x82, 0x02, 0x03, 0x99, 0x1c, 0x62, 0x7c, 0xa2,
0x41, 0x95, 0x3d, 0x41, 0x4f, 0xb8, 0xc7, 0xfb, 0x45, 0x06, 0x2a, 0x1b, 0x1e, 0xc1, 0x01, 0x3d,
0xfe, 0x2f, 0x0c, 0xf4, 0x3c, 0x94, 0xb9, 0x60, 0xa4, 0x6e, 0x5b, 0xd4, 0x92, 0xe1, 0xea, 0x21,
0x65, 0x16, 0xf9, 0x45, 0x86, 0xb7, 0x6e, 0x51, 0xcb, 0x14, 0xda, 0x21, 0xec, 0x1b, 0x3d, 0x08,
0xa5, 0x96, 0x45, 0x5a, 0xf5, 0x5d, 0xdc, 0x13, 0xd7, 0xbe, 0x8a, 0x59, 0x64, 0x80, 0x97, 0x70,
0x8f, 0xa0, 0x07, 0xa0, 0xe8, 0x75, 0xdb, 0xe2, 0x80, 0x15, 0x96, 0xb5, 0xd5, 0x8a, 0x59, 0xf0,
0xba, 0x6d, 0x7e, 0xbc, 0xfe, 0x94, 0x81, 0x99, 0xbb, 0x5d, 0xf6, 0x9e, 0xe1, 0x39, 0xf0, 0xae,
0x4b, 0xef, 0xcf, 0x18, 0x2f, 0x42, 0x56, 0xdc, 0x19, 0x18, 0xc5, 0x92, 0x92, 0xf1, 0x8d, 0x75,
0x62, 0x32, 0x24, 0x5e, 0x67, 0xea, 0x36, 0x1a, 0xf2, 0x92, 0x95, 0xe5, 0xcc, 0x96, 0x18, 0x84,
0x5b, 0x1c, 0x13, 0x05, 0x07, 0x41, 0x74, 0x05, 0xe3, 0xa2, 0xe0, 0x20, 0x10, 0x83, 0x06, 0xe8,
0x56, 0x63, 0xd7, 0xf3, 0xf7, 0x5d, 0x6c, 0x37, 0xb1, 0xcd, 0xb7, 0xbd, 0x68, 0x26, 0x60, 0xc2,
0x30, 0xd8, 0xc6, 0xd7, 0x1b, 0x1e, 0xe5, 0x0f, 0x89, 0x2c, 0x33, 0x0c, 0x06, 0xb9, 0xe9, 0x51,
0x36, 0x6c, 0x63, 0x17, 0x53, 0xcc, 0x87, 0x0b, 0x62, 0x58, 0x40, 0xe4, 0x70, 0xb7, 0x13, 0x51,
0x17, 0xc5, 0xb0, 0x80, 0xb0, 0xe1, 0x33, 0x50, 0xea, 0x27, 0xb9, 0x4b, 0xfd, 0x6c, 0xa0, 0x48,
0x6d, 0xef, 0x41, 0x75, 0xd3, 0xb5, 0x1a, 0xb8, 0xe5, 0xbb, 0x36, 0x0e, 0x78, 0xf4, 0x43, 0x55,
0xc8, 0x52, 0xab, 0x29, 0xc3, 0x2b, 0xfb, 0x44, 0xcf, 0xc8, 0x37, 0x8e, 0x38, 0xb8, 0x8f, 0x28,
0xe3, 0x50, 0x6c, 0x9a, 0x58, 0xea, 0x70, 0x11, 0xf2, 0xbc, 0x34, 0x23, 0x02, 0xaf, 0x6e, 0xca,
0x3f, 0xe3, 0xad, 0xc4, 0xba, 0xb7, 0x02, 0xbf, 0xdb, 0x41, 0x1b, 0xa0, 0x77, 0xfa, 0x30, 0xb6,
0x9b, 0xe9, 0x51, 0x6f, 0x90, 0x69, 0x33, 0x41, 0x6a, 0x7c, 0x9a, 0x85, 0xca, 0x16, 0xb6, 0x82,
0x46, 0xeb, 0x24, 0x24, 0x1b, 0x98, 0xc6, 0x6d, 0xe2, 0x4a, 0x97, 0xc0, 0x3e, 0xd1, 0x25, 0x38,
0x15, 0x13, 0xa8, 0xde, 0x64, 0x0a, 0xe2, 0x96, 0xa1, 0x9b, 0xd5, 0xce, 0xa0, 0xe2, 0x9e, 0x86,
0xa2, 0x4d, 0xdc, 0x3a, 0xdf, 0xa2, 0x02, 0xdf, 0x22, 0xb5, 0x7c, 0xeb, 0xc4, 0xe5, 0x5b, 0x53,
0xb0, 0xc5, 0x07, 0x7a, 0x18, 0x2a, 0x7e, 0x97, 0x76, 0xba, 0xb4, 0x2e, 0x4e, 0xe6, 0x52, 0x91,
0xb3, 0xa7, 0x0b, 0x20, 0x3f, 0xb8, 0x04, 0xbd, 0x08, 0x15, 0xc2, 0x55, 0x19, 0xde, 0x4d, 0x4b,
0xe3, 0x5e, 0xa1, 0x74, 0x41, 0x27, 0x2e, 0xa7, 0xe8, 0x02, 0x54, 0x69, 0x60, 0xed, 0x61, 0x37,
0x56, 0x74, 0x01, 0x6e, 0x8f, 0xb3, 0x02, 0xde, 0x2f, 0xd2, 0x5c, 0x81, 0xb9, 0x66, 0xd7, 0x0a,
0x2c, 0x8f, 0x62, 0x1c, 0xc3, 0x2e, 0x73, 0x6c, 0x14, 0x0d, 0xf5, 0x2b, 0x34, 0x7f, 0xcf, 0xc0,
0xac, 0x89, 0x69, 0xe0, 0xe0, 0x3d, 0x7c, 0x22, 0x76, 0xfc, 0x22, 0x64, 0x1d, 0x9b, 0xf0, 0x1d,
0x1f, 0xe9, 0x7e, 0x1c, 0x9b, 0x0c, 0xef, 0x52, 0x5e, 0xb1, 0x4b, 0x2a, 0xed, 0x16, 0x0e, 0xa5,
0xdd, 0x62, 0xaa, 0x76, 0x3f, 0xd6, 0xe2, 0xda, 0x65, 0x3e, 0x97, 0xdc, 0xb7, 0xd3, 0x65, 0x52,
0x67, 0xc6, 0x91, 0x7a, 0x20, 0xc2, 0x64, 0x0f, 0x1b, 0x61, 0x8c, 0x97, 0x60, 0xfa, 0xb6, 0x43,
0xf9, 0xe1, 0x62, 0x9e, 0x5e, 0xe3, 0xaf, 0x43, 0xee, 0xcf, 0x1f, 0x80, 0x62, 0xe0, 0xef, 0x8b,
0x79, 0x33, 0xdc, 0x2d, 0x15, 0x02, 0x7f, 0x9f, 0x87, 0x25, 0xde, 0x6a, 0xe0, 0x07, 0xd2, 0x5f,
0x65, 0x4c, 0xf9, 0x67, 0x7c, 0x47, 0xeb, 0x3b, 0x94, 0x09, 0x14, 0xf0, 0x3c, 0x14, 0x02, 0x41,
0x3f, 0xb2, 0xf0, 0x1a, 0x5f, 0x89, 0xcb, 0x15, 0x52, 0x19, 0xef, 0x6a, 0xa0, 0xbf, 0xe8, 0x76,
0xc9, 0xe7, 0xe1, 0xd7, 0x54, 0xa5, 0x96, 0xac, 0xba, 0xcc, 0xf3, 0xc3, 0x0c, 0x54, 0x24, 0x1b,
0x93, 0xdc, 0x08, 0x53, 0x59, 0xd9, 0x82, 0x32, 0x5b, 0xb2, 0x4e, 0x70, 0x33, 0xcc, 0x53, 0x95,
0xd7, 0xd6, 0x94, 0x91, 0x20, 0xc1, 0x06, 0x2f, 0x59, 0x6f, 0x71, 0xa2, 0xaf, 0x79, 0x34, 0xe8,
0x99, 0xd0, 0x88, 0x00, 0xb5, 0xb7, 0x60, 0x76, 0x60, 0x98, 0xd9, 0xc6, 0x2e, 0xee, 0x85, 0xa1,
0x6e, 0x17, 0xf7, 0xd0, 0x93, 0xf1, 0xc6, 0x82, 0x34, 0x83, 0xbb, 0xe3, 0x7b, 0xcd, 0xeb, 0x41,
0x60, 0xf5, 0x64, 0xe3, 0xc1, 0xb3, 0x99, 0x67, 0x34, 0xe3, 0x9f, 0x1a, 0xe8, 0xaf, 0x74, 0x71,
0xd0, 0x3b, 0x4a, 0x07, 0x84, 0x60, 0x1a, 0xdf, 0xeb, 0x04, 0xf2, 0xd2, 0xc6, 0xbf, 0x87, 0xfd,
0x47, 0x4e, 0xe1, 0x3f, 0x14, 0x9e, 0x2b, 0xaf, 0x4c, 0x8c, 0xbf, 0xdb, 0x17, 0x73, 0xa2, 0x83,
0x90, 0x38, 0xdd, 0x99, 0x43, 0x9f, 0xee, 0x8f, 0x34, 0x28, 0xbd, 0x8e, 0x1b, 0xd4, 0x0f, 0xd8,
0x89, 0x56, 0xe8, 0x47, 0x1b, 0xe3, 0x8a, 0x9e, 0x19, 0xbc, 0xa2, 0x5f, 0x83, 0xa2, 0x63, 0xd7,
0x2d, 0xb6, 0xb5, 0x5c, 0xc1, 0xa3, 0xbc, 0x54, 0xc1, 0xb1, 0xb9, 0x0d, 0x8c, 0x5f, 0x53, 0xf8,
0xa9, 0x06, 0xba, 0xe0, 0x99, 0x08, 0xca, 0xe7, 0x62, 0xcb, 0x69, 0x2a, 0x7b, 0x93, 0x3f, 0x91,
0xa0, 0xb7, 0xa7, 0xfa, 0xcb, 0x5e, 0x07, 0x60, 0xba, 0x93, 0xe4, 0xc2, 0x5c, 0x97, 0x95, 0xdc,
0x0a, 0x72, 0xae, 0xc7, 0xdb, 0x53, 0x66, 0x89, 0x51, 0xf1, 0x29, 0x6e, 0x14, 0x20, 0xc7, 0xa9,
0x8d, 0xff, 0x68, 0x30, 0x77, 0xd3, 0x72, 0x1b, 0xeb, 0x0e, 0xa1, 0x96, 0xd7, 0x98, 0x20, 0x86,
0x3e, 0x0b, 0x05, 0xbf, 0x53, 0x77, 0xf1, 0x0e, 0x95, 0x2c, 0xad, 0x8c, 0x90, 0x48, 0xa8, 0xc1,
0xcc, 0xfb, 0x9d, 0x3b, 0x78, 0x87, 0xa2, 0x2f, 0x43, 0xd1, 0xef, 0xd4, 0x03, 0xa7, 0xd9, 0xa2,
0x52, 0xfb, 0x63, 0x10, 0x17, 0xfc, 0x8e, 0xc9, 0x28, 0x62, 0x39, 0x9e, 0xe9, 0x43, 0xe6, 0x78,
0x8c, 0xbf, 0x0e, 0x89, 0x3f, 0x81, 0x69, 0x3f, 0x0b, 0x45, 0xc7, 0xa3, 0x75, 0xdb, 0x21, 0xa1,
0x0a, 0xce, 0xaa, 0x6d, 0xc8, 0xa3, 0x5c, 0x02, 0xbe, 0xa7, 0x1e, 0x65, 0x6b, 0xa3, 0x17, 0x00,
0x76, 0x5c, 0xdf, 0x92, 0xd4, 0x42, 0x07, 0xe7, 0xd4, 0xa7, 0x82, 0xa1, 0x85, 0xf4, 0x25, 0x4e,
0xc4, 0x66, 0xe8, 0x6f, 0xe9, 0x9f, 0x35, 0x58, 0xd8, 0xc4, 0x01, 0x71, 0x08, 0xc5, 0x1e, 0x95,
0xf9, 0xd6, 0x0d, 0x6f, 0xc7, 0x4f, 0x26, 0xb6, 0xb5, 0x81, 0xc4, 0xf6, 0x67, 0x93, 0xe6, 0x4d,
0xbc, 0xe0, 0x44, 0x79, 0x25, 0x7c, 0xc1, 0x85, 0x45, 0x24, 0xf1, 0x02, 0x9e, 0x49, 0xd9, 0x26,
0xc9, 0x6f, 0x3c, 0x11, 0x60, 0xfc, 0x48, 0x34, 0x74, 0x28, 0x85, 0xba, 0x7f, 0x83, 0x5d, 0x04,
0xe9, 0x64, 0x07, 0x5c, 0xee, 0x17, 0x60, 0xc0, 0x77, 0xa4, 0xb4, 0x99, 0xfc, 0x4c, 0x83, 0xe5,
0x74, 0xae, 0x26, 0x89, 0x8e, 0x2f, 0x40, 0xce, 0xf1, 0x76, 0xfc, 0x30, 0xfd, 0x77, 0x51, 0xfd,
0x10, 0x52, 0xae, 0x2b, 0x08, 0x8d, 0x7f, 0x69, 0x50, 0xe5, 0xbe, 0xfa, 0x08, 0xb6, 0xbf, 0x8d,
0xdb, 0x75, 0xe2, 0xbc, 0x8d, 0xc3, 0xed, 0x6f, 0xe3, 0xf6, 0x96, 0xf3, 0x36, 0x4e, 0x58, 0x46,
0x2e, 0x69, 0x19, 0xc9, 0x04, 0x49, 0x7e, 0x44, 0x7a, 0xb7, 0x90, 0x48, 0xef, 0x1a, 0xef, 0x6b,
0x50, 0xbb, 0x85, 0xe9, 0xa0, 0xa8, 0x47, 0x67, 0x14, 0x1f, 0x68, 0xf0, 0xa0, 0x92, 0xa1, 0x49,
0xec, 0xe1, 0xb9, 0xa4, 0x3d, 0xa8, 0x1f, 0xc6, 0x43, 0x4b, 0x4a, 0x53, 0xb8, 0x0a, 0xfa, 0x7a,
0xb7, 0xdd, 0x8e, 0x2e, 0x27, 0x2b, 0xa0, 0x07, 0xe2, 0x53, 0xbc, 0x1b, 0x45, 0xb8, 0x2c, 0x4b,
0x18, 0x7b, 0x1d, 0x1a, 0x97, 0xa0, 0x22, 0x49, 0x24, 0xd7, 0x35, 0x28, 0x06, 0xf2, 0x5b, 0xe2,
0x47, 0xff, 0xc6, 0x02, 0xcc, 0x99, 0xb8, 0xc9, 0x2c, 0x31, 0xb8, 0xe3, 0x78, 0xbb, 0x72, 0x19,
0xe3, 0x1d, 0x0d, 0xe6, 0x93, 0x70, 0x39, 0xd7, 0x17, 0xa1, 0x60, 0xd9, 0x76, 0x80, 0x09, 0x19,
0xb9, 0x2d, 0xd7, 0x05, 0x8e, 0x19, 0x22, 0xc7, 0x34, 0x97, 0x19, 0x5b, 0x73, 0x17, 0x57, 0xa0,
0x18, 0x96, 0x60, 0x51, 0x01, 0xb2, 0xd7, 0x5d, 0xb7, 0x3a, 0x85, 0x74, 0x28, 0x6e, 0xc8, 0x3a,
0x63, 0x55, 0xbb, 0xf8, 0x55, 0x98, 0x1d, 0xc8, 0x60, 0xa0, 0x22, 0x4c, 0xbf, 0xec, 0x7b, 0xb8,
0x3a, 0x85, 0xaa, 0xa0, 0xdf, 0x70, 0x3c, 0x2b, 0xe8, 0x89, 0xc8, 0x53, 0xb5, 0xd1, 0x2c, 0x94,
0xb9, 0x07, 0x96, 0x00, 0xbc, 0xf6, 0xef, 0xd3, 0x50, 0xb9, 0xcb, 0x39, 0xd9, 0xc2, 0xc1, 0x9e,
0xd3, 0xc0, 0xa8, 0x0e, 0xd5, 0xc1, 0x26, 0x6a, 0xf4, 0x98, 0x72, 0xcf, 0x52, 0x7a, 0xad, 0x6b,
0xa3, 0x64, 0x33, 0xa6, 0xd0, 0x9b, 0x30, 0x93, 0x6c, 0x6f, 0x46, 0x6a, 0x17, 0xa1, 0xec, 0x81,
0x3e, 0x68, 0xf2, 0x3a, 0x54, 0x12, 0xdd, 0xca, 0xe8, 0x82, 0x72, 0x6e, 0x55, 0x47, 0x73, 0x4d,
0x1d, 0xb5, 0xe3, 0x1d, 0xc5, 0x82, 0xfb, 0x64, 0x4f, 0x65, 0x0a, 0xf7, 0xca, 0xc6, 0xcb, 0x83,
0xb8, 0xb7, 0xe0, 0xd4, 0x50, 0x8b, 0x24, 0x7a, 0x5c, 0x39, 0x7f, 0x5a, 0x2b, 0xe5, 0x41, 0x4b,
0xec, 0x03, 0x1a, 0xee, 0xca, 0x45, 0x97, 0xd5, 0x3b, 0x90, 0xd6, 0x93, 0x5c, 0xbb, 0x32, 0x36,
0x7e, 0xa4, 0xb8, 0xef, 0x6a, 0x70, 0x3a, 0xa5, 0xaf, 0x11, 0x5d, 0x53, 0x4e, 0x37, 0xba, 0x39,
0xb3, 0xf6, 0xe4, 0xe1, 0x88, 0x22, 0x46, 0x3c, 0x98, 0x1d, 0x68, 0xf5, 0x43, 0x97, 0x52, 0xdb,
0x1f, 0x86, 0x7b, 0x1e, 0x6b, 0x8f, 0x8d, 0x87, 0x1c, 0xad, 0xc7, 0xde, 0x6f, 0xc9, 0xfe, 0xb8,
0x94, 0xf5, 0xd4, 0x5d, 0x74, 0x07, 0x6d, 0xe8, 0x1b, 0x50, 0x49, 0x34, 0xb2, 0xa5, 0x58, 0xbc,
0xaa, 0xd9, 0xed, 0xa0, 0xa9, 0xdf, 0x02, 0x3d, 0xde, 0x6f, 0x86, 0x56, 0xd3, 0xce, 0xd2, 0xd0,
0xc4, 0x87, 0x39, 0x4a, 0xfd, 0x76, 0x92, 0x11, 0x47, 0x69, 0xa8, 0x03, 0x67, 0xfc, 0xa3, 0x14,
0x9b, 0x7f, 0xe4, 0x51, 0x3a, 0xf4, 0x12, 0xef, 0x68, 0xb0, 0xa8, 0x6e, 0x57, 0x42, 0x6b, 0x69,
0xb6, 0x99, 0xde, 0x98, 0x55, 0xbb, 0x76, 0x28, 0x9a, 0x48, 0x8b, 0xbb, 0x30, 0x93, 0x6c, 0xca,
0x49, 0xd1, 0xa2, 0xb2, 0x8f, 0xa9, 0x76, 0x69, 0x2c, 0xdc, 0x68, 0xb1, 0xd7, 0xa0, 0x1c, 0x6b,
0x4c, 0x40, 0x8f, 0x8e, 0xb0, 0xe3, 0x78, 0x59, 0xeb, 0x20, 0x4d, 0xb6, 0xa0, 0x92, 0x28, 0x46,
0xa7, 0xd9, 0xb0, 0xa2, 0x47, 0xa0, 0x76, 0x71, 0x1c, 0xd4, 0x48, 0x80, 0x16, 0x54, 0x12, 0xa5,
0xc1, 0x94, 0x95, 0x54, 0x95, 0xd0, 0x94, 0x95, 0x94, 0x95, 0x46, 0x63, 0x0a, 0x7d, 0x3b, 0x56,
0x85, 0x4c, 0x54, 0x7a, 0xd1, 0xd5, 0x91, 0xf3, 0xa8, 0x0a, 0xdd, 0xb5, 0xb5, 0xc3, 0x90, 0x44,
0x2c, 0xbc, 0x02, 0xa5, 0xa8, 0xc0, 0x88, 0xce, 0xa7, 0xba, 0x85, 0xc3, 0xec, 0xd4, 0x16, 0xe4,
0x45, 0xb1, 0x0f, 0x19, 0x29, 0x65, 0xfd, 0x58, 0x25, 0xb0, 0xf6, 0xb0, 0x12, 0x27, 0x59, 0x07,
0x33, 0xa6, 0x90, 0x09, 0x79, 0x91, 0x3a, 0x4c, 0x99, 0x34, 0x51, 0x12, 0xa9, 0x8d, 0xc6, 0x11,
0xf9, 0xc6, 0x29, 0xf4, 0x0d, 0x28, 0x86, 0xb9, 0x5f, 0xf4, 0x48, 0xca, 0xb1, 0x4f, 0x24, 0xde,
0x6b, 0x07, 0x61, 0x85, 0x33, 0x6f, 0x42, 0x8e, 0x27, 0xef, 0xd0, 0xca, 0xa8, 0xc4, 0xde, 0x28,
0x5e, 0x13, 0xb9, 0x3f, 0x63, 0x0a, 0x7d, 0x1d, 0x72, 0xfc, 0xfe, 0x9b, 0x32, 0x63, 0x3c, 0x3b,
0x57, 0x1b, 0x89, 0x12, 0xb2, 0x68, 0x83, 0x1e, 0xcf, 0x0b, 0xa4, 0x38, 0x6e, 0x45, 0xe6, 0xa4,
0x36, 0x0e, 0x66, 0xb8, 0xca, 0xf7, 0x34, 0x58, 0x4a, 0x7b, 0x42, 0xa2, 0xd4, 0xe8, 0x3c, 0xea,
0x1d, 0x5c, 0x7b, 0xea, 0x90, 0x54, 0x91, 0x0a, 0xdf, 0x86, 0x39, 0xc5, 0xc3, 0x05, 0x5d, 0x49,
0x9b, 0x2f, 0xe5, 0xcd, 0x55, 0x7b, 0x62, 0x7c, 0x82, 0x68, 0xed, 0x4d, 0xc8, 0xf1, 0x07, 0x47,
0xca, 0xf6, 0xc5, 0xdf, 0x2f, 0x29, 0x06, 0x91, 0x78, 0xaf, 0x18, 0x53, 0x08, 0x83, 0x1e, 0x7f,
0x7d, 0xa4, 0xec, 0x9f, 0xe2, 0xe1, 0x52, 0xbb, 0x30, 0x06, 0x66, 0xb8, 0xcc, 0x5a, 0x17, 0xf4,
0xcd, 0xc0, 0xbf, 0xd7, 0x0b, 0xaf, 0xfe, 0xff, 0x9f, 0x65, 0x6f, 0x3c, 0xf5, 0xcd, 0x6b, 0x4d,
0x87, 0xb6, 0xba, 0xdb, 0xcc, 0xbb, 0x5c, 0x11, 0xb8, 0x8f, 0x3b, 0xbe, 0xfc, 0xba, 0xe2, 0x78,
0x14, 0x07, 0x9e, 0xe5, 0x5e, 0xe1, 0x73, 0x49, 0x68, 0x67, 0x7b, 0x3b, 0xcf, 0xff, 0xaf, 0xfd,
0x2f, 0x00, 0x00, 0xff, 0xff, 0x0c, 0x57, 0x35, 0x52, 0x26, 0x3a, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.

20
internal/proto/query_coord.proto
View File

@ -47,22 +47,26 @@ service QueryNode {
message ShowCollectionsRequest {
common.MsgBase base = 1;
int64 dbID = 2;
repeated int64 collectionIDs = 3;
}
message ShowCollectionsResponse {
common.Status status = 1;
repeated int64 collectionIDs = 2;
repeated int64 inMemory_percentages = 3;
}
message ShowPartitionsRequest {
common.MsgBase base = 1;
int64 dbID = 2;
int64 collectionID = 3;
repeated int64 partitionIDs = 4;
}
message ShowPartitionsResponse {
common.Status status = 1;
repeated int64 partitionIDs = 2;
repeated int64 inMemory_percentages = 3;
}
message LoadCollectionRequest {
@ -126,6 +130,7 @@ enum PartitionState {
message PartitionStates {
int64 partitionID = 1;
PartitionState state = 2;
int64 inMemory_percentage = 3;
}
message GetPartitionStatesResponse {
@ -241,6 +246,11 @@ enum SegmentState {
sealed = 4;
}
enum LoadType {
LoadPartition = 0;
loadCollection = 1;
}
message DmChannelInfo {
int64 nodeID_loaded = 1;
repeated string channelIDs = 2;
@ -255,10 +265,12 @@ message QueryChannelInfo {
message CollectionInfo {
int64 collectionID = 1;
repeated int64 partitionIDs = 2;
repeated DmChannelInfo channel_infos = 3;
bool load_collection = 4;
schema.CollectionSchema schema = 5;
repeated int64 released_partitionIDs = 6;
repeated PartitionStates partition_states = 3;
repeated DmChannelInfo channel_infos = 4;
LoadType load_type = 5;
schema.CollectionSchema schema = 6;
repeated int64 released_partitionIDs = 7;
int64 inMemory_percentage = 8;
}
message HandoffSegments {

334
internal/proto/querypb/query_coord.pb.go
View File

@ -135,10 +135,36 @@ func (SegmentState) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_aab7cc9a69ed26e8, []int{2}
}
type LoadType int32
const (
LoadType_LoadPartition LoadType = 0
LoadType_loadCollection LoadType = 1
)
var LoadType_name = map[int32]string{
0: "LoadPartition",
1: "loadCollection",
}
var LoadType_value = map[string]int32{
"LoadPartition": 0,
"loadCollection": 1,
}
func (x LoadType) String() string {
return proto.EnumName(LoadType_name, int32(x))
}
func (LoadType) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_aab7cc9a69ed26e8, []int{3}
}
//--------------------query coordinator proto------------------
type ShowCollectionsRequest struct {
Base *commonpb.MsgBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
DbID int64 `protobuf:"varint,2,opt,name=dbID,proto3" json:"dbID,omitempty"`
CollectionIDs []int64 `protobuf:"varint,3,rep,packed,name=collectionIDs,proto3" json:"collectionIDs,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
@ -183,9 +209,17 @@ func (m *ShowCollectionsRequest) GetDbID() int64 {
return 0
}
func (m *ShowCollectionsRequest) GetCollectionIDs() []int64 {
if m != nil {
return m.CollectionIDs
}
return nil
}
type ShowCollectionsResponse struct {
Status *commonpb.Status `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
CollectionIDs []int64 `protobuf:"varint,2,rep,packed,name=collectionIDs,proto3" json:"collectionIDs,omitempty"`
InMemoryPercentages []int64 `protobuf:"varint,3,rep,packed,name=inMemory_percentages,json=inMemoryPercentages,proto3" json:"inMemory_percentages,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
@ -230,10 +264,18 @@ func (m *ShowCollectionsResponse) GetCollectionIDs() []int64 {
return nil
}
func (m *ShowCollectionsResponse) GetInMemoryPercentages() []int64 {
if m != nil {
return m.InMemoryPercentages
}
return nil
}
type ShowPartitionsRequest struct {
Base *commonpb.MsgBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
DbID int64 `protobuf:"varint,2,opt,name=dbID,proto3" json:"dbID,omitempty"`
CollectionID int64 `protobuf:"varint,3,opt,name=collectionID,proto3" json:"collectionID,omitempty"`
PartitionIDs []int64 `protobuf:"varint,4,rep,packed,name=partitionIDs,proto3" json:"partitionIDs,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
@ -285,9 +327,17 @@ func (m *ShowPartitionsRequest) GetCollectionID() int64 {
return 0
}
func (m *ShowPartitionsRequest) GetPartitionIDs() []int64 {
if m != nil {
return m.PartitionIDs
}
return nil
}
type ShowPartitionsResponse struct {
Status *commonpb.Status `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
PartitionIDs []int64 `protobuf:"varint,2,rep,packed,name=partitionIDs,proto3" json:"partitionIDs,omitempty"`
InMemoryPercentages []int64 `protobuf:"varint,3,rep,packed,name=inMemory_percentages,json=inMemoryPercentages,proto3" json:"inMemory_percentages,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
@ -332,6 +382,13 @@ func (m *ShowPartitionsResponse) GetPartitionIDs() []int64 {
return nil
}
func (m *ShowPartitionsResponse) GetInMemoryPercentages() []int64 {
if m != nil {
return m.InMemoryPercentages
}
return nil
}
type LoadCollectionRequest struct {
Base *commonpb.MsgBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
DbID int64 `protobuf:"varint,2,opt,name=dbID,proto3" json:"dbID,omitempty"`
@ -768,6 +825,7 @@ func (m *GetPartitionStatesRequest) GetPartitionIDs() []int64 {
type PartitionStates struct {
PartitionID int64 `protobuf:"varint,1,opt,name=partitionID,proto3" json:"partitionID,omitempty"`
State PartitionState `protobuf:"varint,2,opt,name=state,proto3,enum=milvus.proto.query.PartitionState" json:"state,omitempty"`
InMemoryPercentage int64 `protobuf:"varint,3,opt,name=inMemory_percentage,json=inMemoryPercentage,proto3" json:"inMemory_percentage,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
@ -812,6 +870,13 @@ func (m *PartitionStates) GetState() PartitionState {
return PartitionState_NotExist
}
func (m *PartitionStates) GetInMemoryPercentage() int64 {
if m != nil {
return m.InMemoryPercentage
}
return 0
}
type GetPartitionStatesResponse struct {
Status *commonpb.Status `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
PartitionDescriptions []*PartitionStates `protobuf:"bytes,2,rep,name=partition_descriptions,json=partitionDescriptions,proto3" json:"partition_descriptions,omitempty"`
@ -1629,10 +1694,12 @@ func (m *QueryChannelInfo) GetQueryResultChannelID() string {
type CollectionInfo struct {
CollectionID int64 `protobuf:"varint,1,opt,name=collectionID,proto3" json:"collectionID,omitempty"`
PartitionIDs []int64 `protobuf:"varint,2,rep,packed,name=partitionIDs,proto3" json:"partitionIDs,omitempty"`
ChannelInfos []*DmChannelInfo `protobuf:"bytes,3,rep,name=channel_infos,json=channelInfos,proto3" json:"channel_infos,omitempty"`
LoadCollection bool `protobuf:"varint,4,opt,name=load_collection,json=loadCollection,proto3" json:"load_collection,omitempty"`
Schema *schemapb.CollectionSchema `protobuf:"bytes,5,opt,name=schema,proto3" json:"schema,omitempty"`
ReleasedPartitionIDs []int64 `protobuf:"varint,6,rep,packed,name=released_partitionIDs,json=releasedPartitionIDs,proto3" json:"released_partitionIDs,omitempty"`
PartitionStates []*PartitionStates `protobuf:"bytes,3,rep,name=partition_states,json=partitionStates,proto3" json:"partition_states,omitempty"`
ChannelInfos []*DmChannelInfo `protobuf:"bytes,4,rep,name=channel_infos,json=channelInfos,proto3" json:"channel_infos,omitempty"`
LoadType LoadType `protobuf:"varint,5,opt,name=load_type,json=loadType,proto3,enum=milvus.proto.query.LoadType" json:"load_type,omitempty"`
Schema *schemapb.CollectionSchema `protobuf:"bytes,6,opt,name=schema,proto3" json:"schema,omitempty"`
ReleasedPartitionIDs []int64 `protobuf:"varint,7,rep,packed,name=released_partitionIDs,json=releasedPartitionIDs,proto3" json:"released_partitionIDs,omitempty"`
InMemoryPercentage int64 `protobuf:"varint,8,opt,name=inMemory_percentage,json=inMemoryPercentage,proto3" json:"inMemory_percentage,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
@ -1677,6 +1744,13 @@ func (m *CollectionInfo) GetPartitionIDs() []int64 {
return nil
}
func (m *CollectionInfo) GetPartitionStates() []*PartitionStates {
if m != nil {
return m.PartitionStates
}
return nil
}
func (m *CollectionInfo) GetChannelInfos() []*DmChannelInfo {
if m != nil {
return m.ChannelInfos
@ -1684,11 +1758,11 @@ func (m *CollectionInfo) GetChannelInfos() []*DmChannelInfo {
return nil
}
func (m *CollectionInfo) GetLoadCollection() bool {
func (m *CollectionInfo) GetLoadType() LoadType {
if m != nil {
return m.LoadCollection
return m.LoadType
}
return false
return LoadType_LoadPartition
}
func (m *CollectionInfo) GetSchema() *schemapb.CollectionSchema {
@ -1705,6 +1779,13 @@ func (m *CollectionInfo) GetReleasedPartitionIDs() []int64 {
return nil
}
func (m *CollectionInfo) GetInMemoryPercentage() int64 {
if m != nil {
return m.InMemoryPercentage
}
return 0
}
type HandoffSegments struct {
Base *commonpb.MsgBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
Infos []*SegmentLoadInfo `protobuf:"bytes,2,rep,name=infos,proto3" json:"infos,omitempty"`
@ -1906,6 +1987,7 @@ func init() {
proto.RegisterEnum("milvus.proto.query.PartitionState", PartitionState_name, PartitionState_value)
proto.RegisterEnum("milvus.proto.query.TriggerCondition", TriggerCondition_name, TriggerCondition_value)
proto.RegisterEnum("milvus.proto.query.SegmentState", SegmentState_name, SegmentState_value)
proto.RegisterEnum("milvus.proto.query.LoadType", LoadType_name, LoadType_value)
proto.RegisterType((*ShowCollectionsRequest)(nil), "milvus.proto.query.ShowCollectionsRequest")
proto.RegisterType((*ShowCollectionsResponse)(nil), "milvus.proto.query.ShowCollectionsResponse")
proto.RegisterType((*ShowPartitionsRequest)(nil), "milvus.proto.query.ShowPartitionsRequest")
@ -1939,122 +2021,128 @@ func init() {
func init() { proto.RegisterFile("query_coord.proto", fileDescriptor_aab7cc9a69ed26e8) }
var fileDescriptor_aab7cc9a69ed26e8 = []byte{
// 1831 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x58, 0xcd, 0x6f, 0x24, 0x47,
0x15, 0x77, 0xcf, 0x97, 0x67, 0xde, 0x7c, 0xf5, 0x56, 0xd6, 0xc3, 0xec, 0x90, 0x4d, 0x4c, 0x6f,
0x96, 0xdd, 0x38, 0xc4, 0x1b, 0xcd, 0x06, 0x89, 0x1c, 0x38, 0x64, 0x3d, 0x59, 0x33, 0x90, 0x38,
0xa6, 0xbd, 0x04, 0xb1, 0x5a, 0xd1, 0xf4, 0x4c, 0x97, 0x67, 0x5a, 0xe9, 0xee, 0x1a, 0x77, 0xf5,
0xac, 0xbd, 0x3e, 0x20, 0x21, 0x71, 0xe6, 0xc6, 0x09, 0x2e, 0x5c, 0x90, 0x38, 0xf0, 0x0f, 0x20,
0x21, 0xe5, 0x1f, 0x01, 0x09, 0x91, 0x1b, 0xff, 0x04, 0xaa, 0x8f, 0xee, 0xe9, 0xaf, 0xb1, 0xc7,
0x76, 0x1c, 0x47, 0x88, 0x5b, 0xd7, 0xab, 0x57, 0xef, 0xbb, 0x7e, 0xfd, 0xea, 0xc1, 0xad, 0xa3,
0x39, 0xf6, 0x5f, 0x19, 0x63, 0x42, 0x7c, 0x6b, 0x7b, 0xe6, 0x93, 0x80, 0x20, 0xe4, 0xda, 0xce,
0xcb, 0x39, 0x15, 0xab, 0x6d, 0xbe, 0xdf, 0x6b, 0x8c, 0x89, 0xeb, 0x12, 0x4f, 0xd0, 0x7a, 0x8d,
0x38, 0x47, 0xaf, 0x65, 0x7b, 0x01, 0xf6, 0x3d, 0xd3, 0x09, 0x77, 0xe9, 0x78, 0x8a, 0x5d, 0x53,
0xae, 0x54, 0xcb, 0x0c, 0xcc, 0xb8, 0x7c, 0xed, 0x97, 0xd0, 0x39, 0x98, 0x92, 0xe3, 0x1d, 0xe2,
0x38, 0x78, 0x1c, 0xd8, 0xc4, 0xa3, 0x3a, 0x3e, 0x9a, 0x63, 0x1a, 0xa0, 0xf7, 0xa0, 0x34, 0x32,
0x29, 0xee, 0x2a, 0x9b, 0xca, 0xc3, 0x7a, 0xff, 0xf5, 0xed, 0x84, 0x21, 0xd2, 0x82, 0x4f, 0xe8,
0xe4, 0x89, 0x49, 0xb1, 0xce, 0x39, 0x11, 0x82, 0x92, 0x35, 0x1a, 0x0e, 0xba, 0x85, 0x4d, 0xe5,
0x61, 0x51, 0xe7, 0xdf, 0x5a, 0x00, 0xdf, 0xca, 0xc8, 0xa7, 0x33, 0xe2, 0x51, 0x8c, 0x1e, 0x43,
0x85, 0x06, 0x66, 0x30, 0xa7, 0x52, 0xc5, 0xb7, 0x73, 0x55, 0x1c, 0x70, 0x16, 0x5d, 0xb2, 0xa2,
0xb7, 0xa0, 0x39, 0x8e, 0x64, 0x0d, 0x07, 0xb4, 0x5b, 0xd8, 0x2c, 0x3e, 0x2c, 0xea, 0x49, 0xa2,
0xf6, 0x1b, 0x05, 0x36, 0x98, 0xda, 0x7d, 0xd3, 0x0f, 0xec, 0xaf, 0xde, 0x2b, 0xa4, 0x41, 0x23,
0xae, 0xb0, 0x5b, 0xe4, 0x7b, 0x09, 0x9a, 0x76, 0x24, 0x22, 0x1b, 0x37, 0xe1, 0x2a, 0x8e, 0x6b,
0xd0, 0x98, 0x85, 0xa2, 0x16, 0x7e, 0x27, 0x68, 0xda, 0x17, 0x0a, 0x6c, 0x7c, 0x4c, 0x4c, 0x6b,
0x11, 0xed, 0xaf, 0xdd, 0x6d, 0xf4, 0x43, 0xa8, 0x88, 0x92, 0xeb, 0x96, 0xb8, 0xae, 0xfb, 0x49,
0x5d, 0xb2, 0x1c, 0x17, 0x16, 0x1e, 0x70, 0x82, 0x2e, 0x0f, 0x69, 0x7f, 0x54, 0xa0, 0xab, 0x63,
0x07, 0x9b, 0x14, 0xdf, 0xa4, 0x17, 0x1d, 0xa8, 0x78, 0xc4, 0xc2, 0xc3, 0x01, 0xf7, 0xa2, 0xa8,
0xcb, 0x95, 0xf6, 0xa5, 0x8c, 0xf0, 0x0d, 0x16, 0x56, 0xa6, 0x12, 0x4a, 0xd9, 0x4a, 0x88, 0x65,
0xa1, 0x7c, 0x99, 0x2c, 0x7c, 0xb1, 0xc8, 0xc2, 0x37, 0xdd, 0xd3, 0x45, 0xa6, 0xca, 0x89, 0x4c,
0xfd, 0x02, 0xee, 0xec, 0xf8, 0xd8, 0x0c, 0xf0, 0x4f, 0x19, 0x66, 0xee, 0x4c, 0x4d, 0xcf, 0xc3,
0x4e, 0xe8, 0x42, 0x5a, 0xb9, 0x92, 0xa3, 0xbc, 0x0b, 0xeb, 0x33, 0x9f, 0x9c, 0xbc, 0x8a, 0xec,
0x0e, 0x97, 0xda, 0x9f, 0x14, 0xe8, 0xe5, 0xc9, 0xbe, 0xca, 0xf5, 0x7e, 0x00, 0x6d, 0x5f, 0x18,
0x67, 0x8c, 0x85, 0x3c, 0xae, 0xb5, 0xa6, 0xb7, 0x24, 0x59, 0x6a, 0x41, 0xf7, 0xa1, 0xe5, 0x63,
0x3a, 0x77, 0x16, 0x7c, 0x45, 0xce, 0xd7, 0x14, 0x54, 0xc9, 0xa6, 0xfd, 0x45, 0x81, 0x3b, 0xbb,
0x38, 0x88, 0xb2, 0xc7, 0xd4, 0xe1, 0x6f, 0x66, 0x0a, 0x35, 0x17, 0xda, 0x29, 0x3b, 0xd1, 0x26,
0xd4, 0x63, 0x2c, 0x32, 0x3f, 0x71, 0x12, 0xfa, 0x01, 0x94, 0x59, 0xe8, 0x30, 0xb7, 0xa8, 0xd5,
0xd7, 0xb6, 0xb3, 0x3f, 0xca, 0xed, 0xa4, 0x54, 0x5d, 0x1c, 0xd0, 0xfe, 0xaa, 0x40, 0x2f, 0x2f,
0x34, 0x57, 0x49, 0xdf, 0x73, 0xe8, 0x44, 0xc6, 0x19, 0x16, 0xa6, 0x63, 0xdf, 0x9e, 0xf1, 0x4b,
0xc3, 0x71, 0xba, 0xde, 0xbf, 0x77, 0xbe, 0x79, 0x54, 0xdf, 0x88, 0x44, 0x0c, 0x62, 0x12, 0x34,
0x1b, 0x36, 0x76, 0x71, 0x70, 0x80, 0x27, 0x2e, 0xf6, 0x82, 0xa1, 0x77, 0x48, 0x2e, 0x9f, 0xc5,
0x37, 0x00, 0xa8, 0x94, 0x13, 0xfd, 0x42, 0x62, 0x14, 0xed, 0x1f, 0x05, 0xa8, 0xc7, 0x14, 0xa1,
0xd7, 0xa1, 0x16, 0xed, 0xca, 0x24, 0x2c, 0x08, 0x99, 0xfc, 0x17, 0x72, 0xf2, 0x9f, 0x4a, 0x64,
0x31, 0x9b, 0xc8, 0x25, 0x50, 0x8b, 0xee, 0x40, 0xd5, 0xc5, 0xae, 0x41, 0xed, 0x53, 0x2c, 0xaf,
0xf6, 0xba, 0x8b, 0xdd, 0x03, 0xfb, 0x14, 0xb3, 0x2d, 0x6f, 0xee, 0x1a, 0x3e, 0x39, 0xa6, 0xdd,
0x8a, 0xd8, 0xf2, 0xe6, 0xae, 0x4e, 0x8e, 0x29, 0xba, 0x0b, 0x60, 0x7b, 0x16, 0x3e, 0x31, 0x3c,
0xd3, 0xc5, 0xdd, 0x75, 0x7e, 0x35, 0x6a, 0x9c, 0xb2, 0x67, 0xba, 0x98, 0x5d, 0x6a, 0xbe, 0x18,
0x0e, 0xba, 0x55, 0x71, 0x50, 0x2e, 0x99, 0xab, 0xf2, 0x42, 0x0d, 0x07, 0xdd, 0x9a, 0x38, 0x17,
0x11, 0xd0, 0x47, 0xd0, 0x94, 0x7e, 0x1b, 0xa2, 0xea, 0x80, 0x57, 0xdd, 0x66, 0x5e, 0x5a, 0x65,
0x00, 0x45, 0xcd, 0x35, 0x68, 0x6c, 0xa5, 0xfd, 0x56, 0x81, 0x4e, 0x3a, 0x97, 0x57, 0x29, 0xbb,
0xef, 0x43, 0xd9, 0xf6, 0x0e, 0x49, 0x58, 0x65, 0x6f, 0x9e, 0x61, 0x0e, 0x57, 0x26, 0xb8, 0xb5,
0x7f, 0x2a, 0xd0, 0xf9, 0xd0, 0xb2, 0xf2, 0x90, 0xf1, 0xe2, 0x35, 0xb5, 0xc8, 0x5f, 0x21, 0x91,
0xbf, 0x55, 0xd0, 0xe1, 0x1d, 0xb8, 0x95, 0x42, 0x3d, 0x59, 0x06, 0x35, 0x5d, 0x4d, 0xe2, 0xde,
0x70, 0x80, 0xde, 0x06, 0x35, 0x89, 0x7c, 0x12, 0xf3, 0x6b, 0x7a, 0x3b, 0x81, 0x7d, 0xc3, 0x81,
0xf6, 0x2f, 0x05, 0xee, 0xe8, 0xd8, 0x25, 0x2f, 0xf1, 0xff, 0xae, 0x8f, 0xff, 0x2e, 0x40, 0xe7,
0xe7, 0x66, 0x30, 0x9e, 0x0e, 0x5c, 0x49, 0xa4, 0x37, 0xe3, 0x60, 0xea, 0x8a, 0x97, 0xb2, 0x57,
0x3c, 0x2a, 0xd3, 0x72, 0x5e, 0x99, 0xb2, 0x37, 0xc9, 0xf6, 0x67, 0xa1, 0xbf, 0x8b, 0x32, 0x8d,
0x35, 0x31, 0x95, 0x4b, 0x34, 0x31, 0x68, 0x07, 0x9a, 0xf8, 0x64, 0xec, 0xcc, 0x2d, 0x6c, 0x08,
0xed, 0xeb, 0x5c, 0xfb, 0x1b, 0x39, 0xda, 0xe3, 0x77, 0xa4, 0x21, 0x0f, 0x0d, 0xf9, 0x55, 0xf9,
0x8f, 0x02, 0x6d, 0xb9, 0xcb, 0xfa, 0xbe, 0x15, 0x50, 0x31, 0x15, 0x8e, 0x42, 0x36, 0x1c, 0xab,
0x04, 0x35, 0xfc, 0xdf, 0x96, 0x62, 0xff, 0xdb, 0xbb, 0x00, 0x87, 0xce, 0x9c, 0x4e, 0x8d, 0xc0,
0x76, 0x43, 0x4c, 0xac, 0x71, 0xca, 0x33, 0xdb, 0xc5, 0xe8, 0x43, 0x68, 0x8c, 0x6c, 0xcf, 0x21,
0x13, 0x63, 0x66, 0x06, 0x53, 0x86, 0x8c, 0xcb, 0xdc, 0x7d, 0x6a, 0x63, 0xc7, 0x7a, 0xc2, 0x79,
0xf5, 0xba, 0x38, 0xb3, 0xcf, 0x8e, 0x68, 0x7f, 0x2e, 0xc0, 0x6b, 0xcc, 0x4d, 0xe9, 0xf1, 0x35,
0x14, 0xd4, 0x07, 0x61, 0x29, 0x14, 0x97, 0xff, 0x17, 0x53, 0xf1, 0xce, 0x96, 0xc3, 0x65, 0x5e,
0x16, 0xe8, 0x27, 0xd0, 0x72, 0x88, 0x69, 0x19, 0x63, 0xe2, 0x59, 0x3c, 0x13, 0x3c, 0x82, 0xad,
0xfe, 0x5b, 0x79, 0x26, 0x3c, 0xf3, 0xed, 0xc9, 0x04, 0xfb, 0x3b, 0x21, 0xaf, 0xde, 0x74, 0xf8,
0xbb, 0x4a, 0x2e, 0x39, 0x82, 0xca, 0x06, 0xf9, 0xfa, 0x62, 0x15, 0xd6, 0x40, 0xf1, 0x8c, 0x9e,
0xab, 0xb4, 0x42, 0xcf, 0x55, 0xce, 0x69, 0x9b, 0x93, 0x9d, 0x40, 0x25, 0xd3, 0x09, 0x3c, 0x83,
0x66, 0x84, 0x2b, 0xbc, 0xe8, 0xef, 0x41, 0x53, 0x98, 0x65, 0xb0, 0x48, 0x60, 0x2b, 0xec, 0x99,
0x05, 0xf1, 0x63, 0x4e, 0x63, 0x52, 0x23, 0xdc, 0x12, 0x3f, 0xa5, 0x9a, 0x1e, 0xa3, 0x68, 0xbf,
0x57, 0x40, 0x8d, 0x23, 0x32, 0x97, 0xbc, 0x4a, 0x33, 0xfe, 0x00, 0xda, 0x72, 0x36, 0x12, 0xc1,
0xa2, 0x6c, 0x8f, 0x8f, 0xe2, 0xe2, 0x06, 0xe8, 0x7d, 0xe8, 0x08, 0xc6, 0x0c, 0x8c, 0x8a, 0x36,
0xf9, 0x36, 0xdf, 0xd5, 0x53, 0x58, 0xfa, 0xf7, 0x02, 0xb4, 0x16, 0x85, 0xb3, 0xb2, 0x55, 0x2b,
0xbc, 0xc9, 0xd1, 0x53, 0x68, 0x4a, 0x1b, 0x8c, 0x78, 0xe1, 0x7f, 0x27, 0xaf, 0xea, 0x12, 0x11,
0xd7, 0x1b, 0x31, 0x48, 0xe4, 0x0f, 0x04, 0x59, 0xbe, 0xa1, 0x01, 0x3c, 0xf7, 0x55, 0xbd, 0xe5,
0x24, 0x5e, 0xfc, 0x57, 0x7c, 0xfa, 0xa1, 0xc7, 0xb0, 0xe1, 0x8b, 0xc2, 0xb6, 0x8c, 0x84, 0x73,
0xa2, 0x46, 0x6e, 0x87, 0x9b, 0xfb, 0xf1, 0x0e, 0xfe, 0xd7, 0xd0, 0xfe, 0x91, 0xe9, 0x59, 0xe4,
0xf0, 0x30, 0xbc, 0x0d, 0x97, 0xb8, 0x06, 0x1f, 0x24, 0x9b, 0x99, 0x0b, 0x40, 0x83, 0xf6, 0x87,
0x02, 0x74, 0x18, 0xed, 0x89, 0xe9, 0x98, 0xde, 0x18, 0xaf, 0xde, 0xc2, 0x7e, 0x35, 0x60, 0x7d,
0x0f, 0x9a, 0x94, 0xcc, 0xfd, 0x31, 0x36, 0x12, 0x9d, 0x6c, 0x43, 0x10, 0xf7, 0xc4, 0x6d, 0xbe,
0x0b, 0x60, 0xd1, 0xc0, 0x48, 0x3c, 0x56, 0x6b, 0x16, 0x0d, 0xe4, 0xf6, 0x9b, 0x50, 0x97, 0x32,
0x2c, 0xe2, 0x61, 0xfe, 0xc7, 0xab, 0xea, 0x20, 0x48, 0x03, 0xe2, 0xf1, 0xa6, 0x97, 0x9d, 0xe7,
0xbb, 0xeb, 0x7c, 0x77, 0xdd, 0xa2, 0x01, 0xdf, 0xba, 0x0b, 0xf0, 0xd2, 0x74, 0x6c, 0x8b, 0x57,
0x18, 0x6f, 0x6c, 0xab, 0x7a, 0x8d, 0x53, 0x58, 0x08, 0xb4, 0xbf, 0x29, 0x80, 0x62, 0xd1, 0xb9,
0x3c, 0x50, 0xdd, 0x87, 0x56, 0xc2, 0xcf, 0x68, 0xfa, 0x16, 0x77, 0x94, 0x32, 0xa4, 0x1d, 0x09,
0x55, 0x86, 0x8f, 0x4d, 0x4a, 0x3c, 0x1e, 0xb4, 0x95, 0x91, 0x76, 0x14, 0x9a, 0xc9, 0x8e, 0x6e,
0x9d, 0x42, 0x2b, 0xf9, 0x4e, 0x42, 0x0d, 0xa8, 0xee, 0x91, 0xe0, 0xa3, 0x13, 0x9b, 0x06, 0xea,
0x1a, 0x6a, 0x01, 0xec, 0x91, 0x60, 0xdf, 0xc7, 0x14, 0x7b, 0x81, 0xaa, 0x20, 0x80, 0xca, 0xa7,
0xde, 0xc0, 0xa6, 0x9f, 0xab, 0x05, 0xf4, 0x9a, 0x7c, 0x58, 0x9a, 0xce, 0xd0, 0xfb, 0x04, 0xbb,
0xc4, 0x7f, 0xa5, 0x16, 0xd9, 0xf1, 0x68, 0x55, 0x42, 0x2a, 0x34, 0x22, 0x96, 0xdd, 0xfd, 0x9f,
0xa9, 0x65, 0x54, 0x83, 0xb2, 0xf8, 0xac, 0x6c, 0x7d, 0x0a, 0x6a, 0xda, 0x3c, 0x54, 0x87, 0xf5,
0xa9, 0x28, 0x75, 0x75, 0x0d, 0xb5, 0xa1, 0xee, 0x2c, 0x02, 0xab, 0x2a, 0x8c, 0x30, 0xf1, 0x67,
0x63, 0x19, 0x62, 0xb5, 0xc0, 0xb4, 0xb1, 0x58, 0x0d, 0xc8, 0xb1, 0xa7, 0x16, 0xb7, 0x7e, 0x0c,
0x8d, 0xf8, 0xeb, 0x00, 0x55, 0xa1, 0xb4, 0x47, 0x3c, 0xac, 0xae, 0x31, 0xb1, 0xbb, 0x3e, 0x39,
0xb6, 0xbd, 0x89, 0xf0, 0xe1, 0xa9, 0x4f, 0x4e, 0xb1, 0xa7, 0x16, 0xd8, 0x06, 0xc5, 0xa6, 0xc3,
0x36, 0x8a, 0x6c, 0x83, 0x2d, 0xb0, 0xa5, 0x96, 0xfa, 0xbf, 0x03, 0x00, 0x81, 0xa5, 0x84, 0xf8,
0x16, 0x9a, 0x01, 0xda, 0xc5, 0xc1, 0x0e, 0x71, 0x67, 0xc4, 0x0b, 0xe5, 0x53, 0xf4, 0x5e, 0x32,
0xe4, 0xd1, 0x70, 0x38, 0xcb, 0x2a, 0x4d, 0xee, 0x7d, 0x77, 0xc9, 0x89, 0x14, 0xbb, 0xb6, 0x86,
0x5c, 0xae, 0x91, 0xb5, 0x1e, 0xcf, 0xec, 0xf1, 0xe7, 0xe1, 0x7c, 0xe2, 0x0c, 0x8d, 0x29, 0xd6,
0x50, 0x63, 0xea, 0xa2, 0xcb, 0xc5, 0x41, 0xe0, 0xdb, 0xde, 0x24, 0x7c, 0x1e, 0x69, 0x6b, 0xe8,
0x08, 0x6e, 0xb3, 0xa7, 0x53, 0x60, 0x06, 0x36, 0x0d, 0xec, 0x31, 0x0d, 0x15, 0xf6, 0x97, 0x2b,
0xcc, 0x30, 0x5f, 0x50, 0xa5, 0x03, 0xed, 0xd4, 0xf0, 0x1a, 0x6d, 0xe5, 0xa2, 0x52, 0xee, 0x04,
0xbd, 0xf7, 0xce, 0x4a, 0xbc, 0x91, 0x36, 0x1b, 0x5a, 0xc9, 0x81, 0x31, 0x7a, 0x7b, 0x99, 0x80,
0xcc, 0x50, 0xae, 0xb7, 0xb5, 0x0a, 0x6b, 0xa4, 0xea, 0x39, 0xb4, 0x92, 0x53, 0xcc, 0x7c, 0x55,
0xb9, 0x93, 0xce, 0xde, 0x59, 0x2f, 0x53, 0x6d, 0x0d, 0xfd, 0x0a, 0x6e, 0x65, 0x46, 0x87, 0xe8,
0x7b, 0x79, 0xe2, 0x97, 0x4d, 0x18, 0xcf, 0xd3, 0x20, 0xad, 0x8f, 0xfd, 0xf3, 0x96, 0x5a, 0x9f,
0x99, 0x21, 0xaf, 0x6e, 0x7d, 0x4c, 0xfc, 0x59, 0xd6, 0x5f, 0x58, 0xc3, 0x1c, 0x50, 0x76, 0x78,
0x88, 0xde, 0xcd, 0x53, 0xb1, 0x74, 0x80, 0xd9, 0xdb, 0x5e, 0x95, 0x3d, 0x4a, 0xf9, 0x9c, 0xdf,
0xd6, 0xf4, 0x9c, 0x2d, 0x57, 0xed, 0xd2, 0xb9, 0x61, 0xbe, 0xda, 0xe5, 0xb3, 0x34, 0x51, 0xd4,
0xc9, 0x81, 0x47, 0x7e, 0xae, 0x72, 0x07, 0x5c, 0xf9, 0x45, 0x9d, 0x3f, 0x3f, 0xd1, 0xd6, 0xfa,
0x5f, 0x56, 0xa1, 0xc6, 0x9d, 0x67, 0xff, 0xa1, 0xff, 0xe3, 0xe1, 0x35, 0xe0, 0xe1, 0x0b, 0x68,
0xa7, 0xc6, 0x46, 0xf9, 0x78, 0x98, 0x3f, 0x5b, 0x3a, 0xef, 0x62, 0x8c, 0x00, 0x65, 0x67, 0x36,
0xf9, 0x15, 0xba, 0x74, 0xb6, 0x73, 0x9e, 0x8e, 0x17, 0xd0, 0x4e, 0xcd, 0x4c, 0xf2, 0x3d, 0xc8,
0x1f, 0xac, 0x9c, 0x27, 0xfd, 0x33, 0x68, 0xc4, 0x5f, 0xcf, 0xe8, 0xc1, 0x32, 0x58, 0x4a, 0xbd,
0x19, 0x6f, 0x1e, 0x94, 0xae, 0x1f, 0xb4, 0x5f, 0x40, 0x3b, 0xf5, 0x60, 0xce, 0x8f, 0x7c, 0xfe,
0xab, 0xfa, 0x3c, 0xe9, 0x5f, 0x1f, 0xcc, 0x3c, 0x79, 0xff, 0x79, 0x7f, 0x62, 0x07, 0xd3, 0xf9,
0x88, 0x19, 0xf1, 0x48, 0x9c, 0x7c, 0xd7, 0x26, 0xf2, 0xeb, 0x51, 0x78, 0xdf, 0x1e, 0x71, 0x61,
0x8f, 0xb8, 0xb0, 0xd9, 0x68, 0x54, 0xe1, 0xcb, 0xc7, 0xff, 0x0d, 0x00, 0x00, 0xff, 0xff, 0x9d,
0x23, 0x87, 0xd7, 0xe3, 0x1f, 0x00, 0x00,
// 1933 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x59, 0xcd, 0x6f, 0x1b, 0xc7,
0x15, 0xd7, 0x92, 0x14, 0x45, 0x3e, 0xf1, 0x63, 0x3d, 0xb6, 0x54, 0x9a, 0xb5, 0x13, 0x75, 0x1d,
0xd7, 0x8e, 0xd2, 0x48, 0x89, 0x9c, 0x02, 0xf5, 0xa1, 0x87, 0x58, 0x8c, 0x55, 0xb6, 0x89, 0xa2,
0xae, 0xd4, 0x14, 0x35, 0x0c, 0x6c, 0x97, 0xdc, 0x11, 0xb5, 0xc8, 0xee, 0x0e, 0xbd, 0xb3, 0xb4,
0x2c, 0x1f, 0x7a, 0xea, 0xb9, 0xb7, 0x9e, 0x5a, 0x14, 0x28, 0xd0, 0x0f, 0xf4, 0xd0, 0x7f, 0xa0,
0xa7, 0xfc, 0x09, 0xfd, 0x07, 0x5a, 0xa0, 0x68, 0x6e, 0xfd, 0x27, 0x8a, 0xf9, 0xd8, 0xe5, 0x7e,
0x0c, 0x25, 0x4a, 0xaa, 0x62, 0xa3, 0xc8, 0x8d, 0xfb, 0xe6, 0xcd, 0xfb, 0x9e, 0xdf, 0xbc, 0x79,
0x84, 0x6b, 0xcf, 0x26, 0x38, 0x3c, 0xb1, 0x86, 0x84, 0x84, 0xce, 0xc6, 0x38, 0x24, 0x11, 0x41,
0xc8, 0x77, 0xbd, 0xe7, 0x13, 0x2a, 0xbe, 0x36, 0xf8, 0x7a, 0xb7, 0x31, 0x24, 0xbe, 0x4f, 0x02,
0x41, 0xeb, 0x36, 0xd2, 0x1c, 0xdd, 0x96, 0x1b, 0x44, 0x38, 0x0c, 0x6c, 0x2f, 0x5e, 0xa5, 0xc3,
0x23, 0xec, 0xdb, 0xf2, 0x4b, 0x77, 0xec, 0xc8, 0x4e, 0xcb, 0x37, 0x7e, 0xa9, 0xc1, 0xea, 0xfe,
0x11, 0x39, 0xde, 0x26, 0x9e, 0x87, 0x87, 0x91, 0x4b, 0x02, 0x6a, 0xe2, 0x67, 0x13, 0x4c, 0x23,
0xf4, 0x1e, 0x54, 0x06, 0x36, 0xc5, 0x1d, 0x6d, 0x4d, 0xbb, 0xbf, 0xbc, 0x75, 0x6b, 0x23, 0x63,
0x89, 0x34, 0xe1, 0x13, 0x3a, 0x7a, 0x64, 0x53, 0x6c, 0x72, 0x4e, 0x84, 0xa0, 0xe2, 0x0c, 0xfa,
0xbd, 0x4e, 0x69, 0x4d, 0xbb, 0x5f, 0x36, 0xf9, 0x6f, 0xf4, 0x16, 0x34, 0x87, 0x89, 0xec, 0x7e,
0x8f, 0x76, 0xca, 0x6b, 0xe5, 0xfb, 0x65, 0x33, 0x4b, 0x34, 0xfe, 0xac, 0xc1, 0x37, 0x0a, 0x66,
0xd0, 0x31, 0x09, 0x28, 0x46, 0x0f, 0xa0, 0x4a, 0x23, 0x3b, 0x9a, 0x50, 0x69, 0xc9, 0x37, 0x95,
0x96, 0xec, 0x73, 0x16, 0x53, 0xb2, 0x16, 0xd5, 0x96, 0x14, 0x6a, 0xd1, 0xfb, 0x70, 0xc3, 0x0d,
0x3e, 0xc1, 0x3e, 0x09, 0x4f, 0xac, 0x31, 0x0e, 0x87, 0x38, 0x88, 0xec, 0x11, 0x8e, 0x6d, 0xbc,
0x1e, 0xaf, 0xed, 0x4d, 0x97, 0x8c, 0x3f, 0x6a, 0xb0, 0xc2, 0x2c, 0xdd, 0xb3, 0xc3, 0xc8, 0xbd,
0x82, 0x78, 0x19, 0xd0, 0x48, 0xdb, 0xd8, 0x29, 0xf3, 0xb5, 0x0c, 0x8d, 0xf1, 0x8c, 0x63, 0xf5,
0xcc, 0xb7, 0x0a, 0x37, 0x37, 0x43, 0x33, 0xfe, 0x20, 0x13, 0x9b, 0xb6, 0xf3, 0x32, 0x01, 0xcd,
0xeb, 0x2c, 0x15, 0x75, 0x5e, 0x24, 0x9c, 0x5f, 0x68, 0xb0, 0xf2, 0x31, 0xb1, 0x9d, 0x69, 0xe2,
0xbf, 0xfa, 0x70, 0x7e, 0x1f, 0xaa, 0xe2, 0x94, 0x74, 0x2a, 0x5c, 0xd7, 0xdd, 0xac, 0x2e, 0x79,
0x82, 0xa6, 0x16, 0xee, 0x73, 0x82, 0x29, 0x37, 0x19, 0xbf, 0xd5, 0xa0, 0x63, 0x62, 0x0f, 0xdb,
0x14, 0xbf, 0x4a, 0x2f, 0x56, 0xa1, 0x1a, 0x10, 0x07, 0xf7, 0x7b, 0xdc, 0x8b, 0xb2, 0x29, 0xbf,
0x8c, 0x2f, 0x65, 0x84, 0x5f, 0xf3, 0x82, 0x4d, 0x65, 0x61, 0xf1, 0x22, 0x59, 0xf8, 0x62, 0x9a,
0x85, 0xd7, 0xdd, 0xd3, 0x69, 0xa6, 0x16, 0x33, 0x99, 0xfa, 0x19, 0xdc, 0xdc, 0x0e, 0xb1, 0x1d,
0xe1, 0x1f, 0x33, 0x98, 0xdf, 0x3e, 0xb2, 0x83, 0x00, 0x7b, 0xb1, 0x0b, 0x79, 0xe5, 0x9a, 0x42,
0x79, 0x07, 0x96, 0xc6, 0x21, 0x79, 0x71, 0x92, 0xd8, 0x1d, 0x7f, 0x1a, 0xbf, 0xd7, 0xa0, 0xab,
0x92, 0x7d, 0x19, 0x44, 0xb8, 0x07, 0xed, 0x50, 0x18, 0x67, 0x0d, 0x85, 0x3c, 0xae, 0xb5, 0x6e,
0xb6, 0x24, 0x59, 0x6a, 0x41, 0x77, 0xa1, 0x15, 0x62, 0x3a, 0xf1, 0xa6, 0x7c, 0x65, 0xce, 0xd7,
0x14, 0x54, 0xc9, 0x66, 0xfc, 0x45, 0x83, 0x9b, 0x3b, 0x38, 0x4a, 0xb2, 0xc7, 0xd4, 0xe1, 0xd7,
0x14, 0x5d, 0x7f, 0xa7, 0x41, 0x3b, 0x67, 0x28, 0x5a, 0x83, 0xe5, 0x14, 0x8f, 0x4c, 0x50, 0x9a,
0x84, 0xbe, 0x07, 0x8b, 0x2c, 0x76, 0x98, 0x9b, 0xd4, 0xda, 0x32, 0x36, 0x8a, 0x97, 0xfb, 0x46,
0x56, 0xaa, 0x29, 0x36, 0xa0, 0x4d, 0xb8, 0xae, 0x40, 0x56, 0x69, 0x3e, 0x2a, 0x02, 0xab, 0xf1,
0x57, 0x0d, 0xba, 0xaa, 0x60, 0x5e, 0x26, 0xe1, 0x4f, 0x60, 0x35, 0xf1, 0xc6, 0x72, 0x30, 0x1d,
0x86, 0xee, 0x98, 0x1f, 0x33, 0x7e, 0x19, 0x2c, 0x6f, 0xdd, 0x39, 0xdb, 0x1f, 0x6a, 0xae, 0x24,
0x22, 0x7a, 0x29, 0x09, 0x86, 0x0b, 0x2b, 0x3b, 0x38, 0xda, 0xc7, 0x23, 0x1f, 0x07, 0x51, 0x3f,
0x38, 0x24, 0x17, 0xcf, 0xfb, 0x1b, 0x00, 0x54, 0xca, 0x49, 0xee, 0xa9, 0x14, 0xc5, 0xf8, 0x47,
0x09, 0x96, 0x53, 0x8a, 0xd0, 0x2d, 0xa8, 0x27, 0xab, 0x32, 0x6b, 0x53, 0x42, 0xa1, 0x62, 0x4a,
0x8a, 0x8a, 0xc9, 0x65, 0xbe, 0x5c, 0xcc, 0xfc, 0x0c, 0x70, 0x46, 0x37, 0xa1, 0xe6, 0x63, 0xdf,
0xa2, 0xee, 0x4b, 0x2c, 0xc1, 0x60, 0xc9, 0xc7, 0xfe, 0xbe, 0xfb, 0x12, 0xb3, 0xa5, 0x60, 0xe2,
0x5b, 0x21, 0x39, 0xa6, 0x9d, 0xaa, 0x58, 0x0a, 0x26, 0xbe, 0x49, 0x8e, 0x29, 0xba, 0x0d, 0xe0,
0x06, 0x0e, 0x7e, 0x61, 0x05, 0xb6, 0x8f, 0x3b, 0x4b, 0xfc, 0x30, 0xd5, 0x39, 0x65, 0xd7, 0xf6,
0x31, 0x83, 0x01, 0xfe, 0xd1, 0xef, 0x75, 0x6a, 0x62, 0xa3, 0xfc, 0x64, 0xae, 0xca, 0x23, 0xd8,
0xef, 0x75, 0xea, 0x62, 0x5f, 0x42, 0x40, 0x1f, 0x41, 0x53, 0xfa, 0x6d, 0x89, 0x32, 0x05, 0x5e,
0xa6, 0x6b, 0xaa, 0xb4, 0xca, 0x00, 0x8a, 0x22, 0x6d, 0xd0, 0xd4, 0x17, 0x6f, 0x29, 0xf3, 0xb9,
0xbc, 0x4c, 0xd9, 0x7d, 0x17, 0x16, 0xdd, 0xe0, 0x90, 0xc4, 0x55, 0xf6, 0xe6, 0x29, 0xe6, 0x70,
0x65, 0x82, 0xdb, 0xf8, 0xa7, 0x06, 0xab, 0x1f, 0x3a, 0x8e, 0x0a, 0x4b, 0xcf, 0x5f, 0x53, 0xd3,
0xfc, 0x95, 0x32, 0xf9, 0x9b, 0x07, 0x4f, 0xde, 0x81, 0x6b, 0x39, 0x9c, 0x94, 0x65, 0x50, 0x37,
0xf5, 0x2c, 0x52, 0xf6, 0x7b, 0xe8, 0x6d, 0xd0, 0xb3, 0x58, 0x29, 0x6f, 0x89, 0xba, 0xd9, 0xce,
0xa0, 0x65, 0xbf, 0x67, 0xfc, 0x4b, 0x83, 0x9b, 0x26, 0xf6, 0xc9, 0x73, 0xfc, 0xff, 0xeb, 0xe3,
0xbf, 0x4b, 0xb0, 0xfa, 0x53, 0x3b, 0x1a, 0x1e, 0xf5, 0x7c, 0x49, 0xa4, 0xaf, 0xc6, 0xc1, 0xdc,
0x11, 0xaf, 0x14, 0x8f, 0x78, 0x52, 0xa6, 0x8b, 0xaa, 0x32, 0x65, 0x0f, 0xaf, 0x8d, 0xcf, 0x62,
0x7f, 0xa7, 0x65, 0x9a, 0x6a, 0x7b, 0xaa, 0x17, 0x68, 0x7b, 0xd0, 0x36, 0x34, 0xf1, 0x8b, 0xa1,
0x37, 0x71, 0xb0, 0x25, 0xb4, 0x2f, 0x71, 0xed, 0x6f, 0x28, 0xb4, 0xa7, 0xcf, 0x48, 0x43, 0x6e,
0xea, 0xf3, 0xa3, 0xf2, 0x1f, 0x0d, 0xda, 0x72, 0x95, 0x75, 0x8a, 0x73, 0xa0, 0x62, 0x2e, 0x1c,
0xa5, 0x62, 0x38, 0xe6, 0x09, 0x6a, 0x7c, 0x43, 0x57, 0x52, 0x37, 0xf4, 0x6d, 0x80, 0x43, 0x6f,
0x42, 0x8f, 0xac, 0xc8, 0xf5, 0x63, 0x4c, 0xac, 0x73, 0xca, 0x81, 0xeb, 0x63, 0xf4, 0x21, 0x34,
0x06, 0x6e, 0xe0, 0x91, 0x91, 0x35, 0xb6, 0xa3, 0x23, 0x86, 0x8c, 0xb3, 0xdc, 0x7d, 0xec, 0x62,
0xcf, 0x79, 0xc4, 0x79, 0xcd, 0x65, 0xb1, 0x67, 0x8f, 0x6d, 0x31, 0xfe, 0x54, 0x82, 0xeb, 0xcc,
0x4d, 0xe9, 0xf1, 0x15, 0x14, 0xd4, 0xc3, 0xb8, 0x14, 0xca, 0xb3, 0xef, 0xc5, 0x5c, 0xbc, 0x8b,
0xe5, 0x70, 0x91, 0xb7, 0x08, 0xfa, 0x11, 0xb4, 0x3c, 0x62, 0x3b, 0xd6, 0x90, 0x04, 0x0e, 0xcf,
0x04, 0x8f, 0x60, 0x6b, 0xeb, 0x2d, 0x95, 0x09, 0x07, 0xa1, 0x3b, 0x1a, 0xe1, 0x70, 0x3b, 0xe6,
0x35, 0x9b, 0x1e, 0x7f, 0x89, 0xc9, 0x4f, 0x8e, 0xa0, 0xb2, 0xa5, 0xbe, 0xba, 0x58, 0xc5, 0x35,
0x50, 0x3e, 0xa5, 0x4b, 0xab, 0xcc, 0xd1, 0xa5, 0x2d, 0x2a, 0x1a, 0xed, 0x6c, 0x27, 0x50, 0x2d,
0x74, 0x02, 0x07, 0xd0, 0x4c, 0x70, 0x85, 0x17, 0xfd, 0x1d, 0x68, 0x0a, 0xb3, 0x2c, 0x16, 0x09,
0xec, 0xc4, 0x5d, 0xb6, 0x20, 0x7e, 0xcc, 0x69, 0x4c, 0x6a, 0x82, 0x5b, 0xe2, 0x52, 0xaa, 0x9b,
0x29, 0x8a, 0xf1, 0x6b, 0x0d, 0xf4, 0x34, 0x22, 0x73, 0xc9, 0xf3, 0xb4, 0xef, 0xf7, 0xa0, 0x2d,
0x07, 0x40, 0x09, 0x2c, 0xca, 0x86, 0xfa, 0x59, 0x5a, 0x5c, 0x0f, 0x7d, 0x00, 0xab, 0x82, 0xb1,
0x00, 0xa3, 0xa2, 0xb1, 0xbe, 0xc1, 0x57, 0xcd, 0x1c, 0x96, 0xfe, 0xbd, 0x0c, 0xad, 0x69, 0xe1,
0xcc, 0x6d, 0xd5, 0x3c, 0x0f, 0xff, 0x5d, 0xd0, 0xa7, 0x9d, 0x21, 0xef, 0x1d, 0x4e, 0xad, 0xfd,
0x7c, 0x4f, 0xd8, 0x1e, 0xe7, 0x5a, 0xe9, 0xc7, 0xd0, 0x94, 0x3e, 0x49, 0x54, 0xab, 0x70, 0x61,
0xdf, 0x52, 0x09, 0xcb, 0x64, 0xd0, 0x6c, 0xa4, 0x20, 0x96, 0xa2, 0x87, 0x50, 0xe7, 0xc7, 0x21,
0x3a, 0x19, 0x63, 0x79, 0x12, 0x6e, 0xa9, 0x64, 0xb0, 0xcc, 0x1e, 0x9c, 0x8c, 0xb1, 0x59, 0xf3,
0xe4, 0xaf, 0xcb, 0xe2, 0xf2, 0x03, 0x58, 0x09, 0xc5, 0xd1, 0x71, 0xac, 0x4c, 0xf8, 0x96, 0x78,
0xf8, 0x6e, 0xc4, 0x8b, 0x7b, 0xe9, 0x30, 0xce, 0xe8, 0xf2, 0x6b, 0x33, 0xbb, 0xfc, 0x5f, 0x40,
0xfb, 0x07, 0x76, 0xe0, 0x90, 0xc3, 0xc3, 0xf8, 0x80, 0x5e, 0xe0, 0x64, 0x3e, 0xcc, 0xf6, 0x57,
0xe7, 0x40, 0x2b, 0xe3, 0x37, 0x25, 0x58, 0x65, 0xb4, 0x47, 0xb6, 0x67, 0x07, 0x43, 0x3c, 0x7f,
0x57, 0xfd, 0xbf, 0xb9, 0x3f, 0xee, 0x40, 0x93, 0x92, 0x49, 0x38, 0xc4, 0x56, 0xa6, 0xb9, 0x6e,
0x08, 0xe2, 0xae, 0x00, 0x98, 0xdb, 0x00, 0x0e, 0x8d, 0xac, 0xcc, 0x8b, 0xbb, 0xee, 0xd0, 0x48,
0x2e, 0xbf, 0x09, 0xcb, 0x52, 0x86, 0x43, 0x02, 0xcc, 0x93, 0x5d, 0x33, 0x41, 0x90, 0x7a, 0x24,
0xe0, 0x7d, 0x38, 0xdb, 0xcf, 0x57, 0x97, 0xf8, 0xea, 0x92, 0x43, 0x23, 0xbe, 0x74, 0x1b, 0xe0,
0xb9, 0xed, 0xb9, 0x0e, 0x2f, 0x52, 0x9e, 0xa6, 0x9a, 0x59, 0xe7, 0x14, 0x16, 0x02, 0xe3, 0x6f,
0x1a, 0xa0, 0x54, 0x74, 0x2e, 0x8e, 0x9d, 0x77, 0xa1, 0x95, 0xf1, 0x33, 0x99, 0x66, 0xa6, 0x1d,
0xa5, 0x0c, 0xfc, 0x07, 0x42, 0x95, 0x15, 0x62, 0x9b, 0x92, 0x80, 0x07, 0x6d, 0x6e, 0xf0, 0x1f,
0xc4, 0x66, 0xb2, 0xad, 0xeb, 0x2f, 0xa1, 0x95, 0x3d, 0xa6, 0xa8, 0x01, 0xb5, 0x5d, 0x12, 0x7d,
0xf4, 0xc2, 0xa5, 0x91, 0xbe, 0x80, 0x5a, 0x00, 0xbb, 0x24, 0xda, 0x0b, 0x31, 0xc5, 0x41, 0xa4,
0x6b, 0x08, 0xa0, 0xfa, 0x69, 0xd0, 0x73, 0xe9, 0xe7, 0x7a, 0x09, 0x5d, 0x97, 0x8f, 0x63, 0xdb,
0xeb, 0xcb, 0x9a, 0xd5, 0xcb, 0x6c, 0x7b, 0xf2, 0x55, 0x41, 0x3a, 0x34, 0x12, 0x96, 0x9d, 0xbd,
0x9f, 0xe8, 0x8b, 0xa8, 0x0e, 0x8b, 0xe2, 0x67, 0x75, 0xfd, 0x53, 0xd0, 0xf3, 0xe6, 0xa1, 0x65,
0x58, 0x3a, 0x12, 0xa5, 0xae, 0x2f, 0xa0, 0x36, 0x2c, 0x7b, 0xd3, 0xc0, 0xea, 0x1a, 0x23, 0x8c,
0xc2, 0xf1, 0x50, 0x86, 0x58, 0x2f, 0x31, 0x6d, 0x2c, 0x56, 0x3d, 0x72, 0x1c, 0xe8, 0xe5, 0xf5,
0x1f, 0x42, 0x23, 0xfd, 0x60, 0x41, 0x35, 0xa8, 0xec, 0x92, 0x00, 0xeb, 0x0b, 0x4c, 0xec, 0x4e,
0x48, 0x8e, 0xdd, 0x60, 0x24, 0x7c, 0x78, 0x1c, 0x92, 0x97, 0x38, 0xd0, 0x4b, 0x6c, 0x81, 0x62,
0xdb, 0x63, 0x0b, 0x65, 0xb6, 0xc0, 0x3e, 0xb0, 0xa3, 0x57, 0xd6, 0xdf, 0x87, 0x5a, 0x0c, 0x17,
0xe8, 0x1a, 0x34, 0x33, 0xa3, 0x35, 0x7d, 0x01, 0x21, 0x71, 0x03, 0x4f, 0x81, 0x41, 0xd7, 0xb6,
0x7e, 0x05, 0x00, 0xe2, 0x46, 0x20, 0x24, 0x74, 0xd0, 0x18, 0xd0, 0x0e, 0x8e, 0xb6, 0x89, 0x3f,
0x26, 0x41, 0x6c, 0x12, 0x45, 0xef, 0x65, 0xb3, 0x94, 0xcc, 0xf1, 0x8b, 0xac, 0xd2, 0xcb, 0xee,
0xb7, 0x67, 0xec, 0xc8, 0xb1, 0x1b, 0x0b, 0xc8, 0xe7, 0x1a, 0x59, 0x03, 0x75, 0xe0, 0x0e, 0x3f,
0x8f, 0xe7, 0x32, 0xa7, 0x68, 0xcc, 0xb1, 0xc6, 0x1a, 0x73, 0xd8, 0x20, 0x3f, 0xf6, 0xa3, 0xd0,
0x0d, 0x46, 0xf1, 0x23, 0xcf, 0x58, 0x40, 0xcf, 0xe0, 0x06, 0x7b, 0x00, 0x46, 0x76, 0xe4, 0xd2,
0xc8, 0x1d, 0xd2, 0x58, 0xe1, 0xd6, 0x6c, 0x85, 0x05, 0xe6, 0x73, 0xaa, 0xf4, 0xa0, 0x9d, 0xfb,
0xff, 0x00, 0xad, 0x2b, 0x81, 0x4c, 0xf9, 0x5f, 0x47, 0xf7, 0x9d, 0xb9, 0x78, 0x13, 0x6d, 0x2e,
0xb4, 0xb2, 0xb3, 0x75, 0xf4, 0xf6, 0x2c, 0x01, 0x85, 0x61, 0x64, 0x77, 0x7d, 0x1e, 0xd6, 0x44,
0xd5, 0x13, 0x68, 0x65, 0xa7, 0xb7, 0x6a, 0x55, 0xca, 0x09, 0x6f, 0xf7, 0xb4, 0xf7, 0xb5, 0xb1,
0x80, 0x7e, 0x0e, 0xd7, 0x0a, 0x23, 0x53, 0xf4, 0x1d, 0x95, 0xf8, 0x59, 0x93, 0xd5, 0xb3, 0x34,
0x48, 0xeb, 0xa7, 0x51, 0x9c, 0x6d, 0x7d, 0x61, 0x76, 0x3e, 0xbf, 0xf5, 0x29, 0xf1, 0xa7, 0x59,
0x7f, 0x6e, 0x0d, 0x13, 0x40, 0xc5, 0xa1, 0x29, 0x7a, 0x57, 0xa5, 0x62, 0xe6, 0xe0, 0xb6, 0xbb,
0x31, 0x2f, 0x7b, 0x92, 0xf2, 0x09, 0x3f, 0xad, 0xf9, 0xf1, 0xa2, 0x52, 0xed, 0xcc, 0x79, 0xa9,
0x5a, 0xed, 0xec, 0x89, 0xa0, 0x28, 0xea, 0xec, 0xd8, 0x46, 0x9d, 0x2b, 0xe5, 0x98, 0x4e, 0x5d,
0xd4, 0xea, 0x29, 0x90, 0xb1, 0xb0, 0xf5, 0x65, 0x0d, 0xea, 0xdc, 0x79, 0x76, 0x75, 0x7d, 0x8d,
0x87, 0x57, 0x80, 0x87, 0x4f, 0xa1, 0x9d, 0x1b, 0x7e, 0xa9, 0xf1, 0x50, 0x3d, 0x21, 0x3b, 0xeb,
0x60, 0x0c, 0x00, 0x15, 0x27, 0x4f, 0xea, 0x0a, 0x9d, 0x39, 0xa1, 0x3a, 0x4b, 0xc7, 0x53, 0x68,
0xe7, 0x26, 0x3f, 0x6a, 0x0f, 0xd4, 0xe3, 0xa1, 0xb3, 0xa4, 0x7f, 0x06, 0x8d, 0xf4, 0x0c, 0x00,
0xdd, 0x9b, 0x05, 0x4b, 0xb9, 0x97, 0xef, 0xab, 0x07, 0xa5, 0xab, 0x07, 0xed, 0xa7, 0xd0, 0xce,
0x3d, 0xfb, 0xd5, 0x91, 0x57, 0xcf, 0x06, 0xce, 0x92, 0xfe, 0xd5, 0xc1, 0xcc, 0xa3, 0x0f, 0x9e,
0x6c, 0x8d, 0xdc, 0xe8, 0x68, 0x32, 0x60, 0x46, 0x6c, 0x8a, 0x9d, 0xef, 0xba, 0x44, 0xfe, 0xda,
0x8c, 0xcf, 0xdb, 0x26, 0x17, 0xb6, 0xc9, 0x85, 0x8d, 0x07, 0x83, 0x2a, 0xff, 0x7c, 0xf0, 0xdf,
0x00, 0x00, 0x00, 0xff, 0xff, 0xa6, 0xcb, 0xb1, 0x73, 0x8e, 0x21, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.

21
internal/proxy/impl.go
View File

@ -488,16 +488,13 @@ func (node *Proxy) ShowCollections(ctx context.Context, request *milvuspb.ShowCo
log.Debug("ShowCollections",
zap.String("role", Params.RoleName),
zap.Int64("msgID", request.Base.MsgID),
zap.Uint64("timestamp", request.Base.Timestamp),
zap.String("db", request.DbName))
zap.Any("request", request))
defer func() {
log.Debug("ShowCollections Done",
zap.Error(err),
zap.String("role", Params.RoleName),
zap.Int64("msgID", request.Base.MsgID),
zap.Uint64("timestamp", request.Base.Timestamp),
zap.String("db", request.DbName))
zap.Any("request", request),
zap.Any("result", sct.result))
}()
err = sct.WaitToFinish()
@ -828,6 +825,7 @@ func (node *Proxy) ShowPartitions(ctx context.Context, request *milvuspb.ShowPar
Condition: NewTaskCondition(ctx),
ShowPartitionsRequest: request,
rootCoord: node.rootCoord,
queryCoord: node.queryCoord,
result: nil,
}
@ -844,18 +842,13 @@ func (node *Proxy) ShowPartitions(ctx context.Context, request *milvuspb.ShowPar
log.Debug("ShowPartitions",
zap.String("role", Params.RoleName),
zap.Int64("msgID", request.Base.MsgID),
zap.Uint64("timestamp", request.Base.Timestamp),
zap.String("db", request.DbName),
zap.String("collection", request.CollectionName))
zap.Any("request", request))
defer func() {
log.Debug("ShowPartitions Done",
zap.Error(err),
zap.String("role", Params.RoleName),
zap.Int64("msgID", request.Base.MsgID),
zap.Uint64("timestamp", request.Base.Timestamp),
zap.String("db", request.DbName),
zap.String("collection", request.CollectionName))
zap.Any("request", request),
zap.Any("result", spt.result))
}()
err = spt.WaitToFinish()

142
internal/proxy/meta_cache.go
View File

@ -17,9 +17,9 @@ import (
"fmt"
"sync"
"github.com/milvus-io/milvus/internal/log"
"go.uber.org/zap"
"github.com/milvus-io/milvus/internal/log"
"github.com/milvus-io/milvus/internal/proto/commonpb"
"github.com/milvus-io/milvus/internal/proto/milvuspb"
"github.com/milvus-io/milvus/internal/proto/schemapb"
@ -29,17 +29,27 @@ import (
type Cache interface {
GetCollectionID(ctx context.Context, collectionName string) (typeutil.UniqueID, error)
GetCollectionInfo(ctx context.Context, collectionName string) (*collectionInfo, error)
GetPartitionID(ctx context.Context, collectionName string, partitionName string) (typeutil.UniqueID, error)
GetPartitions(ctx context.Context, collectionName string) (map[string]typeutil.UniqueID, error)
GetPartitionInfo(ctx context.Context, collectionName string, partitionName string) (*partitionInfo, error)
GetCollectionSchema(ctx context.Context, collectionName string) (*schemapb.CollectionSchema, error)
RemoveCollection(ctx context.Context, collectionName string)
RemovePartition(ctx context.Context, collectionName string, partitionName string)
}
type collectionInfo struct {
collID typeutil.UniqueID
schema *schemapb.CollectionSchema
partInfo map[string]typeutil.UniqueID
collID typeutil.UniqueID
schema *schemapb.CollectionSchema
partInfo map[string]*partitionInfo
createdTimestamp uint64
createdUtcTimestamp uint64
}
type partitionInfo struct {
partitionID typeutil.UniqueID
createdTimestamp uint64
createdUtcTimestamp uint64
}
type MetaCache struct {
@ -88,6 +98,32 @@ func (m *MetaCache) GetCollectionID(ctx context.Context, collectionName string)
return collInfo.collID, nil
}
func (m *MetaCache) GetCollectionInfo(ctx context.Context, collectionName string) (*collectionInfo, error) {
m.mu.RLock()
var collInfo *collectionInfo
collInfo, ok := m.collInfo[collectionName]
m.mu.RUnlock()
if !ok {
coll, err := m.describeCollection(ctx, collectionName)
if err != nil {
return nil, err
}
m.mu.Lock()
defer m.mu.Unlock()
m.updateCollection(coll, collectionName)
collInfo = m.collInfo[collectionName]
}
return &collectionInfo{
collID: collInfo.collID,
schema: collInfo.schema,
partInfo: collInfo.partInfo,
createdTimestamp: collInfo.createdTimestamp,
createdUtcTimestamp: collInfo.createdUtcTimestamp,
}, nil
}
func (m *MetaCache) GetCollectionSchema(ctx context.Context, collectionName string) (*schemapb.CollectionSchema, error) {
m.mu.RLock()
collInfo, ok := m.collInfo[collectionName]
@ -116,45 +152,16 @@ func (m *MetaCache) updateCollection(coll *milvuspb.DescribeCollectionResponse,
}
m.collInfo[collectionName].schema = coll.Schema
m.collInfo[collectionName].collID = coll.CollectionID
m.collInfo[collectionName].createdTimestamp = coll.CreatedTimestamp
m.collInfo[collectionName].createdUtcTimestamp = coll.CreatedUtcTimestamp
}
func (m *MetaCache) GetPartitionID(ctx context.Context, collectionName string, partitionName string) (typeutil.UniqueID, error) {
_, err := m.GetCollectionID(ctx, collectionName)
partInfo, err := m.GetPartitionInfo(ctx, collectionName, partitionName)
if err != nil {
return 0, err
}
m.mu.RLock()
collInfo, ok := m.collInfo[collectionName]
if !ok {
m.mu.RUnlock()
return 0, fmt.Errorf("can't find collection name:%s", collectionName)
}
partitionID, ok := collInfo.partInfo[partitionName]
m.mu.RUnlock()
if !ok {
partitions, err := m.showPartitions(ctx, collectionName)
if err != nil {
return 0, err
}
m.mu.Lock()
defer m.mu.Unlock()
log.Debug("proxy", zap.Any("GetPartitionID:partitions before update", partitions), zap.Any("collectionName", collectionName))
m.updatePartitions(partitions, collectionName)
log.Debug("proxy", zap.Any("GetPartitionID:partitions after update", partitions), zap.Any("collectionName", collectionName))
partInfo := m.collInfo[collectionName].partInfo
_, ok := partInfo[partitionName]
if !ok {
return 0, fmt.Errorf("partitionID of partitionName:%s can not be find", partitionName)
}
return partInfo[partitionName], nil
}
return partitionID, nil
return partInfo.partitionID, nil
}
func (m *MetaCache) GetPartitions(ctx context.Context, collectionName string) (map[string]typeutil.UniqueID, error) {
@ -187,7 +194,7 @@ func (m *MetaCache) GetPartitions(ctx context.Context, collectionName string) (m
ret := make(map[string]typeutil.UniqueID)
partInfo := m.collInfo[collectionName].partInfo
for k, v := range partInfo {
ret[k] = v
ret[k] = v.partitionID
}
return ret, nil
@ -197,12 +204,54 @@ func (m *MetaCache) GetPartitions(ctx context.Context, collectionName string) (m
ret := make(map[string]typeutil.UniqueID)
partInfo := m.collInfo[collectionName].partInfo
for k, v := range partInfo {
ret[k] = v
ret[k] = v.partitionID
}
return ret, nil
}
func (m *MetaCache) GetPartitionInfo(ctx context.Context, collectionName string, partitionName string) (*partitionInfo, error) {
_, err := m.GetCollectionID(ctx, collectionName)
if err != nil {
return nil, err
}
m.mu.RLock()
collInfo, ok := m.collInfo[collectionName]
if !ok {
m.mu.RUnlock()
return nil, fmt.Errorf("can't find collection name:%s", collectionName)
}
var partInfo *partitionInfo
partInfo, ok = collInfo.partInfo[partitionName]
m.mu.RUnlock()
if !ok {
partitions, err := m.showPartitions(ctx, collectionName)
if err != nil {
return nil, err
}
m.mu.Lock()
defer m.mu.Unlock()
log.Debug("proxy", zap.Any("GetPartitionID:partitions before update", partitions), zap.Any("collectionName", collectionName))
m.updatePartitions(partitions, collectionName)
log.Debug("proxy", zap.Any("GetPartitionID:partitions after update", partitions), zap.Any("collectionName", collectionName))
partInfo, ok = m.collInfo[collectionName].partInfo[partitionName]
if !ok {
return nil, fmt.Errorf("partitionID of partitionName:%s can not be find", partitionName)
}
}
return &partitionInfo{
partitionID: partInfo.partitionID,
createdTimestamp: partInfo.createdTimestamp,
createdUtcTimestamp: partInfo.createdUtcTimestamp,
}, nil
}
func (m *MetaCache) describeCollection(ctx context.Context, collectionName string) (*milvuspb.DescribeCollectionResponse, error) {
req := &milvuspb.DescribeCollectionRequest{
Base: &commonpb.MsgBase{
@ -228,6 +277,8 @@ func (m *MetaCache) describeCollection(ctx context.Context, collectionName strin
CollectionID: coll.CollectionID,
VirtualChannelNames: coll.VirtualChannelNames,
PhysicalChannelNames: coll.PhysicalChannelNames,
CreatedTimestamp: coll.CreatedTimestamp,
CreatedUtcTimestamp: coll.CreatedUtcTimestamp,
}
for _, field := range coll.Schema.Fields {
if field.FieldID >= 100 { // TODO(dragondriver): use StartOfUserField to replace 100
@ -265,18 +316,21 @@ func (m *MetaCache) updatePartitions(partitions *milvuspb.ShowPartitionsResponse
_, ok := m.collInfo[collectionName]
if !ok {
m.collInfo[collectionName] = &collectionInfo{
partInfo: map[string]typeutil.UniqueID{},
partInfo: map[string]*partitionInfo{},
}
}
partInfo := m.collInfo[collectionName].partInfo
if partInfo == nil {
partInfo = map[string]typeutil.UniqueID{}
partInfo = map[string]*partitionInfo{}
}
for i := 0; i < len(partitions.PartitionIDs); i++ {
_, ok := partInfo[partitions.PartitionNames[i]]
if !ok {
partInfo[partitions.PartitionNames[i]] = partitions.PartitionIDs[i]
if _, ok := partInfo[partitions.PartitionNames[i]]; !ok {
partInfo[partitions.PartitionNames[i]] = &partitionInfo{
partitionID: partitions.PartitionIDs[i],
createdTimestamp: partitions.CreatedTimestamps[i],
createdUtcTimestamp: partitions.CreatedUtcTimestamps[i],
}
}
}
m.collInfo[collectionName].partInfo = partInfo

179
internal/proxy/task.go
View File

@ -1420,6 +1420,7 @@ func (st *SearchTask) PreExecute(ctx context.Context) error {
zap.Any("collections", showResp.CollectionIDs),
)
collectionLoaded := false
for _, collectionID := range showResp.CollectionIDs {
if collectionID == collID {
collectionLoaded = true
@ -2105,6 +2106,7 @@ func (rt *RetrieveTask) PreExecute(ctx context.Context) error {
log.Debug("query coordinator show collections",
zap.Any("collections", showResp.CollectionIDs),
zap.Any("collID", collectionID))
collectionLoaded := false
for _, collID := range showResp.CollectionIDs {
if collectionID == collID {
@ -2838,13 +2840,18 @@ func (sct *ShowCollectionsTask) OnEnqueue() error {
func (sct *ShowCollectionsTask) PreExecute(ctx context.Context) error {
sct.Base.MsgType = commonpb.MsgType_ShowCollections
sct.Base.SourceID = Params.ProxyID
if sct.GetType() == milvuspb.ShowType_InMemory {
for _, collectionName := range sct.CollectionNames {
if err := ValidateCollectionName(collectionName); err != nil {
return err
}
}
}
return nil
}
func (sct *ShowCollectionsTask) Execute(ctx context.Context) error {
var err error
respFromRootCoord, err := sct.rootCoord.ShowCollections(ctx, sct.ShowCollectionsRequest)
if err != nil {
@ -2859,15 +2866,33 @@ func (sct *ShowCollectionsTask) Execute(ctx context.Context) error {
return errors.New(respFromRootCoord.Status.Reason)
}
if sct.ShowCollectionsRequest.Type == milvuspb.ShowCollectionsType_InMemory {
if sct.GetType() == milvuspb.ShowType_InMemory {
IDs2Names := make(map[UniqueID]string)
for offset, collectionName := range respFromRootCoord.CollectionNames {
collectionID := respFromRootCoord.CollectionIds[offset]
IDs2Names[collectionID] = collectionName
}
collectionIDs := make([]UniqueID, 0)
for _, collectionName := range sct.CollectionNames {
collectionID, err := globalMetaCache.GetCollectionID(ctx, collectionName)
if err != nil {
log.Debug("Failed to get collection id.", zap.Any("collectionName", collectionName),
zap.Any("requestID", sct.Base.MsgID), zap.Any("requestType", "showCollections"))
return err
}
collectionIDs = append(collectionIDs, collectionID)
IDs2Names[collectionID] = collectionName
}
resp, err := sct.queryCoord.ShowCollections(ctx, &querypb.ShowCollectionsRequest{
Base: &commonpb.MsgBase{
MsgType: commonpb.MsgType_ShowCollections,
MsgID: sct.ShowCollectionsRequest.Base.MsgID,
Timestamp: sct.ShowCollectionsRequest.Base.Timestamp,
SourceID: sct.ShowCollectionsRequest.Base.SourceID,
MsgID: sct.Base.MsgID,
Timestamp: sct.Base.Timestamp,
SourceID: sct.Base.SourceID,
},
//DbID: sct.ShowCollectionsRequest.DbName,
CollectionIDs: collectionIDs,
})
if err != nil {
@ -2888,19 +2913,27 @@ func (sct *ShowCollectionsTask) Execute(ctx context.Context) error {
CollectionIds: make([]int64, 0, len(resp.CollectionIDs)),
CreatedTimestamps: make([]uint64, 0, len(resp.CollectionIDs)),
CreatedUtcTimestamps: make([]uint64, 0, len(resp.CollectionIDs)),
InMemoryPercentages: make([]int64, 0, len(resp.CollectionIDs)),
}
idMap := make(map[int64]int) // id -> location of respFromRootCoord
for i := range respFromRootCoord.CollectionNames {
idMap[respFromRootCoord.CollectionIds[i]] = i
}
for _, id := range resp.CollectionIDs {
loc := idMap[id]
for offset, id := range resp.CollectionIDs {
collectionName, ok := IDs2Names[id]
if !ok {
log.Debug("Failed to get collection info.", zap.Any("collectionName", collectionName),
zap.Any("requestID", sct.Base.MsgID), zap.Any("requestType", "showCollections"))
return errors.New("failed to show collections")
}
collectionInfo, err := globalMetaCache.GetCollectionInfo(ctx, collectionName)
if err != nil {
log.Debug("Failed to get collection info.", zap.Any("collectionName", collectionName),
zap.Any("requestID", sct.Base.MsgID), zap.Any("requestType", "showCollections"))
return err
}
sct.result.CollectionIds = append(sct.result.CollectionIds, id)
sct.result.CollectionNames = append(sct.result.CollectionNames, respFromRootCoord.CollectionNames[loc])
sct.result.CreatedTimestamps = append(sct.result.CreatedTimestamps, respFromRootCoord.CreatedTimestamps[loc])
sct.result.CreatedUtcTimestamps = append(sct.result.CreatedUtcTimestamps, respFromRootCoord.CreatedUtcTimestamps[loc])
sct.result.CollectionNames = append(sct.result.CollectionNames, collectionName)
sct.result.CreatedTimestamps = append(sct.result.CreatedTimestamps, collectionInfo.createdTimestamp)
sct.result.CreatedUtcTimestamps = append(sct.result.CreatedUtcTimestamps, collectionInfo.createdUtcTimestamp)
sct.result.InMemoryPercentages = append(sct.result.InMemoryPercentages, resp.InMemoryPercentages[offset])
}
} else {
sct.result = respFromRootCoord
@ -3146,9 +3179,10 @@ func (hpt *HasPartitionTask) PostExecute(ctx context.Context) error {
type ShowPartitionsTask struct {
Condition
*milvuspb.ShowPartitionsRequest
ctx context.Context
rootCoord types.RootCoord
result *milvuspb.ShowPartitionsResponse
ctx context.Context
rootCoord types.RootCoord
queryCoord types.QueryCoord
result *milvuspb.ShowPartitionsResponse
}
func (spt *ShowPartitionsTask) TraceCtx() context.Context {
@ -3195,19 +3229,112 @@ func (spt *ShowPartitionsTask) PreExecute(ctx context.Context) error {
if err := ValidateCollectionName(spt.CollectionName); err != nil {
return err
}
if spt.GetType() == milvuspb.ShowType_InMemory {
for _, partitionName := range spt.PartitionNames {
if err := ValidatePartitionTag(partitionName, true); err != nil {
return err
}
}
}
return nil
}
func (spt *ShowPartitionsTask) Execute(ctx context.Context) error {
var err error
spt.result, err = spt.rootCoord.ShowPartitions(ctx, spt.ShowPartitionsRequest)
if spt.result == nil {
return errors.New("get collection statistics resp is nil")
respFromRootCoord, err := spt.rootCoord.ShowPartitions(ctx, spt.ShowPartitionsRequest)
if err != nil {
return err
}
if spt.result.Status.ErrorCode != commonpb.ErrorCode_Success {
return errors.New(spt.result.Status.Reason)
if respFromRootCoord == nil {
return errors.New("failed to show partitions")
}
return err
if respFromRootCoord.Status.ErrorCode != commonpb.ErrorCode_Success {
return errors.New(respFromRootCoord.Status.Reason)
}
if spt.GetType() == milvuspb.ShowType_InMemory {
collectionName := spt.CollectionName
collectionID, err := globalMetaCache.GetCollectionID(ctx, collectionName)
if err != nil {
log.Debug("Failed to get collection id.", zap.Any("collectionName", collectionName),
zap.Any("requestID", spt.Base.MsgID), zap.Any("requestType", "showPartitions"))
return err
}
IDs2Names := make(map[UniqueID]string)
for offset, partitionName := range respFromRootCoord.PartitionNames {
partitionID := respFromRootCoord.PartitionIDs[offset]
IDs2Names[partitionID] = partitionName
}
partitionIDs := make([]UniqueID, 0)
for _, partitionName := range spt.PartitionNames {
partitionID, err := globalMetaCache.GetPartitionID(ctx, collectionName, partitionName)
if err != nil {
log.Debug("Failed to get partition id.", zap.Any("partitionName", partitionName),
zap.Any("requestID", spt.Base.MsgID), zap.Any("requestType", "showPartitions"))
return err
}
partitionIDs = append(partitionIDs, partitionID)
IDs2Names[partitionID] = partitionName
}
resp, err := spt.queryCoord.ShowPartitions(ctx, &querypb.ShowPartitionsRequest{
Base: &commonpb.MsgBase{
MsgType: commonpb.MsgType_ShowCollections,
MsgID: spt.Base.MsgID,
Timestamp: spt.Base.Timestamp,
SourceID: spt.Base.SourceID,
},
CollectionID: collectionID,
PartitionIDs: partitionIDs,
})
if err != nil {
return err
}
if resp == nil {
return errors.New("failed to show partitions")
}
if resp.Status.ErrorCode != commonpb.ErrorCode_Success {
return errors.New(resp.Status.Reason)
}
spt.result = &milvuspb.ShowPartitionsResponse{
Status: resp.Status,
PartitionNames: make([]string, 0, len(resp.PartitionIDs)),
PartitionIDs: make([]int64, 0, len(resp.PartitionIDs)),
CreatedTimestamps: make([]uint64, 0, len(resp.PartitionIDs)),
CreatedUtcTimestamps: make([]uint64, 0, len(resp.PartitionIDs)),
InMemoryPercentages: make([]int64, 0, len(resp.PartitionIDs)),
}
for offset, id := range resp.PartitionIDs {
partitionName, ok := IDs2Names[id]
if !ok {
log.Debug("Failed to get partition id.", zap.Any("partitionName", partitionName),
zap.Any("requestID", spt.Base.MsgID), zap.Any("requestType", "showPartitions"))
return errors.New("failed to show partitions")
}
partitionInfo, err := globalMetaCache.GetPartitionInfo(ctx, collectionName, partitionName)
if err != nil {
log.Debug("Failed to get partition id.", zap.Any("partitionName", partitionName),
zap.Any("requestID", spt.Base.MsgID), zap.Any("requestType", "showPartitions"))
return err
}
spt.result.PartitionIDs = append(spt.result.PartitionIDs, id)
spt.result.PartitionNames = append(spt.result.PartitionNames, partitionName)
spt.result.CreatedTimestamps = append(spt.result.CreatedTimestamps, partitionInfo.createdTimestamp)
spt.result.CreatedUtcTimestamps = append(spt.result.CreatedUtcTimestamps, partitionInfo.createdUtcTimestamp)
spt.result.InMemoryPercentages = append(spt.result.InMemoryPercentages, resp.InMemoryPercentages[offset])
}
} else {
spt.result = respFromRootCoord
}
return nil
}
func (spt *ShowPartitionsTask) PostExecute(ctx context.Context) error {

323
internal/querycoord/cluster.go
View File

@ -25,7 +25,6 @@ import (
etcdkv "github.com/milvus-io/milvus/internal/kv/etcd"
"github.com/milvus-io/milvus/internal/log"
"github.com/milvus-io/milvus/internal/proto/commonpb"
"github.com/milvus-io/milvus/internal/proto/internalpb"
"github.com/milvus-io/milvus/internal/proto/querypb"
"github.com/milvus-io/milvus/internal/util/sessionutil"
@ -36,16 +35,45 @@ const (
queryNodeInfoPrefix = "queryCoord-queryNodeInfo"
)
type Cluster interface {
reloadFromKV() error
getComponentInfos(ctx context.Context) ([]*internalpb.ComponentInfo, error)
loadSegments(ctx context.Context, nodeID int64, in *querypb.LoadSegmentsRequest) error
releaseSegments(ctx context.Context, nodeID int64, in *querypb.ReleaseSegmentsRequest) error
getNumSegments(nodeID int64) (int, error)
watchDmChannels(ctx context.Context, nodeID int64, in *querypb.WatchDmChannelsRequest) error
getNumDmChannels(nodeID int64) (int, error)
hasWatchedQueryChannel(ctx context.Context, nodeID int64, collectionID UniqueID) bool
getCollectionInfosByID(ctx context.Context, nodeID int64) []*querypb.CollectionInfo
addQueryChannel(ctx context.Context, nodeID int64, in *querypb.AddQueryChannelRequest) error
removeQueryChannel(ctx context.Context, nodeID int64, in *querypb.RemoveQueryChannelRequest) error
releaseCollection(ctx context.Context, nodeID int64, in *querypb.ReleaseCollectionRequest) error
releasePartitions(ctx context.Context, nodeID int64, in *querypb.ReleasePartitionsRequest) error
getSegmentInfo(ctx context.Context, in *querypb.GetSegmentInfoRequest) ([]*querypb.SegmentInfo, error)
registerNode(ctx context.Context, session *sessionutil.Session, id UniqueID) error
getNodeByID(nodeID int64) (Node, error)
removeNodeInfo(nodeID int64) error
stopNode(nodeID int64)
onServiceNodes() (map[int64]Node, error)
isOnService(nodeID int64) (bool, error)
printMeta()
}
type queryNodeCluster struct {
client *etcdkv.EtcdKV
sync.RWMutex
clusterMeta *meta
nodes map[int64]*queryNode
clusterMeta Meta
nodes map[int64]Node
}
func newQueryNodeCluster(clusterMeta *meta, kv *etcdkv.EtcdKV) (*queryNodeCluster, error) {
nodes := make(map[int64]*queryNode)
func newQueryNodeCluster(clusterMeta Meta, kv *etcdkv.EtcdKV) (*queryNodeCluster, error) {
nodes := make(map[int64]Node)
c := &queryNodeCluster{
client: kv,
clusterMeta: clusterMeta,
@ -76,67 +104,57 @@ func (c *queryNodeCluster) reloadFromKV() error {
if err != nil {
return err
}
err = c.RegisterNode(context.Background(), session, nodeID)
err = c.registerNode(context.Background(), session, nodeID)
if err != nil {
log.Debug("reloadFromKV: failed to add queryNode to cluster", zap.Int64("nodeID", nodeID), zap.String("error info", err.Error()))
log.Debug("ReloadFromKV: failed to add queryNode to cluster", zap.Int64("nodeID", nodeID), zap.String("error info", err.Error()))
continue
}
nodeIDs = append(nodeIDs, nodeID)
}
for _, nodeID := range nodeIDs {
infoPrefix := fmt.Sprintf("%s/%d", queryNodeMetaPrefix, nodeID)
collectionKeys, collectionValues, err := c.client.LoadWithPrefix(infoPrefix)
_, collectionValues, err := c.client.LoadWithPrefix(infoPrefix)
if err != nil {
return err
}
for index := range collectionKeys {
collectionID, err := strconv.ParseInt(filepath.Base(collectionKeys[index]), 10, 64)
if err != nil {
return err
}
for _, value := range collectionValues {
collectionInfo := &querypb.CollectionInfo{}
err = proto.UnmarshalText(collectionValues[index], collectionInfo)
err = proto.UnmarshalText(value, collectionInfo)
if err != nil {
return err
}
c.nodes[nodeID].collectionInfos[collectionID] = collectionInfo
err = c.nodes[nodeID].setCollectionInfo(collectionInfo)
if err != nil {
log.Debug("ReloadFromKV: failed to add queryNode meta to cluster", zap.Int64("nodeID", nodeID), zap.String("error info", err.Error()))
return err
}
}
}
return nil
}
func (c *queryNodeCluster) GetComponentInfos(ctx context.Context) ([]*internalpb.ComponentInfo, error) {
func (c *queryNodeCluster) getComponentInfos(ctx context.Context) ([]*internalpb.ComponentInfo, error) {
c.RLock()
defer c.RUnlock()
subComponentInfos := make([]*internalpb.ComponentInfo, 0)
nodes, err := c.getOnServiceNodes()
if err != nil {
log.Debug("GetComponentInfos: failed get on service nodes", zap.String("error info", err.Error()))
return nil, err
}
for nodeID := range nodes {
node := c.nodes[nodeID]
componentStates, err := node.client.GetComponentStates(ctx)
if err != nil {
subComponentInfos = append(subComponentInfos, &internalpb.ComponentInfo{
NodeID: nodeID,
StateCode: internalpb.StateCode_Abnormal,
})
continue
}
subComponentInfos = append(subComponentInfos, componentStates.State)
for _, node := range nodes {
componentState := node.getComponentInfo(ctx)
subComponentInfos = append(subComponentInfos, componentState)
}
return subComponentInfos, nil
}
func (c *queryNodeCluster) LoadSegments(ctx context.Context, nodeID int64, in *querypb.LoadSegmentsRequest) (*commonpb.Status, error) {
func (c *queryNodeCluster) loadSegments(ctx context.Context, nodeID int64, in *querypb.LoadSegmentsRequest) error {
c.Lock()
defer c.Unlock()
if node, ok := c.nodes[nodeID]; ok {
if !node.isOnService() {
return nil, errors.New("node offline")
}
segmentInfos := make(map[UniqueID]*querypb.SegmentInfo)
for _, info := range in.Infos {
segmentID := info.SegmentID
@ -158,86 +176,74 @@ func (c *queryNodeCluster) LoadSegments(ctx context.Context, nodeID int64, in *q
}
c.clusterMeta.setSegmentInfo(segmentID, segmentInfo)
}
status, err := node.client.LoadSegments(ctx, in)
if err == nil && status.ErrorCode == commonpb.ErrorCode_Success {
for _, info := range in.Infos {
//c.clusterMeta.addCollection(info.CollectionID, in.Schema)
//c.clusterMeta.addPartition(info.CollectionID, info.PartitionID)
node.addCollection(info.CollectionID, in.Schema)
node.addPartition(info.CollectionID, info.PartitionID)
}
} else {
err := node.loadSegments(ctx, in)
if err != nil {
for _, info := range in.Infos {
segmentID := info.SegmentID
if _, ok = segmentInfos[segmentID]; ok {
c.clusterMeta.setSegmentInfo(segmentID, segmentInfos[segmentID])
continue
}
c.clusterMeta.removeSegmentInfo(segmentID)
c.clusterMeta.deleteSegmentInfoByID(segmentID)
}
log.Debug("LoadSegments: queryNode load segments error", zap.Int64("nodeID", nodeID), zap.String("error info", err.Error()))
return err
}
return status, err
return nil
}
return nil, errors.New("Can't find query node by nodeID ")
return errors.New("LoadSegments: Can't find query node by nodeID ")
}
func (c *queryNodeCluster) ReleaseSegments(ctx context.Context, nodeID int64, in *querypb.ReleaseSegmentsRequest) (*commonpb.Status, error) {
func (c *queryNodeCluster) releaseSegments(ctx context.Context, nodeID int64, in *querypb.ReleaseSegmentsRequest) error {
c.Lock()
defer c.Unlock()
if node, ok := c.nodes[nodeID]; ok {
if !node.isOnService() {
return nil, errors.New("node offline")
return errors.New("node offline")
}
err := node.releaseSegments(ctx, in)
if err != nil {
log.Debug("ReleaseSegments: queryNode release segments error", zap.Int64("nodeID", nodeID), zap.String("error info", err.Error()))
return err
}
for _, segmentID := range in.SegmentIDs {
err := c.clusterMeta.removeSegmentInfo(segmentID)
if err != nil {
log.Error("ReleaseSegments: remove segmentInfo Error", zap.Any("error", err.Error()), zap.Int64("segmentID", segmentID))
}
c.clusterMeta.deleteSegmentInfoByID(segmentID)
}
status, err := node.client.ReleaseSegments(ctx, in)
if err == nil && status.ErrorCode == commonpb.ErrorCode_Success {
for _, segmentID := range in.SegmentIDs {
c.clusterMeta.deleteSegmentInfoByID(segmentID)
}
}
return status, err
return nil
}
return nil, errors.New("Can't find query node by nodeID ")
return errors.New("ReleaseSegments: Can't find query node by nodeID ")
}
func (c *queryNodeCluster) WatchDmChannels(ctx context.Context, nodeID int64, in *querypb.WatchDmChannelsRequest) (*commonpb.Status, error) {
func (c *queryNodeCluster) watchDmChannels(ctx context.Context, nodeID int64, in *querypb.WatchDmChannelsRequest) error {
c.Lock()
defer c.Unlock()
if node, ok := c.nodes[nodeID]; ok {
if !node.isOnService() {
return nil, errors.New("node offline")
err := node.watchDmChannels(ctx, in)
if err != nil {
log.Debug("WatchDmChannels: queryNode watch dm channel error", zap.String("error", err.Error()))
return err
}
channels := make([]string, 0)
for _, info := range in.Infos {
channels = append(channels, info.ChannelName)
}
log.Debug("WatchDmChannels: wait queryNode watch dm channel")
status, err := node.client.WatchDmChannels(ctx, in)
log.Debug("WatchDmChannels: queryNode watch dm channel done")
if err == nil && status.ErrorCode == commonpb.ErrorCode_Success {
collectionID := in.CollectionID
//c.clusterMeta.addCollection(collectionID, in.Schema)
c.clusterMeta.addDmChannel(collectionID, nodeID, channels)
node.addCollection(collectionID, in.Schema)
node.addDmChannel(collectionID, channels)
} else {
collectionID := in.CollectionID
//c.clusterMeta.addCollection(collectionID, in.Schema)
err = c.clusterMeta.addDmChannel(collectionID, nodeID, channels)
if err != nil {
log.Debug("WatchDmChannels: queryNode watch dm channel error", zap.String("error", err.Error()))
return err
}
return status, err
return nil
}
return nil, errors.New("Can't find query node by nodeID ")
return errors.New("WatchDmChannels: Can't find query node by nodeID ")
}
func (c *queryNodeCluster) hasWatchedQueryChannel(ctx context.Context, nodeID int64, collectionID UniqueID) bool {
@ -247,92 +253,79 @@ func (c *queryNodeCluster) hasWatchedQueryChannel(ctx context.Context, nodeID in
return c.nodes[nodeID].hasWatchedQueryChannel(collectionID)
}
func (c *queryNodeCluster) AddQueryChannel(ctx context.Context, nodeID int64, in *querypb.AddQueryChannelRequest) (*commonpb.Status, error) {
func (c *queryNodeCluster) addQueryChannel(ctx context.Context, nodeID int64, in *querypb.AddQueryChannelRequest) error {
c.Lock()
defer c.Unlock()
if node, ok := c.nodes[nodeID]; ok {
if !node.isOnService() {
return nil, errors.New("node offline")
err := node.addQueryChannel(ctx, in)
if err != nil {
log.Debug("AddQueryChannel: queryNode add query channel error", zap.String("error", err.Error()))
return err
}
status, err := node.client.AddQueryChannel(ctx, in)
if err == nil && status.ErrorCode == commonpb.ErrorCode_Success {
//TODO::should reopen
collectionID := in.CollectionID
//collectionID := int64(0)
if queryChannelInfo, ok := c.clusterMeta.queryChannelInfos[0]; ok {
node.addQueryChannel(collectionID, queryChannelInfo)
return status, err
}
log.Error("AddQueryChannel: queryChannel for collection not assigned", zap.Int64("collectionID", collectionID))
}
return status, err
return nil
}
return nil, errors.New("can't find query node by nodeID")
return errors.New("AddQueryChannel: can't find query node by nodeID")
}
func (c *queryNodeCluster) removeQueryChannel(ctx context.Context, nodeID int64, in *querypb.RemoveQueryChannelRequest) (*commonpb.Status, error) {
func (c *queryNodeCluster) removeQueryChannel(ctx context.Context, nodeID int64, in *querypb.RemoveQueryChannelRequest) error {
c.Lock()
defer c.Unlock()
if node, ok := c.nodes[nodeID]; ok {
if !node.isOnService() {
return nil, errors.New("node offline")
err := node.removeQueryChannel(ctx, in)
if err != nil {
log.Debug("RemoveQueryChannel: queryNode remove query channel error", zap.String("error", err.Error()))
return err
}
status, err := node.client.RemoveQueryChannel(ctx, in)
if err == nil && status.ErrorCode == commonpb.ErrorCode_Success {
//TODO::should reopen
//collectionID := in.CollectionID
collectionID := int64(0)
if _, ok = node.watchedQueryChannels[collectionID]; ok {
node.removeQueryChannel(collectionID)
return status, err
}
log.Error("removeQueryChannel: queryChannel for collection not watched", zap.Int64("collectionID", collectionID))
}
return status, err
return nil
}
return nil, errors.New("can't find query node by nodeID")
return errors.New("RemoveQueryChannel: can't find query node by nodeID")
}
func (c *queryNodeCluster) releaseCollection(ctx context.Context, nodeID int64, in *querypb.ReleaseCollectionRequest) (*commonpb.Status, error) {
func (c *queryNodeCluster) releaseCollection(ctx context.Context, nodeID int64, in *querypb.ReleaseCollectionRequest) error {
c.Lock()
defer c.Unlock()
if node, ok := c.nodes[nodeID]; ok {
if !node.isOnService() {
return nil, errors.New("node offline")
err := node.releaseCollection(ctx, in)
if err != nil {
log.Debug("ReleaseCollection: queryNode release collection error", zap.String("error", err.Error()))
return err
}
status, err := node.client.ReleaseCollection(ctx, in)
if err == nil && status.ErrorCode == commonpb.ErrorCode_Success {
node.releaseCollection(in.CollectionID)
c.clusterMeta.releaseCollection(in.CollectionID)
err = c.clusterMeta.releaseCollection(in.CollectionID)
if err != nil {
log.Debug("ReleaseCollection: meta release collection error", zap.String("error", err.Error()))
return err
}
return status, err
return nil
}
return nil, errors.New("can't find query node by nodeID")
return errors.New("ReleaseCollection: can't find query node by nodeID")
}
func (c *queryNodeCluster) releasePartitions(ctx context.Context, nodeID int64, in *querypb.ReleasePartitionsRequest) (*commonpb.Status, error) {
func (c *queryNodeCluster) releasePartitions(ctx context.Context, nodeID int64, in *querypb.ReleasePartitionsRequest) error {
c.Lock()
defer c.Unlock()
if node, ok := c.nodes[nodeID]; ok {
if !node.isOnService() {
return nil, errors.New("node offline")
err := node.releasePartitions(ctx, in)
if err != nil {
log.Debug("ReleasePartitions: queryNode release partitions error", zap.String("error", err.Error()))
return err
}
status, err := node.client.ReleasePartitions(ctx, in)
if err == nil && status.ErrorCode == commonpb.ErrorCode_Success {
for _, partitionID := range in.PartitionIDs {
node.releasePartition(in.CollectionID, partitionID)
c.clusterMeta.releasePartition(in.CollectionID, partitionID)
for _, partitionID := range in.PartitionIDs {
err = c.clusterMeta.releasePartition(in.CollectionID, partitionID)
if err != nil {
log.Debug("ReleasePartitions: meta release partitions error", zap.String("error", err.Error()))
return err
}
}
return status, err
return nil
}
return nil, errors.New("can't find query node by nodeID")
return errors.New("ReleasePartitions: can't find query node by nodeID")
}
func (c *queryNodeCluster) getSegmentInfo(ctx context.Context, in *querypb.GetSegmentInfoRequest) ([]*querypb.SegmentInfo, error) {
@ -340,19 +333,17 @@ func (c *queryNodeCluster) getSegmentInfo(ctx context.Context, in *querypb.GetSe
defer c.RUnlock()
segmentInfos := make([]*querypb.SegmentInfo, 0)
nodes, err := c.getOnServiceNodes()
if err != nil {
log.Warn(err.Error())
return segmentInfos, nil
}
for nodeID := range nodes {
res, err := c.nodes[nodeID].client.GetSegmentInfo(ctx, in)
for _, node := range c.nodes {
res, err := node.getSegmentInfo(ctx, in)
if err != nil {
return nil, err
}
segmentInfos = append(segmentInfos, res.Infos...)
if res != nil {
segmentInfos = append(segmentInfos, res.Infos...)
}
}
//TODO::update meta
return segmentInfos, nil
}
@ -361,11 +352,12 @@ func (c *queryNodeCluster) getNumDmChannels(nodeID int64) (int, error) {
defer c.RUnlock()
if _, ok := c.nodes[nodeID]; !ok {
return 0, errors.New("Can't find query node by nodeID ")
return 0, errors.New("GetNumDmChannels: Can't find query node by nodeID ")
}
numChannel := 0
for _, info := range c.clusterMeta.collectionInfos {
collectionInfos := c.clusterMeta.showCollections()
for _, info := range collectionInfos {
for _, channelInfo := range info.ChannelInfos {
if channelInfo.NodeIDLoaded == nodeID {
numChannel++
@ -380,11 +372,17 @@ func (c *queryNodeCluster) getNumSegments(nodeID int64) (int, error) {
defer c.RUnlock()
if _, ok := c.nodes[nodeID]; !ok {
return 0, errors.New("Can't find query node by nodeID ")
return 0, errors.New("getNumSegments: Can't find query node by nodeID ")
}
numSegment := 0
for _, info := range c.clusterMeta.segmentInfos {
segmentInfos := make([]*querypb.SegmentInfo, 0)
collectionInfos := c.clusterMeta.showCollections()
for _, info := range collectionInfos {
res := c.clusterMeta.showSegmentInfos(info.CollectionID, nil)
segmentInfos = append(segmentInfos, res...)
}
for _, info := range segmentInfos {
if info.NodeID == nodeID {
numSegment++
}
@ -392,13 +390,14 @@ func (c *queryNodeCluster) getNumSegments(nodeID int64) (int, error) {
return numSegment, nil
}
func (c *queryNodeCluster) RegisterNode(ctx context.Context, session *sessionutil.Session, id UniqueID) error {
func (c *queryNodeCluster) registerNode(ctx context.Context, session *sessionutil.Session, id UniqueID) error {
c.Lock()
defer c.Unlock()
if _, ok := c.nodes[id]; !ok {
sessionJSON, err := json.Marshal(session)
if err != nil {
log.Debug("RegisterNode: marshal session error", zap.Int64("nodeID", id), zap.Any("address", session))
return err
}
key := fmt.Sprintf("%s/%d", queryNodeInfoPrefix, id)
@ -415,16 +414,16 @@ func (c *queryNodeCluster) RegisterNode(ctx context.Context, session *sessionuti
log.Error("RegisterNode: start queryNode client failed", zap.Int64("nodeID", id), zap.String("error", err.Error()))
return
}
log.Debug("RegisterNode: start queryNode success, print cluster meta info", zap.Int64("nodeID", id))
log.Debug("RegisterNode: start queryNode success, print cluster MetaReplica info", zap.Int64("nodeID", id))
c.printMeta()
}()
return nil
}
return fmt.Errorf("node %d alredy exists in cluster", id)
return fmt.Errorf("RegisterNode: node %d alredy exists in cluster", id)
}
func (c *queryNodeCluster) getNodeByID(nodeID int64) (*queryNode, error) {
func (c *queryNodeCluster) getNodeByID(nodeID int64) (Node, error) {
c.RLock()
defer c.RUnlock()
@ -432,7 +431,7 @@ func (c *queryNodeCluster) getNodeByID(nodeID int64) (*queryNode, error) {
return node, nil
}
return nil, fmt.Errorf("query node %d not exist", nodeID)
return nil, fmt.Errorf("GetNodeByID: query node %d not exist", nodeID)
}
func (c *queryNodeCluster) removeNodeInfo(nodeID int64) error {
@ -451,7 +450,7 @@ func (c *queryNodeCluster) removeNodeInfo(nodeID int64) error {
return err
}
delete(c.nodes, nodeID)
log.Debug("removeNodeInfo: delete nodeInfo in cluster meta and etcd", zap.Int64("nodeID", nodeID))
log.Debug("RemoveNodeInfo: delete nodeInfo in cluster MetaReplica and etcd", zap.Int64("nodeID", nodeID))
}
return nil
@ -460,26 +459,26 @@ func (c *queryNodeCluster) removeNodeInfo(nodeID int64) error {
func (c *queryNodeCluster) stopNode(nodeID int64) {
if node, ok := c.nodes[nodeID]; ok {
node.stop()
log.Debug("stopNode: queryNode offline", zap.Int64("nodeID", nodeID))
log.Debug("StopNode: queryNode offline", zap.Int64("nodeID", nodeID))
}
}
func (c *queryNodeCluster) onServiceNodes() (map[int64]*queryNode, error) {
func (c *queryNodeCluster) onServiceNodes() (map[int64]Node, error) {
c.RLock()
defer c.RUnlock()
return c.getOnServiceNodes()
}
func (c *queryNodeCluster) getOnServiceNodes() (map[int64]*queryNode, error) {
nodes := make(map[int64]*queryNode)
func (c *queryNodeCluster) getOnServiceNodes() (map[int64]Node, error) {
nodes := make(map[int64]Node)
for nodeID, node := range c.nodes {
if node.isOnService() {
nodes[nodeID] = node
}
}
if len(nodes) == 0 {
return nil, errors.New("no queryNode is alive")
return nil, errors.New("GetOnServiceNodes: no queryNode is alive")
}
return nodes, nil
@ -493,22 +492,34 @@ func (c *queryNodeCluster) isOnService(nodeID int64) (bool, error) {
return node.isOnService(), nil
}
return false, fmt.Errorf("query node %d not exist", nodeID)
return false, fmt.Errorf("IsOnService: query node %d not exist", nodeID)
}
func (c *queryNodeCluster) printMeta() {
c.Lock()
defer c.Unlock()
c.RLock()
defer c.RUnlock()
for id, node := range c.nodes {
if node.isOnService() {
for collectionID, info := range node.collectionInfos {
log.Debug("query coordinator cluster info: collectionInfo", zap.Int64("nodeID", id), zap.Int64("collectionID", collectionID), zap.Any("info", info))
collectionInfos := node.showCollections()
for _, info := range collectionInfos {
log.Debug("PrintMeta: query coordinator cluster info: collectionInfo", zap.Int64("nodeID", id), zap.Int64("collectionID", info.CollectionID), zap.Any("info", info))
}
for collectionID, info := range node.watchedQueryChannels {
log.Debug("query coordinator cluster info: watchedQueryChannelInfo", zap.Int64("nodeID", id), zap.Int64("collectionID", collectionID), zap.Any("info", info))
queryChannelInfos := node.showWatchedQueryChannels()
for _, info := range queryChannelInfos {
log.Debug("PrintMeta: query coordinator cluster info: watchedQueryChannelInfo", zap.Int64("nodeID", id), zap.Int64("collectionID", info.CollectionID), zap.Any("info", info))
}
}
}
}
func (c *queryNodeCluster) getCollectionInfosByID(ctx context.Context, nodeID int64) []*querypb.CollectionInfo {
c.RLock()
defer c.RUnlock()
if node, ok := c.nodes[nodeID]; ok {
return node.showCollections()
}
return nil
}

94
internal/querycoord/impl.go
View File

@ -84,11 +84,41 @@ func (qc *QueryCoord) ShowCollections(ctx context.Context, req *querypb.ShowColl
Status: status,
}, err
}
collectionIDs := qc.meta.showCollections()
log.Debug("show collection end", zap.Int64s("collections", collectionIDs))
collectionInfos := qc.meta.showCollections()
ID2collectionInfo := make(map[UniqueID]*querypb.CollectionInfo)
inMemoryCollectionIDs := make([]UniqueID, 0)
for _, info := range collectionInfos {
ID2collectionInfo[info.CollectionID] = info
inMemoryCollectionIDs = append(inMemoryCollectionIDs, info.CollectionID)
}
inMemoryPercentages := make([]int64, 0)
if len(req.CollectionIDs) == 0 {
for _, id := range inMemoryCollectionIDs {
inMemoryPercentages = append(inMemoryPercentages, ID2collectionInfo[id].InMemoryPercentage)
}
log.Debug("show collection end", zap.Int64s("collections", inMemoryCollectionIDs), zap.Int64s("inMemoryPercentage", inMemoryPercentages))
return &querypb.ShowCollectionsResponse{
Status: status,
CollectionIDs: inMemoryCollectionIDs,
InMemoryPercentages: inMemoryPercentages,
}, nil
}
for _, id := range req.CollectionIDs {
if _, ok := ID2collectionInfo[id]; !ok {
status.ErrorCode = commonpb.ErrorCode_UnexpectedError
err := errors.New("collection not exist or has not been loaded to memory")
status.Reason = err.Error()
return &querypb.ShowCollectionsResponse{
Status: status,
}, err
}
inMemoryPercentages = append(inMemoryPercentages, ID2collectionInfo[id].InMemoryPercentage)
}
log.Debug("show collection end", zap.Int64s("collections", req.CollectionIDs), zap.Int64s("inMemoryPercentage", inMemoryPercentages))
return &querypb.ShowCollectionsResponse{
Status: status,
CollectionIDs: collectionIDs,
Status: status,
CollectionIDs: req.CollectionIDs,
InMemoryPercentages: inMemoryPercentages,
}, nil
}
@ -175,14 +205,14 @@ func (qc *QueryCoord) ReleaseCollection(ctx context.Context, req *querypb.Releas
}
log.Debug("ReleaseCollectionRequest completed", zap.String("role", Params.RoleName), zap.Int64("msgID", req.Base.MsgID), zap.Int64("collectionID", collectionID))
//qc.meta.printMeta()
//qc.MetaReplica.printMeta()
//qc.cluster.printMeta()
return status, nil
}
func (qc *QueryCoord) ShowPartitions(ctx context.Context, req *querypb.ShowPartitionsRequest) (*querypb.ShowPartitionsResponse, error) {
collectionID := req.CollectionID
log.Debug("show partitions start, ", zap.Int64("collectionID", collectionID))
log.Debug("show partitions start, ", zap.Int64("collectionID", collectionID), zap.Int64s("partitionIDs", req.PartitionIDs))
status := &commonpb.Status{
ErrorCode: commonpb.ErrorCode_Success,
}
@ -196,7 +226,7 @@ func (qc *QueryCoord) ShowPartitions(ctx context.Context, req *querypb.ShowParti
}, err
}
partitionIDs, err := qc.meta.showPartitions(collectionID)
partitionStates, err := qc.meta.showPartitions(collectionID)
if err != nil {
status.ErrorCode = commonpb.ErrorCode_UnexpectedError
status.Reason = err.Error()
@ -204,12 +234,42 @@ func (qc *QueryCoord) ShowPartitions(ctx context.Context, req *querypb.ShowParti
Status: status,
}, err
}
ID2PartitionState := make(map[UniqueID]*querypb.PartitionStates)
inMemoryPartitionIDs := make([]UniqueID, 0)
for _, state := range partitionStates {
ID2PartitionState[state.PartitionID] = state
inMemoryPartitionIDs = append(inMemoryPartitionIDs, state.PartitionID)
}
inMemoryPercentages := make([]int64, 0)
if len(req.PartitionIDs) == 0 {
for _, id := range inMemoryPartitionIDs {
inMemoryPercentages = append(inMemoryPercentages, ID2PartitionState[id].InMemoryPercentage)
}
log.Debug("show partitions end", zap.Int64("collectionID", collectionID), zap.Int64s("partitionIDs", inMemoryPartitionIDs), zap.Int64s("inMemoryPercentage", inMemoryPercentages))
return &querypb.ShowPartitionsResponse{
Status: status,
PartitionIDs: inMemoryPartitionIDs,
InMemoryPercentages: inMemoryPercentages,
}, nil
}
for _, id := range req.PartitionIDs {
if _, ok := ID2PartitionState[id]; !ok {
status.ErrorCode = commonpb.ErrorCode_UnexpectedError
err := errors.New("partition not exist or has not been loaded to memory")
status.Reason = err.Error()
return &querypb.ShowPartitionsResponse{
Status: status,
}, err
}
inMemoryPercentages = append(inMemoryPercentages, ID2PartitionState[id].InMemoryPercentage)
}
log.Debug("show partitions end", zap.Int64("collectionID", collectionID), zap.Int64s("partitionIDs", partitionIDs))
log.Debug("show partitions end", zap.Int64("collectionID", collectionID), zap.Int64s("partitionIDs", req.PartitionIDs), zap.Int64s("inMemoryPercentage", inMemoryPercentages))
return &querypb.ShowPartitionsResponse{
Status: status,
PartitionIDs: partitionIDs,
Status: status,
PartitionIDs: req.PartitionIDs,
InMemoryPercentages: inMemoryPercentages,
}, nil
}
@ -239,8 +299,8 @@ func (qc *QueryCoord) LoadPartitions(ctx context.Context, req *querypb.LoadParti
hasCollection := qc.meta.hasCollection(collectionID)
if hasCollection {
partitionIDsToLoad := make([]UniqueID, 0)
loadCollection, _ := qc.meta.getLoadCollection(collectionID)
if loadCollection {
loadType, _ := qc.meta.getLoadType(collectionID)
if loadType == querypb.LoadType_loadCollection {
for _, partitionID := range partitionIDs {
hasReleasePartition := qc.meta.hasReleasePartition(collectionID, partitionID)
if hasReleasePartition {
@ -336,7 +396,7 @@ func (qc *QueryCoord) ReleasePartitions(ctx context.Context, req *querypb.Releas
return status, err
}
log.Debug("ReleasePartitionRequest completed", zap.String("role", Params.RoleName), zap.Int64("msgID", req.Base.MsgID), zap.Int64("collectionID", collectionID), zap.Int64s("partitionIDs", partitionIDs))
//qc.meta.printMeta()
//qc.MetaReplica.printMeta()
//qc.cluster.printMeta()
return status, nil
}
@ -382,7 +442,7 @@ func (qc *QueryCoord) GetPartitionStates(ctx context.Context, req *querypb.GetPa
partitionIDs := req.PartitionIDs
partitionStates := make([]*querypb.PartitionStates, 0)
for _, partitionID := range partitionIDs {
state, err := qc.meta.getPartitionStateByID(partitionID)
res, err := qc.meta.getPartitionStatesByID(req.CollectionID, partitionID)
if err != nil {
status.ErrorCode = commonpb.ErrorCode_UnexpectedError
status.Reason = err.Error()
@ -392,7 +452,7 @@ func (qc *QueryCoord) GetPartitionStates(ctx context.Context, req *querypb.GetPa
}
partitionState := &querypb.PartitionStates{
PartitionID: partitionID,
State: state,
State: res.State,
}
partitionStates = append(partitionStates, partitionState)
}
@ -419,9 +479,9 @@ func (qc *QueryCoord) GetSegmentInfo(ctx context.Context, req *querypb.GetSegmen
totalMemSize := int64(0)
totalNumRows := int64(0)
//TODO::get segment infos from meta
//TODO::get segment infos from MetaReplica
//segmentIDs := req.SegmentIDs
//segmentInfos, err := qs.meta.getSegmentInfos(segmentIDs)
//segmentInfos, err := qs.MetaReplica.getSegmentInfos(segmentIDs)
segmentInfos, err := qc.cluster.getSegmentInfo(ctx, req)
if err != nil {
status.ErrorCode = commonpb.ErrorCode_UnexpectedError

393
internal/querycoord/meta.go
View File

@ -33,7 +33,46 @@ const (
queryChannelMetaPrefix = "queryCoord-queryChannel"
)
type meta struct {
type Meta interface {
reloadFromKV() error
showCollections() []*querypb.CollectionInfo
hasCollection(collectionID UniqueID) bool
getCollectionInfoByID(collectionID UniqueID) (*querypb.CollectionInfo, error)
addCollection(collectionID UniqueID, schema *schemapb.CollectionSchema) error
releaseCollection(collectionID UniqueID) error
addPartition(collectionID UniqueID, partitionID UniqueID) error
showPartitions(collectionID UniqueID) ([]*querypb.PartitionStates, error)
hasPartition(collectionID UniqueID, partitionID UniqueID) bool
hasReleasePartition(collectionID UniqueID, partitionID UniqueID) bool
releasePartition(collectionID UniqueID, partitionID UniqueID) error
deleteSegmentInfoByID(segmentID UniqueID) error
deleteSegmentInfoByNodeID(nodeID UniqueID) error
setSegmentInfo(segmentID UniqueID, info *querypb.SegmentInfo) error
hasSegmentInfo(segmentID UniqueID) bool
showSegmentInfos(collectionID UniqueID, partitionIDs []UniqueID) []*querypb.SegmentInfo
getSegmentInfoByID(segmentID UniqueID) (*querypb.SegmentInfo, error)
getPartitionStatesByID(collectionID UniqueID, partitionID UniqueID) (*querypb.PartitionStates, error)
hasWatchedDmChannel(collectionID UniqueID, channelID string) (bool, error)
getDmChannelsByCollectionID(collectionID UniqueID) ([]string, error)
getDmChannelsByNodeID(collectionID UniqueID, nodeID int64) ([]string, error)
addDmChannel(collectionID UniqueID, nodeID int64, channels []string) error
removeDmChannel(collectionID UniqueID, nodeID int64, channels []string) error
getQueryChannelInfoByID(collectionID UniqueID) (*querypb.QueryChannelInfo, error)
GetQueryChannel(collectionID UniqueID) (string, string)
setLoadType(collectionID UniqueID, loadType querypb.LoadType) error
getLoadType(collectionID UniqueID) (querypb.LoadType, error)
setLoadPercentage(collectionID UniqueID, partitionID UniqueID, percentage int64, loadType querypb.LoadType) error
printMeta()
}
type MetaReplica struct {
client *etcdkv.EtcdKV // client of a reliable kv service, i.e. etcd client
sync.RWMutex
@ -41,21 +80,19 @@ type meta struct {
segmentInfos map[UniqueID]*querypb.SegmentInfo
queryChannelInfos map[UniqueID]*querypb.QueryChannelInfo
partitionStates map[UniqueID]querypb.PartitionState
//partitionStates map[UniqueID]*querypb.PartitionStates
}
func newMeta(kv *etcdkv.EtcdKV) (*meta, error) {
func newMeta(kv *etcdkv.EtcdKV) (Meta, error) {
collectionInfos := make(map[UniqueID]*querypb.CollectionInfo)
segmentInfos := make(map[UniqueID]*querypb.SegmentInfo)
queryChannelInfos := make(map[UniqueID]*querypb.QueryChannelInfo)
partitionStates := make(map[UniqueID]querypb.PartitionState)
m := &meta{
m := &MetaReplica{
client: kv,
collectionInfos: collectionInfos,
segmentInfos: segmentInfos,
queryChannelInfos: queryChannelInfos,
partitionStates: partitionStates,
}
err := m.reloadFromKV()
@ -66,7 +103,7 @@ func newMeta(kv *etcdkv.EtcdKV) (*meta, error) {
return m, nil
}
func (m *meta) reloadFromKV() error {
func (m *MetaReplica) reloadFromKV() error {
collectionKeys, collectionValues, err := m.client.LoadWithPrefix(collectionMetaPrefix)
if err != nil {
return err
@ -122,30 +159,34 @@ func (m *meta) reloadFromKV() error {
return nil
}
func (m *meta) showCollections() []UniqueID {
func (m *MetaReplica) showCollections() []*querypb.CollectionInfo {
m.RLock()
defer m.RUnlock()
collections := make([]UniqueID, 0)
for id := range m.collectionInfos {
collections = append(collections, id)
collections := make([]*querypb.CollectionInfo, 0)
for _, info := range m.collectionInfos {
collections = append(collections, proto.Clone(info).(*querypb.CollectionInfo))
}
return collections
}
func (m *meta) showPartitions(collectionID UniqueID) ([]UniqueID, error) {
func (m *MetaReplica) showPartitions(collectionID UniqueID) ([]*querypb.PartitionStates, error) {
m.RLock()
defer m.RUnlock()
//TODO::should update after load collection
results := make([]*querypb.PartitionStates, 0)
if info, ok := m.collectionInfos[collectionID]; ok {
return info.PartitionIDs, nil
for _, state := range info.PartitionStates {
results = append(results, proto.Clone(state).(*querypb.PartitionStates))
}
return results, nil
}
return nil, errors.New("showPartitions: can't find collection in collectionInfos")
}
func (m *meta) hasCollection(collectionID UniqueID) bool {
func (m *MetaReplica) hasCollection(collectionID UniqueID) bool {
m.RLock()
defer m.RUnlock()
@ -156,7 +197,7 @@ func (m *meta) hasCollection(collectionID UniqueID) bool {
return false
}
func (m *meta) hasPartition(collectionID UniqueID, partitionID UniqueID) bool {
func (m *MetaReplica) hasPartition(collectionID UniqueID, partitionID UniqueID) bool {
m.RLock()
defer m.RUnlock()
@ -171,7 +212,7 @@ func (m *meta) hasPartition(collectionID UniqueID, partitionID UniqueID) bool {
return false
}
func (m *meta) hasReleasePartition(collectionID UniqueID, partitionID UniqueID) bool {
func (m *MetaReplica) hasReleasePartition(collectionID UniqueID, partitionID UniqueID) bool {
m.RLock()
defer m.RUnlock()
@ -186,41 +227,40 @@ func (m *meta) hasReleasePartition(collectionID UniqueID, partitionID UniqueID)
return false
}
func (m *meta) addCollection(collectionID UniqueID, schema *schemapb.CollectionSchema) error {
func (m *MetaReplica) addCollection(collectionID UniqueID, schema *schemapb.CollectionSchema) error {
m.Lock()
defer m.Unlock()
if _, ok := m.collectionInfos[collectionID]; !ok {
partitions := make([]UniqueID, 0)
partitionStates := make([]*querypb.PartitionStates, 0)
channels := make([]*querypb.DmChannelInfo, 0)
newCollection := &querypb.CollectionInfo{
CollectionID: collectionID,
PartitionIDs: partitions,
ChannelInfos: channels,
Schema: schema,
CollectionID: collectionID,
PartitionIDs: partitions,
PartitionStates: partitionStates,
ChannelInfos: channels,
Schema: schema,
}
m.collectionInfos[collectionID] = newCollection
err := m.saveCollectionInfo(collectionID, newCollection)
err := saveGlobalCollectionInfo(collectionID, newCollection, m.client)
if err != nil {
log.Error("save collectionInfo error", zap.Any("error", err.Error()), zap.Int64("collectionID", collectionID))
return err
}
log.Debug("add collection",
zap.Any("collectionID", collectionID),
)
return nil
}
return errors.New("addCollection: collection already exists")
return nil
}
func (m *meta) addPartition(collectionID UniqueID, partitionID UniqueID) error {
func (m *MetaReplica) addPartition(collectionID UniqueID, partitionID UniqueID) error {
m.Lock()
defer m.Unlock()
if col, ok := m.collectionInfos[collectionID]; ok {
log.Debug("add a partition to meta...", zap.Int64s("partitionIDs", col.PartitionIDs))
log.Debug("add a partition to MetaReplica...", zap.Int64s("partitionIDs", col.PartitionIDs))
for _, id := range col.PartitionIDs {
if id == partitionID {
return errors.New("addPartition: partition already exists in collectionInfos")
return nil
}
}
col.PartitionIDs = append(col.PartitionIDs, partitionID)
@ -231,72 +271,94 @@ func (m *meta) addPartition(collectionID UniqueID, partitionID UniqueID) error {
}
}
col.ReleasedPartitionIDs = releasedPartitionIDs
m.partitionStates[partitionID] = querypb.PartitionState_NotPresent
log.Debug("add a partition to meta", zap.Int64s("partitionIDs", col.PartitionIDs))
err := m.saveCollectionInfo(collectionID, col)
col.PartitionStates = append(col.PartitionStates, &querypb.PartitionStates{
PartitionID: partitionID,
State: querypb.PartitionState_NotPresent,
})
log.Debug("add a partition to MetaReplica", zap.Int64s("partitionIDs", col.PartitionIDs))
err := saveGlobalCollectionInfo(collectionID, col, m.client)
if err != nil {
log.Error("save collectionInfo error", zap.Any("error", err.Error()), zap.Int64("collectionID", collectionID))
return err
}
return nil
}
return errors.New("addPartition: can't find collection when add partition")
}
func (m *meta) deleteSegmentInfoByID(segmentID UniqueID) {
func (m *MetaReplica) deleteSegmentInfoByID(segmentID UniqueID) error {
m.Lock()
defer m.Unlock()
if _, ok := m.segmentInfos[segmentID]; ok {
err := m.removeSegmentInfo(segmentID)
err := removeSegmentInfo(segmentID, m.client)
if err != nil {
log.Error("remove segmentInfo error", zap.Any("error", err.Error()), zap.Int64("segmentID", segmentID))
return err
}
delete(m.segmentInfos, segmentID)
}
return nil
}
func (m *meta) deleteSegmentInfoByNodeID(nodeID UniqueID) {
func (m *MetaReplica) deleteSegmentInfoByNodeID(nodeID UniqueID) error {
m.Lock()
defer m.Unlock()
for segmentID, info := range m.segmentInfos {
if info.NodeID == nodeID {
err := m.removeSegmentInfo(segmentID)
err := removeSegmentInfo(segmentID, m.client)
if err != nil {
log.Error("remove segmentInfo error", zap.Any("error", err.Error()), zap.Int64("segmentID", segmentID))
return err
}
delete(m.segmentInfos, segmentID)
}
}
return nil
}
func (m *meta) setSegmentInfo(segmentID UniqueID, info *querypb.SegmentInfo) {
func (m *MetaReplica) setSegmentInfo(segmentID UniqueID, info *querypb.SegmentInfo) error {
m.Lock()
defer m.Unlock()
err := m.saveSegmentInfo(segmentID, info)
err := saveSegmentInfo(segmentID, info, m.client)
if err != nil {
log.Error("save segmentInfo error", zap.Any("error", err.Error()), zap.Int64("segmentID", segmentID))
return err
}
m.segmentInfos[segmentID] = info
return nil
}
func (m *meta) getSegmentInfos(segmentIDs []UniqueID) ([]*querypb.SegmentInfo, error) {
m.Lock()
defer m.Unlock()
func (m *MetaReplica) showSegmentInfos(collectionID UniqueID, partitionIDs []UniqueID) []*querypb.SegmentInfo {
m.RLock()
defer m.RUnlock()
results := make([]*querypb.SegmentInfo, 0)
segmentInfos := make([]*querypb.SegmentInfo, 0)
for _, segmentID := range segmentIDs {
if info, ok := m.segmentInfos[segmentID]; ok {
for _, info := range m.segmentInfos {
if info.CollectionID == collectionID {
segmentInfos = append(segmentInfos, proto.Clone(info).(*querypb.SegmentInfo))
continue
}
return nil, errors.New("segment not exist")
}
return segmentInfos, nil
if len(partitionIDs) == 0 {
return segmentInfos
}
for _, info := range segmentInfos {
for _, partitionID := range partitionIDs {
if info.PartitionID == partitionID {
results = append(results, info)
}
}
}
return results
}
func (m *meta) hasSegmentInfo(segmentID UniqueID) bool {
func (m *MetaReplica) hasSegmentInfo(segmentID UniqueID) bool {
m.RLock()
defer m.RUnlock()
@ -307,19 +369,18 @@ func (m *meta) hasSegmentInfo(segmentID UniqueID) bool {
return false
}
func (m *meta) getSegmentInfoByID(segmentID UniqueID) (*querypb.SegmentInfo, error) {
func (m *MetaReplica) getSegmentInfoByID(segmentID UniqueID) (*querypb.SegmentInfo, error) {
m.Lock()
defer m.Unlock()
if info, ok := m.segmentInfos[segmentID]; ok {
return proto.Clone(info).(*querypb.SegmentInfo), nil
}
return nil, errors.New("getSegmentInfoByID: can't find segmentID in segmentInfos")
}
func (m *meta) getCollectionInfoByID(collectionID UniqueID) (*querypb.CollectionInfo, error) {
func (m *MetaReplica) getCollectionInfoByID(collectionID UniqueID) (*querypb.CollectionInfo, error) {
m.Lock()
defer m.Unlock()
@ -330,7 +391,7 @@ func (m *meta) getCollectionInfoByID(collectionID UniqueID) (*querypb.Collection
return nil, errors.New("getCollectionInfoByID: can't find collectionID in collectionInfo")
}
func (m *meta) getQueryChannelInfoByID(collectionID UniqueID) (*querypb.QueryChannelInfo, error) {
func (m *MetaReplica) getQueryChannelInfoByID(collectionID UniqueID) (*querypb.QueryChannelInfo, error) {
m.Lock()
defer m.Unlock()
@ -341,69 +402,63 @@ func (m *meta) getQueryChannelInfoByID(collectionID UniqueID) (*querypb.QueryCha
return nil, errors.New("getQueryChannelInfoByID: can't find collectionID in queryChannelInfo")
}
func (m *meta) updatePartitionState(partitionID UniqueID, state querypb.PartitionState) error {
m.Lock()
defer m.Unlock()
if _, ok := m.partitionStates[partitionID]; ok {
m.partitionStates[partitionID] = state
}
return errors.New("updatePartitionState: can't find partition in partitionStates")
}
func (m *meta) getPartitionStateByID(partitionID UniqueID) (querypb.PartitionState, error) {
func (m *MetaReplica) getPartitionStatesByID(collectionID UniqueID, partitionID UniqueID) (*querypb.PartitionStates, error) {
m.RLock()
defer m.RUnlock()
if state, ok := m.partitionStates[partitionID]; ok {
return state, nil
if info, ok := m.collectionInfos[collectionID]; ok {
for offset, id := range info.PartitionIDs {
if id == partitionID {
return proto.Clone(info.PartitionStates[offset]).(*querypb.PartitionStates), nil
}
}
return nil, errors.New("getPartitionStateByID: can't find partitionID in partitionStates")
}
return 0, errors.New("getPartitionStateByID: can't find partition in partitionStates")
return nil, errors.New("getPartitionStateByID: can't find collectionID in collectionInfo")
}
func (m *meta) releaseCollection(collectionID UniqueID) {
func (m *MetaReplica) releaseCollection(collectionID UniqueID) error {
m.Lock()
defer m.Unlock()
if info, ok := m.collectionInfos[collectionID]; ok {
for _, partitionID := range info.PartitionIDs {
delete(m.partitionStates, partitionID)
}
delete(m.collectionInfos, collectionID)
}
delete(m.collectionInfos, collectionID)
for id, info := range m.segmentInfos {
if info.CollectionID == collectionID {
err := m.removeSegmentInfo(id)
err := removeSegmentInfo(id, m.client)
if err != nil {
log.Error("remove segmentInfo error", zap.Any("error", err.Error()), zap.Int64("segmentID", id))
return err
}
delete(m.segmentInfos, id)
}
}
delete(m.queryChannelInfos, collectionID)
err := m.removeCollectionInfo(collectionID)
err := removeGlobalCollectionInfo(collectionID, m.client)
if err != nil {
log.Error("remove collectionInfo error", zap.Any("error", err.Error()), zap.Int64("collectionID", collectionID))
return err
}
return nil
}
func (m *meta) releasePartition(collectionID UniqueID, partitionID UniqueID) {
func (m *MetaReplica) releasePartition(collectionID UniqueID, partitionID UniqueID) error {
m.Lock()
defer m.Unlock()
if info, ok := m.collectionInfos[collectionID]; ok {
newPartitionIDs := make([]UniqueID, 0)
for _, id := range info.PartitionIDs {
if id == partitionID {
delete(m.partitionStates, partitionID)
} else {
newPartitionStates := make([]*querypb.PartitionStates, 0)
for offset, id := range info.PartitionIDs {
if id != partitionID {
newPartitionIDs = append(newPartitionIDs, id)
newPartitionStates = append(newPartitionStates, info.PartitionStates[offset])
}
}
info.PartitionIDs = newPartitionIDs
info.PartitionStates = newPartitionStates
releasedPartitionIDs := make([]UniqueID, 0)
for _, id := range info.ReleasedPartitionIDs {
@ -413,23 +468,27 @@ func (m *meta) releasePartition(collectionID UniqueID, partitionID UniqueID) {
}
releasedPartitionIDs = append(releasedPartitionIDs, partitionID)
info.ReleasedPartitionIDs = releasedPartitionIDs
err := m.saveCollectionInfo(collectionID, info)
err := saveGlobalCollectionInfo(collectionID, info, m.client)
if err != nil {
log.Error("save collectionInfo error", zap.Any("error", err.Error()), zap.Int64("collectionID", collectionID))
return err
}
}
for id, info := range m.segmentInfos {
if info.PartitionID == partitionID {
err := m.removeSegmentInfo(id)
err := removeSegmentInfo(id, m.client)
if err != nil {
log.Error("delete segmentInfo error", zap.Any("error", err.Error()), zap.Int64("collectionID", collectionID), zap.Int64("segmentID", id))
return err
}
delete(m.segmentInfos, id)
}
}
return nil
}
func (m *meta) hasWatchedDmChannel(collectionID UniqueID, channelID string) (bool, error) {
func (m *MetaReplica) hasWatchedDmChannel(collectionID UniqueID, channelID string) (bool, error) {
m.RLock()
defer m.RUnlock()
@ -448,7 +507,7 @@ func (m *meta) hasWatchedDmChannel(collectionID UniqueID, channelID string) (boo
return false, errors.New("hasWatchedDmChannel: can't find collection in collectionInfos")
}
func (m *meta) getDmChannelsByCollectionID(collectionID UniqueID) ([]string, error) {
func (m *MetaReplica) getDmChannelsByCollectionID(collectionID UniqueID) ([]string, error) {
m.RLock()
defer m.RUnlock()
@ -463,7 +522,7 @@ func (m *meta) getDmChannelsByCollectionID(collectionID UniqueID) ([]string, err
return nil, errors.New("getDmChannelsByCollectionID: can't find collection in collectionInfos")
}
func (m *meta) getDmChannelsByNodeID(collectionID UniqueID, nodeID int64) ([]string, error) {
func (m *MetaReplica) getDmChannelsByNodeID(collectionID UniqueID, nodeID int64) ([]string, error) {
m.RLock()
defer m.RUnlock()
@ -480,11 +539,11 @@ func (m *meta) getDmChannelsByNodeID(collectionID UniqueID, nodeID int64) ([]str
return nil, errors.New("getDmChannelsByNodeID: can't find collection in collectionInfos")
}
func (m *meta) addDmChannel(collectionID UniqueID, nodeID int64, channels []string) error {
func (m *MetaReplica) addDmChannel(collectionID UniqueID, nodeID int64, channels []string) error {
m.Lock()
defer m.Unlock()
//before add channel, should ensure toAddedChannels not in meta
//before add channel, should ensure toAddedChannels not in MetaReplica
if info, ok := m.collectionInfos[collectionID]; ok {
findNodeID := false
for _, channelInfo := range info.ChannelInfos {
@ -501,16 +560,18 @@ func (m *meta) addDmChannel(collectionID UniqueID, nodeID int64, channels []stri
info.ChannelInfos = append(info.ChannelInfos, newChannelInfo)
}
err := m.saveCollectionInfo(collectionID, info)
err := saveGlobalCollectionInfo(collectionID, info, m.client)
if err != nil {
log.Error("save collectionInfo error", zap.Any("error", err.Error()), zap.Int64("collectionID", collectionID))
return err
}
return nil
}
return errors.New("addDmChannels: can't find collection in collectionInfos")
}
func (m *meta) removeDmChannel(collectionID UniqueID, nodeID int64, channels []string) error {
func (m *MetaReplica) removeDmChannel(collectionID UniqueID, nodeID int64, channels []string) error {
m.Lock()
defer m.Unlock()
@ -533,16 +594,19 @@ func (m *meta) removeDmChannel(collectionID UniqueID, nodeID int64, channels []s
}
}
err := m.saveCollectionInfo(collectionID, info)
err := saveGlobalCollectionInfo(collectionID, info, m.client)
if err != nil {
log.Error("save collectionInfo error", zap.Any("error", err.Error()), zap.Int64("collectionID", collectionID))
return err
}
return nil
}
return errors.New("addDmChannels: can't find collection in collectionInfos")
}
func (m *meta) GetQueryChannel(collectionID UniqueID) (string, string) {
func (m *MetaReplica) GetQueryChannel(collectionID UniqueID) (string, string) {
m.Lock()
defer m.Unlock()
@ -568,78 +632,129 @@ func (m *meta) GetQueryChannel(collectionID UniqueID) (string, string) {
return allocatedQueryChannel, allocatedQueryResultChannel
}
func (m *meta) saveCollectionInfo(collectionID UniqueID, info *querypb.CollectionInfo) error {
infoBytes := proto.MarshalTextString(info)
key := fmt.Sprintf("%s/%d", collectionMetaPrefix, collectionID)
return m.client.Save(key, infoBytes)
}
func (m *meta) removeCollectionInfo(collectionID UniqueID) error {
key := fmt.Sprintf("%s/%d", collectionMetaPrefix, collectionID)
return m.client.Remove(key)
}
func (m *meta) saveSegmentInfo(segmentID UniqueID, info *querypb.SegmentInfo) error {
infoBytes := proto.MarshalTextString(info)
key := fmt.Sprintf("%s/%d", segmentMetaPrefix, segmentID)
return m.client.Save(key, infoBytes)
}
func (m *meta) removeSegmentInfo(segmentID UniqueID) error {
key := fmt.Sprintf("%s/%d", segmentMetaPrefix, segmentID)
return m.client.Remove(key)
}
func (m *meta) saveQueryChannelInfo(collectionID UniqueID, info *querypb.QueryChannelInfo) error {
infoBytes := proto.MarshalTextString(info)
key := fmt.Sprintf("%s/%d", queryChannelMetaPrefix, collectionID)
return m.client.Save(key, infoBytes)
}
func (m *meta) removeQueryChannelInfo(collectionID UniqueID) error {
key := fmt.Sprintf("%s/%d", queryChannelMetaPrefix, collectionID)
return m.client.Remove(key)
}
func (m *meta) setLoadCollection(collectionID UniqueID, state bool) error {
func (m *MetaReplica) setLoadType(collectionID UniqueID, loadType querypb.LoadType) error {
m.Lock()
defer m.Unlock()
if info, ok := m.collectionInfos[collectionID]; ok {
info.LoadCollection = state
err := m.saveCollectionInfo(collectionID, info)
info.LoadType = loadType
err := saveGlobalCollectionInfo(collectionID, info, m.client)
if err != nil {
log.Error("save collectionInfo error", zap.Any("error", err.Error()), zap.Int64("collectionID", collectionID))
return err
}
return nil
}
return errors.New("setLoadCollection: can't find collection in collectionInfos")
return errors.New("setLoadType: can't find collection in collectionInfos")
}
func (m *meta) getLoadCollection(collectionID UniqueID) (bool, error) {
func (m *MetaReplica) getLoadType(collectionID UniqueID) (querypb.LoadType, error) {
m.RLock()
defer m.RUnlock()
if info, ok := m.collectionInfos[collectionID]; ok {
return info.LoadCollection, nil
return info.LoadType, nil
}
return false, errors.New("getLoadCollection: can't find collection in collectionInfos")
return 0, errors.New("getLoadType: can't find collection in collectionInfos")
}
func (m *meta) printMeta() {
func (m *MetaReplica) setLoadPercentage(collectionID UniqueID, partitionID UniqueID, percentage int64, loadType querypb.LoadType) error {
m.Lock()
defer m.Unlock()
info, ok := m.collectionInfos[collectionID]
if !ok {
return errors.New("setLoadPercentage: can't find collection in collectionInfos")
}
if loadType == querypb.LoadType_loadCollection {
info.InMemoryPercentage = percentage
for _, partitionState := range info.PartitionStates {
if percentage >= 100 {
partitionState.State = querypb.PartitionState_InMemory
} else {
partitionState.State = querypb.PartitionState_PartialInMemory
}
partitionState.InMemoryPercentage = percentage
}
err := saveGlobalCollectionInfo(collectionID, info, m.client)
if err != nil {
log.Error("save collectionInfo error", zap.Any("error", err.Error()), zap.Int64("collectionID", collectionID))
return err
}
} else {
for _, partitionState := range info.PartitionStates {
if partitionState.PartitionID == partitionID {
if percentage >= 100 {
partitionState.State = querypb.PartitionState_InMemory
} else {
partitionState.State = querypb.PartitionState_PartialInMemory
}
partitionState.InMemoryPercentage = percentage
err := saveGlobalCollectionInfo(collectionID, info, m.client)
if err != nil {
log.Error("save collectionInfo error", zap.Any("error", err.Error()), zap.Int64("collectionID", collectionID))
return err
}
return nil
}
}
return errors.New("setLoadPercentage: can't find partitionID in collectionInfos")
}
return nil
}
func (m *MetaReplica) printMeta() {
m.RLock()
defer m.RUnlock()
for id, info := range m.collectionInfos {
log.Debug("query coordinator meta: collectionInfo", zap.Int64("collectionID", id), zap.Any("info", info))
log.Debug("query coordinator MetaReplica: collectionInfo", zap.Int64("collectionID", id), zap.Any("info", info))
}
for id, info := range m.segmentInfos {
log.Debug("query coordinator meta: segmentInfo", zap.Int64("segmentID", id), zap.Any("info", info))
log.Debug("query coordinator MetaReplica: segmentInfo", zap.Int64("segmentID", id), zap.Any("info", info))
}
for id, info := range m.queryChannelInfos {
log.Debug("query coordinator meta: queryChannelInfo", zap.Int64("collectionID", id), zap.Any("info", info))
log.Debug("query coordinator MetaReplica: queryChannelInfo", zap.Int64("collectionID", id), zap.Any("info", info))
}
}
func saveGlobalCollectionInfo(collectionID UniqueID, info *querypb.CollectionInfo, kv *etcdkv.EtcdKV) error {
infoBytes := proto.MarshalTextString(info)
key := fmt.Sprintf("%s/%d", collectionMetaPrefix, collectionID)
return kv.Save(key, infoBytes)
}
func removeGlobalCollectionInfo(collectionID UniqueID, kv *etcdkv.EtcdKV) error {
key := fmt.Sprintf("%s/%d", collectionMetaPrefix, collectionID)
return kv.Remove(key)
}
func saveSegmentInfo(segmentID UniqueID, info *querypb.SegmentInfo, kv *etcdkv.EtcdKV) error {
infoBytes := proto.MarshalTextString(info)
key := fmt.Sprintf("%s/%d", segmentMetaPrefix, segmentID)
return kv.Save(key, infoBytes)
}
func removeSegmentInfo(segmentID UniqueID, kv *etcdkv.EtcdKV) error {
key := fmt.Sprintf("%s/%d", segmentMetaPrefix, segmentID)
return kv.Remove(key)
}
func saveQueryChannelInfo(collectionID UniqueID, info *querypb.QueryChannelInfo, kv *etcdkv.EtcdKV) error {
infoBytes := proto.MarshalTextString(info)
key := fmt.Sprintf("%s/%d", queryChannelMetaPrefix, collectionID)
return kv.Save(key, infoBytes)
}
func removeQueryChannelInfo(collectionID UniqueID, kv *etcdkv.EtcdKV) error {
key := fmt.Sprintf("%s/%d", queryChannelMetaPrefix, collectionID)
return kv.Remove(key)
}

16
internal/querycoord/query_coord.go
View File

@ -51,7 +51,7 @@ type QueryCoord struct {
kvClient *etcdkv.EtcdKV
queryCoordID uint64
meta *meta
meta Meta
cluster *queryNodeCluster
scheduler *TaskScheduler
@ -186,7 +186,7 @@ func (qc *QueryCoord) watchNodeLoop() {
if _, ok := qc.cluster.nodes[nodeID]; !ok {
serverID := session.ServerID
log.Debug("start add a queryNode to cluster", zap.Any("nodeID", serverID))
err := qc.cluster.RegisterNode(ctx, session, serverID)
err := qc.cluster.registerNode(ctx, session, serverID)
if err != nil {
log.Error("query node failed to register", zap.Int64("nodeID", serverID), zap.String("error info", err.Error()))
}
@ -229,7 +229,7 @@ func (qc *QueryCoord) watchNodeLoop() {
case sessionutil.SessionAddEvent:
serverID := event.Session.ServerID
log.Debug("start add a queryNode to cluster", zap.Any("nodeID", serverID))
err := qc.cluster.RegisterNode(ctx, event.Session, serverID)
err := qc.cluster.registerNode(ctx, event.Session, serverID)
if err != nil {
log.Error("query node failed to register", zap.Int64("nodeID", serverID), zap.String("error info", err.Error()))
}
@ -275,25 +275,25 @@ func (qc *QueryCoord) watchMetaLoop() {
defer cancel()
defer qc.loopWg.Done()
log.Debug("query coordinator start watch meta loop")
log.Debug("query coordinator start watch MetaReplica loop")
watchChan := qc.meta.client.WatchWithPrefix("queryNode-segmentMeta")
watchChan := qc.kvClient.WatchWithPrefix("queryNode-segmentMeta")
for {
select {
case <-ctx.Done():
return
case resp := <-watchChan:
log.Debug("segment meta updated.")
log.Debug("segment MetaReplica updated.")
for _, event := range resp.Events {
segmentID, err := strconv.ParseInt(filepath.Base(string(event.Kv.Key)), 10, 64)
if err != nil {
log.Error("watch meta loop error when get segmentID", zap.Any("error", err.Error()))
log.Error("watch MetaReplica loop error when get segmentID", zap.Any("error", err.Error()))
}
segmentInfo := &querypb.SegmentInfo{}
err = proto.UnmarshalText(string(event.Kv.Value), segmentInfo)
if err != nil {
log.Error("watch meta loop error when unmarshal", zap.Any("error", err.Error()))
log.Error("watch MetaReplica loop error when unmarshal", zap.Any("error", err.Error()))
}
switch event.Type {
case mvccpb.PUT:

390
internal/querycoord/querynode.go
View File

@ -23,11 +23,48 @@ import (
nodeclient "github.com/milvus-io/milvus/internal/distributed/querynode/client"
etcdkv "github.com/milvus-io/milvus/internal/kv/etcd"
"github.com/milvus-io/milvus/internal/log"
"github.com/milvus-io/milvus/internal/proto/commonpb"
"github.com/milvus-io/milvus/internal/proto/internalpb"
"github.com/milvus-io/milvus/internal/proto/querypb"
"github.com/milvus-io/milvus/internal/proto/schemapb"
"github.com/milvus-io/milvus/internal/types"
)
type Node interface {
start() error
stop()
clearNodeInfo() error
hasCollection(collectionID UniqueID) bool
addCollection(collectionID UniqueID, schema *schemapb.CollectionSchema) error
setCollectionInfo(info *querypb.CollectionInfo) error
getCollectionInfoByID(collectionID UniqueID) (*querypb.CollectionInfo, error)
showCollections() []*querypb.CollectionInfo
releaseCollection(ctx context.Context, in *querypb.ReleaseCollectionRequest) error
hasPartition(collectionID UniqueID, partitionID UniqueID) bool
addPartition(collectionID UniqueID, partitionID UniqueID) error
releasePartitions(ctx context.Context, in *querypb.ReleasePartitionsRequest) error
hasWatchedDmChannel(collectionID UniqueID, channelID string) (bool, error)
getDmChannelsByCollectionID(collectionID UniqueID) ([]string, error)
watchDmChannels(ctx context.Context, in *querypb.WatchDmChannelsRequest) error
removeDmChannel(collectionID UniqueID, channels []string) error
hasWatchedQueryChannel(collectionID UniqueID) bool
showWatchedQueryChannels() []*querypb.QueryChannelInfo
addQueryChannel(ctx context.Context, in *querypb.AddQueryChannelRequest) error
removeQueryChannel(ctx context.Context, in *querypb.RemoveQueryChannelRequest) error
setNodeState(onService bool)
isOnService() bool
getSegmentInfo(ctx context.Context, in *querypb.GetSegmentInfoRequest) (*querypb.GetSegmentInfoResponse, error)
loadSegments(ctx context.Context, in *querypb.LoadSegmentsRequest) error
releaseSegments(ctx context.Context, in *querypb.ReleaseSegmentsRequest) error
getComponentInfo(ctx context.Context) *internalpb.ComponentInfo
}
type queryNode struct {
ctx context.Context
cancel context.CancelFunc
@ -40,10 +77,10 @@ type queryNode struct {
collectionInfos map[UniqueID]*querypb.CollectionInfo
watchedQueryChannels map[UniqueID]*querypb.QueryChannelInfo
onService bool
serviceLock sync.Mutex
serviceLock sync.RWMutex
}
func newQueryNode(ctx context.Context, address string, id UniqueID, kv *etcdkv.EtcdKV) *queryNode {
func newQueryNode(ctx context.Context, address string, id UniqueID, kv *etcdkv.EtcdKV) Node {
collectionInfo := make(map[UniqueID]*querypb.CollectionInfo)
watchedChannels := make(map[UniqueID]*querypb.QueryChannelInfo)
childCtx, cancel := context.WithCancel(ctx)
@ -77,7 +114,7 @@ func (qn *queryNode) start() error {
qn.serviceLock.Lock()
qn.onService = true
qn.serviceLock.Unlock()
log.Debug("queryNode client start success", zap.Int64("nodeID", qn.id), zap.String("address", qn.address))
log.Debug("Start: queryNode client start success", zap.Int64("nodeID", qn.id), zap.String("address", qn.address))
return nil
}
@ -131,14 +168,27 @@ func (qn *queryNode) addCollection(collectionID UniqueID, schema *schemapb.Colle
Schema: schema,
}
qn.collectionInfos[collectionID] = newCollection
err := qn.saveCollectionInfo(collectionID, newCollection)
err := saveNodeCollectionInfo(collectionID, newCollection, qn.id, qn.kvClient)
if err != nil {
log.Error("save collectionInfo error", zap.Any("error", err.Error()), zap.Int64("collectionID", collectionID))
log.Error("AddCollection: save collectionInfo error", zap.Any("error", err.Error()), zap.Int64("collectionID", collectionID))
return err
}
return nil
}
return errors.New("addCollection: collection already exists")
return nil
}
func (qn *queryNode) setCollectionInfo(info *querypb.CollectionInfo) error {
qn.Lock()
defer qn.Unlock()
qn.collectionInfos[info.CollectionID] = info
err := saveNodeCollectionInfo(info.CollectionID, info, qn.id, qn.kvClient)
if err != nil {
log.Error("SetCollectionInfo: save collectionInfo error", zap.Any("error", err.Error()), zap.Int64("collectionID", info.CollectionID))
return err
}
return nil
}
func (qn *queryNode) getCollectionInfoByID(collectionID UniqueID) (*querypb.CollectionInfo, error) {
@ -148,7 +198,19 @@ func (qn *queryNode) getCollectionInfoByID(collectionID UniqueID) (*querypb.Coll
if _, ok := qn.collectionInfos[collectionID]; ok {
return proto.Clone(qn.collectionInfos[collectionID]).(*querypb.CollectionInfo), nil
}
return nil, errors.New("addPartition: can't find collection")
return nil, errors.New("GetCollectionInfoByID: can't find collection")
}
func (qn *queryNode) showCollections() []*querypb.CollectionInfo {
qn.RLock()
defer qn.RUnlock()
results := make([]*querypb.CollectionInfo, 0)
for _, info := range qn.collectionInfos {
results = append(results, proto.Clone(info).(*querypb.CollectionInfo))
}
return results
}
func (qn *queryNode) addPartition(collectionID UniqueID, partitionID UniqueID) error {
@ -157,50 +219,62 @@ func (qn *queryNode) addPartition(collectionID UniqueID, partitionID UniqueID) e
if col, ok := qn.collectionInfos[collectionID]; ok {
for _, id := range col.PartitionIDs {
if id == partitionID {
return errors.New("addPartition: partition already exists in collectionInfos")
return nil
}
}
col.PartitionIDs = append(col.PartitionIDs, partitionID)
err := qn.saveCollectionInfo(collectionID, col)
err := saveNodeCollectionInfo(collectionID, col, qn.id, qn.kvClient)
if err != nil {
log.Error("save collectionInfo error", zap.Any("error", err.Error()), zap.Int64("collectionID", collectionID))
log.Error("AddPartition: save collectionInfo error", zap.Any("error", err.Error()), zap.Int64("collectionID", collectionID))
}
return nil
}
return errors.New("addPartition: can't find collection when add partition")
return errors.New("AddPartition: can't find collection when add partition")
}
func (qn *queryNode) releaseCollection(collectionID UniqueID) {
func (qn *queryNode) releaseCollectionInfo(collectionID UniqueID) error {
qn.Lock()
defer qn.Unlock()
if _, ok := qn.collectionInfos[collectionID]; ok {
err := qn.removeCollectionInfo(collectionID)
err := removeNodeCollectionInfo(collectionID, qn.id, qn.kvClient)
if err != nil {
log.Error("remove collectionInfo error", zap.Any("error", err.Error()), zap.Int64("collectionID", collectionID))
log.Error("ReleaseCollectionInfo: remove collectionInfo error", zap.Any("error", err.Error()), zap.Int64("collectionID", collectionID))
return err
}
delete(qn.collectionInfos, collectionID)
}
delete(qn.watchedQueryChannels, collectionID)
return nil
}
func (qn *queryNode) releasePartition(collectionID UniqueID, partitionID UniqueID) {
func (qn *queryNode) releasePartitionsInfo(collectionID UniqueID, partitionIDs []UniqueID) error {
qn.Lock()
defer qn.Unlock()
if info, ok := qn.collectionInfos[collectionID]; ok {
newPartitionIDs := make([]UniqueID, 0)
for _, id := range info.PartitionIDs {
if id != partitionID {
match := false
for _, partitionID := range partitionIDs {
if id == partitionID {
match = true
break
}
}
if !match {
newPartitionIDs = append(newPartitionIDs, id)
}
}
info.PartitionIDs = newPartitionIDs
err := qn.removeCollectionInfo(collectionID)
err := removeNodeCollectionInfo(collectionID, qn.id, qn.kvClient)
if err != nil {
log.Error("remove collectionInfo error", zap.Any("error", err.Error()), zap.Int64("collectionID", collectionID))
log.Error("ReleasePartitionsInfo: remove collectionInfo error", zap.Any("error", err.Error()), zap.Int64("collectionID", collectionID))
return err
}
}
return nil
}
func (qn *queryNode) hasWatchedDmChannel(collectionID UniqueID, channelID string) (bool, error) {
@ -219,7 +293,7 @@ func (qn *queryNode) hasWatchedDmChannel(collectionID UniqueID, channelID string
return false, nil
}
return false, errors.New("hasWatchedDmChannel: can't find collection in collectionInfos")
return false, errors.New("HasWatchedDmChannel: can't find collection in collectionInfos")
}
func (qn *queryNode) getDmChannelsByCollectionID(collectionID UniqueID) ([]string, error) {
@ -234,14 +308,14 @@ func (qn *queryNode) getDmChannelsByCollectionID(collectionID UniqueID) ([]strin
return channels, nil
}
return nil, errors.New("getDmChannelsByCollectionID: can't find collection in collectionInfos")
return nil, errors.New("GetDmChannelsByCollectionID: can't find collection in collectionInfos")
}
func (qn *queryNode) addDmChannel(collectionID UniqueID, channels []string) error {
qn.Lock()
defer qn.Unlock()
//before add channel, should ensure toAddedChannels not in meta
//before add channel, should ensure toAddedChannels not in MetaReplica
if info, ok := qn.collectionInfos[collectionID]; ok {
findNodeID := false
for _, channelInfo := range info.ChannelInfos {
@ -257,13 +331,15 @@ func (qn *queryNode) addDmChannel(collectionID UniqueID, channels []string) erro
}
info.ChannelInfos = append(info.ChannelInfos, newChannelInfo)
}
err := qn.saveCollectionInfo(collectionID, info)
err := saveNodeCollectionInfo(collectionID, info, qn.id, qn.kvClient)
if err != nil {
log.Error("save collectionInfo error", zap.Any("error", err.Error()), zap.Int64("collectionID", collectionID))
log.Error("AddDmChannel: save collectionInfo error", zap.Any("error", err.Error()), zap.Int64("collectionID", collectionID))
return err
}
return nil
}
return errors.New("addDmChannels: can't find collection in watchedQueryChannel")
return errors.New("AddDmChannels: can't find collection in watchedQueryChannel")
}
func (qn *queryNode) removeDmChannel(collectionID UniqueID, channels []string) error {
@ -289,13 +365,13 @@ func (qn *queryNode) removeDmChannel(collectionID UniqueID, channels []string) e
}
}
err := qn.saveCollectionInfo(collectionID, info)
err := saveNodeCollectionInfo(collectionID, info, qn.id, qn.kvClient)
if err != nil {
log.Error("save collectionInfo error", zap.Any("error", err.Error()), zap.Int64("collectionID", collectionID))
log.Error("RemoveDmChannel: save collectionInfo error", zap.Any("error", err.Error()), zap.Int64("collectionID", collectionID))
}
}
return errors.New("addDmChannels: can't find collection in watchedQueryChannel")
return errors.New("RemoveDmChannel: can't find collection in watchedQueryChannel")
}
func (qn *queryNode) hasWatchedQueryChannel(collectionID UniqueID) bool {
@ -309,37 +385,37 @@ func (qn *queryNode) hasWatchedQueryChannel(collectionID UniqueID) bool {
return false
}
func (qn *queryNode) addQueryChannel(collectionID UniqueID, queryChannel *querypb.QueryChannelInfo) {
func (qn *queryNode) showWatchedQueryChannels() []*querypb.QueryChannelInfo {
qn.RLock()
defer qn.RUnlock()
results := make([]*querypb.QueryChannelInfo, 0)
for _, info := range qn.watchedQueryChannels {
results = append(results, proto.Clone(info).(*querypb.QueryChannelInfo))
}
return results
}
func (qn *queryNode) setQueryChannelInfo(info *querypb.QueryChannelInfo) {
qn.Lock()
defer qn.Unlock()
qn.watchedQueryChannels[collectionID] = queryChannel
qn.watchedQueryChannels[info.CollectionID] = info
}
func (qn *queryNode) removeQueryChannel(collectionID UniqueID) error {
func (qn *queryNode) removeQueryChannelInfo(collectionID UniqueID) {
qn.Lock()
defer qn.Unlock()
delete(qn.watchedQueryChannels, collectionID)
return errors.New("removeQueryChannel: can't find collection in watchedQueryChannel")
}
func (qn *queryNode) saveCollectionInfo(collectionID UniqueID, info *querypb.CollectionInfo) error {
infoBytes := proto.MarshalTextString(info)
key := fmt.Sprintf("%s/%d/%d", queryNodeMetaPrefix, qn.id, collectionID)
return qn.kvClient.Save(key, infoBytes)
}
func (qn *queryNode) removeCollectionInfo(collectionID UniqueID) error {
key := fmt.Sprintf("%s/%d/%d", queryNodeMetaPrefix, qn.id, collectionID)
return qn.kvClient.Remove(key)
}
func (qn *queryNode) clearNodeInfo() error {
qn.RLock()
defer qn.RUnlock()
for collectionID := range qn.collectionInfos {
err := qn.removeCollectionInfo(collectionID)
err := removeNodeCollectionInfo(collectionID, qn.id, qn.kvClient)
if err != nil {
return err
}
@ -356,8 +432,226 @@ func (qn *queryNode) setNodeState(onService bool) {
}
func (qn *queryNode) isOnService() bool {
qn.serviceLock.Lock()
defer qn.serviceLock.Unlock()
qn.serviceLock.RLock()
defer qn.serviceLock.RUnlock()
return qn.onService
}
//***********************grpc req*************************//
func (qn *queryNode) watchDmChannels(ctx context.Context, in *querypb.WatchDmChannelsRequest) error {
qn.serviceLock.RLock()
onService := qn.onService
qn.serviceLock.RUnlock()
if !onService {
return errors.New("WatchDmChannels: queryNode is offline")
}
status, err := qn.client.WatchDmChannels(ctx, in)
if err != nil {
return err
}
if status.ErrorCode != commonpb.ErrorCode_Success {
return errors.New(status.Reason)
}
channels := make([]string, 0)
for _, info := range in.Infos {
channels = append(channels, info.ChannelName)
}
err = qn.addCollection(in.CollectionID, in.Schema)
if err != nil {
return err
}
err = qn.addDmChannel(in.CollectionID, channels)
return err
}
func (qn *queryNode) addQueryChannel(ctx context.Context, in *querypb.AddQueryChannelRequest) error {
qn.serviceLock.RLock()
onService := qn.onService
qn.serviceLock.RUnlock()
if !onService {
return errors.New("AddQueryChannel: queryNode is offline")
}
status, err := qn.client.AddQueryChannel(ctx, in)
if err != nil {
return err
}
if status.ErrorCode != commonpb.ErrorCode_Success {
return errors.New(status.Reason)
}
queryChannelInfo := &querypb.QueryChannelInfo{
CollectionID: in.CollectionID,
QueryChannelID: in.RequestChannelID,
QueryResultChannelID: in.ResultChannelID,
}
qn.setQueryChannelInfo(queryChannelInfo)
return nil
}
func (qn *queryNode) removeQueryChannel(ctx context.Context, in *querypb.RemoveQueryChannelRequest) error {
qn.serviceLock.RLock()
onService := qn.onService
qn.serviceLock.RUnlock()
if !onService {
return nil
}
status, err := qn.client.RemoveQueryChannel(ctx, in)
if err != nil {
return err
}
if status.ErrorCode != commonpb.ErrorCode_Success {
return errors.New(status.Reason)
}
qn.removeQueryChannelInfo(in.CollectionID)
return nil
}
func (qn *queryNode) releaseCollection(ctx context.Context, in *querypb.ReleaseCollectionRequest) error {
qn.serviceLock.RLock()
onService := qn.onService
qn.serviceLock.RUnlock()
if !onService {
return nil
}
status, err := qn.client.ReleaseCollection(ctx, in)
if err != nil {
return err
}
if status.ErrorCode != commonpb.ErrorCode_Success {
return errors.New(status.Reason)
}
err = qn.releaseCollectionInfo(in.CollectionID)
if err != nil {
return err
}
return nil
}
func (qn *queryNode) releasePartitions(ctx context.Context, in *querypb.ReleasePartitionsRequest) error {
qn.serviceLock.RLock()
onService := qn.onService
qn.serviceLock.RUnlock()
if !onService {
return nil
}
status, err := qn.client.ReleasePartitions(ctx, in)
if err != nil {
return err
}
if status.ErrorCode != commonpb.ErrorCode_Success {
return errors.New(status.Reason)
}
err = qn.releasePartitionsInfo(in.CollectionID, in.PartitionIDs)
if err != nil {
return err
}
return nil
}
func (qn *queryNode) getSegmentInfo(ctx context.Context, in *querypb.GetSegmentInfoRequest) (*querypb.GetSegmentInfoResponse, error) {
qn.serviceLock.RLock()
if !qn.onService {
return nil, nil
}
qn.serviceLock.RUnlock()
res, err := qn.client.GetSegmentInfo(ctx, in)
if err == nil && res.Status.ErrorCode == commonpb.ErrorCode_Success {
return res, nil
}
return nil, nil
}
func (qn *queryNode) getComponentInfo(ctx context.Context) *internalpb.ComponentInfo {
qn.serviceLock.RLock()
if !qn.onService {
return &internalpb.ComponentInfo{
NodeID: qn.id,
StateCode: internalpb.StateCode_Abnormal,
}
}
qn.serviceLock.RUnlock()
res, err := qn.client.GetComponentStates(ctx)
if err != nil || res.Status.ErrorCode != commonpb.ErrorCode_Success {
return &internalpb.ComponentInfo{
NodeID: qn.id,
StateCode: internalpb.StateCode_Abnormal,
}
}
return res.State
}
func (qn *queryNode) loadSegments(ctx context.Context, in *querypb.LoadSegmentsRequest) error {
qn.serviceLock.RLock()
onService := qn.onService
qn.serviceLock.RUnlock()
if !onService {
return errors.New("LoadSegments: queryNode is offline")
}
status, err := qn.client.LoadSegments(ctx, in)
if err != nil {
return err
}
if status.ErrorCode != commonpb.ErrorCode_Success {
return errors.New(status.Reason)
}
for _, info := range in.Infos {
err = qn.addCollection(info.CollectionID, in.Schema)
if err != nil {
return err
}
err = qn.addPartition(info.CollectionID, info.PartitionID)
if err != nil {
return err
}
}
return nil
}
func (qn *queryNode) releaseSegments(ctx context.Context, in *querypb.ReleaseSegmentsRequest) error {
qn.serviceLock.RLock()
onService := qn.onService
qn.serviceLock.RUnlock()
if !onService {
return errors.New("ReleaseSegments: queryNode is offline")
}
status, err := qn.client.ReleaseSegments(ctx, in)
if err != nil {
return err
}
if status.ErrorCode != commonpb.ErrorCode_Success {
return errors.New(status.Reason)
}
return nil
}
//****************************************************//
func saveNodeCollectionInfo(collectionID UniqueID, info *querypb.CollectionInfo, nodeID int64, kv *etcdkv.EtcdKV) error {
infoBytes := proto.MarshalTextString(info)
key := fmt.Sprintf("%s/%d/%d", queryNodeMetaPrefix, nodeID, collectionID)
return kv.Save(key, infoBytes)
}
func removeNodeCollectionInfo(collectionID UniqueID, nodeID int64, kv *etcdkv.EtcdKV) error {
key := fmt.Sprintf("%s/%d/%d", queryNodeMetaPrefix, nodeID, collectionID)
return kv.Remove(key)
}

130
internal/querycoord/task.go
View File

@ -135,7 +135,7 @@ type LoadCollectionTask struct {
rootCoord types.RootCoord
dataCoord types.DataCoord
cluster *queryNodeCluster
meta *meta
meta Meta
}
func (lct *LoadCollectionTask) MsgBase() *commonpb.MsgBase {
@ -194,8 +194,8 @@ func (lct *LoadCollectionTask) Execute(ctx context.Context) error {
watchPartition := false
if hasCollection {
watchPartition = true
loadCollection, _ := lct.meta.getLoadCollection(collectionID)
if loadCollection {
loadType, _ := lct.meta.getLoadType(collectionID)
if loadType == querypb.LoadType_loadCollection {
for _, partitionID := range partitionIDs {
hasReleasePartition := lct.meta.hasReleasePartition(collectionID, partitionID)
if hasReleasePartition {
@ -216,7 +216,7 @@ func (lct *LoadCollectionTask) Execute(ctx context.Context) error {
log.Debug("loadCollectionTask: toLoadPartitionIDs", zap.Int64s("partitionIDs", toLoadPartitionIDs))
lct.meta.addCollection(collectionID, lct.Schema)
lct.meta.setLoadCollection(collectionID, true)
lct.meta.setLoadType(collectionID, querypb.LoadType_loadCollection)
for _, id := range toLoadPartitionIDs {
lct.meta.addPartition(collectionID, id)
}
@ -312,7 +312,14 @@ func (lct *LoadCollectionTask) Execute(ctx context.Context) error {
func (lct *LoadCollectionTask) PostExecute(ctx context.Context) error {
collectionID := lct.CollectionID
lct.meta.addCollection(collectionID, lct.Schema)
if lct.State() == taskDone {
err := lct.meta.setLoadPercentage(collectionID, 0, 100, querypb.LoadType_loadCollection)
if err != nil {
log.Debug("loadCollectionTask: set load percentage to meta's collectionInfo", zap.Int64("collectionID", collectionID))
return err
}
return nil
}
if lct.result.ErrorCode != commonpb.ErrorCode_Success {
lct.childTasks = make([]task, 0)
nodes, err := lct.cluster.onServiceNodes()
@ -344,6 +351,7 @@ func (lct *LoadCollectionTask) PostExecute(ctx context.Context) error {
log.Debug("loadCollectionTask: add a releaseCollectionTask to loadCollectionTask's childTask", zap.Any("task", releaseCollectionTask))
}
}
lct.meta.addCollection(collectionID, lct.Schema)
log.Debug("LoadCollectionTask postExecute done",
zap.Int64("msgID", lct.ID()),
zap.Int64("collectionID", collectionID))
@ -354,7 +362,7 @@ type ReleaseCollectionTask struct {
BaseTask
*querypb.ReleaseCollectionRequest
cluster *queryNodeCluster
meta *meta
meta Meta
rootCoord types.RootCoord
}
@ -438,20 +446,13 @@ func (rct *ReleaseCollectionTask) Execute(ctx context.Context) error {
log.Debug("ReleaseCollectionTask: add a releaseCollectionTask to releaseCollectionTask's childTask", zap.Any("task", releaseCollectionTask))
}
} else {
res, err := rct.cluster.releaseCollection(ctx, rct.NodeID, rct.ReleaseCollectionRequest)
err := rct.cluster.releaseCollection(ctx, rct.NodeID, rct.ReleaseCollectionRequest)
if err != nil {
log.Error("ReleaseCollectionTask: release collection end, node occur error", zap.Int64("nodeID", rct.NodeID))
status.Reason = err.Error()
rct.result = status
return err
}
if res.ErrorCode != commonpb.ErrorCode_Success {
log.Error("ReleaseCollectionTask: release collection end, node occur error", zap.Int64("nodeID", rct.NodeID))
err = errors.New("queryNode releaseCollection failed")
status.Reason = err.Error()
rct.result = status
return err
}
}
log.Debug("ReleaseCollectionTask Execute done",
@ -476,7 +477,7 @@ type LoadPartitionTask struct {
*querypb.LoadPartitionsRequest
dataCoord types.DataCoord
cluster *queryNodeCluster
meta *meta
meta Meta
addCol bool
}
@ -590,6 +591,16 @@ func (lpt *LoadPartitionTask) Execute(ctx context.Context) error {
func (lpt *LoadPartitionTask) PostExecute(ctx context.Context) error {
collectionID := lpt.CollectionID
partitionIDs := lpt.PartitionIDs
if lpt.State() == taskDone {
for _, id := range partitionIDs {
err := lpt.meta.setLoadPercentage(collectionID, id, 100, querypb.LoadType_LoadPartition)
if err != nil {
log.Debug("loadPartitionTask: set load percentage to meta's collectionInfo", zap.Int64("collectionID", collectionID), zap.Int64("partitionID", id))
return err
}
}
return nil
}
if lpt.result.ErrorCode != commonpb.ErrorCode_Success {
lpt.childTasks = make([]task, 0)
if lpt.addCol {
@ -725,20 +736,13 @@ func (rpt *ReleasePartitionTask) Execute(ctx context.Context) error {
log.Debug("ReleasePartitionTask: add a releasePartitionTask to releasePartitionTask's childTask", zap.Any("task", releasePartitionTask))
}
} else {
res, err := rpt.cluster.releasePartitions(ctx, rpt.NodeID, rpt.ReleasePartitionsRequest)
err := rpt.cluster.releasePartitions(ctx, rpt.NodeID, rpt.ReleasePartitionsRequest)
if err != nil {
log.Error("ReleasePartitionsTask: release partition end, node occur error", zap.String("nodeID", fmt.Sprintln(rpt.NodeID)))
status.Reason = err.Error()
rpt.result = status
return err
}
if res.ErrorCode != commonpb.ErrorCode_Success {
log.Error("ReleasePartitionsTask: release partition end, node occur error", zap.String("nodeID", fmt.Sprintln(rpt.NodeID)))
err = errors.New("queryNode releasePartition failed")
status.Reason = err.Error()
rpt.result = status
return err
}
}
log.Debug("ReleasePartitionTask Execute done",
@ -765,7 +769,7 @@ func (rpt *ReleasePartitionTask) PostExecute(context.Context) error {
type LoadSegmentTask struct {
BaseTask
*querypb.LoadSegmentsRequest
meta *meta
meta Meta
cluster *queryNodeCluster
}
@ -799,6 +803,10 @@ func (lst *LoadSegmentTask) PreExecute(context.Context) error {
for _, info := range lst.Infos {
segmentIDs = append(segmentIDs, info.SegmentID)
}
status := &commonpb.Status{
ErrorCode: commonpb.ErrorCode_Success,
}
lst.result = status
log.Debug("start do loadSegmentTask",
zap.Int64s("segmentIDs", segmentIDs),
zap.Int64("loaded nodeID", lst.NodeID),
@ -807,13 +815,17 @@ func (lst *LoadSegmentTask) PreExecute(context.Context) error {
}
func (lst *LoadSegmentTask) Execute(ctx context.Context) error {
status, err := lst.cluster.LoadSegments(ctx, lst.NodeID, lst.LoadSegmentsRequest)
status := &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
}
err := lst.cluster.loadSegments(ctx, lst.NodeID, lst.LoadSegmentsRequest)
if err != nil {
log.Error("LoadSegmentTask: loadSegment occur error", zap.Int64("taskID", lst.ID()))
status.Reason = err.Error()
lst.result = status
return err
}
lst.result = status
log.Debug("loadSegmentTask Execute done",
zap.Int64("taskID", lst.ID()))
return nil
@ -924,6 +936,10 @@ func (rst *ReleaseSegmentTask) Timestamp() Timestamp {
func (rst *ReleaseSegmentTask) PreExecute(context.Context) error {
segmentIDs := rst.SegmentIDs
status := &commonpb.Status{
ErrorCode: commonpb.ErrorCode_Success,
}
rst.result = status
log.Debug("start do releaseSegmentTask",
zap.Int64s("segmentIDs", segmentIDs),
zap.Int64("loaded nodeID", rst.NodeID),
@ -932,13 +948,17 @@ func (rst *ReleaseSegmentTask) PreExecute(context.Context) error {
}
func (rst *ReleaseSegmentTask) Execute(ctx context.Context) error {
status, err := rst.cluster.ReleaseSegments(rst.ctx, rst.NodeID, rst.ReleaseSegmentsRequest)
status := &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
}
err := rst.cluster.releaseSegments(rst.ctx, rst.NodeID, rst.ReleaseSegmentsRequest)
if err != nil {
log.Error("ReleaseSegmentTask: releaseSegment occur error", zap.Int64("taskID", rst.ID()))
status.Reason = err.Error()
rst.result = status
return err
}
rst.result = status
log.Debug("releaseSegmentTask Execute done",
zap.Int64s("segmentIDs", rst.SegmentIDs),
zap.Int64("taskID", rst.ID()))
@ -956,7 +976,7 @@ func (rst *ReleaseSegmentTask) PostExecute(context.Context) error {
type WatchDmChannelTask struct {
BaseTask
*querypb.WatchDmChannelsRequest
meta *meta
meta Meta
cluster *queryNodeCluster
}
@ -990,6 +1010,10 @@ func (wdt *WatchDmChannelTask) PreExecute(context.Context) error {
for _, info := range channelInfos {
channels = append(channels, info.ChannelName)
}
status := &commonpb.Status{
ErrorCode: commonpb.ErrorCode_Success,
}
wdt.result = status
log.Debug("start do watchDmChannelTask",
zap.Strings("dmChannels", channels),
zap.Int64("loaded nodeID", wdt.NodeID),
@ -998,13 +1022,17 @@ func (wdt *WatchDmChannelTask) PreExecute(context.Context) error {
}
func (wdt *WatchDmChannelTask) Execute(ctx context.Context) error {
status, err := wdt.cluster.WatchDmChannels(wdt.ctx, wdt.NodeID, wdt.WatchDmChannelsRequest)
status := &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
}
err := wdt.cluster.watchDmChannels(wdt.ctx, wdt.NodeID, wdt.WatchDmChannelsRequest)
if err != nil {
log.Error("WatchDmChannelTask: watchDmChannel occur error", zap.Int64("taskID", wdt.ID()))
status.Reason = err.Error()
wdt.result = status
return err
}
wdt.result = status
log.Debug("watchDmChannelsTask Execute done",
zap.Int64("taskID", wdt.ID()))
return nil
@ -1119,6 +1147,10 @@ func (wqt *WatchQueryChannelTask) Timestamp() Timestamp {
}
func (wqt *WatchQueryChannelTask) PreExecute(context.Context) error {
status := &commonpb.Status{
ErrorCode: commonpb.ErrorCode_Success,
}
wqt.result = status
log.Debug("start do WatchQueryChannelTask",
zap.Int64("collectionID", wqt.CollectionID),
zap.String("queryChannel", wqt.RequestChannelID),
@ -1129,13 +1161,17 @@ func (wqt *WatchQueryChannelTask) PreExecute(context.Context) error {
}
func (wqt *WatchQueryChannelTask) Execute(ctx context.Context) error {
status, err := wqt.cluster.AddQueryChannel(wqt.ctx, wqt.NodeID, wqt.AddQueryChannelRequest)
status := &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
}
err := wqt.cluster.addQueryChannel(wqt.ctx, wqt.NodeID, wqt.AddQueryChannelRequest)
if err != nil {
log.Error("WatchQueryChannelTask: watchQueryChannel occur error", zap.Int64("taskID", wqt.ID()))
status.Reason = err.Error()
wqt.result = status
return err
}
wqt.result = status
log.Debug("watchQueryChannelTask Execute done",
zap.Int64("collectionID", wqt.CollectionID),
zap.String("queryChannel", wqt.RequestChannelID),
@ -1164,7 +1200,7 @@ type LoadBalanceTask struct {
rootCoord types.RootCoord
dataCoord types.DataCoord
cluster *queryNodeCluster
meta *meta
meta Meta
}
func (lbt *LoadBalanceTask) MsgBase() *commonpb.MsgBase {
@ -1184,6 +1220,10 @@ func (lbt *LoadBalanceTask) Timestamp() Timestamp {
}
func (lbt *LoadBalanceTask) PreExecute(context.Context) error {
status := &commonpb.Status{
ErrorCode: commonpb.ErrorCode_Success,
}
lbt.result = status
log.Debug("start do LoadBalanceTask",
zap.Int64s("sourceNodeIDs", lbt.SourceNodeIDs),
zap.Any("balanceReason", lbt.BalanceReason),
@ -1198,20 +1238,16 @@ func (lbt *LoadBalanceTask) Execute(ctx context.Context) error {
if lbt.triggerCondition == querypb.TriggerCondition_nodeDown {
for _, nodeID := range lbt.SourceNodeIDs {
node, err := lbt.cluster.getNodeByID(nodeID)
if err != nil {
log.Error(err.Error())
continue
}
lbt.meta.deleteSegmentInfoByNodeID(nodeID)
collectionInfos := node.collectionInfos
for collectionID, info := range collectionInfos {
collectionInfos := lbt.cluster.getCollectionInfosByID(lbt.ctx, nodeID)
for _, info := range collectionInfos {
collectionID := info.CollectionID
metaInfo, err := lbt.meta.getCollectionInfoByID(collectionID)
if err != nil {
log.Error(err.Error())
log.Error("LoadBalanceTask: getCollectionInfoByID occur error", zap.String("error", err.Error()))
continue
}
loadCollection := metaInfo.LoadCollection
loadType := metaInfo.LoadType
schema := metaInfo.Schema
partitionIDs := info.PartitionIDs
@ -1267,7 +1303,7 @@ func (lbt *LoadBalanceTask) Execute(ctx context.Context) error {
for _, channelInfo := range recoveryInfo.Channels {
for _, channel := range dmChannels {
if channelInfo.ChannelName == channel {
if loadCollection {
if loadType == querypb.LoadType_loadCollection {
merged := false
for index, channelName := range channelsToWatch {
if channel == channelName {
@ -1342,7 +1378,7 @@ func (lbt *LoadBalanceTask) PostExecute(context.Context) error {
func shuffleChannelsToQueryNode(dmChannels []string, cluster *queryNodeCluster) []int64 {
maxNumChannels := 0
nodes := make(map[int64]*queryNode)
nodes := make(map[int64]Node)
var err error
for {
nodes, err = cluster.onServiceNodes()
@ -1398,7 +1434,7 @@ func shuffleChannelsToQueryNode(dmChannels []string, cluster *queryNodeCluster)
func shuffleSegmentsToQueryNode(segmentIDs []UniqueID, cluster *queryNodeCluster) []int64 {
maxNumSegments := 0
nodes := make(map[int64]*queryNode)
nodes := make(map[int64]Node)
var err error
for {
nodes, err = cluster.onServiceNodes()
@ -1486,7 +1522,7 @@ func mergeVChannelInfo(info1 *datapb.VchannelInfo, info2 *datapb.VchannelInfo) *
func assignInternalTask(ctx context.Context,
collectionID UniqueID,
parentTask task,
meta *meta,
meta Meta,
cluster *queryNodeCluster,
loadSegmentRequests []*querypb.LoadSegmentsRequest,
watchDmChannelRequests []*querypb.WatchDmChannelsRequest) {

23
internal/querycoord/task_scheduler.go
View File

@ -121,7 +121,7 @@ func NewTaskQueue() *TaskQueue {
type TaskScheduler struct {
triggerTaskQueue *TaskQueue
activateTaskChan chan task
meta *meta
meta Meta
cluster *queryNodeCluster
taskIDAllocator func() (UniqueID, error)
client *etcdkv.EtcdKV
@ -134,7 +134,7 @@ type TaskScheduler struct {
cancel context.CancelFunc
}
func NewTaskScheduler(ctx context.Context, meta *meta, cluster *queryNodeCluster, kv *etcdkv.EtcdKV, rootCoord types.RootCoord, dataCoord types.DataCoord) (*TaskScheduler, error) {
func NewTaskScheduler(ctx context.Context, meta Meta, cluster *queryNodeCluster, kv *etcdkv.EtcdKV, rootCoord types.RootCoord, dataCoord types.DataCoord) (*TaskScheduler, error) {
ctx1, cancel := context.WithCancel(ctx)
taskChan := make(chan task, 1024)
s := &TaskScheduler{
@ -216,6 +216,10 @@ func (scheduler *TaskScheduler) reloadFromKV() error {
}
state := taskState(value)
taskInfos[taskID] = state
if _, ok := triggerTasks[taskID]; !ok {
return errors.New("taskStateInfo and triggerTaskInfo are inconsistent")
}
triggerTasks[taskID].SetState(state)
}
var doneTriggerTask task = nil
@ -427,6 +431,7 @@ func (scheduler *TaskScheduler) Enqueue(tasks []task) {
log.Error("error when save trigger task to etcd", zap.Int64("taskID", t.ID()))
}
log.Debug("EnQueue a triggerTask and save to etcd", zap.Int64("taskID", t.ID()))
t.SetState(taskUndo)
}
scheduler.triggerTaskQueue.addTask(tasks)
@ -445,15 +450,16 @@ func (scheduler *TaskScheduler) processTask(t task) error {
key := fmt.Sprintf("%s/%d", taskInfoPrefix, t.ID())
err := scheduler.client.Save(key, strconv.Itoa(int(taskDoing)))
if err != nil {
log.Debug("processTask: update task state err", zap.String("reason", err.Error()))
log.Debug("processTask: update task state err", zap.String("reason", err.Error()), zap.Int64("taskID", t.ID()))
trace.LogError(span, err)
return err
}
t.SetState(taskDoing)
span.LogFields(oplog.Int64("processTask: scheduler process Execute", t.ID()))
err = t.Execute(ctx)
if err != nil {
log.Debug("processTask: execute err", zap.String("reason", err.Error()))
log.Debug("processTask: execute err", zap.String("reason", err.Error()), zap.Int64("taskID", t.ID()))
trace.LogError(span, err)
return err
}
@ -485,13 +491,14 @@ func (scheduler *TaskScheduler) processTask(t task) error {
err = scheduler.client.Save(key, strconv.Itoa(int(taskDone)))
if err != nil {
log.Debug("processTask: update task state err", zap.String("reason", err.Error()))
log.Debug("processTask: update task state err", zap.String("reason", err.Error()), zap.Int64("taskID", t.ID()))
trace.LogError(span, err)
return err
}
span.LogFields(oplog.Int64("processTask: scheduler process PostExecute", t.ID()))
t.PostExecute(ctx)
t.SetState(taskDone)
return nil
}
@ -529,6 +536,10 @@ func (scheduler *TaskScheduler) scheduleLoop() {
}
}
activeTaskWg.Wait()
if t.Type() == commonpb.MsgType_LoadCollection || t.Type() == commonpb.MsgType_LoadPartitions {
t.PostExecute(scheduler.ctx)
}
keys := make([]string, 0)
taskKey := fmt.Sprintf("%s/%d", triggerTaskPrefix, t.ID())
stateKey := fmt.Sprintf("%s/%d", taskInfoPrefix, t.ID())
@ -618,7 +629,7 @@ func (scheduler *TaskScheduler) waitActivateTaskDone(wg *sync.WaitGroup, t task)
removes = append(removes, stateKey)
err = scheduler.client.MultiRemove(removes)
if err != nil {
log.Error("waitActivateTaskDone: error when remove task from etcd")
log.Error("waitActivateTaskDone: error when remove task from etcd", zap.Int64("taskID", t.ID()))
}
}
}

2
internal/querycoord/task_scheduler_test.go
View File

@ -15,7 +15,7 @@ type testTask struct {
BaseTask
baseMsg *commonpb.MsgBase
cluster *queryNodeCluster
meta *meta
meta Meta
nodeID int64
}

2
tests/python_test/requirements.txt
View File

@ -12,7 +12,7 @@ pytest-print==0.2.1
pytest-level==0.1.1
pytest-xdist==2.2.1
# pytest-parallel
pymilvus-orm==2.0.0rc3.dev13
pymilvus-orm==2.0.0rc3.dev15
pytest-rerunfailures==9.1.1
git+https://github.com/Projectplace/pytest-tags
ndg-httpsclient

2
tests20/python_client/requirements.txt
View File

@ -12,7 +12,7 @@ pytest-print==0.2.1
pytest-level==0.1.1
pytest-xdist==2.2.1
# pytest-parallel
pymilvus-orm==2.0.0rc3.dev13
pymilvus-orm==2.0.0rc3.dev15
pytest-rerunfailures==9.1.1
git+https://github.com/Projectplace/pytest-tags
ndg-httpsclient